Merge branch 'mouredev:main' into main

Author: FabianRpv

Roadmap/03 - ESTRUCTURAS DE DATOS/c/04khaos.c

@@ -0,0 +1,115 @@
+// cadenas de texto
+// metodos de cadenas de texto
+
+let str = "Banana";
+let my_name = "Andrés";
+console.log(my_name);
+
+// Acceso a caracteres específicos
+
+console.log(my_name.charAt(0)); // "A"
+console.log(my_name.charAt(100)); // "" si está fuera de rango devuelve una cadena vacía
+
+console.log(my_name.at(0), my_name.at(1), my_name.at(2));  // ["A", "n", "d"]
+console.log(my_name.at(200)); // undefined ... si está fuera de rango devuelve undefined
+console.log(my_name.at(-1)); // s ... acepta valores negativos. En indices negativos se representa -1 como la ultima letra o posicion de la cadena
+
+// subcadenas
+
+console.log(my_name.substring()) // Andrés .substring(inicio, fin) Si no se especifica el fin devuelve toda la cadena
+console.log(my_name.substring(1, 4)) // "ndr"
+
+console.log(my_name.slice(-5, -1)); // "ndré" .slice(inicio, fin) Funciona parecido a substring, pero acepta valores negativos.
+console.log(my_name.slice(500)); // ""
+console.log(my_name.slice(0)); // "Andrés"
+
+// longitud
+
+console.log(my_name.length); // 6
+
+// búsqueda
+
+console.log(str.match(/a/g)); // busca de manera global por la cadena y separa en un array todas las coindidencias ["a","a","a"]
+console.log(str.match(/[an]/g)); // para buscar más de una letra usar [] ["a", "n", "a", "n", "a"]
+
+console.log(my_name.search("A")); // 0 devuelve la posición de la primera coincidencia
+console.log(my_name.search("z")); // -1 si no encuentra la letra devuelve -1
+
+console.log(my_name.indexOf("A")); // 0 devuelve la posición de la primera coincidencia
+console.log(my_name.indexOf("z")); // -1 si no encuentra la letra devuelve -1
+
+// concatenación
+
+console.log(my_name + ' ' + str); // "Andrés Banana" con operador +
+
+console.log(my_name.concat(' ', str)); // "Andrés Banana" .concat(str1, str2,  ...)
+
+console.log(`José ${my_name} ${str} con backticks`); // "José Andrés Banana" con el metodo de los backstick. Se pueden concatenar variables y variables directamente en la cadena de texto
+
+// repetición
+
+console.log(my_name.repeat(3)); // "AndrésAndrésAndrés" .repeat(n) repite la cadena n veces
+
+// recorrido
+
+console.log(my_name.endsWith("s")); // true ...verifica si la cadena termina con el caracter especificado
+console.log(my_name.startsWith("A")); // true ...verifica si la cadena comienza con el caracter especificado 
+console.log(my_name.includes("n")); // true ...verifica si la cadena contiene el caracter especificado 
+
+// conversion a mayusculas y minusculas
+
+console.log(my_name.toUpperCase()); // "ANDRÉS" convierte la cadena de texto a mayúsculas
+console.log(my_name.toLowerCase()); // "andrés" convierte la cadena de texto en minúsculas
+
+// reemplazo
+
+console.log(my_name.replace("A", "a")); // "andrés" reemplaza la primera coincidencia
+console.log(my_name.replace(/A/g, "a")); // "andrés" reemplaza todas las coincidencias
+
+let str2 = "Hola, Hola mundo, Hola a todos";
+console.log(str2.replaceAll("Hola", "Chao")); // 
+
+// división
+
+console.log(my_name.split("")); // ["A", "n", "d", "r", "é", "s"] Divide la cadena de texto en un array de caracteres equivalente a la cadena original
+
+// interpolación
+
+console.log(`
+    Hola! Mi nombre es ${my_name}
+    Y esto es un ejemplo de interpolación de cadenas de texto`);
+
+// DIFICULTAD EXTRA:
+
+let word1 = "Zorra";
+let word2 = "Arroz";
+let word3 = "Background";
+let word4 = "Mary";
+let word5 = "Army";
+
+function isPalindrom() { // palabras que se leen igual de izquierda a derecha que de derecha a izquierda
+    let _word1 = word1.toLowerCase().split("").reverse().join("");
+    let _word2 = word2.toLowerCase();
+    
+    return _word1 === _word2 ? true : false;
+    
+}
+
+function isAnagram() { // palabras que tienen las mismas letras pero en diferente orden
+    let _word4 = word4.toLowerCase().split("").sort().join("");
+    return _word4 === word5.toLowerCase().split("").sort().join("") ? true : false;
+}
+
+function isIsogram() { // palabras que o frases que no tienen letras repetidas
+
+    let _word3 = word3.toLowerCase().split("").sort().join("");
+    let _word3Set = new Set(_word3);
+
+    return _word3.length === _word3Set.size ? true : false;
+}
+
+console.log(`Las palabras ${word1} y ${word2} son Palíndromos? : ${isPalindrom()}`);
+
+console.log(`Las palabras ${word4} y ${word5} son Anagramas? : ${isAnagram()}`);
+
+console.log(`La palabra ${word3} es un Isograma? : ${isIsogram()}`);

