Merge branch 'main' of github.com:adra-dev/roadmap-retos-programacion

Author: adra-dev

README.md

@@ -33,7 +33,8 @@
 |02|[FUNCIONES Y ALCANCE](./Roadmap/02%20-%20FUNCIONES%20Y%20ALCANCE/ejercicio.md)|[📝](./Roadmap/02%20-%20FUNCIONES%20Y%20ALCANCE/python/mouredev.py)|[▶️](https://youtu.be/auxClgiX6UM)|[👥](./Roadmap/02%20-%20FUNCIONES%20Y%20ALCANCE/)
 |03|[ESTRUCTURAS DE DATOS](./Roadmap/03%20-%20ESTRUCTURAS%20DE%20DATOS/ejercicio.md)|[📝](./Roadmap/03%20-%20ESTRUCTURAS%20DE%20DATOS/python/mouredev.py)|[▶️](https://youtu.be/brxtPtUbU7M)|[👥](./Roadmap/03%20-%20ESTRUCTURAS%20DE%20DATOS/)
 |04|[CADENAS DE CARACTERES](./Roadmap/04%20-%20CADENAS%20DE%20CARACTERES/ejercicio.md)|[📝](./Roadmap/04%20-%20CADENAS%20DE%20CARACTERES/python/mouredev.py)|[▶️](https://youtu.be/CKzY7nHwulA)|[👥](./Roadmap/04%20-%20CADENAS%20DE%20CARACTERES/)
-|05|[VALOR Y REFERENCIA](./Roadmap/05%20-%20VALOR%20Y%20REFERENCIA/ejercicio.md)|[🗓️ 05/02/24](https://discord.gg/YEU3gzfe?event=1201413529924796416)||[👥](./Roadmap/05%20-%20VALOR%20Y%20REFERENCIA/)
+|05|[VALOR Y REFERENCIA](./Roadmap/05%20-%20VALOR%20Y%20REFERENCIA/ejercicio.md)|[📝](./Roadmap/05%20-%20VALOR%20Y%20REFERENCIA/python/mouredev.py)||[👥](./Roadmap/05%20-%20VALOR%20Y%20REFERENCIA/)
+|06|[RECURSIVIDAD](./Roadmap/06%20-%20RECURSIVIDAD/ejercicio.md)|[🗓️ 12/02/24](https://discord.gg/wbqPzvPg?event=1204001786575200306)||[👥](./Roadmap/06%20-%20RECURSIVIDAD/)
 
 ## Instrucciones
 

Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/rust/javiearth.rs

@@ -0,0 +1,73 @@
+//=====================================================
+// 00 - Sintaxis, variales, tipos de datos y hola mundo
+//=====================================================
+
+// 1. WEB  OFICIAL
+// Rust official documentation: https://www.rust-lang.org
+
+// 2. COMENTARIOS EN RUST
+// One line comment
+/* Multiple line comments
+just like C!!
+*/
+
+// CREANDO UNA VARIALE Y UNA CONSTANTE
+
+// Variable
+let a = 5;
+
+// Creando una constante:
+const GRAVEDAD_TERRESTRE: 9.81;
+
+// CREA VARIABLES REPRESENTANDO TODOS LOS TIPOS DE DATOS
+
+// NOTA: el compilador infiere el tipo de dato y no es necesatio indicarlo, pero se puede hacer.
+
+// Tipo escalar:
+  // Tipos integer, pueden ser con signo (i) o sin signo (u): i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize.
+  let entero_8bits i8 = -128;
+  let positivo_8bits u8 = 255;
+  let entero_16bits i16 = =-32768;
+  let positivo_16bits u16 = 62535;
+  let entero_32bits i32 = 42;
+  let positivo_32bits u32 = 73;
+  let entero_64bits i64 = 137;
+  let positivo_64bits u64 = 20000000;
+  let entero_128bits i128 = 1;
+  let positivo_128bits u128 = 345;
+  let entero_arquitectura isize = 546236;
+  let positivo_arquitectura usize = 243653426;
+  // Tipos integer literals: son enteros en otras notaciones(0x, 0o, 0b)
+  let moure_dev = 1_987; //Decimal, sin prefijo, se puede usar _ para leerlo mejor sin que afecte en nada.
+  let que_champu = 0x7C3; //Hexadecimal (todos los numeros hexadecimales empiezan por 0x, 7C3 es 1987 en hexadecimal)
+  let usas_para = 0o3703; //Octal (notacion octal empieza por 0o)
+  let la_barba = 0b11111000011; //Binario (0b indica binario)
+  
+// Coma flotante (f32 y f64, IEEE-754 standard)
+  let x f32 = 1.234;
+  let y f64 = -1.23456789;
+
+//Tipo boolean:
+let delicioso = true;
+let love: = 0; // notacion explicita
+
+// Tipo character (ocupan 4 bytes y represaentan valores Unicode):
+let g = 'j';
+let v: char = 'B';
+let heart = 💓;
+
+// Tipos compuestos: Tupla. almacena varios datos de diferente tipo.
+let tuplita: (i32, f64, u8) = (500, 6.4, 1);
+// Tipos compuestos: array. Almacena varios valores del mismo tipo.
+let array = [1,2,3,4,5];
+
+ //Cadenas de caracteres: para este caso hay que usar la funcion String::from o el metodo .to_string().
+ let mi_cadena: String = String::from("mi casa");
+ let mi_otra_cadena: String = "mi otra casa".to_string();
+ // Seria incorrecto escribir algo como let mi-cadena: String = "mi casa".
+
+ // IMPREME POR PANTALLA "HOLA MUNDO"
+
+ fn main() {
+    println("Hola, mundo");
+ }

Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/go/allanoscoding.go

@@ -0,0 +1,116 @@
+/*
+ * 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.
+ */
+
+package main
+
+import "fmt"
+
+func defer_example() {
+	defer fmt.Println("Mundo!")
+	fmt.Println("Hola")
+	return
+}
+func is_multiple_of(num int, multiple int) bool {
+	return num % multiple == 0
+}
+
+func main() {
+	// Operadores aritmeticos
+	my_sum := 3 + 4
+	my_diff := 5 - 3
+	my_mult := 2 * 2
+	my_division := 6 / 3
+	my_modulo := 10 % 2
+
+	fmt.Printf("Suma: 3 + 4 = %d \n", my_sum)
+	fmt.Printf("Resta: 5 - 3 = %d \n", my_diff)
+	fmt.Printf("Multiplicacion: 2 * 2 = %d \n", my_mult)
+	fmt.Printf("Division: 6 / 3 = %d \n", my_division)
+	fmt.Printf("Resto: 10 %% 2 = %d \n", my_modulo)
+
+	// Operadores relacionales
+	my_op_1 := 5 == 3
+	my_op_2 := 5 != 3
+	my_op_3 := 5 < 3
+	my_op_4 := 5 <= 3
+	my_op_5 := 5 > 3
+	my_op_6 := 5 >= 3
+
+	fmt.Printf("Operador ==: 5 == 3 -> %t \n", my_op_1)
+	fmt.Printf("Operador !=: 5 != 3 -> %t \n", my_op_2)
+	fmt.Printf("Operador <: 5 < 3 -> %t \n", my_op_3)
+	fmt.Printf("Operador <=: 5 <= 3 -> %t \n", my_op_4)
+	fmt.Printf("Operador >: 5 > 3 -> %t \n", my_op_5)
+	fmt.Printf("Operador >=: 5 >= 3 -> %t \n", my_op_6)
+
+	// Operadores logicos
+	my_op_7 := my_op_5 && my_op_1
+	my_op_8 := my_op_6 || my_op_3
+	my_op_9 := !my_op_2
+
+	fmt.Printf("Resultado: (5 > 3) && (5 == 3) = %t \n", my_op_7)
+	fmt.Printf("Resultado: (5 >= 3) && (5 < 3) = %t \n", my_op_8)
+	fmt.Printf("Resultado: !(5 != 3) = %t \n", my_op_9)
+
+	// Operadores bit a bit
+	a := 55
+	b := 11
+
+	fmt.Printf("Bitwise AND: a & b = %d \n", a & b)
+	fmt.Printf("Bitwise OR: a | b = %d \n", a | b)
+	fmt.Printf("Bitwise XOR: a ^ b = %d \n", a ^ b)
+	fmt.Printf("Desplazamiento a la izq: a << 1 = %d \n", a << 1)
+	fmt.Printf("Desplazamiento a la dcha: a >> 1 = %d \n", a >> 1)
+	fmt.Printf("Bitwise AND NOT(clear): a &^ b = %d \n", a &^ b)
+
+	// Operadores miscelaneos
+	c := 22
+	d := &c
+
+	fmt.Printf("La direccion en memoria de c es %v \n", &c)
+	fmt.Printf("El valor de c es %v \n", *d)
+
+	// Estructuras de control
+	if e := a + b; e > c {
+		fmt.Println("e > a + b")
+	} else {
+		fmt.Println("e < a + b")
+	}
+
+	for i := 0; i < 10; i++ {
+		fmt.Println(i)
+	}
+
+	switch name := "Angel"; name {
+	case "Angel":
+		fmt.Println("Es Angel")
+	default:
+		fmt.Println("Es otra persona")
+	}
+
+	defer_example()
+
+	// PROBLEMA EXTRA
+	fmt.Println("Problema EXTRA")
+	fmt.Println("-------------------------------")
+	for i := 10; i <= 55; i++ {
+		if is_multiple_of(i, 2) && !is_multiple_of(i, 3) && i != 16 {
+			fmt.Println(i)
+		}
+	}
+}

Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/rust/javiearth.rs

@@ -0,0 +1,37 @@
+//=========================================
+// 01 - OPERADORES Y ESTRUCTURAS DE CONTROL
+//=========================================
+
+// EJEMPLO DE TODOS LOS TIPOS DE OPERADORES
+
+let mut a: u8 = 2;
+let b: u8 = 4;
+let c: u8 = 8;
+
+// Aritmeticos:
+
+
+// Logicos:
+Pritln ("AND: a < b && c > b da {}", a < b && c > b);
+Pritln ("OR: a < b || b > c da {}", a < b && b > c);
+Pritln ("NOT: !! a < b da {}", !! a < b);
+
+// Comparacion:
+Println ("{} es distinto de {}, es {}", a, b, a != b );
+Println ("{} es igual de {}, es {}", a, b,  );
+Println ("{} es mayor que {}, es {}", a, b,  );
+Println ("{} es menor que {}, es {}", a, b,  );
+Println ("{} es mayor o igual que {}, es {}", a, b,  );
+Println ("{} es menor igual de que {}, es {}", a, b,  );
+
+// Asignacion:
+Println ("{} += 1, ahora vale {}", a, a);
+Println ("{} -= 1, ahora vale {}", a, a);
+Println ("{} *= 2, ahora vale {}", a, a);
+Println ("{} /= 2, ahora vale {}", a, a);
+Println ("{} %= 2, ahora vale {}", a, a);
+
+// Pretenencia:
+
+// Bits:
+

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

@@ -0,0 +1,121 @@
+'''
+  FUNCIONES
+'''
+
+# Función sin parámetros ni retorno
+def greet():
+  print('Hi!')
+
+greet()
+
+# Función con parámetros sin retorno
+def greetPerson(name):
+  print(f'¡Hello {name}!')
+
+greetPerson('César')
+
+# Función con varios parámetros sin retorno
+def add(number1, number2):
+  print(f'{number1} + {number2} = {number1 + number2}')
+
+add(5, 8)
+
+# Función con varios parámetros con retorno
+def subtract(number1, number2):
+  return number1 - number2
+
+result = subtract(175, 123)
+print(f'175 - 123 = {result}')
+
+# Función con parámetros variables
+def average(*args):
+  sum = 0
+  for arg in args:
+    sum += arg
+  return sum/len(args)
+
+result = average(9, 8, 7, 9, 9, 8, 10, 10)
+print(result)
+
+# Función con parámetros variables con identificador
+def capitals(**kwargs):
+  for country, city in kwargs.items():
+    print(f"{country} - {city}")
+  return
+
+countries = {
+  'Mexico': 'Mexico City',
+  'Argentina': 'Buenos Aires',
+  'Spain': 'Madrid',
+  'Chile': 'Santiago'
+  }
+
+capitals(**countries)  
+
+# Funciones anónimas o lambda
+exponentiate = lambda number, exponent: number ** exponent
+result = exponentiate(2, 8)
+
+print(f'2 ** 8 = {result}')
+
+# Funciones dentro de funciones
+def exterior_function(x):
+    def interior_function(y):
+        return y * 2
+    
+    result = x + interior_function(x)
+    return result
+
+operation = exterior_function(5)
+print(operation)
+
+# Funciones nativas
+my_list = [5, 6, 7, 3, 6, 7, 9, 3, 5, 8]
+print(f'Esta es la función nativa: print()\nMi lista: {my_list}')
+print(f'Tipo de dato: {type(my_list)}')
+print(f'Longitud de mi lista: {len(my_list)}')
+print(f'Máximo de mi lista: {max(my_list)}')
+print(f'Mínimo de mi lista: {min(my_list)}')
+print(f'Suma de mi lista: {sum(my_list)}')
+input('Esta es la función input, \n para continuar escribe un número: ')
+
+'''
+  VARIABLE LOCAL Y GLOBAL
+'''
+
+global_var = "Soy global"
+
+def myFunction():
+    local_var = "Soy local"
+    print(f'Accediendo a la variable global dentro de la función: {global_var}')
+    print(f'Accediendo a la variable local dentro de la función: {local_var}')
+
+myFunction()
+
+print(f'Accediendo a la variable global fuera de la función: {global_var}')
+try:
+  print(f'Accediendo a la variable loca fuera de la función: {local_var}')
+except NameError as err:
+  print(f'Error: {type(err).__name__}')
+  print(f'No se puede acceder a la variable local desde afuera de su bloque')
+
+'''
+  EXTRA
+'''
+
+def printNumbers(text1, text2):
+  printed_numbers = 0
+  for number in range(1, 101):
+    if number % 3 == 0 and number % 5 == 0:
+      print(f"{text1} y {text2}")
+    elif number % 3 == 0:
+      print(text1)
+    elif number % 5 == 0:
+      print(text2)
+    else:
+      print(f"{number}")
+      printed_numbers += 1
+  return printed_numbers  
+
+prints = printNumbers(text2 = 'Múltiplo de 5', text1 = 'Múltiplo de 3')
+print(prints)