Merge branch 'mouredev:main' into develop

Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/javascript/miguelRejon96.js

@@ -0,0 +1,35 @@
+// Sitio oficial de Javascript: https://developer.mozilla.org/es/docs/Web/JavaScript
+
+//Este es un comentario en una línea
+/*
+    Este es un comentario en varías líneas
+*/
+
+//Constante
+const greetings = 'Hello'
+
+//Variable
+let language = 'Javascript'
+
+//Tipos de datos:
+
+//String 
+const thiIsAString = 'This is a string'
+
+//Number
+const thisIsANumber = 1
+
+//BigInt
+const thisIsABigInt = BigInt(9007199254740991)
+
+//Boolean
+const thisIsABoolean = true 
+
+//Undefined
+let thisIsAnUndefined
+
+//Symbol
+const thisIsASymbol = Symbol()
+
+
+console.log(`${greetings} ${language}`)

Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/python/owen-ian.py

@@ -0,0 +1,34 @@
+# URL del sitio web oficial de Python: https://www.python.org/
+
+# La amohadilla nos permite escribir un comentario de una sola línea
+
+"""
+Las comillas dobles nos permiten 
+escribir un comentario de varias líneas
+"""
+
+'''
+Las comillas simples tambien nos permiten 
+escribir un comentario de varias líneas
+'''
+
+# Variable
+my_variable = "Una variable en Python"
+
+# Constante
+MY_CONSTANTE = "Una constante en Python" # Aclaracion, al parecer la gente escribe sus constantes en MAYUSCULAS
+
+my_int = 1
+my_float = 1.5
+my_bool = True
+my_bool = False
+my_string = "Cadena de texto"
+my_other_string = 'Otra cadena de texto'
+
+# Imprimir por terminal
+print("¡Hola, Python!")
+
+print(type(my_int))
+print(type(my_float))
+print(type(my_bool))
+print(type(my_string))

Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/javascript/miguelRejon96.js