Roadmap/04 - CADENAS DE CARACTERES/javascript/JoseAndresGC.js

@@ -0,0 +1,88 @@
+"""
+ * EJERCICIO:
+ * - Muestra ejemplos de asignación de variables "por valor" y "por referencia", según
+ *   su tipo de dato.
+ * - Muestra ejemplos de funciones con variables que se les pasan "por valor" y 
+ *   "por referencia", y cómo se comportan en cada caso en el momento de ser modificadas.
+ * (Entender estos conceptos es algo esencial en la gran mayoría de lenguajes)
+ *
+ * DIFICULTAD EXTRA (opcional):
+ * Crea dos programas que reciban dos parámetros (cada uno) definidos como variables anteriormente.
+ * - Cada programa recibe, en un caso, dos parámetros por valor, y en otro caso, por referencia.
+ *   Estos parámetros los intercambia entre ellos en su interior, los retorna, y su retorno
+ *   se asigna a dos variables diferentes a las originales. A continuación, imprime el valor de las
+ *   variables originales y las nuevas, comprobando que se ha invertido su valor en las segundas.
+ *   Comprueba también que se ha conservado el valor original en las primeras.
+ */
+ """
+
+# Asignación de variables "por valor"
+suma = 1 + 40
+multiplicacion = 20 * 17
+
+# Asignación de variables "por referencia".
+
+def descuentoAplicado(precio):
+    return precio - (precio * 10 / 100)
+
+precio = 100
+
+precio_total = descuentoAplicado(precio)
+
+print(precio_total)
+
+# Asignación de variables según tipo de dato.
+
+cadena = "Esto es una cadena"
+num = 20
+flotante =  43.0
+booleano = False
+
+# Funciones con variables que se les pasan "por valor" y "por referencia", y cómo se comportan en cada caso en el momento de ser modificadas.
+
+def porValor(num):
+    num * 2
+
+num = porValor(num)
+print(num)
+
+listado = ['Rojo', 'Verde', 'Amarillo', 'Blanco', 'Negro']
+
+# Por referencia
+def porReferencia(listado):
+    listado.append('Naranja')
+
+porReferencia(listado)
+print(listado)
+
+# /////////////////////////////////////  DIFICULTAD EXTRA (opcional)  /////////////////////////////////////
+
+param1 = "Primer parametro"
+param2 = "Segundo parametro"
+
+param_ref1 = ['arroz', 'manzana', 'pollo']
+param_ref2 = ['destornillador', 'taladro', 'martillo']
+
+def programa1(valor1, valor2):
+    valor_cambio = valor2
+    valor2 = valor1
+    valor1 = valor_cambio
+
+    return valor1, valor2
+
+def programa2(ref1, ref2):
+    ref_cambio = ref2
+    ref2 = ref1
+    ref1 = ref_cambio
+
+    return ref1, ref2
+
+
+resultado1 = programa1(param1, param2)
+resultado2 = programa2(param_ref1, param_ref2)
+
+print(f"Sin cambio: \nParametro 1 = {param1} \nParametro 2 = {param2}")
+print(f"Con cambio: \nParametro 1 = {resultado1[0]} \nParametro 2 = {resultado1[1]}\n")
+
+print(f"Sin cambio: \nParametro 1 = {param_ref1} \nParametro 2 = {param_ref2}")
+print(f"Con cambio: \nParametro 1 = {resultado2[0]} \nParametro 2 = {resultado2[1]}")

Roadmap/05 - VALOR Y REFERENCIA/python/D3rk1us.py

@@ -0,0 +1,52 @@
+"""
+ * EJERCICIO:
+ * Entiende el concepto de recursividad creando una función recursiva que imprima
+ * números del 100 al 0.
+ *
+ * DIFICULTAD EXTRA (opcional):
+ * Utiliza el concepto de recursividad para:
+ * - Calcular el factorial de un número concreto (la función recibe ese número).
+ * - Calcular el valor de un elemento concreto (según su posición) en la 
+ *   sucesión de Fibonacci (la función recibe la posición).
+"""
+
+# Función recursiva
+
+def recurFuncion(num):
+
+    if num == 0:
+        return num
+    else:
+        print(num)
+        return recurFuncion(num - 1)
+
+print(recurFuncion(100))
+
+
+# /////////////////////////////////////////////////  DIFICULTAD EXTRA  /////////////////////////////////////////////////
+
+# Factorial
+def factorial(num):
+
+    if num == 1:
+        return num
+    else:
+        return num * factorial(num - 1)
+
+print(factorial(5))
+
+
+# Posición Fibonacci
+
+def fibonacci(posicion):
+
+    if posicion == 0:
+        return 0
+
+    elif posicion == 1:
+        return 1
+
+    else:
+        return fibonacci(posicion - 1) + fibonacci(posicion - 2)
+
+print(fibonacci(10))