@@ -0,0 +1,129 @@
+/*
+ * EJERCICIO:
+ * - Crea ejemplos utilizando todos los tipos de operadores de tu lenguaje:
+ *   Aritméticos, lógicos, de comparación, asignación, identidad, pertenencia, bits...
+ *   (Ten en cuenta que cada lenguaje puede poseer unos diferentes)
+ * - Utilizando las operaciones con operadores que tú quieras, crea ejemplos
+ *   que representen todos los tipos de estructuras de control que existan
+ *   en tu lenguaje:
+ *   Condicionales, iterativas, excepciones...
+ * - Debes hacer print por consola del resultado de todos los ejemplos.
+ *
+ * DIFICULTAD EXTRA (opcional):
+ * Crea un programa que imprima por consola todos los números comprendidos
+ * entre 10 y 55 (incluidos), pares, y que no son ni el 16 ni múltiplos de 3.
+ *
+ * Seguro que al revisar detenidamente las posibilidades has descubierto algo nuevo.
+ */
+
+//Operadores Aritméticos
+let x = 10;
+let y = 5;
+console.log("Suma: ", x + y); //Suma
+console.log("Resta: ", x - y); //Resta
+console.log("Multiplicación: ", x * y); //Multiplicación
+console.log("División", x / y); //División
+console.log("Residuo", x % y); //Residuo
+console.log("Exponenciación: ", x ** y); //Exponenciación
+
+//Operadores de asignación
+let a = 10;
+a += 3; // a = a +3
+console.log("a += 3: ", a);
+a -= 3; // a = a - 3
+console.log("a -= 3: ", a);
+a *= 3; // a = a * 3
+console.log("a *= 3: ", a);
+a /= 3; // a = a / 3
+console.log("a /= 3: ", a);
+a %= 3; // a = a % 3
+console.log("a %= 3: ", a);
+a **= 3; // a = a ** 3
+console.log("a **= 3: ", a);
+
+//Operadores de comparación
+let b = 5;
+console.log("a == b: ", a == b); //Igualdad
+console.log("a === b: ", a === b); //Igualdad estricta
+console.log("a != b: ", a != b); //Desigualdad
+console.log("a !== b: ", a !== b); //Desigualdad estricta
+console.log("a > b: ", a > b); //Mayor que
+console.log("a < b: ", a < b); //Menor que
+console.log("a >= b: ", a >= b); //Mayor o igual que
+console.log("a <= b: ", a <= b); //Menor o igual que
+
+//Operadores lógicos
+console.log("true && false: ", true && false); // AND
+console.log("true || false: ", true || false); // OR
+console.log("!true: ", !true); //NOT
+
+//Operadores de Bits
+console.log(x << y); //Desplazamiento a la izquierda
+console.log(x >> y); //Desplazamiento a la derecha
+console.log(x >>> y); //Desplazamiento a la derecha sin signo
+console.log(x & y); //Asignación AND bit a bit
+console.log(x ^ y); //Asignación XOR bit a bit
+console.log(x | y); //Asignación OR bit a bit
+console.log(x && (x = y)); //Asignación AND lógico
+console.log(x || (x = y)); //Asignación OR lógico
+console.log(x ?? (x = y)); //Asignación de anulación lógica
+
+//Estucturas de control
+
+// Condicionales
+
+if (x > y) {
+  console.log("x es mayor que y");
+} else {
+  console.log("x no es mayor que y");
+}
+
+let z = 3;
+switch (z) {
+  case 1:
+    console.log("Z es 1");
+    break;
+  case 2:
+    console.log("Z es 2");
+    break;
+  case 3:
+    console.log("z es 3");
+    break;
+  default:
+    console.log("z no es 1,2 o 3");
+}
+
+//Iterativas
+for (let i = 0; i < 5; i++) {
+  console.log("For loop i: ", i);
+}
+let j = 0;
+while (j < 5) {
+  console.log("while loop j: ", j);
+  j++;
+}
+let k = 0;
+do {
+  console.log("do while loop k: ", k);
+  k++;
+} while (k < 5);
+
+//Excepciones
+try {
+  throw new error("Error");
+} catch (error) {
+  console.log("Mensaje: ", error.message);
+} finally {
+  console.log("Finally");
+}
+
+//Ejercicio Extra
+function extraExercise() {
+  for (let i = 10; i <= 55; i++) {
+    if (i % 2 == 0 && i !== 16 && i % 3 !== 0) {
+      console.log(i);
+    }
+  }
+}
+
+extraExercise();

Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/python/saicobys.py

@@ -0,0 +1,82 @@
+# Operadores aritméticos
+x = 10
+y = 3
+suma = x + y
+resta = x - y
+multiplicacion = x * y
+division = x / y
+division_entera = x // y
+modulo = x % y
+potencia = x ** y
+
+print("Suma:", suma)
+print("Resta:", resta)
+print("Multiplicacion:", multiplicacion)
+print("Division:", division)
+print("division entera:", division_entera)
+print("Modulo:", modulo)
+print("Potencia:", potencia)
+
+# Operadores de comparacion
+a = 5 
+b = 8
+print("a == b:", a == b)
+print("a != b:", a != b)
+print("a > b:", a > b)
+print("a < b:", a < b)
+print("a >= b:", a >= b)
+print("a <= b:", a <= b)
+
+# Operadores lógicos
+c = True
+d = False
+print("c and d:", c and d)
+print("c or d:", c or d)
+print("not c:", not c)
+
+# Operadores de asignación
+e = 15
+e += 5  # e = e + 5
+print("e += 5:", e)
+e -= 3  # e = e - 3
+print("e -= 3:", e)
+
+# Operadores de identidad
+f = [1, 2, 3]
+g = [1, 2, 3]
+h = f
+print("f is g:", f is g)  # False (objetos diferentes)
+print("f is h:", f is h)  # True (misma referencia)
+print("f == g:", f == g)  # True (mismo contenido)
+
+# Operadores de pertenencia
+lista = [1, 2, 3, 4]
+print("1 in lista:", 1 in lista)
+print("5 in lista:", 5 in lista)
+
+# Condicionales
+edad = 25
+
+if edad < 18:
+  print("Eres menor de edad")
+elif edad >= 18 and edad < 65:
+  print("Eres adulto")
+else:
+  print("Eres jubilado")
+
+# Iterativas (bucles)
+for i in range(1, 6):  # Imprime números del 1 al 5
+  print(i)
+
+numero = 1
+while numero <= 5:  # Imprime números del 1 al 5
+  print(numero)
+  numero += 1
+
+# Excepciones
+try:
+  resultado = 10 / 0  # División por cero (error)
+except ZeroDivisionError as e:
+  print("Error:", e)
+finally:
+  print("Fin del programa")