Roadmap/06 - RECURSIVIDAD/python/D3rk1us.py

@@ -0,0 +1,132 @@
+"""
+ * Implementa los mecanismos de introducción y recuperación de elementos propios de las
+ * pilas (stacks - LIFO) y las colas (queue - FIFO) utilizando una estructura de array
+ * o lista (dependiendo de las posibilidades de tu lenguaje).
+"""
+
+# Pila/Stack (LIFO)
+
+stack = []
+
+def push_stack(element):
+    stack.append(element)
+
+def pull_stack():
+    return stack.pop()
+
+print(stack)
+push_stack(1)
+print(stack)
+push_stack(2)
+print(stack)
+print(f" Elemento sacado: {pull_stack()}")
+print(stack)
+push_stack(3)
+print(stack)
+push_stack(4)
+print(stack)
+print(f" Elemento sacado: {pull_stack()}")
+print(stack)
+
+
+# Cola/Queue (FIFO)
+
+queue = []
+
+def push_queue(element):
+    queue.append(element)
+
+def pull_queue():
+    return queue.pop(0)
+
+
+print("----------------------------")
+print(queue)
+push_queue(1)
+print(queue)
+push_queue(2)
+print(queue)
+print(f" Elemento sacado: {pull_queue()}")
+print(queue)
+push_queue(3)
+print(queue)
+push_queue(4)
+print(queue)
+print(f" Elemento sacado: {pull_queue()}")
+print(queue)
+
+
+"""
+ * DIFICULTAD EXTRA (opcional):
+ * - Utilizando la implementación de pila y cadenas de texto, simula el mecanismo adelante/atrás
+ *   de un navegador web. Crea un programa en el que puedas navegar a una página o indicarle
+ *   que te quieres desplazar adelante o atrás, mostrando en cada caso el nombre de la web.
+ *   Las palabras "adelante", "atrás" desencadenan esta acción, el resto se interpreta como
+ *   el nombre de una nueva web.
+ * - Utilizando la implementación de cola y cadenas de texto, simula el mecanismo de una
+ *   impresora compartida que recibe documentos y los imprime cuando así se le indica.
+ *   La palabra "imprimir" imprime un elemento de la cola, el resto de palabras se
+ *   interpretan como nombres de documentos.
+"""
+
+def web_browser():
+
+    back = [] #Pila: almacena la web actual en la parte más alta y las de atras acontinuación
+    forward = [] #Pila: Almacena las paginas a las que avanzar cuando vamos atras.
+    salir = False
+
+    while not salir:
+        action = input("Introduce una web o una accion (adelante/atras/salir): ")
+
+        if action == "salir":
+            salir = True
+
+        elif action == "adelante":
+            if len(forward) > 0:    # Si hay paginas para avanzar(si hay elementos en forward)
+                web = forward.pop() # Sacamos de forward y lo pasamos a back.
+                back.append(web)
+                print(f"Pagina actual: {back[-1]}") #Pagina actual el pico de la pila
+            else:
+                print(f"No hay mas paginas adelante")
+
+        elif action == "atras":
+            if len(back) > 1:       # Si hay mas de una web en back podremos usar atras.
+                web = back.pop()    # Sacamos de back y pasamos el elemtno a forward, ya que son los elementos que podremos avanzar.
+                forward.append(web) #
+                print(f"Pagina actual: {back[-1]}") #Siempre se imprime el pico de back
+            else:
+                print("No hay más paginas atras")
+
+        else:
+            back.append(action) # Para añadir una nueva web se añade en back
+            print(f"Pagina actual: {back[-1]}")
+            forward.clear()     # En el caso de añadir una nueva web se descartan las que estaban
+                                # preparadas para ir adelante (pila forward)
+                                # Asi lo hace chrome.
+
+web_browser()
+
+def printer():
+
+    printer_queue =[]
+    salir = False
+    while not salir:
+
+        action = input("Introduce nombre de documento, o una acción(imprimir, salir): ")
+
+        if action == "salir":
+            salir = True
+
+        elif action == "imprimir":
+            if len(printer_queue) > 0:
+                document = printer_queue.pop(0)
+                print(f"Imprimiendo... {document}")
+                print(printer_queue)
+            else:
+                print("Cola de impresion vacía")
+
+        else:
+            printer_queue.append(action)
+            print(printer_queue)
+
+printer()