Roadmap/02 - FUNCIONES Y ALCANCE/python/saicobys.py

@@ -0,0 +1,78 @@
+""" 1. Funciones sin parámetros ni retorno: """
+def saludar():  
+    print("¡Hola desde una función!")
+
+saludar()  # Llamada a la función
+
+""" 2. Funciones con parámetros: """
+def saludar_con_nombre(nombre):
+    print(f"¡Hola, {nombre}!")
+
+saludar_con_nombre("Ana")  # Llamada con un argumento
+
+""" 3. Funciones con múltiples parámetros: """
+def sumar(a, b):
+    resultado = a + b
+    print(f"La suma de {a} y {b} es: {resultado}")
+
+sumar(5, 3)  # Llamada con dos argumentos
+
+""" 4. Funciones con retorno: """
+def calcular_area_rectangulo(base, altura):
+    area = base * altura
+    return area
+
+area = calcular_area_rectangulo(4, 6)
+print(f"El área del rectángulo es: {area}")
+
+""" 5. Funciones dentro de funciones (anidadas): """
+def operacion_matematica(x, y):
+    def sumar(a, b):
+        return a + b
+
+    def restar(a, b):
+        return a - b
+
+    suma_resultado = sumar(x, y)
+    resta_resultado = restar(x, y)
+
+    print(f"Suma: {suma_resultado}, Resta: {resta_resultado}")
+
+operacion_matematica(8, 3)
+
+""" 6. Uso de funciones integradas: """
+mensaje = "Hola, mundo!"
+longitud = len(mensaje)  # Función len() para obtener la longitud de la cadena
+print(f"La longitud del mensaje es: {longitud}")
+
+""" . Variables locales y globales: """
+variable_global = "Soy global"
+
+def funcion_ejemplo():
+    variable_local = "Soy local"
+    print("Dentro de la función:", variable_global, variable_local)
+
+funcion_ejemplo()
+print("Fuera de la función:", variable_global)
+# print("Fuera de la función:", variable_local)  # Error: variable_local no está definida fuera de la función
+
+
+def fizzbuzz(texto_multiplo_3, texto_multiplo_5):
+    """Imprime los números del 1 al 100 con reglas especiales y retorna el número de veces que se imprime un número en lugar de texto."""
+    contador_numeros = 0
+
+    for numero in range(1, 101):
+        if numero % 15 == 0:  # Múltiplo de 3 y 5
+            print(texto_multiplo_3 + texto_multiplo_5)
+        elif numero % 3 == 0:  # Múltiplo de 3
+            print(texto_multiplo_3)
+        elif numero % 5 == 0:  # Múltiplo de 5
+            print(texto_multiplo_5)
+        else:  # No es múltiplo de 3 ni de 5
+            print(numero)
+            contador_numeros += 1  # Incrementa el contador si se imprime un número
+
+    return contador_numeros
+
+resultado = fizzbuzz("Fizz", "Buzz")
+print(f"Número de veces que se imprimió un número: {resultado}")