From 7fb77258bc483a97bf8be618ae16f02cccfd7a9a Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 07:56:15 -0500 Subject: [PATCH 01/38] #00 - Python --- .../python/mysterio-wil.py | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/python/mysterio-wil.py diff --git a/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/python/mysterio-wil.py b/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/python/mysterio-wil.py new file mode 100644 index 0000000000..292373786a --- /dev/null +++ b/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/python/mysterio-wil.py @@ -0,0 +1,35 @@ +# EJERCICIO: +# - Crea un comentario en el código y coloca la URL del sitio web oficial del lenguaje de programación que has seleccionado. +# https://www.python.org + +# - Representa las diferentes sintaxis que existen de crear comentarios en el lenguaje (en una línea, varias...). + +# Esto es un comentario de una línea + +""" +Esto es un comentario +de varias líneas +""" + +''' +Esto también es +un comentario de +varias líneas +''' + +# - Crea una variable (y una constante si el lenguaje lo soporta). +my_variable = "Mi variable" +# Python no tiene constantes, pero por convención se usan mayúsculas +MY_CONSTANT = "Mi constante" + +# - Crea variables representando todos los tipos de datos primitivos del lenguaje (cadenas de texto, enteros, booleanos...). +my_string = "Cadena de texto" +my_int = 10 +my_float = 10.5 +my_bool_true = True +my_bool_false = False +my_none = None +my_complex = 1 + 2j + +# - Imprime por terminal el texto: "¡Hola, [y el nombre de tu lenguaje]!" +print("¡Hola, Python!") \ No newline at end of file From 939e756c39b4c712f41a401f0c41e2f3f6bfbe2e Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 07:56:28 -0500 Subject: [PATCH 02/38] #00 - JavaScript --- .../javascript/mysterio-wil.js | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/javascript/mysterio-wil.js diff --git a/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/javascript/mysterio-wil.js b/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/javascript/mysterio-wil.js new file mode 100644 index 0000000000..2e3377ba5a --- /dev/null +++ b/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/javascript/mysterio-wil.js @@ -0,0 +1,28 @@ +// EJERCICIO: +// - Crea un comentario en el código y coloca la URL del sitio web oficial del lenguaje de programación que has seleccionado. +// https://developer.mozilla.org/en-US/docs/Web/JavaScript + +// - Representa las diferentes sintaxis que existen de crear comentarios en el lenguaje (en una línea, varias...). + +// Esto es un comentario de una línea + +/* +Esto es un comentario +de varias líneas +*/ + +// - Crea una variable (y una constante si el lenguaje lo soporta). +let myVariable = "Mi variable"; +const MY_CONSTANT = "Mi constante"; + +// - Crea variables representando todos los tipos de datos primitivos del lenguaje (cadenas de texto, enteros, booleanos...). +let myString = "Cadena de texto"; +let myNumber = 10; +let myBigInt = 1234567890123456789012345678901234567890n; +let myBoolean = true; +let myUndefined = undefined; +let myNull = null; +let mySymbol = Symbol("my symbol"); + +// - Imprime por terminal el texto: "¡Hola, [y el nombre de tu lenguaje]!" +console.log("¡Hola, JavaScript!"); From c32d5836f3ca0debb63ce7a9c3857ae82c114891 Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 07:57:00 -0500 Subject: [PATCH 03/38] #00 - Java --- .../java/mysterio-wil.java | 44 +++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/java/mysterio-wil.java diff --git a/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/java/mysterio-wil.java b/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/java/mysterio-wil.java new file mode 100644 index 0000000000..7d33abefc0 --- /dev/null +++ b/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/java/mysterio-wil.java @@ -0,0 +1,44 @@ +// EJERCICIO: +// - Crea un comentario en el código y coloca la URL del sitio web oficial del lenguaje de programación que has seleccionado. +// https://www.java.com/ + +// Nota: El nombre del archivo "mysterio-wil.java" no es un nombre de clase público válido en Java. +// Para que el código compile, la clase no es pública y se ha nombrado "mysterio_wil". +class mysterio_wil { + + public static void main(String[] args) { + + // - Representa las diferentes sintaxis que existen de crear comentarios en el lenguaje (en una línea, varias...). + + // Esto es un comentario de una línea + + /* + Esto es un comentario + de varias líneas + */ + + /** + * Esto es un comentario de documentación (Javadoc) + */ + + // - Crea una variable (y una constante si el lenguaje lo soporta). + String myVariable = "Mi variable"; + final String MY_CONSTANT = "Mi constante"; + + // - Crea variables representando todos los tipos de datos primitivos del lenguaje. + byte myByte = 100; + short myShort = 10000; + int myInt = 100000; + long myLong = 1000000000L; + float myFloat = 10.5f; + double myDouble = 10.55555; + boolean myBoolean = true; + char myChar = 'a'; + // String no es un tipo primitivo en Java, es un objeto. + String myString = "Cadena de texto"; + + + // - Imprime por terminal el texto: "¡Hola, [y el nombre de tu lenguaje]!" + System.out.println("¡Hola, Java!"); + } +} From 4e0c9fc98024453863aaf61dbb583f39db7213db Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 07:57:11 -0500 Subject: [PATCH 04/38] #00 - C++ --- .../c++/mysterio-wil.cpp | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/c++/mysterio-wil.cpp diff --git a/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/c++/mysterio-wil.cpp b/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/c++/mysterio-wil.cpp new file mode 100644 index 0000000000..217d391ec0 --- /dev/null +++ b/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/c++/mysterio-wil.cpp @@ -0,0 +1,34 @@ +// EJERCICIO: +// - Crea un comentario en el código y coloca la URL del sitio web oficial del lenguaje de programación que has seleccionado. +// https://isocpp.org/ + +#include +#include + +// - Representa las diferentes sintaxis que existen de crear comentarios en el lenguaje (en una línea, varias...). + +// Esto es un comentario de una línea + +/* +Esto es un comentario +de varias líneas +*/ + +int main() { + // - Crea una variable (y una constante si el lenguaje lo soporta). + std::string myVariable = "Mi variable"; + const std::string MY_CONSTANT = "Mi constante"; + + // - Crea variables representando todos los tipos de datos primitivos del lenguaje (cadenas de texto, enteros, booleanos...). + int myInt = 10; + float myFloat = 10.5f; + double myDouble = 10.555; + char myChar = 'a'; + bool myBoolean = true; + std::string myString = "Cadena de texto"; // En C++, std::string es una clase, no un tipo primitivo. + + // - Imprime por terminal el texto: "¡Hola, [y el nombre de tu lenguaje]!" + std::cout << "¡Hola, C++!" << std::endl; + + return 0; +} From e03ec9d077aec65972e990c18bad15d10381439b Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 07:57:22 -0500 Subject: [PATCH 05/38] #00 - PHP --- .../php/mysterio-wil.php | 31 +++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/php/mysterio-wil.php diff --git a/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/php/mysterio-wil.php b/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/php/mysterio-wil.php new file mode 100644 index 0000000000..9aa739f151 --- /dev/null +++ b/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/php/mysterio-wil.php @@ -0,0 +1,31 @@ + From cbded3b51ac8df5098aed2acc58144c99c36a163 Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 07:57:37 -0500 Subject: [PATCH 06/38] #00 - C# --- .../c#/mysterio-wil.cs | 41 +++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/c#/mysterio-wil.cs diff --git a/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/c#/mysterio-wil.cs b/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/c#/mysterio-wil.cs new file mode 100644 index 0000000000..378ca64cdf --- /dev/null +++ b/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/c#/mysterio-wil.cs @@ -0,0 +1,41 @@ +// EJERCICIO: +// - Crea un comentario en el código y coloca la URL del sitio web oficial del lenguaje de programación que has seleccionado. +// https://learn.microsoft.com/en-us/dotnet/csharp/ + +using System; + +// El nombre de la clase "mysterio-wil" no es válido en C#. Se usará "MysterioWil". +public class MysterioWil +{ + public static void Main(string[] args) + { + // - Representa las diferentes sintaxis que existen de crear comentarios en el lenguaje (en una línea, varias...). + + // Comentario de una línea + + /* + Comentario + de varias + líneas + */ + + /// + /// Comentario de documentación XML. + /// + + // - Crea una variable (y una constante si el lenguaje lo soporta). + string myVariable = "Mi variable"; + const string MY_CONSTANT = "Mi constante"; + + // - Crea variables representando todos los tipos de datos primitivos del lenguaje (cadenas de texto, enteros, booleanos...). + string myString = "Cadena de texto"; + int myInt = 10; + float myFloat = 10.5f; + double myDouble = 10.555; + bool myBoolean = true; + char myChar = 'a'; + + // - Imprime por terminal el texto: "¡Hola, [y el nombre de tu lenguaje]!" + Console.WriteLine("¡Hola, C#!"); + } +} From fa62adac96a6102299f3ae25bd73e9925c38276f Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 07:57:51 -0500 Subject: [PATCH 07/38] #00 - Go --- .../go/mysterio-wil.go | 33 +++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/go/mysterio-wil.go diff --git a/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/go/mysterio-wil.go b/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/go/mysterio-wil.go new file mode 100644 index 0000000000..5a0a4f3e57 --- /dev/null +++ b/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/go/mysterio-wil.go @@ -0,0 +1,33 @@ +// EJERCICIO: +// - Crea un comentario en el código y coloca la URL del sitio web oficial del lenguaje de programación que has seleccionado. +// https://go.dev/ + +package main + +import "fmt" + +// - Representa las diferentes sintaxis que existen de crear comentarios en el lenguaje (en una línea, varias...). + +// Esto es un comentario de una línea + +/* +Esto es un comentario +de varias líneas +*/ + +func main() { + // - Crea una variable (y una constante si el lenguaje lo soporta). + var myVariable string = "Mi variable" + const myConstant = "Mi constante" + + // - Crea variables representando todos los tipos de datos primitivos del lenguaje (cadenas de texto, enteros, booleanos...). + var myString string = "Cadena de texto" + var myInt int = 10 + var myFloat float64 = 10.5 + var myBool bool = true + // En Go, los caracteres se representan con el tipo rune (alias de int32) + var myRune rune = 'a' + + // - Imprime por terminal el texto: "¡Hola, [y el nombre de tu lenguaje]!" + fmt.Println("¡Hola, Go!") +} From 36522e3b0adde0850a50dadd30030e5bb088be59 Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 07:58:01 -0500 Subject: [PATCH 08/38] #00 - Swift --- .../swift/mysterio-wil.swift | 29 +++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/swift/mysterio-wil.swift diff --git a/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/swift/mysterio-wil.swift b/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/swift/mysterio-wil.swift new file mode 100644 index 0000000000..2f94d90a66 --- /dev/null +++ b/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/swift/mysterio-wil.swift @@ -0,0 +1,29 @@ +// EJERCICIO: +// - Crea un comentario en el código y coloca la URL del sitio web oficial del lenguaje de programación que has seleccionado. +// https://www.swift.org/ + +import Foundation + +// - Representa las diferentes sintaxis que existen de crear comentarios en el lenguaje (en una línea, varias...). + +// Esto es un comentario de una línea + +/* +Esto es un comentario +de varias líneas +*/ + +// - Crea una variable (y una constante si el lenguaje lo soporta). +var myVariable = "Mi variable" +let myConstant = "Mi constante" + +// - Crea variables representando todos los tipos de datos primitivos del lenguaje (cadenas de texto, enteros, booleanos...). +let myString: String = "Cadena de texto" +let myInt: Int = 10 +let myFloat: Float = 10.5 +let myDouble: Double = 10.555 +let myBool: Bool = true +let myCharacter: Character = "a" + +// - Imprime por terminal el texto: "¡Hola, [y el nombre de tu lenguaje]!" +print("¡Hola, Swift!") From 2ca45a8ff6d396b113e613f8d622c819483f8b82 Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 07:58:11 -0500 Subject: [PATCH 09/38] #00 - TypeScript --- .../typescript/mysterio-wil.ts | 29 +++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/typescript/mysterio-wil.ts diff --git a/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/typescript/mysterio-wil.ts b/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/typescript/mysterio-wil.ts new file mode 100644 index 0000000000..cc6f11cad0 --- /dev/null +++ b/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/typescript/mysterio-wil.ts @@ -0,0 +1,29 @@ +// EJERCICIO: +// - Crea un comentario en el código y coloca la URL del sitio web oficial del lenguaje de programación que has seleccionado. +// https://www.typescriptlang.org/ + +// - Representa las diferentes sintaxis que existen de crear comentarios en el lenguaje (en una línea, varias...). + +// Esto es un comentario de una línea + +/* +Esto es un comentario +de varias líneas +*/ + +// - Crea una variable (y una constante si el lenguaje lo soporta). +let myVariable: string = "Mi variable"; +const MY_CONSTANT: string = "Mi constante"; + +// - Crea variables representando todos los tipos de datos primitivos del lenguaje (cadenas de texto, enteros, booleanos...). +let myString: string = "Cadena de texto"; +let myNumber: number = 10; +let myBoolean: boolean = true; +let myNull: null = null; +let myUndefined: undefined = undefined; +let mySymbol: symbol = Symbol("mi simbolo"); +let myBigInt: bigint = 9007199254740991n; + + +// - Imprime por terminal el texto: "¡Hola, [y el nombre de tu lenguaje]!" +console.log("¡Hola, TypeScript!"); From 98eb95d8d278f83e5e015a58b03c751c5b3d3005 Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 07:58:22 -0500 Subject: [PATCH 10/38] #00 - SQL --- .../sql/mysterio-wil.sql | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/sql/mysterio-wil.sql diff --git a/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/sql/mysterio-wil.sql b/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/sql/mysterio-wil.sql new file mode 100644 index 0000000000..215ff699c1 --- /dev/null +++ b/Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/sql/mysterio-wil.sql @@ -0,0 +1,36 @@ +-- EJERCICIO: +-- - Crea un comentario en el código y coloca la URL del sitio web oficial del lenguaje de programación que has seleccionado. +-- No hay un único sitio web oficial para SQL, ya que es un estándar, pero un buen recurso es: https://www.iso.org/standard/63555.html + +-- - Representa las diferentes sintaxis que existen de crear comentarios en el lenguaje (en una línea, varias...). + +-- Esto es un comentario de una línea + +/* +Esto es un comentario +de varias líneas. +*/ + +-- - Crea una variable (y una constante si el lenguaje lo soporta). +-- La sintaxis para variables depende del dialecto de SQL (T-SQL, PL/SQL, etc.). +-- Ejemplo en T-SQL (SQL Server): +DECLARE @my_variable VARCHAR(20) = 'Mi variable'; + +-- SQL no tiene un concepto de constante como otros lenguajes, pero se puede usar un valor literal. + +-- - Crea variables representando todos los tipos de datos primitivos del lenguaje (cadenas de texto, enteros, booleanos...). +-- En SQL, más que variables, se definen columnas en tablas con tipos de datos. +-- Ejemplo de creación de una tabla para mostrar los tipos: +/* +CREATE TABLE TiposDeDatos ( + columna_varchar VARCHAR(255), -- Cadena de texto + columna_int INT, -- Entero + columna_decimal DECIMAL(10, 2),-- Decimal + columna_boolean BOOLEAN, -- Booleano (la disponibilidad varía) + columna_date DATE -- Fecha +); +*/ + +-- - Imprime por terminal el texto: "¡Hola, [y el nombre de tu lenguaje]!" +-- La forma estándar de devolver un valor o "imprimir" es con una sentencia SELECT. +SELECT '¡Hola, SQL!'; From 7809f68e3a738e418ef8ea1d0cbacf25cede206c Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 09:28:03 -0500 Subject: [PATCH 11/38] #01 - Python --- .../python/mysterio-wil.py | 117 ++++++++++++++++++ 1 file changed, 117 insertions(+) create mode 100644 Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/python/mysterio-wil.py diff --git a/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/python/mysterio-wil.py b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/python/mysterio-wil.py new file mode 100644 index 0000000000..ceacd212bf --- /dev/null +++ b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/python/mysterio-wil.py @@ -0,0 +1,117 @@ +# EJERCICIO: +# - Crea ejemplos utilizando todos los tipos de operadores de tu lenguaje: Aritméticos, lógicos, de comparación, asignación, dentidad, pertenencia, bits... (Ten en cuenta que cada lenguaje puede poseer unos diferentes) + +print("### OPERADORES ###") + +# Operadores Aritméticos +print("\n--- Aritméticos ---") +a = 10 +b = 3 +print(f"Suma: 10 + 3 = {a + b}") +print(f"Resta: 10 - 3 = {a - b}") +print(f"Multiplicación: 10 * 3 = {a * b}") +print(f"División: 10 / 3 = {a / b}") +print(f"Módulo: 10 % 3 = {a % b}") +print(f"Exponenciación: 10 ** 3 = {a ** b}") +print(f"División entera: 10 // 3 = {a // b}") + +# Operadores Lógicos +print("\n--- Lógicos ---") +print(f"AND (True and False): {True and False}") +print(f"OR (True or False): {True or False}") +print(f"NOT (not True): {not True}") + +# Operadores de Comparación +print("\n--- Comparación ---") +print(f"Igualdad (10 == 3): {10 == 3}") +print(f"Desigualdad (10 != 3): {10 != 3}") +print(f"Mayor que (10 > 3): {10 > 3}") +print(f"Menor que (10 < 3): {10 < 3}") +print(f"Mayor o igual que (10 >= 10): {10 >= 10}") +print(f"Menor o igual que (10 <= 3): {10 <= 3}") + +# Operadores de Asignación +print("\n--- Asignación ---") +x = 5 +print(f"Asignación simple: x = {x}") +x += 2 +print(f"Suma y asignación: x += 2 -> x = {x}") +x -= 1 +print(f"Resta y asignación: x -= 1 -> x = {x}") +x *= 3 +print(f"Multiplicación y asignación: x *= 3 -> x = {x}") +x /= 2 +print(f"División y asignación: x /= 2 -> x = {x}") + +# Operadores de Identidad +print("\n--- Identidad ---") +y = x +z = 5.0 +print(f"is (x is y): {x is y}") +print(f"is not (x is not z): {x is not z}") + +# Operadores de Pertenencia +print("\n--- Pertenencia ---") +lista = [1, 2, 3, 4, 5] +print(f"in (3 in lista): {3 in lista}") +print(f"not in (6 not in lista): {6 not in lista}") + +# Operadores de Bits +print("\n--- Bits ---") +p = 10 # 1010 +q = 3 # 0011 +print(f"AND a nivel de bits (10 & 3): {p & q}") +print(f"OR a nivel de bits (10 | 3): {p | q}") +print(f"XOR a nivel de bits (10 ^ 3): {p ^ q}") +print(f"NOT a nivel de bits (~10): {~p}") +print(f"Desplazamiento a la izquierda (10 << 2): {p << 2}") +print(f"Desplazamiento a la derecha (10 >> 1): {p >> 1}") + +# - 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... + +print("\n### ESTRUCTURAS DE CONTROL ###") + +# Condicionales +print("\n--- Condicionales (if, elif, else) ---") +edad = 18 +if edad < 18: + print("Eres menor de edad.") +elif edad == 18: + print("Tienes 18 años.") +else: + print("Eres mayor de edad.") + +# Iterativas +print("\n--- Iterativas (for) ---") +print("Imprimiendo números del 1 al 3:") +for i in range(1, 4): + print(i) + +print("\n--- Iterativas (while) ---") +contador = 3 +print("Cuenta regresiva desde 3:") +while contador > 0: + print(contador) + contador -= 1 + +# Excepciones +print("\n--- Excepciones (try, except, finally) ---") +try: + resultado = 10 / 0 +except ZeroDivisionError as e: + print(f"Se intentó dividir por cero. Error: {e}") +finally: + print("Este bloque (finally) se ejecuta siempre.") + +# - Debes hacer print por consola del resultado de todos los ejemplos. +# (Esta instrucción se cumple a lo largo de todo el código) + +# 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. + +print("\n### DIFICULTAD EXTRA ###") +print("Números entre 10 y 55, pares, no 16 y no múltiplos de 3:") +for numero in range(10, 56): + if numero % 2 == 0 and numero != 16 and numero % 3 != 0: + print(numero) From 7086c4f08f1f06fb16678624e28e9b5272a44356 Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 09:28:13 -0500 Subject: [PATCH 12/38] #01 - JavaScript --- .../javascript/mysterio-wil.js | 114 ++++++++++++++++++ 1 file changed, 114 insertions(+) create mode 100644 Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/javascript/mysterio-wil.js diff --git a/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/javascript/mysterio-wil.js b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/javascript/mysterio-wil.js new file mode 100644 index 0000000000..ec56e0a368 --- /dev/null +++ b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/javascript/mysterio-wil.js @@ -0,0 +1,114 @@ +/* + * 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) + */ + +console.log("### OPERADORES ###"); + +// Operadores Aritméticos +console.log("\n--- Aritméticos ---"); +let a = 10; +let b = 3; +console.log(`Suma: 10 + 3 = ${a + b}`); +console.log(`Resta: 10 - 3 = ${a - b}`); +console.log(`Multiplicación: 10 * 3 = ${a * b}`); +console.log(`División: 10 / 3 = ${a / b}`); +console.log(`Módulo: 10 % 3 = ${a % b}`); +console.log(`Exponenciación: 10 ** 3 = ${a ** b}`); + +// Operadores Lógicos +console.log("\n--- Lógicos ---"); +console.log(`AND (true && false): ${true && false}`); +console.log(`OR (true || false): ${true || false}`); +console.log(`NOT (!true): ${!true}`); + +// Operadores de Comparación +console.log("\n--- Comparación ---"); +console.log(`Igualdad (10 == '10'): ${10 == '10'}`); // Compara valor +console.log(`Igualdad Estricta (10 === '10'): ${10 === '10'}`); // Compara valor y tipo +console.log(`Desigualdad (10 != '10'): ${10 != '10'}`); +console.log(`Desigualdad Estricta (10 !== '10'): ${10 !== '10'}`); +console.log(`Mayor que (10 > 3): ${10 > 3}`); + +// Operadores de Asignación +console.log("\n--- Asignación ---"); +let x = 5; +console.log(`Asignación simple: x = ${x}`); +x += 2; +console.log(`Suma y asignación: x += 2 -> x = ${x}`); + +// Operadores de Identidad (ya vistos con === y !==) + +// Operadores de Pertenencia +console.log("\n--- Pertenencia ---"); +const arr = [1, 2, 3]; +const obj = { a: 1, b: 2 }; +console.log(`in para arrays (2 in arr): ${2 in arr}`); // true, busca el índice +console.log(`in para objetos ('a' in obj): ${'a' in obj}`); // true, busca la propiedad + +// Operadores de Bits +console.log("\n--- Bits ---"); +let p = 10; // 1010 +let q = 3; // 0011 +console.log(`AND a nivel de bits (10 & 3): ${p & q}`); +console.log(`OR a nivel de bits (10 | 3): ${p | q}`); + +/* + * - 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... + */ + +console.log("\n### ESTRUCTURAS DE CONTROL ###"); + +// Condicionales +console.log("\n--- Condicionales (if, else if, else) ---"); +let edad = 18; +if (edad < 18) { + console.log("Eres menor de edad."); +} else if (edad === 18) { + console.log("Tienes 18 años."); +} else { + console.log("Eres mayor de edad."); +} + +// Iterativas +console.log("\n--- Iterativas (for) ---"); +for (let i = 1; i <= 3; i++) { + console.log(i); +} + +console.log("\n--- Iterativas (while) ---"); +let contador = 3; +while (contador > 0) { + console.log(contador); + contador--; +} + +// Excepciones +console.log("\n--- Excepciones (try, catch, finally) ---"); +try { + let resultado = 10 / 0; + if (resultado === Infinity) throw new Error("División por cero produce Infinity"); +} catch (e) { + console.log(`Se capturó un error: ${e.message}`); +} finally { + console.log("Este bloque (finally) se ejecuta siempre."); +} + +/* + * 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. + */ + +console.log("\n### DIFICULTAD EXTRA ###"); +console.log("Números entre 10 y 55, pares, no 16 y no múltiplos de 3:"); +for (let numero = 10; numero <= 55; numero++) { + if (numero % 2 === 0 && numero !== 16 && numero % 3 !== 0) { + console.log(numero); + } +} From c8586e3e31bd000be283a1d53de118f9fd156e8a Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 09:28:26 -0500 Subject: [PATCH 13/38] #01 - Java --- .../java/mysterio-wil.java | 112 ++++++++++++++++++ 1 file changed, 112 insertions(+) create mode 100644 Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/java/mysterio-wil.java diff --git a/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/java/mysterio-wil.java b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/java/mysterio-wil.java new file mode 100644 index 0000000000..9147242582 --- /dev/null +++ b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/java/mysterio-wil.java @@ -0,0 +1,112 @@ +/* + * 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) + */ + +// Nota: El nombre de la clase debe ser válido en Java. Usamos mysterio_wil. +public class mysterio_wil { + public static void main(String[] args) { + + System.out.println("### OPERADORES ###"); + + // Operadores Aritméticos + System.out.println("\n--- Aritméticos ---"); + int a = 10; + int b = 3; + System.out.println("Suma: 10 + 3 = " + (a + b)); + System.out.println("Resta: 10 - 3 = " + (a - b)); + System.out.println("Multiplicación: 10 * 3 = " + (a * b)); + System.out.println("División: 10 / 3 = " + (a / b)); + System.out.println("Módulo: 10 % 3 = " + (a % b)); + + // Operadores Lógicos + System.out.println("\n--- Lógicos ---"); + System.out.println("AND (true && false): " + (true && false)); + System.out.println("OR (true || false): " + (true || false)); + System.out.println("NOT (!true): " + (!true)); + + // Operadores de Comparación + System.out.println("\n--- Comparación ---"); + System.out.println("Igualdad (10 == 3): " + (10 == 3)); + System.out.println("Desigualdad (10 != 3): " + (10 != 3)); + System.out.println("Mayor que (10 > 3): " + (10 > 3)); + + // Operadores de Asignación + System.out.println("\n--- Asignación ---"); + int x = 5; + System.out.println("Asignación simple: x = " + x); + x += 2; + System.out.println("Suma y asignación: x += 2 -> x = " + x); + + // Operador de Pertenencia (instanceof) + System.out.println("\n--- Pertenencia (instanceof) ---"); + String texto = "Hola"; + System.out.println("¿'texto' es una instancia de String? " + (texto instanceof String)); + + // Operadores de Bits + System.out.println("\n--- Bits ---"); + int p = 10; // 1010 + int q = 3; // 0011 + System.out.println("AND a nivel de bits (10 & 3): " + (p & q)); + System.out.println("OR a nivel de bits (10 | 3): " + (p | q)); + + /* + * - 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... + */ + + System.out.println("\n### ESTRUCTURAS DE CONTROL ###"); + + // Condicionales + System.out.println("\n--- Condicionales (if, else if, else) ---"); + int edad = 18; + if (edad < 18) { + System.out.println("Eres menor de edad."); + } else if (edad == 18) { + System.out.println("Tienes 18 años."); + } else { + System.out.println("Eres mayor de edad."); + } + + // Iterativas + System.out.println("\n--- Iterativas (for) ---"); + for (int i = 1; i <= 3; i++) { + System.out.println(i); + } + + System.out.println("\n--- Iterativas (while) ---"); + int contador = 3; + while (contador > 0) { + System.out.println(contador); + contador--; + } + + // Excepciones + System.out.println("\n--- Excepciones (try, catch, finally) ---"); + try { + int resultado = 10 / 0; + } catch (ArithmeticException e) { + System.out.println("Se capturó una excepción aritmética: " + e.getMessage()); + } finally { + System.out.println("Este bloque (finally) se ejecuta siempre."); + } + + /* + * 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. + */ + + System.out.println("\n### DIFICULTAD EXTRA ###"); + System.out.println("Números entre 10 y 55, pares, no 16 y no móltiplos de 3:"); + for (int numero = 10; numero <= 55; numero++) { + if (numero % 2 == 0 && numero != 16 && numero % 3 != 0) { + System.out.println(numero); + } + } + } +} From b35926fa554bc9b1287c79e41c1095df9b5f338a Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 09:28:42 -0500 Subject: [PATCH 14/38] #01 - C++ --- .../c++/mysterio-wil.cpp | 101 ++++++++++++++++++ 1 file changed, 101 insertions(+) create mode 100644 Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/c++/mysterio-wil.cpp diff --git a/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/c++/mysterio-wil.cpp b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/c++/mysterio-wil.cpp new file mode 100644 index 0000000000..60e50140f5 --- /dev/null +++ b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/c++/mysterio-wil.cpp @@ -0,0 +1,101 @@ +/* + * 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) + */ + +#include +#include +#include + +int main() { + std::cout << "### OPERADORES ###" << std::endl; + + // Operadores Aritméticos + std::cout << "\n--- Aritméticos ---" << std::endl; + int a = 10, b = 3; + std::cout << "Suma: 10 + 3 = " << (a + b) << std::endl; + std::cout << "Resta: 10 - 3 = " << (a - b) << std::endl; + std::cout << "Multiplicación: 10 * 3 = " << (a * b) << std::endl; + std::cout << "División: 10 / 3 = " << (a / b) << std::endl; + std::cout << "Módulo: 10 % 3 = " << (a % b) << std::endl; + + // Operadores Lógicos + std::cout << "\n--- Lógicos ---" << std::endl; + std::cout << "AND (true && false): " << (true && false) << std::endl; + std::cout << "OR (true || false): " << (true || false) << std::endl; + std::cout << "NOT (!true): " << (!true) << std::endl; + + // Operadores de Comparación + std::cout << "\n--- Comparación ---" << std::endl; + std::cout << "Igualdad (10 == 3): " << (10 == 3) << std::endl; + std::cout << "Desigualdad (10 != 3): " << (10 != 3) << std::endl; + + // Operadores de Asignación + std::cout << "\n--- Asignación ---" << std::endl; + int x = 5; + x += 2; + std::cout << "Suma y asignación: x += 2 -> x = " << x << std::endl; + + // Operadores de Bits + std::cout << "\n--- Bits ---" << std::endl; + int p = 10; // 1010 + int q = 3; // 0011 + std::cout << "AND a nivel de bits (10 & 3): " << (p & q) << std::endl; + std::cout << "OR a nivel de bits (10 | 3): " << (p | q) << std::endl; + + /* + * - 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... + */ + + std::cout << "\n### ESTRUCTURAS DE CONTROL ###" << std::endl; + + // Condicionales + std::cout << "\n--- Condicionales (if, else) ---" << std::endl; + int edad = 18; + if (edad < 18) { + std::cout << "Eres menor de edad." << std::endl; + } else { + std::cout << "Eres mayor de edad." << std::endl; + } + + // Iterativas + std::cout << "\n--- Iterativas (for) ---" << std::endl; + for (int i = 1; i <= 3; ++i) { + std::cout << i << std::endl; + } + + std::cout << "\n--- Iterativas (while) ---" << std::endl; + int contador = 3; + while (contador > 0) { + std::cout << contador << std::endl; + contador--; + } + + // Excepciones + std::cout << "\n--- Excepciones (try, catch) ---" << std::endl; + try { + throw std::runtime_error("Este es un error de ejemplo"); + } catch (const std::exception& e) { + std::cout << "Se capturó una excepción: " << e.what() << std::endl; + } + + /* + * 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. + */ + + std::cout << "\n### DIFICULTAD EXTRA ###" << std::endl; + for (int numero = 10; numero <= 55; ++numero) { + if (numero % 2 == 0 && numero != 16 && numero % 3 != 0) { + std::cout << numero << std::endl; + } + } + + return 0; +} From 53e1410f6ade7014e2fc74363dbaec62148cab62 Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 09:28:50 -0500 Subject: [PATCH 15/38] #01 - PHP --- .../php/mysterio-wil.php | 97 +++++++++++++++++++ 1 file changed, 97 insertions(+) create mode 100644 Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/php/mysterio-wil.php diff --git a/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/php/mysterio-wil.php b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/php/mysterio-wil.php new file mode 100644 index 0000000000..00cee8bb8c --- /dev/null +++ b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/php/mysterio-wil.php @@ -0,0 +1,97 @@ + x = $x\n"; + +// Operadores de Bits +echo "\n--- Bits ---\n"; +$p = 10; // 1010 +$q = 3; // 0011 +echo "AND a nivel de bits (10 & 3): " . ($p & $q) . "\n"; +echo "OR a nivel de bits (10 | 3): " . ($p | $q) . "\n"; + +/* + * - 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... + */ + +echo "\n### ESTRUCTURAS DE CONTROL ###\n"; + +// Condicionales +echo "\n--- Condicionales (if, else) ---\n"; +$edad = 18; +if ($edad < 18) { + echo "Eres menor de edad.\n"; +} else { + echo "Eres mayor de edad.\n"; +} + +// Iterativas +echo "\n--- Iterativas (for) ---\n"; +for ($i = 1; $i <= 3; $i++) { + echo $i . "\n"; +} + +echo "\n--- Iterativas (while) ---\n"; +$contador = 3; +while ($contador > 0) { + echo $contador . "\n"; + $contador--; +} + +// Excepciones +echo "\n--- Excepciones (try, catch) ---\n"; +try { + throw new Exception("Este es un error de ejemplo"); +} catch (Exception $e) { + echo "Se capturó una excepción: " . $e->getMessage() . "\n"; +} + +/* + * 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. + */ + +echo "\n### DIFICULTAD EXTRA ###\n"; +for ($numero = 10; $numero <= 55; $numero++) { + if ($numero % 2 == 0 && $numero != 16 && $numero % 3 != 0) { + echo $numero . "\n"; + } +} + +?> From a66b3712e8aaf88ca0d4f81e1f7509217d358750 Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 09:28:58 -0500 Subject: [PATCH 16/38] #01 - C# --- .../c#/mysterio-wil.cs | 99 +++++++++++++++++++ 1 file changed, 99 insertions(+) create mode 100644 Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/c#/mysterio-wil.cs diff --git a/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/c#/mysterio-wil.cs b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/c#/mysterio-wil.cs new file mode 100644 index 0000000000..e1bfb1abc0 --- /dev/null +++ b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/c#/mysterio-wil.cs @@ -0,0 +1,99 @@ +/* + * 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) + */ + +using System; + +public class MysterioWil { + public static void Main(string[] args) { + Console.WriteLine("### OPERADORES ###"); + + // Operadores Aritméticos + Console.WriteLine("\n--- Aritméticos ---"); + int a = 10, b = 3; + Console.WriteLine($"Suma: 10 + 3 = {a + b}"); + Console.WriteLine($"Resta: 10 - 3 = {a - b}"); + Console.WriteLine($"Multiplicación: 10 * 3 = {a * b}"); + Console.WriteLine($"División: 10 / 3 = {a / b}"); + Console.WriteLine($"Módulo: 10 % 3 = {a % b}"); + + // Operadores Lógicos + Console.WriteLine("\n--- Lógicos ---"); + Console.WriteLine($"AND (true && false): {true && false}"); + Console.WriteLine($"OR (true || false): {true || false}"); + Console.WriteLine($"NOT (!true): {!true}"); + + // Operadores de Comparación + Console.WriteLine("\n--- Comparación ---"); + Console.WriteLine($"Igualdad (10 == 3): {10 == 3}"); + Console.WriteLine($"Desigualdad (10 != 3): {10 != 3}"); + + // Operadores de Asignación + Console.WriteLine("\n--- Asignación ---"); + int x = 5; + x += 2; + Console.WriteLine($"Suma y asignación: x += 2 -> x = {x}"); + + // Operadores de Bits + Console.WriteLine("\n--- Bits ---"); + int p = 10; // 1010 + int q = 3; // 0011 + Console.WriteLine($"AND a nivel de bits (10 & 3): {p & q}"); + Console.WriteLine($"OR a nivel de bits (10 | 3): {p | q}"); + + /* + * - 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... + */ + + Console.WriteLine("\n### ESTRUCTURAS DE CONTROL ###"); + + // Condicionales + Console.WriteLine("\n--- Condicionales (if, else) ---"); + int edad = 18; + if (edad < 18) { + Console.WriteLine("Eres menor de edad."); + } else { + Console.WriteLine("Eres mayor de edad."); + } + + // Iterativas + Console.WriteLine("\n--- Iterativas (for) ---"); + for (int i = 1; i <= 3; i++) { + Console.WriteLine(i); + } + + Console.WriteLine("\n--- Iterativas (while) ---"); + int contador = 3; + while (contador > 0) { + Console.WriteLine(contador); + contador--; + } + + // Excepciones + Console.WriteLine("\n--- Excepciones (try, catch) ---"); + try { + int div = 10 / int.Parse("0"); + } catch (DivideByZeroException e) { + Console.WriteLine($"Se capturó una excepción: {e.Message}"); + } + + /* + * 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. + */ + + Console.WriteLine("\n### DIFICULTAD EXTRA ###"); + for (int numero = 10; numero <= 55; numero++) { + if (numero % 2 == 0 && numero != 16 && numero % 3 != 0) { + Console.WriteLine(numero); + } + } + } +} From 91d72b19389230ab8677df1622579fbcdfe64107 Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 09:29:08 -0500 Subject: [PATCH 17/38] #01 - Go --- .../go/mysterio-wil.go | 102 ++++++++++++++++++ 1 file changed, 102 insertions(+) create mode 100644 Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/go/mysterio-wil.go diff --git a/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/go/mysterio-wil.go b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/go/mysterio-wil.go new file mode 100644 index 0000000000..5f661e5397 --- /dev/null +++ b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/go/mysterio-wil.go @@ -0,0 +1,102 @@ +/* + * 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) + */ + +package main + +import "fmt" + +func main() { + fmt.Println("### OPERADORES ###") + + // Operadores Aritméticos + fmt.Println("\n--- Aritméticos ---") + a, b := 10, 3 + fmt.Printf("Suma: 10 + 3 = %d\n", a+b) + fmt.Printf("Resta: 10 - 3 = %d\n", a-b) + fmt.Printf("Multiplicación: 10 * 3 = %d\n", a*b) + fmt.Printf("División: 10 / 3 = %d\n", a/b) + fmt.Printf("Módulo: 10 %% 3 = %d\n", a%b) + + // Operadores Lógicos + fmt.Println("\n--- Lógicos ---") + fmt.Printf("AND (true && false): %t\n", true && false) + fmt.Printf("OR (true || false): %t\n", true || false) + fmt.Printf("NOT (!true): %t\n", !true) + + // Operadores de Comparación + fmt.Println("\n--- Comparación ---") + fmt.Printf("Igualdad (10 == 3): %t\n", 10 == 3) + fmt.Printf("Desigualdad (10 != 3): %t\n", 10 != 3) + + // Operadores de Asignación + fmt.Println("\n--- Asignación ---") + x := 5 + x += 2 + fmt.Printf("Suma y asignación: x += 2 -> x = %d\n", x) + + // Operadores de Bits + fmt.Println("\n--- Bits ---") + p, q := 10, 3 // 1010, 0011 + fmt.Printf("AND a nivel de bits (10 & 3): %d\n", p&q) + fmt.Printf("OR a nivel de bits (10 | 3): %d\n", p|q) + + /* + * - 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... + */ + + fmt.Println("\n### ESTRUCTURAS DE CONTROL ###") + + // Condicionales + fmt.Println("\n--- Condicionales (if, else) ---") + edad := 18 + if edad < 18 { + fmt.Println("Eres menor de edad.") + } else { + fmt.Println("Eres mayor de edad.") + } + + // Iterativas (Go solo tiene `for`) + fmt.Println("\n--- Iterativas (for) ---") + for i := 1; i <= 3; i++ { + fmt.Println(i) + } + + fmt.Println("\n--- Iterativas (for como while) ---") + contador := 3 + for contador > 0 { + fmt.Println(contador) + contador-- + } + + // Manejo de errores (defer, panic, recover) + fmt.Println("\n--- Manejo de errores ---") + func() { + defer func() { + if r := recover(); r != nil { + fmt.Printf("Se recuperó de un pánico: %v\n", r) + } + }() + panic("Este es un pánico de ejemplo") + }() + fmt.Println("El programa continúa después del pánico.") + + /* + * 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. + */ + + fmt.Println("\n### DIFICULTAD EXTRA ###") + for numero := 10; numero <= 55; numero++ { + if numero%2 == 0 && numero != 16 && numero%3 != 0 { + fmt.Println(numero) + } + } +} From ac9e8b4fcba1c523b21f595cbc165e4f829a0ae1 Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 09:29:15 -0500 Subject: [PATCH 18/38] #01 - Swift --- .../swift/mysterio-wil.swift | 109 ++++++++++++++++++ 1 file changed, 109 insertions(+) create mode 100644 Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/swift/mysterio-wil.swift diff --git a/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/swift/mysterio-wil.swift b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/swift/mysterio-wil.swift new file mode 100644 index 0000000000..0e0564aa55 --- /dev/null +++ b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/swift/mysterio-wil.swift @@ -0,0 +1,109 @@ +/* + * 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) + */ + +import Foundation + +print("### OPERADORES ###") + +// Operadores Aritméticos +print("\n--- Aritméticos ---") +let a = 10 +let b = 3 +print("Suma: 10 + 3 = \(a + b)") +print("Resta: 10 - 3 = \(a - b)") +print("Multiplicación: 10 * 3 = \(a * b)") +print("División: 10 / 3 = \(a / b)") +print("Módulo: 10 % 3 = \(a % b)") + +// Operadores Lógicos +print("\n--- Lógicos ---") +print("AND (true && false): \(true && false)") +print("OR (true || false): \(true || false)") +print("NOT (!true): \(!true)") + +// Operadores de Comparación +print("\n--- Comparación ---") +print("Igualdad (10 == 3): \(10 == 3)") +print("Desigualdad (10 != 3): \(10 != 3)") + +// Operadores de Asignación +print("\n--- Asignación ---") +var x = 5 +x += 2 +print("Suma y asignación: x += 2 -> x = \(x)") + +// Operador de Pertenencia (rangos) +print("\n--- Pertenencia (Rangos) ---") +let rango = 1...5 +print("¿El rango 1...5 contiene 3? \(rango.contains(3))") + +// Operadores de Bits +print("\n--- Bits ---") +let p: UInt8 = 10 // 00001010 +let q: UInt8 = 3 // 00000011 +print("AND a nivel de bits (10 & 3): \(p & q)") +print("OR a nivel de bits (10 | 3): \(p | q)") + +/* + * - 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... + */ + +print("\n### ESTRUCTURAS DE CONTROL ###") + +// Condicionales +print("\n--- Condicionales (if, else) ---") +let edad = 18 +if edad < 18 { + print("Eres menor de edad.") +} else { + print("Eres mayor de edad.") +} + +// Iterativas +print("\n--- Iterativas (for-in) ---") +for i in 1...3 { + print(i) +} + +print("\n--- Iterativas (while) ---") +var contador = 3 +while contador > 0 { + print(contador) + contador -= 1 +} + +// Manejo de errores +print("\n--- Manejo de errores (do, try, catch) ---") +enum MiError: Error { + case errorDeEjemplo +} + +func puedeLanzarError() throws { + throw MiError.errorDeEjemplo +} + +do { + try puedeLanzarError() +} catch { + print("Se capturó un error: \(error)") +} + +/* + * 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. + */ + +print("\n### DIFICULTAD EXTRA ###") +for numero in 10...55 { + if numero % 2 == 0 && numero != 16 && numero % 3 != 0 { + print(numero) + } +} From 419272c2b5f017c2b0ad2bd69f1d8235214ae2eb Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 09:29:30 -0500 Subject: [PATCH 19/38] #01 - TypeScript --- .../typescript/mysterio-wil.ts | 96 +++++++++++++++++++ 1 file changed, 96 insertions(+) create mode 100644 Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/mysterio-wil.ts diff --git a/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/mysterio-wil.ts b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/mysterio-wil.ts new file mode 100644 index 0000000000..ff3f8805dc --- /dev/null +++ b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/typescript/mysterio-wil.ts @@ -0,0 +1,96 @@ +/* + * 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) + */ + +console.log("### OPERADORES ###"); + +// Operadores Aritméticos +console.log("\n--- Aritméticos ---"); +let a: number = 10; +let b: number = 3; +console.log(`Suma: 10 + 3 = ${a + b}`); +console.log(`Resta: 10 - 3 = ${a - b}`); +console.log(`Multiplicación: 10 * 3 = ${a * b}`); +console.log(`División: 10 / 3 = ${a / b}`); +console.log(`Módulo: 10 % 3 = ${a % b}`); + +// Operadores Lógicos +console.log("\n--- Lógicos ---"); +console.log(`AND (true && false): ${true && false}`); +console.log(`OR (true || false): ${true || false}`); +console.log(`NOT (!true): ${!true}`); + +// Operadores de Comparación +console.log("\n--- Comparación ---"); +console.log(`Igualdad (10 == 10): ${10 == 10}`); +console.log(`Igualdad Estricta (10 === 10): ${10 === 10}`); + +// Operadores de Asignación +console.log("\n--- Asignación ---"); +let x: number = 5; +x += 2; +console.log(`Suma y asignación: x += 2 -> x = ${x}`); + +// Operadores de Bits +console.log("\n--- Bits ---"); +let p: number = 10; // 1010 +let q: number = 3; // 0011 +console.log(`AND a nivel de bits (10 & 3): ${p & q}`); +console.log(`OR a nivel de bits (10 | 3): ${p | q}`); + +/* + * - 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... + */ + +console.log("\n### ESTRUCTURAS DE CONTROL ###"); + +// Condicionales +console.log("\n--- Condicionales (if, else) ---"); +let edad: number = 18; +if (edad < 18) { + console.log("Eres menor de edad."); +} else { + console.log("Eres mayor de edad."); +} + +// Iterativas +console.log("\n--- Iterativas (for) ---"); +for (let i: number = 1; i <= 3; i++) { + console.log(i); +} + +console.log("\n--- Iterativas (while) ---"); +let contador: number = 3; +while (contador > 0) { + console.log(contador); + contador--; +} + +// Excepciones +console.log("\n--- Excepciones (try, catch) ---"); +try { + throw new Error("Este es un error de ejemplo"); +} catch (e) { + if (e instanceof Error) { + console.log(`Se capturó una excepción: ${e.message}`); + } +} + +/* + * 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. + */ + +console.log("\n### DIFICULTAD EXTRA ###"); +for (let numero: number = 10; numero <= 55; numero++) { + if (numero % 2 === 0 && numero !== 16 && numero % 3 !== 0) { + console.log(numero); + } +} From be1dfdafb7d792c5a986636e6258e72f1bb371db Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 09:29:40 -0500 Subject: [PATCH 20/38] #01 - Rust --- .../rust/mysterio-wil.rs | 111 ++++++++++++++++++ 1 file changed, 111 insertions(+) create mode 100644 Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/rust/mysterio-wil.rs diff --git a/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/rust/mysterio-wil.rs b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/rust/mysterio-wil.rs new file mode 100644 index 0000000000..7056faa33d --- /dev/null +++ b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/rust/mysterio-wil.rs @@ -0,0 +1,111 @@ +/* + * 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) + */ + +fn main() { + println!("### OPERADORES ###"); + + // Operadores Aritméticos + println!("\n--- Aritméticos ---"); + let (a, b) = (10, 3); + println!("Suma: 10 + 3 = {}", a + b); + println!("Resta: 10 - 3 = {}", a - b); + println!("Multiplicación: 10 * 3 = {}", a * b); + println!("División: 10 / 3 = {}", a / b); + println!("Módulo: 10 % 3 = {}", a % b); + + // Operadores Lógicos + println!("\n--- Lógicos ---"); + println!("AND (true && false): {}", true && false); + println!("OR (true || false): {}", true || false); + println!("NOT (!true): {}", !true); + + // Operadores de Comparación + println!("\n--- Comparación ---"); + println!("Igualdad (10 == 3): {}", 10 == 3); + println!("Desigualdad (10 != 3): {}", 10 != 3); + + // Operadores de Asignación + println!("\n--- Asignación ---"); + let mut x = 5; + x += 2; + println!("Suma y asignación: x += 2 -> x = {}", x); + + // Operadores de Bits + println!("\n--- Bits ---"); + let p = 10; // 1010 + let q = 3; // 0011 + println!("AND a nivel de bits (10 & 3): {}", p & q); + println!("OR a nivel de bits (10 | 3): {}", p | q); + + /* + * - 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... + */ + + println!("\n### ESTRUCTURAS DE CONTROL ###"); + + // Condicionales + println!("\n--- Condicionales (if, else) ---"); + let edad = 18; + if edad < 18 { + println!("Eres menor de edad."); + } else { + println!("Eres mayor de edad."); + } + + // Iterativas + println!("\n--- Iterativas (for) ---"); + for i in 1..=3 { + println!("{}", i); + } + + println!("\n--- Iterativas (while) ---"); + let mut contador = 3; + while contador > 0 { + println!("{}", contador); + contador -= 1; + } + + println!("\n--- Iterativas (loop) ---"); + let mut loop_contador = 0; + loop { + println!("Loop infinito (iteración {})", loop_contador); + if loop_contador == 1 { + break; + } + loop_contador += 1; + } + + // Manejo de errores (Result y Option) + println!("\n--- Manejo de errores (match con Result) ---"); + fn dividir(a: f64, b: f64) -> Result { + if b == 0.0 { + Err("No se puede dividir por cero".to_string()) + } else { + Ok(a / b) + } + } + match dividir(10.0, 0.0) { + Ok(resultado) => println!("Resultado: {}", resultado), + Err(e) => println!("Error: {}", e), + } + + /* + * 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. + */ + + println!("\n### DIFICULTAD EXTRA ###"); + for numero in 10..=55 { + if numero % 2 == 0 && numero != 16 && numero % 3 != 0 { + println!("{}", numero); + } + } +} From 73727058607a1500ce1ade6036524b045f7fdcb8 Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 09:29:53 -0500 Subject: [PATCH 21/38] #01 - Kotlin --- .../kotlin/mysterio-wil.kt | 109 ++++++++++++++++++ 1 file changed, 109 insertions(+) create mode 100644 Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/kotlin/mysterio-wil.kt diff --git a/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/kotlin/mysterio-wil.kt b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/kotlin/mysterio-wil.kt new file mode 100644 index 0000000000..135d4078eb --- /dev/null +++ b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/kotlin/mysterio-wil.kt @@ -0,0 +1,109 @@ +/* + * 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) + */ + +fun main() { + println("### OPERADORES ###") + + // Operadores Aritméticos + println("\n--- Aritméticos ---") + val a = 10 + val b = 3 + println("Suma: 10 + 3 = ${a + b}") + println("Resta: 10 - 3 = ${a - b}") + println("Multiplicación: 10 * 3 = ${a * b}") + println("División: 10 / 3 = ${a / b}") + println("Módulo: 10 % 3 = ${a % b}") + + // Operadores Lógicos + println("\n--- Lógicos ---") + println("AND (true && false): ${true && false}") + println("OR (true || false): ${true || false}") + println("NOT (!true): ${!true}") + + // Operadores de Comparación + println("\n--- Comparación ---") + println("Igualdad (10 == 3): ${10 == 3}") + println("Desigualdad (10 != 3): ${10 != 3}") + + // Operadores de Asignación + println("\n--- Asignación ---") + var x = 5 + x += 2 + println("Suma y asignación: x += 2 -> x = $x") + + // Operadores de Pertenencia + println("\n--- Pertenencia (in) ---") + val rango = 1..5 + println("¿El número 3 está en el rango 1..5? ${3 in rango}") + + // Operadores de Bits + println("\n--- Bits ---") + val p = 10 + val q = 3 + println("AND a nivel de bits (10 and 3): ${p and q}") + println("OR a nivel de bits (10 or 3): ${p or q}") + + /* + * - 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... + */ + + println("\n### ESTRUCTURAS DE CONTROL ###") + + // Condicionales + println("\n--- Condicionales (if, else) ---") + val edad = 18 + if (edad < 18) { + println("Eres menor de edad.") + } else { + println("Eres mayor de edad.") + } + + // When (similar a switch) + println("\n--- Condicionales (when) ---") + when (edad) { + in 0..17 -> println("Menor de edad (con when)") + 18 -> println("Justo 18 años (con when)") + else -> println("Mayor de edad (con when)") + } + + // Iterativas + println("\n--- Iterativas (for) ---") + for (i in 1..3) { + println(i) + } + + println("\n--- Iterativas (while) ---") + var contador = 3 + while (contador > 0) { + println(contador) + contador-- + } + + // Excepciones + println("\n--- Excepciones (try, catch) ---") + try { + val division = 10 / 0 + } catch (e: ArithmeticException) { + println("Se capturó una excepción: ${e.message}") + } + + /* + * 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. + */ + + println("\n### DIFICULTAD EXTRA ###") + for (numero in 10..55) { + if (numero % 2 == 0 && numero != 16 && numero % 3 != 0) { + println(numero) + } + } +} From 09a44fce7121c94c54bbf8a2ee43f1a1a2478b4e Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 09:30:06 -0500 Subject: [PATCH 22/38] #01 - Ruby --- .../ruby/mysterio-wil.rb | 101 ++++++++++++++++++ 1 file changed, 101 insertions(+) create mode 100644 Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/ruby/mysterio-wil.rb diff --git a/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/ruby/mysterio-wil.rb b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/ruby/mysterio-wil.rb new file mode 100644 index 0000000000..579eafddd3 --- /dev/null +++ b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/ruby/mysterio-wil.rb @@ -0,0 +1,101 @@ +# frozen_string_literal: true + +# +# 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) +# + +puts '### OPERADORES ###' + +# Operadores Aritméticos +puts "\n--- Aritméticos ---" +a = 10 +b = 3 +puts "Suma: 10 + 3 = #{a + b}" +puts "Resta: 10 - 3 = #{a - b}" +puts "Multiplicación: 10 * 3 = #{a * b}" +puts "División: 10 / 3 = #{a / b}" +puts "Módulo: 10 % 3 = #{a % b}" + +# Operadores Lógicos +puts "\n--- Lógicos ---" +puts "AND (true && false): #{true && false}" +puts "OR (true || false): #{true || false}" +puts "NOT (!true): #{!true}" + +# Operadores de Comparación +puts "\n--- Comparación ---" +puts "Igualdad (10 == 3): #{10 == 3}" +puts "Desigualdad (10 != 3): #{10 != 3}" + +# Operadores de Asignación +puts "\n--- Asignación ---" +x = 5 +x += 2 +puts "Suma y asignación: x += 2 -> x = #{x}" + +# Operador de Pertenencia (rangos) +puts "\n--- Pertenencia (Rangos) ---" +rango = (1..5) +puts "¿El rango 1..5 incluye 3? #{rango.include?(3)}" + +# Operadores de Bits +puts "\n--- Bits ---" +p = 10 # 1010 +q = 3 # 0011 +puts "AND a nivel de bits (10 & 3): #{p & q}" +puts "OR a nivel de bits (10 | 3): #{p | q}" + +# +# - 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... +# + +puts "\n### ESTRUCTURAS DE CONTROL ###" + +# Condicionales +puts "\n--- Condicionales (if, else) ---" +edad = 18 +if edad < 18 + puts 'Eres menor de edad.' +else + puts 'Eres mayor de edad.' +end + +# Iterativas +puts "\n--- Iterativas (for) ---" +(1..3).each do |i| + puts i +end + +puts "\n--- Iterativas (while) ---" +contador = 3 +while contador > 0 + puts contador + contador -= 1 +end + +# Excepciones +puts "\n--- Excepciones (begin, rescue) ---" +begin + raise 'Este es un error de ejemplo' +rescue StandardError => e + puts "Se capturó una excepción: #{e.message}" +end + +# +# 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. +# + +puts "\n### DIFICULTAD EXTRA ###" +(10..55).each do |numero| + if numero.even? && numero != 16 && (numero % 3 != 0) + puts numero + end +end From 7c79ca303ffa160b682e954681c2167634074fc4 Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 09:30:15 -0500 Subject: [PATCH 23/38] #01 - Dart --- .../dart/mysterio-wil.dart | 102 ++++++++++++++++++ 1 file changed, 102 insertions(+) create mode 100644 Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/dart/mysterio-wil.dart diff --git a/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/dart/mysterio-wil.dart b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/dart/mysterio-wil.dart new file mode 100644 index 0000000000..9ad91f7fae --- /dev/null +++ b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/dart/mysterio-wil.dart @@ -0,0 +1,102 @@ +/* + * 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) + */ + +void main() { + print("### OPERADORES ###"); + + // Operadores Aritméticos + print("\n--- Aritméticos ---"); + var a = 10; + var b = 3; + print("Suma: 10 + 3 = ${a + b}"); + print("Resta: 10 - 3 = ${a - b}"); + print("Multiplicación: 10 * 3 = ${a * b}"); + print("División: 10 / 3 = ${a / b}"); + print("División entera: 10 ~/ 3 = ${a ~/ b}"); + print("Módulo: 10 % 3 = ${a % b}"); + + // Operadores Lógicos + print("\n--- Lógicos ---"); + print("AND (true && false): ${true && false}"); + print("OR (true || false): ${true || false}"); + print("NOT (!true): ${!true}"); + + // Operadores de Comparación + print("\n--- Comparación ---"); + print("Igualdad (10 == 3): ${10 == 3}"); + print("Desigualdad (10 != 3): ${10 != 3}"); + + // Operadores de Asignación + print("\n--- Asignación ---"); + var x = 5; + x += 2; + print("Suma y asignación: x += 2 -> x = $x"); + + // Operador de tipo (is) + print("\n--- Pertenencia/Tipo (is) ---"); + var texto = "Hola"; + print("¿La variable 'texto' es un String? ${texto is String}"); + + // Operadores de Bits + print("\n--- Bits ---"); + var p = 10; // 1010 + var q = 3; // 0011 + print("AND a nivel de bits (10 & 3): ${p & q}"); + print("OR a nivel de bits (10 | 3): ${p | q}"); + + /* + * - 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... + */ + + print("\n### ESTRUCTURAS DE CONTROL ###"); + + // Condicionales + print("\n--- Condicionales (if, else) ---"); + var edad = 18; + if (edad < 18) { + print("Eres menor de edad."); + } else { + print("Eres mayor de edad."); + } + + // Iterativas + print("\n--- Iterativas (for) ---"); + for (var i = 1; i <= 3; i++) { + print(i); + } + + print("\n--- Iterativas (while) ---"); + var contador = 3; + while (contador > 0) { + print(contador); + contador--; + } + + // Excepciones + print("\n--- Excepciones (try, catch) ---"); + try { + throw Exception('Este es un error de ejemplo'); + } catch (e) { + print("Se capturó una excepción: $e"); + } + + /* + * 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. + */ + + print("\n### DIFICULTAD EXTRA ###"); + for (var numero = 10; numero <= 55; numero++) { + if (numero % 2 == 0 && numero != 16 && numero % 3 != 0) { + print(numero); + } + } +} From 18e7f6c65a52f05d0f2b81aafc821d5ed842abfb Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Sun, 28 Sep 2025 09:30:24 -0500 Subject: [PATCH 24/38] #01 - C --- .../c/mysterio-wil.c | 96 +++++++++++++++++++ 1 file changed, 96 insertions(+) create mode 100644 Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/c/mysterio-wil.c diff --git a/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/c/mysterio-wil.c b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/c/mysterio-wil.c new file mode 100644 index 0000000000..2a38cebe3f --- /dev/null +++ b/Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/c/mysterio-wil.c @@ -0,0 +1,96 @@ +/* + * 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) + */ + +#include +#include + +int main() { + printf("### OPERADORES ###\n"); + + // Operadores Aritméticos + printf("\n--- Aritméticos ---\n"); + int a = 10, b = 3; + printf("Suma: 10 + 3 = %d\n", a + b); + printf("Resta: 10 - 3 = %d\n", a - b); + printf("Multiplicación: 10 * 3 = %d\n", a * b); + printf("División: 10 / 3 = %d\n", a / b); + printf("Módulo: 10 %% 3 = %d\n", a %% b); + + // Operadores Lógicos + printf("\n--- Lógicos ---\n"); + printf("AND (true && false): %d\n", true && false); + printf("OR (true || false): %d\n", true || false); + printf("NOT (!true): %d\n", !true); + + // Operadores de Comparación + printf("\n--- Comparación ---\n"); + printf("Igualdad (10 == 3): %d\n", 10 == 3); + printf("Desigualdad (10 != 3): %d\n", 10 != 3); + + // Operadores de Asignación + printf("\n--- Asignación ---\n"); + int x = 5; + x += 2; + printf("Suma y asignación: x += 2 -> x = %d\n", x); + + // Operadores de Bits + printf("\n--- Bits ---\n"); + int p = 10; // 1010 + int q = 3; // 0011 + printf("AND a nivel de bits (10 & 3): %d\n", p & q); + printf("OR a nivel de bits (10 | 3): %d\n", p | q); + + /* + * - 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... + */ + + printf("\n### ESTRUCTURAS DE CONTROL ###\n"); + + // Condicionales + printf("\n--- Condicionales (if, else) ---\n"); + int edad = 18; + if (edad < 18) { + printf("Eres menor de edad.\n"); + } else { + printf("Eres mayor de edad.\n"); + } + + // Iterativas + printf("\n--- Iterativas (for) ---\n"); + for (int i = 1; i <= 3; i++) { + printf("%d\n", i); + } + + printf("\n--- Iterativas (while) ---\n"); + int contador = 3; + while (contador > 0) { + printf("%d\n", contador); + contador--; + } + + // Excepciones (C no tiene un sistema de excepciones try-catch) + printf("\n--- Excepciones ---\n"); + printf("C no tiene manejo de excepciones try-catch. El manejo de errores se hace usualmente devolviendo códigos de error.\n"); + + /* + * 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. + */ + + printf("\n### DIFICULTAD EXTRA ###\n"); + for (int numero = 10; numero <= 55; numero++) { + if (numero %% 2 == 0 && numero != 16 && numero %% 3 != 0) { + printf("%d\n", numero); + } + } + + return 0; +} From 8c3a42e4ec92ef653bc028b9315151ba11425673 Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Mon, 29 Sep 2025 12:19:04 -0500 Subject: [PATCH 25/38] #02 - C++ --- .../c++/mysterio-wil.cpp | 150 ++++++++++++++++++ 1 file changed, 150 insertions(+) create mode 100644 Roadmap/02 - FUNCIONES Y ALCANCE/c++/mysterio-wil.cpp diff --git a/Roadmap/02 - FUNCIONES Y ALCANCE/c++/mysterio-wil.cpp b/Roadmap/02 - FUNCIONES Y ALCANCE/c++/mysterio-wil.cpp new file mode 100644 index 0000000000..2622197ad6 --- /dev/null +++ b/Roadmap/02 - FUNCIONES Y ALCANCE/c++/mysterio-wil.cpp @@ -0,0 +1,150 @@ +#include +#include +#include +#include +#include + +/* + * EJERCICIO: + * - Crea ejemplos de funciones básicas que representen las diferentes + * posibilidades del lenguaje: + * Sin parámetros ni retorno, con uno o varios parámetros, con retorno... + * - Comprueba si puedes crear funciones dentro de funciones. + * - Utiliza algún ejemplo de funciones ya creadas en el lenguaje. + * - Pon a prueba el concepto de variable LOCAL y GLOBAL. + * - Debes hacer print por consola del resultado de todos los ejemplos. + * (y tener en cuenta que cada lenguaje puede poseer más o menos posibilidades) + * + * DIFICULTAD EXTRA (opcional): + * Crea una función que reciba dos parámetros de tipo cadena de texto y retorne un número. + * - La función imprime todos los números del 1 al 100. Teniendo en cuenta que: + * - Si el número es múltiplo de 3, muestra la cadena de texto del primer parámetro. + * - Si el número es múltiplo de 5, muestra la cadena de texto del segundo parámetro. + * - Si el número es múltiplo de 3 y de 5, muestra las dos cadenas de texto concatenadas. + * - La función retorna el número de veces que se ha impreso el número en lugar de los textos. + * + * Presta especial atención a la sintaxis que debes utilizar en cada uno de los casos. + * Cada lenguaje sigue una convenciones que debes de respetar para que el código se entienda. + */ + +// --- Declaraciones de funciones --- + +void greet(); +void greet_person(const std::string& name); +void add(int a, int b); +int multiply(int a, int b); +void greet_default(const std::string& name, const std::string& greeting = "Hola"); +void print_args(std::initializer_list args); +void outer_function(); +void my_function_scope(); +void modify_global(); +int fizz_buzz_extra(const std::string& text1, const std::string& text2); + +// --- Variable Global --- +std::string global_var = "Soy una variable global"; + +// --- Función Principal --- +int main() { + std::cout << "===> Funciones básicas <===\n"; + + greet(); + greet_person("Wilmer"); + add(5, 3); + int result = multiply(5, 3); + std::cout << "El resultado de la multiplicación es " << result << std::endl; + + greet_default("MoureDev"); + greet_default("Wilmer", "Hello"); + + std::cout << "Argumentos variables (initializer_list):\n"; + print_args({"uno", "dos", "tres"}); + + std::cout << "\n===> Funciones dentro de funciones (Lambdas) <===\n"; + outer_function(); + + std::cout << "\n===> Funciones de la Librería Estándar (STL) <===\n"; + std::vector my_list = {1, 2, 3, 4, 5}; + std::cout << "Usando el método size() de un vector: El vector tiene " << my_list.size() << " elementos." << std::endl; + auto max_it = std::max_element(my_list.begin(), my_list.end()); + std::cout << "Usando std::max_element: El valor máximo es " << *max_it << std::endl; + + std::cout << "\n===> Variable LOCAL y GLOBAL <===\n"; + my_function_scope(); + + std::cout << "Antes de modificar: " << global_var << std::endl; + modify_global(); + std::cout << "Después de modificar: " << global_var << std::endl; + + std::cout << "\n====> DIFICULTAD EXTRA <====\n"; + int times_printed_number = fizz_buzz_extra("Fizz", "Buzz"); + std::cout << "\nEl número se imprimió un total de " << times_printed_number << " veces." << std::endl; + + return 0; +} + +// --- Definiciones de funciones --- + +void greet() { + std::cout << "Hola, C++!\n"; +} + +void greet_person(const std::string& name) { + std::cout << "Hola, " << name << "!\n"; +} + +void add(int a, int b) { + std::cout << "La suma de " << a << " y " << b << " es " << a + b << std::endl; +} + +int multiply(int a, int b) { + return a * b; +} + +void greet_default(const std::string& name, const std::string& greeting) { + std::cout << greeting << ", " << name << "!\n"; +} + +void print_args(std::initializer_list args) { + for (const auto& arg : args) { + std::cout << "- " << arg << "\n"; + } +} + +void outer_function() { + std::cout << "Esta es la función externa.\n"; + // C++ usa lambdas para funciones anónimas locales. + auto inner_function = []() { + std::cout << "Esta es una función lambda (interna).\n"; + }; + inner_function(); +} + +void my_function_scope() { + std::string local_var = "Soy una variable local"; + std::cout << global_var << std::endl; + std::cout << local_var << std::endl; +} + +void modify_global() { + global_var = "He modificado la variable global"; +} + +int fizz_buzz_extra(const std::string& text1, const std::string& text2) { + int count = 0; + for (int i = 1; i <= 100; ++i) { + std::string output = ""; + if (i % 3 == 0) { + output += text1; + } + if (i % 5 == 0) { + output += text2; + } + if (!output.empty()) { + std::cout << output << "\n"; + } else { + std::cout << i << "\n"; + count++; + } + } + return count; +} From 66eb2ad7c02d856d50e86b0875ebf11033811e12 Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Mon, 29 Sep 2025 12:30:56 -0500 Subject: [PATCH 26/38] #02 - C# --- .../c#/mysterio-wil.cs | 172 ++++++++++++++++++ 1 file changed, 172 insertions(+) create mode 100644 Roadmap/02 - FUNCIONES Y ALCANCE/c#/mysterio-wil.cs diff --git a/Roadmap/02 - FUNCIONES Y ALCANCE/c#/mysterio-wil.cs b/Roadmap/02 - FUNCIONES Y ALCANCE/c#/mysterio-wil.cs new file mode 100644 index 0000000000..1e32231d33 --- /dev/null +++ b/Roadmap/02 - FUNCIONES Y ALCANCE/c#/mysterio-wil.cs @@ -0,0 +1,172 @@ +using System; +using System.Collections.Generic; +using System.Linq; + +/* + * EJERCICIO: + * - Crea ejemplos de funciones básicas que representen las diferentes + * posibilidades del lenguaje: + * Sin parámetros ni retorno, con uno o varios parámetros, con retorno... + * - Comprueba si puedes crear funciones dentro de funciones. + * - Utiliza algún ejemplo de funciones ya creadas en el lenguaje. + * - Pon a prueba el concepto de variable LOCAL y GLOBAL. + * - Debes hacer print por consola del resultado de todos los ejemplos. + * (y tener en cuenta que cada lenguaje puede poseer más o menos posibilidades) + * + * DIFICULTAD EXTRA (opcional): + * Crea una función que reciba dos parámetros de tipo cadena de texto y retorne un número. + * - La función imprime todos los números del 1 al 100. Teniendo en cuenta que: + * - Si el número es múltiplo de 3, muestra la cadena de texto del primer parámetro. + * - Si el número es múltiplo de 5, muestra la cadena de texto del segundo parámetro. + * - Si el número es múltiplo de 3 y de 5, muestra las dos cadenas de texto concatenadas. + * - La función retorna el número de veces que se ha impreso el número en lugar de los textos. + * + * Presta especial atención a la sintaxis que debes utilizar en cada uno de los casos. + * Cada lenguaje sigue una convenciones que debes de respetar para que el código se entienda. + */ + +namespace FuncionesYAlcance +{ + class Program + { + // --- Variable "Global" (campo estático en la clase) --- + private static string globalVar = "Soy una variable global"; + + static void Main(string[] args) + { + Console.WriteLine("===> Funciones básicas <==="); + + // Sin parámetros ni retorno + Greet(); + + // Con un parámetro + GreetPerson("Wilmer"); + + // Con varios parámetros + Add(5, 3); + + // Con retorno + int result = Multiply(5, 3); + Console.WriteLine($"El resultado de la multiplicación es {result}"); + + // Con parámetros por defecto + GreetDefault("MoureDev"); + GreetDefault("Wilmer", "Hello"); + + // Con parámetros de longitud variable (params) + PrintArgs(1, "texto", true, 12.34); + + + Console.WriteLine("\n===> Funciones dentro de funciones (Local Functions) <==="); + void OuterFunction() + { + Console.WriteLine("Esta es la función externa."); + void InnerFunction() + { + Console.WriteLine("Esta es la función interna."); + } + InnerFunction(); + } + OuterFunction(); + + + Console.WriteLine("\n===> Funciones del Framework .NET <==="); + var myList = new List { 1, 2, 3, 4, 5 }; + Console.WriteLine($"Usando la propiedad 'Count' de una Lista: La lista tiene {myList.Count} elementos."); + + // Se necesita using System.Linq + Console.WriteLine($"Usando el método de extensión Max() de LINQ: El valor máximo es {myList.Max()}"); + + + Console.WriteLine("\n===> Variable LOCAL y GLOBAL <==="); + MyFunctionScope(); + + // Modificar una variable global (campo estático) + Console.WriteLine($"Antes de modificar: {globalVar}"); + ModifyGlobal(); + Console.WriteLine($"Después de modificar: {globalVar}"); + + + /* + * DIFICULTAD EXTRA (opcional): + */ + Console.WriteLine("\n====> DIFICULTAD EXTRA <===="); + int timesPrintedNumber = FizzBuzzExtra("Fizz", "Buzz"); + Console.WriteLine($"\nEl número se imprimió un total de {timesPrintedNumber} veces."); + } + + // --- Definiciones de las funciones (métodos estáticos) --- + + static void Greet() + { + Console.WriteLine("Hola, C#! "); + } + + static void GreetPerson(string name) + { + Console.WriteLine($"Hola, {name}!"); + } + + static void Add(int a, int b) + { + Console.WriteLine($"La suma de {a} y {b} es {a + b}"); + } + + static int Multiply(int a, int b) + { + return a * b; + } + + static void GreetDefault(string name, string greeting = "Hola") + { + Console.WriteLine($"{greeting}, {name}!"); + } + + static void PrintArgs(params object[] args) + { + Console.WriteLine("Argumentos variables (params):"); + foreach (var arg in args) + { + Console.WriteLine($"- {arg}"); + } + } + + static void MyFunctionScope() + { + string localVar = "Soy una variable local"; + Console.WriteLine(globalVar); // Acceso a la variable "global" (campo estático) + Console.WriteLine(localVar); + } + + static void ModifyGlobal() + { + globalVar = "He modificado la variable global"; + } + + static int FizzBuzzExtra(string text1, string text2) + { + int count = 0; + for (int i = 1; i <= 100; i++) + { + bool isMultipleOf3 = (i % 3 == 0); + bool isMultipleOf5 = (i % 5 == 0); + + if (isMultipleOf3 && isMultipleOf5) + { + Console.WriteLine($"{text1}{text2}"); + } else if (isMultipleOf3) + { + Console.WriteLine(text1); + } else if (isMultipleOf5) + { + Console.WriteLine(text2); + } else + { + Console.WriteLine(i); + count++; + } + } + return count; + } + } +} From 37c073eeeb5764404331febb980d8f9d60ccdbd5 Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Mon, 29 Sep 2025 12:31:02 -0500 Subject: [PATCH 27/38] #02 - Dart --- .../dart/mysterio-wil.dart | 148 ++++++++++++++++++ 1 file changed, 148 insertions(+) create mode 100644 Roadmap/02 - FUNCIONES Y ALCANCE/dart/mysterio-wil.dart diff --git a/Roadmap/02 - FUNCIONES Y ALCANCE/dart/mysterio-wil.dart b/Roadmap/02 - FUNCIONES Y ALCANCE/dart/mysterio-wil.dart new file mode 100644 index 0000000000..8628162998 --- /dev/null +++ b/Roadmap/02 - FUNCIONES Y ALCANCE/dart/mysterio-wil.dart @@ -0,0 +1,148 @@ +import 'dart:math'; + +/* + * EJERCICIO: + * - Crea ejemplos de funciones básicas que representen las diferentes + * posibilidades del lenguaje: + * Sin parámetros ni retorno, con uno o varios parámetros, con retorno... + * - Comprueba si puedes crear funciones dentro de funciones. + * - Utiliza algún ejemplo de funciones ya creadas en el lenguaje. + * - Pon a prueba el concepto de variable LOCAL y GLOBAL. + * - Debes hacer print por consola del resultado de todos los ejemplos. + * (y tener en cuenta que cada lenguaje puede poseer más o menos posibilidades) + * + * DIFICULTAD EXTRA (opcional): + * Crea una función que reciba dos parámetros de tipo cadena de texto y retorne un número. + * - La función imprime todos los números del 1 al 100. Teniendo en cuenta que: + * - Si el número es múltiplo de 3, muestra la cadena de texto del primer parámetro. + * - Si el número es múltiplo de 5, muestra la cadena de texto del segundo parámetro. + * - Si el número es múltiplo de 3 y de 5, muestra las dos cadenas de texto concatenadas. + * - La función retorna el número de veces que se ha impreso el número en lugar de los textos. + * + * Presta especial atención a la sintaxis que debes utilizar en cada uno de los casos. + * Cada lenguaje sigue una convenciones que debes de respetar para que el código se entienda. + */ + +// --- Variable Global --- +String globalVar = "Soy una variable global"; + +void main() { + print("===> Funciones básicas <==="); + + // Sin parámetros ni retorno + greet(); + + // Con un parámetro + greetPerson("Wilmer"); + + // Con varios parámetros + add(5, 3); + + // Con retorno + int result = multiply(5, 3); + print("El resultado de la multiplicación es $result"); + + // Con parámetros por nombre y por defecto + greetDefault("MoureDev"); + greetDefault("Wilmer", greeting: "Hello"); + + // En Dart no hay una sintaxis para argumentos variables (variadic). + // Se suele usar una Lista. + print("Argumentos variables (pasando una Lista):"); + printArgs([1, "texto", true]); + + + print("\n===> Funciones dentro de funciones <==="); + outerFunction(); + + + print("\n===> Funciones del core de Dart <==="); + var myList = [1, 2, 3, 4, 5]; + print("Usando la propiedad 'length' de una Lista: La lista tiene ${myList.length} elementos."); + + // Usando reduce para encontrar el máximo (se necesita importar 'dart:math') + print("Usando 'reduce' de Iterable con la función 'max': El valor máximo es ${myList.reduce(max)}"); + + + print("\n===> Variable LOCAL y GLOBAL <==="); + myFunctionScope(); + + // Modificar una variable global + print("Antes de modificar: $globalVar"); + modifyGlobal(); + print("Después de modificar: $globalVar"); + + + /* + * DIFICULTAD EXTRA (opcional): + */ + print("\n====> DIFICULTAD EXTRA <===="); + int timesPrintedNumber = fizzBuzzExtra("Fizz", "Buzz"); + print("\nEl número se imprimió un total de $timesPrintedNumber veces."); +} + +// --- Definiciones de funciones --- + +void greet() { + print("Hola, Dart!"); +} + +void greetPerson(String name) { + print("Hola, $name!"); +} + +void add(int a, int b) { + print("La suma de $a y $b es ${a + b}"); +} + +int multiply(int a, int b) { + return a * b; +} + +void greetDefault(String name, {String greeting = "Hola"}) { + print("$greeting, $name!"); +} + +void printArgs(List args) { + for (var arg in args) { + print("- $arg"); + } +} + +void outerFunction() { + print("Esta es la función externa."); + void innerFunction() { + print("Esta es la función interna."); + } + innerFunction(); +} + +void myFunctionScope() { + String localVar = "Soy una variable local"; + print(globalVar); // Acceso a la variable global + print(localVar); +} + +void modifyGlobal() { + globalVar = "He modificado la variable global"; +} + +int fizzBuzzExtra(String text1, String text2) { + int count = 0; + for (int i = 1; i <= 100; i++) { + bool isMultipleOf3 = (i % 3 == 0); + bool isMultipleOf5 = (i % 5 == 0); + + if (isMultipleOf3 && isMultipleOf5) { + print("$text1$text2"); + } else if (isMultipleOf3) { + print(text1); + } else if (isMultipleOf5) { + print(text2); + } else { + print(i); + count++; + } + } + return count; +} From 9bb1c354f5de1e3469acfe7f54b755b4653a584a Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Mon, 29 Sep 2025 12:31:05 -0500 Subject: [PATCH 28/38] #02 - Go --- .../go/mysterio-wil.go | 168 ++++++++++++++++++ 1 file changed, 168 insertions(+) create mode 100644 Roadmap/02 - FUNCIONES Y ALCANCE/go/mysterio-wil.go diff --git a/Roadmap/02 - FUNCIONES Y ALCANCE/go/mysterio-wil.go b/Roadmap/02 - FUNCIONES Y ALCANCE/go/mysterio-wil.go new file mode 100644 index 0000000000..ec5024cf59 --- /dev/null +++ b/Roadmap/02 - FUNCIONES Y ALCANCE/go/mysterio-wil.go @@ -0,0 +1,168 @@ +package main + +import ( + "fmt" +) + +/* + * EJERCICIO: + * - Crea ejemplos de funciones básicas que representen las diferentes + * posibilidades del lenguaje: + * Sin parámetros ni retorno, con uno o varios parámetros, con retorno... + * - Comprueba si puedes crear funciones dentro de funciones. + * - Utiliza algún ejemplo de funciones ya creadas en el lenguaje. + * - Pon a prueba el concepto de variable LOCAL y GLOBAL. + * - Debes hacer print por consola del resultado de todos los ejemplos. + * (y tener en cuenta que cada lenguaje puede poseer más o menos posibilidades) + * + * DIFICULTAD EXTRA (opcional): + * Crea una función que reciba dos parámetros de tipo cadena de texto y retorne un número. + * - La función imprime todos los números del 1 al 100. Teniendo en cuenta que: + * - Si el número es múltiplo de 3, muestra la cadena de texto del primer parámetro. + * - Si el número es múltiplo de 5, muestra la cadena de texto del segundo parámetro. + * - Si el número es múltiplo de 3 y de 5, muestra las dos cadenas de texto concatenadas. + * - La función retorna el número de veces que se ha impreso el número en lugar de los textos. + * + * Presta especial atención a la sintaxis que debes utilizar en cada uno de los casos. + * Cada lenguaje sigue una convenciones que debes de respetar para que el código se entienda. + */ + +// --- Variable Global --- +var globalVar = "Soy una variable global" + +func main() { + fmt.Println("===> Funciones básicas <===") + + // Sin parámetros ni retorno + greet() + + // Con un parámetro + greetPerson("Wilmer") + + // Con varios parámetros + add(5, 3) + + // Con retorno + result := multiply(5, 3) + fmt.Printf("El resultado de la multiplicación es %d\n", result) + + // Con múltiples retornos (una característica de Go) + quotient, remainder := divide(10, 3) + fmt.Printf("10 dividido por 3 es %d con un resto de %d\n", quotient, remainder) + + // Go no tiene parámetros por defecto, se puede simular con structs o sobrecarga. + fmt.Println("Go no soporta parámetros por defecto.") + + // Con parámetros de longitud variable (variadic) + fmt.Println("Argumentos variables (variadic):") + printArgs(1, "texto", true, 15.5) + + + fmt.Println("\n===> Funciones dentro de funciones (Anonymous Functions) <===") + outerFunction() + + + fmt.Println("\n===> Funciones del lenguaje (built-in) <===") + myList := []int{1, 2, 3, 4, 5} + fmt.Printf("Usando la función len() en un slice: El slice tiene %d elementos.\n", len(myList)) + + // No hay una función max() para slices en la librería estándar, se debe implementar. + fmt.Printf("El valor máximo del slice es %d\n", findMax(myList)) + + + fmt.Println("\n===> Variable LOCAL y GLOBAL <===") + myFunctionScope() + + // Modificar una variable global + fmt.Printf("Antes de modificar: %s\n", globalVar) + modifyGlobal() + fmt.Printf("Después de modificar: %s\n", globalVar) + + + /* + * DIFICULTAD EXTRA (opcional): + */ + fmt.Println("\n====> DIFICULTAD EXTRA <====") + timesPrintedNumber := fizzBuzzExtra("Fizz", "Buzz") + fmt.Printf("\nEl número se imprimió un total de %d veces.\n", timesPrintedNumber) +} + +// --- Definiciones de funciones --- + +func greet() { + fmt.Println("Hola, Go!") +} + +func greetPerson(name string) { + fmt.Printf("Hola, %s!\n", name) +} + +func add(a, b int) { + fmt.Printf("La suma de %d y %d es %d\n", a, b, a+b) +} + +func multiply(a, b int) int { + return a * b +} + +func divide(a, b int) (int, int) { + return a / b, a % b +} + +func printArgs(args ...interface{}) { + for _, arg := range args { + fmt.Printf("- %v\n", arg) + } +} + +func outerFunction() { + fmt.Println("Esta es la función externa.") + // Go usa funciones anónimas para un comportamiento similar a funciones anidadas. + innerFunction := func() { + fmt.Println("Esta es una función anónima (interna).") + } + innerFunction() +} + +func findMax(numbers []int) int { + if len(numbers) == 0 { + return 0 // o retornar un error + } + maxVal := numbers[0] + for _, number := range numbers[1:] { + if number > maxVal { + maxVal = number + } + } + return maxVal +} + +func myFunctionScope() { + localVar := "Soy una variable local" + fmt.Println(globalVar) // Acceso a la variable global + fmt.Println(localVar) +} + +func modifyGlobal() { + globalVar = "He modificado la variable global" +} + +func fizzBuzzExtra(text1, text2 string) int { + count := 0 + for i := 1; i <= 100; i++ { + isMultipleOf3 := (i%3 == 0) + isMultipleOf5 := (i%5 == 0) + + if isMultipleOf3 && isMultipleOf5 { + fmt.Println(text1 + text2) + } else if isMultipleOf3 { + fmt.Println(text1) + } else if isMultipleOf5 { + fmt.Println(text2) + } else { + fmt.Println(i) + count++ + } + } + return count +} From f8e7b32afd12562f18c0dc29d3782c415cae9b3a Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Mon, 29 Sep 2025 12:31:09 -0500 Subject: [PATCH 29/38] #02 - Java --- .../java/mysterio-wil.java | 161 ++++++++++++++++++ 1 file changed, 161 insertions(+) create mode 100644 Roadmap/02 - FUNCIONES Y ALCANCE/java/mysterio-wil.java diff --git a/Roadmap/02 - FUNCIONES Y ALCANCE/java/mysterio-wil.java b/Roadmap/02 - FUNCIONES Y ALCANCE/java/mysterio-wil.java new file mode 100644 index 0000000000..289b6c7409 --- /dev/null +++ b/Roadmap/02 - FUNCIONES Y ALCANCE/java/mysterio-wil.java @@ -0,0 +1,161 @@ +import java.util.Arrays; +import java.util.Collections; +import java.util.List; + +/* + * EJERCICIO: + * - Crea ejemplos de funciones básicas que representen las diferentes + * posibilidades del lenguaje: + * Sin parámetros ni retorno, con uno o varios parámetros, con retorno... + * - Comprueba si puedes crear funciones dentro de funciones. + * - Utiliza algún ejemplo de funciones ya creadas en el lenguaje. + * - Pon a prueba el concepto de variable LOCAL y GLOBAL. + * - Debes hacer print por consola del resultado de todos los ejemplos. + * (y tener en cuenta que cada lenguaje puede poseer más o menos posibilidades) + * + * DIFICULTAD EXTRA (opcional): + * Crea una función que reciba dos parámetros de tipo cadena de texto y retorne un número. + * - La función imprime todos los números del 1 al 100. Teniendo en cuenta que: + * - Si el número es múltiplo de 3, muestra la cadena de texto del primer parámetro. + * - Si el número es múltiplo de 5, muestra la cadena de texto del segundo parámetro. + * - Si el número es múltiplo de 3 y de 5, muestra las dos cadenas de texto concatenadas. + * - La función retorna el número de veces que se ha impreso el número en lugar de los textos. + * + * Presta especial atención a la sintaxis que debes utilizar en cada uno de los casos. + * Cada lenguaje sigue una convenciones que debes de respetar para que el código se entienda. + */ + +public class mysterio_wil { + + // --- Variable "Global" (campo estático de la clase) --- + private static String globalVar = "Soy una variable global"; + + public static void main(String[] args) { + System.out.println("===> Funciones básicas <==="); + + // Sin parámetros ni retorno + greet(); + + // Con un parámetro + greetPerson("Wilmer"); + + // Con varios parámetros + add(5, 3); + + // Con retorno + int result = multiply(5, 3); + System.out.println("El resultado de la multiplicación es " + result); + + // Simulación de parámetros por defecto con sobrecarga de métodos + System.out.println("Java no tiene parámetros por defecto, se usa sobrecarga:"); + greetDefault("MoureDev"); + greetDefault("Wilmer", "Hello"); + + // Con parámetros de longitud variable (varargs) + System.out.println("Argumentos variables (varargs):"); + printArgs(1, "texto", true, 12.99); + + + System.out.println("\n===> Funciones dentro de funciones <==="); + System.out.println("Java no soporta funciones anidadas, pero tiene clases locales y anónimas."); + outerMethod(); + + + System.out.println("\n===> Funciones de la Librería Estándar de Java <==="); + List myList = Arrays.asList(1, 2, 3, 4, 5); + System.out.println("Usando el método size() de una Lista: La lista tiene " + myList.size() + " elementos."); + System.out.println("Usando Collections.max(): El valor máximo es " + Collections.max(myList)); + + + System.out.println("\n===> Variable LOCAL y GLOBAL <==="); + myFunctionScope(); + + // Modificar una variable global (campo estático) + System.out.println("Antes de modificar: " + globalVar); + modifyGlobal(); + System.out.println("Después de modificar: " + globalVar); + + + /* + * DIFICULTAD EXTRA (opcional): + */ + System.out.println("\n====> DIFICULTAD EXTRA <===="); + int timesPrintedNumber = fizzBuzzExtra("Fizz", "Buzz"); + System.out.println("\nEl número se imprimió un total de " + timesPrintedNumber + " veces."); + } + + // --- Definiciones de las funciones (métodos estáticos) --- + + static void greet() { + System.out.println("Hola, Java!"); + } + + static void greetPerson(String name) { + System.out.println("Hola, " + name + "!"); + } + + static void add(int a, int b) { + System.out.println("La suma de " + a + " y " + b + " es " + (a + b)); + } + + static int multiply(int a, int b) { + return a * b; + } + + // Sobrecarga para simular parámetro por defecto + static void greetDefault(String name) { + greetDefault(name, "Hola"); + } + + static void greetDefault(String name, String greeting) { + System.out.println(greeting + ", " + name + "!"); + } + + static void printArgs(Object... args) { + for (Object arg : args) { + System.out.println("- " + arg); + } + } + + static void outerMethod() { + System.out.println("Este es el método externo."); + // Clase local como ejemplo de anidamiento + class InnerClass { + void display() { + System.out.println("Este es un método en una clase local (interna)."); + } + } + InnerClass inner = new InnerClass(); + inner.display(); + } + + static void myFunctionScope() { + String localVar = "Soy una variable local"; + System.out.println(globalVar); // Acceso a la variable "global" (campo estático) + System.out.println(localVar); + } + + static void modifyGlobal() { + globalVar = "He modificado la variable global"; + } + + static int fizzBuzzExtra(String text1, String text2) { + int count = 0; + for (int i = 1; i <= 100; i++) { + boolean isMultipleOf3 = (i % 3 == 0); + boolean isMultipleOf5 = (i % 5 == 0); + + if (isMultipleOf3 && isMultipleOf5) { + System.out.println(text1 + text2); + } else if (isMultipleOf3) { + System.out.println(text1); + } else if (isMultipleOf5) { + System.out.println(text2); + } else { + System.out.println(i); + count++; + } + } + return count; + } +} From c54d4c80a20a4ee8845dbf41e09c7e9cd6b4b53f Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Mon, 29 Sep 2025 12:31:12 -0500 Subject: [PATCH 30/38] #02 - Javascript --- .../javascript/mysterio-wil.js | 136 ++++++++++++++++++ 1 file changed, 136 insertions(+) create mode 100644 Roadmap/02 - FUNCIONES Y ALCANCE/javascript/mysterio-wil.js diff --git a/Roadmap/02 - FUNCIONES Y ALCANCE/javascript/mysterio-wil.js b/Roadmap/02 - FUNCIONES Y ALCANCE/javascript/mysterio-wil.js new file mode 100644 index 0000000000..0d6a9f65f8 --- /dev/null +++ b/Roadmap/02 - FUNCIONES Y ALCANCE/javascript/mysterio-wil.js @@ -0,0 +1,136 @@ +/* + * EJERCICIO: + * - Crea ejemplos de funciones básicas que representen las diferentes + * posibilidades del lenguaje: + * Sin parámetros ni retorno, con uno o varios parámetros, con retorno... + * - Comprueba si puedes crear funciones dentro de funciones. + * - Utiliza algún ejemplo de funciones ya creadas en el lenguaje. + * - Pon a prueba el concepto de variable LOCAL y GLOBAL. + * - Debes hacer print por consola del resultado de todos los ejemplos. + * (y tener en cuenta que cada lenguaje puede poseer más o menos posibilidades) + * + * DIFICULTAD EXTRA (opcional): + * Crea una función que reciba dos parámetros de tipo cadena de texto y retorne un número. + * - La función imprime todos los números del 1 al 100. Teniendo en cuenta que: + * - Si el número es múltiplo de 3, muestra la cadena de texto del primer parámetro. + * - Si el número es múltiplo de 5, muestra la cadena de texto del segundo parámetro. + * - Si el número es múltiplo de 3 y de 5, muestra las dos cadenas de texto concatenadas. + * - La función retorna el número de veces que se ha impreso el número en lugar de los textos. + * + * Presta especial atención a la sintaxis que debes utilizar en cada uno de los casos. + * Cada lenguaje sigue una convenciones que debes de respetar para que el código se entienda. + */ + +console.log("===> Funciones básicas <==="); + +// Sin parámetros ni retorno +function greet() { + console.log("Hola, JavaScript!"); +} +greet(); + +// Con un parámetro +function greetPerson(name) { + console.log(`Hola, ${name}!`); +} +greetPerson("Wilmer"); + +// Con varios parámetros +function add(a, b) { + console.log(`La suma de ${a} y ${b} es ${a + b}`); +} +add(5, 3); + +// Con retorno +function multiply(a, b) { + return a * b; +} +const result = multiply(5, 3); +console.log(`El resultado de la multiplicación es ${result}`); + +// Con varios parámetros y un valor por defecto +function greetDefault(name, greeting = "Hola") { + console.log(`${greeting}, ${name}!`); +} +greetDefault("MoureDev"); +greetDefault("Wilmer", "Hello"); + +// Con parámetros de longitud variable (rest parameters) +function printArgs(...args) { + console.log("Argumentos variables (...args):"); + args.forEach(arg => { + console.log(`- ${arg}`); + }); +} +printArgs(1, "texto", true, { framework: "JavaScript", anio: 2024 }); + + +console.log("\n===> Funciones dentro de funciones <==="); +function outerFunction() { + console.log("Esta es la función externa."); + function innerFunction() { + console.log("Esta es la función interna."); + } + innerFunction(); +} +outerFunction(); + + +console.log("\n===> Funciones del lenguaje (built-in) <==="); +console.log("Usando la propiedad 'length' de un array:"); +const myList = [1, 2, 3, 4, 5]; +console.log(`El array ${myList} tiene ${myList.length} elementos.`); + +console.log("Usando Math.max() para obtener el valor máximo:"); +console.log(`El valor máximo del array es ${Math.max(...myList)}`); + + +console.log("\n===> Variable LOCAL y GLOBAL <==="); +let globalVar = "Soy una variable global"; + +function myFunctionScope() { + const localVar = "Soy una variable local"; + console.log(globalVar); // Podemos acceder a la variable global + console.log(localVar); +} +myFunctionScope(); + +// Intentar acceder a la variable local desde fuera dará un error +// console.log(localVar); // ReferenceError: localVar is not defined + +// Modificar una variable global +function modifyGlobal() { + globalVar = "He modificado la variable global"; +} +console.log(`Antes de modificar: ${globalVar}`); +modifyGlobal(); +console.log(`Después de modificar: ${globalVar}`); + + +/* + * DIFICULTAD EXTRA (opcional): + */ +console.log("\n====> DIFICULTAD EXTRA <===="); +function fizzBuzzExtra(text1, text2) { + let count = 0; + for (let i = 1; i <= 100; i++) { + const isMultipleOf3 = (i % 3 === 0); + const isMultipleOf5 = (i % 5 === 0); + + if (isMultipleOf3 && isMultipleOf5) { + console.log(`${text1}${text2}`); + } else if (isMultipleOf3) { + console.log(text1); + } else if (isMultipleOf5) { + console.log(text2); + } else { + console.log(i); + count++; + } + } + return count; +} + +// Llamada a la función de dificultad extra +const timesPrintedNumber = fizzBuzzExtra("Fizz", "Buzz"); +console.log(`\nEl número se imprimió un total de ${timesPrintedNumber} veces.`); From b4812a0d53e125a4f1b89f2c1e29e902f9fee0e6 Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Mon, 29 Sep 2025 12:31:15 -0500 Subject: [PATCH 31/38] #02 - Kotlin --- .../kotlin/mysterio-wil.kt | 142 ++++++++++++++++++ 1 file changed, 142 insertions(+) create mode 100644 Roadmap/02 - FUNCIONES Y ALCANCE/kotlin/mysterio-wil.kt diff --git a/Roadmap/02 - FUNCIONES Y ALCANCE/kotlin/mysterio-wil.kt b/Roadmap/02 - FUNCIONES Y ALCANCE/kotlin/mysterio-wil.kt new file mode 100644 index 0000000000..2dbf8c4221 --- /dev/null +++ b/Roadmap/02 - FUNCIONES Y ALCANCE/kotlin/mysterio-wil.kt @@ -0,0 +1,142 @@ +/* + * EJERCICIO: + * - Crea ejemplos de funciones básicas que representen las diferentes + * posibilidades del lenguaje: + * Sin parámetros ni retorno, con uno o varios parámetros, con retorno... + * - Comprueba si puedes crear funciones dentro de funciones. + * - Utiliza algún ejemplo de funciones ya creadas en el lenguaje. + * - Pon a prueba el concepto de variable LOCAL y GLOBAL. + * - Debes hacer print por consola del resultado de todos los ejemplos. + * (y tener en cuenta que cada lenguaje puede poseer más o menos posibilidades) + * + * DIFICULTAD EXTRA (opcional): + * Crea una función que reciba dos parámetros de tipo cadena de texto y retorne un número. + * - La función imprime todos los números del 1 al 100. Teniendo en cuenta que: + * - Si el número es múltiplo de 3, muestra la cadena de texto del primer parámetro. + * - Si el número es múltiplo de 5, muestra la cadena de texto del segundo parámetro. + * - Si el número es múltiplo de 3 y de 5, muestra las dos cadenas de texto concatenadas. + * - La función retorna el número de veces que se ha impreso el número en lugar de los textos. + * + * Presta especial atención a la sintaxis que debes utilizar en cada uno de los casos. + * Cada lenguaje sigue una convenciones que debes de respetar para que el código se entienda. + */ + +// --- Variable Global (propiedad top-level) --- +var globalVar = "Soy una variable global" + +fun main() { + println("===> Funciones básicas <===") + + // Sin parámetros ni retorno + greet() + + // Con un parámetro + greetPerson("Wilmer") + + // Con varios parámetros + add(5, 3) + + // Con retorno + val result = multiply(5, 3) + println("El resultado de la multiplicación es $result") + + // Con parámetros por defecto y nombrados + greetDefault("MoureDev") + greetDefault("Wilmer", greeting = "Hello") + + // Con parámetros de longitud variable (vararg) + println("Argumentos variables (vararg):") + printArgs(1, "texto", true, 12.99) + + + println("\n===> Funciones dentro de funciones (Local Functions) <===") + outerFunction() + + + println("\n===> Funciones de la Librería Estándar de Kotlin <===") + val myList = listOf(1, 2, 3, 4, 5) + println("Usando la propiedad 'size' de una Lista: La lista tiene ${myList.size} elementos.") + println("Usando list.maxOrNull(): El valor máximo es ${myList.maxOrNull()}") + + + println("\n===> Variable LOCAL y GLOBAL <===") + myFunctionScope() + + // Modificar una variable global + println("Antes de modificar: $globalVar") + modifyGlobal() + println("Después de modificar: $globalVar") + + + /* + * DIFICULTAD EXTRA (opcional): + */ + println("\n====> DIFICULTAD EXTRA <====") + val timesPrintedNumber = fizzBuzzExtra("Fizz", "Buzz") + println("\nEl número se imprimió un total de $timesPrintedNumber veces.") +} + +// --- Definiciones de funciones (top-level) --- + +fun greet() { + println("Hola, Kotlin!") +} + +fun greetPerson(name: String) { + println("Hola, $name!") +} + +fun add(a: Int, b: Int) { + println("La suma de $a y $b es ${a + b}") +} + +fun multiply(a: Int, b: Int): Int { + return a * b +} + +fun greetDefault(name: String, greeting: String = "Hola") { + println("$greeting, $name!") +} + +fun printArgs(vararg args: Any) { + for (arg in args) { + println("- $arg") + } +} + +fun outerFunction() { + println("Esta es la función externa.") + fun innerFunction() { + println("Esta es la función interna.") + } + innerFunction() +} + +fun myFunctionScope() { + val localVar = "Soy una variable local" + println(globalVar) // Acceso a la variable global + println(localVar) +} + +fun modifyGlobal() { + globalVar = "He modificado la variable global" +} + +fun fizzBuzzExtra(text1: String, text2: String): Int { + var count = 0 + for (i in 1..100) { + val isMultipleOf3 = (i % 3 == 0) + val isMultipleOf5 = (i % 5 == 0) + + when { + isMultipleOf3 && isMultipleOf5 -> println("$text1$text2") + isMultipleOf3 -> println(text1) + isMultipleOf5 -> println(text2) + else -> { + println(i) + count++ + } + } + } + return count +} From 1a4c8c476bf9acdf2cd2215559fbbd0882a07c6d Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Mon, 29 Sep 2025 12:31:18 -0500 Subject: [PATCH 32/38] #02 - PHP --- .../php/mysterio-wil.php | 143 ++++++++++++++++++ 1 file changed, 143 insertions(+) create mode 100644 Roadmap/02 - FUNCIONES Y ALCANCE/php/mysterio-wil.php diff --git a/Roadmap/02 - FUNCIONES Y ALCANCE/php/mysterio-wil.php b/Roadmap/02 - FUNCIONES Y ALCANCE/php/mysterio-wil.php new file mode 100644 index 0000000000..422a0e69e0 --- /dev/null +++ b/Roadmap/02 - FUNCIONES Y ALCANCE/php/mysterio-wil.php @@ -0,0 +1,143 @@ + Funciones básicas <===\n"; + +// Sin parámetros ni retorno +function greet() { + echo "Hola, PHP!\n"; +} +greet(); + +// Con un parámetro +function greet_person($name) { + echo "Hola, $name!\n"; +} +greet_person("Wilmer"); + +// Con varios parámetros +function add($a, $b) { + echo "La suma de $a y $b es " . ($a + $b) . "\n"; +} +add(5, 3); + +// Con retorno +function multiply($a, $b) { + return $a * $b; +} +$result = multiply(5, 3); +echo "El resultado de la multiplicación es $result\n"; + +// Con parámetros por defecto +function greet_default($name, $greeting = "Hola") { + echo "$greeting, $name!\n"; +} +greet_default("MoureDev"); +greet_default("Wilmer", "Hello"); + +// Con parámetros de longitud variable (splat operator) +function print_args(...$args) { + echo "Argumentos variables (... a.k.a. splat operator):\n"; + foreach ($args as $arg) { + echo "- "; + print_r($arg); + echo "\n"; + } +} +print_args(1, "texto", true); + + +echo "\n===> Funciones dentro de funciones <===\n"; +function outer_function() { + echo "Esta es la función externa.\n"; + // La función interna solo se define cuando se llama a la externa. + function inner_function() { + echo "Esta es la función interna.\n"; + } +} +// Primero llamamos a la externa para que defina a la interna +outer_function(); +// Ahora podemos llamar a la interna +inner_function(); + + +echo "\n===> Funciones del lenguaje (built-in) <===\n"; +$my_list = [1, 2, 3, 4, 5]; +echo "Usando la función count() para un array: El array tiene " . count($my_list) . " elementos.\n"; +echo "Usando la función max() para un array: El valor máximo es " . max($my_list) . "\n"; + + +echo "\n===> Variable LOCAL y GLOBAL <===\n"; +function my_function_scope() { + // Para usar una variable global, hay que importarla al scope local + global $global_var; + $local_var = "Soy una variable local"; + + echo $global_var . "\n"; + echo $local_var . "\n"; +} +my_function_scope(); + +function modify_global() { + global $global_var; + $global_var = "He modificado la variable global"; +} + +echo "Antes de modificar: $global_var\n"; +modify_global(); +echo "Después de modificar: $global_var\n"; + + +/* + * DIFICULTAD EXTRA (opcional): + */ +echo "\n====> DIFICULTAD EXTRA <====\n"; +function fizz_buzz_extra($text1, $text2) { + $count = 0; + for ($i = 1; $i <= 100; $i++) { + $is_multiple_of_3 = ($i % 3 == 0); + $is_multiple_of_5 = ($i % 5 == 0); + + if ($is_multiple_of_3 && $is_multiple_of_5) { + echo $text1 . $text2 . "\n"; + } elseif ($is_multiple_of_3) { + echo $text1 . "\n"; + } elseif ($is_multiple_of_5) { + echo $text2 . "\n"; + } else { + echo $i . "\n"; + $count++; + } + } + return $count; +} + +$times_printed_number = fizz_buzz_extra("Fizz", "Buzz"); +echo "\nEl número se imprimió un total de $times_printed_number veces.\n"; + +?> From 3d95cd36d8772977f1885b600807b3ebdca19fbb Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Mon, 29 Sep 2025 12:31:22 -0500 Subject: [PATCH 33/38] #02 - Python --- .../python/mysterio-wil.py | 124 ++++++++++++++++++ 1 file changed, 124 insertions(+) create mode 100644 Roadmap/02 - FUNCIONES Y ALCANCE/python/mysterio-wil.py diff --git a/Roadmap/02 - FUNCIONES Y ALCANCE/python/mysterio-wil.py b/Roadmap/02 - FUNCIONES Y ALCANCE/python/mysterio-wil.py new file mode 100644 index 0000000000..542a72fd80 --- /dev/null +++ b/Roadmap/02 - FUNCIONES Y ALCANCE/python/mysterio-wil.py @@ -0,0 +1,124 @@ +# EJERCICIO: +# - Crea ejemplos de funciones básicas que representen las diferentes posibilidades del lenguaje: Sin parámetros ni retorno, con uno o varios parámetros, con retorno... +# - Comprueba si puedes crear funciones dentro de funciones. +# - Utiliza algún ejemplo de funciones ya creadas en el lenguaje. +# - Pon a prueba el concepto de variable LOCAL y GLOBAL. +# - Debes hacer print por consola del resultado de todos los ejemplos. (y tener en cuenta que cada lenguaje puede poseer más o menos posibilidades) + +print("===> Funciones básicas <===") + +# Sin parámetros ni retorno +def greet(): + print("Hola, Python!") + +greet() + +# Con un parámetro +def greet_person(name): + print(f"Hola, {name}!") + +greet_person("Wilmer") + +# Con varios parámetros +def add(a, b): + print(f"La suma de {a} y {b} es {a + b}") + +add(5, 3) + +# Con retorno +def multiply(a, b): + return a * b + +result = multiply(5, 3) +print(f"El resultado de la multiplicación es {result}") + +# Con varios parámetros y un valor por defecto +def greet_default(name, greeting="Hola"): + print(f"{greeting}, {name}!") + +greet_default("MoureDev") +greet_default("Wilmer", "Hello") + +# Con parámetros de longitud variable (*args y **kwargs) +def print_args(*args, **kwargs): + print("Argumentos posicionales (*args):") + for arg in args: + print(f"- {arg}") + print("Argumentos de palabra clave (**kwargs):") + for key, value in kwargs.items(): + print(f"- {key}: {value}") + +print_args(1, "texto", True, framework="Python", anio=2024) + + +print("\n===> Funciones dentro de funciones <===") +def outer_function(): + print("Esta es la función externa.") + def inner_function(): + print("Esta es la función interna.") + inner_function() + +outer_function() + + +print("\n===> Funciones del lenguaje (built-in) <===") +print("Usando la función len() para obtener la longitud de una lista:") +my_list = [1, 2, 3, 4, 5] +print(f"La lista {my_list} tiene {len(my_list)} elementos.") + +print("Usando la función max() para obtener el valor máximo:") +print(f"El valor máximo de la lista es {max(my_list)}") + + +print("\n===> Variable LOCAL y GLOBAL <===") +global_var = "Soy una variable global" + +def my_function_scope(): + local_var = "Soy una variable local" + print(global_var) # Podemos acceder a la variable global desde la función + print(local_var) + +my_function_scope() + +# Intentar acceder a la variable local desde fuera de la función dará un error +# print(local_var) # NameError: name 'local_var' is not defined + +# Modificar una variable global +def modify_global(): + global global_var + global_var = "He modificado la variable global" + +print(f"Antes de modificar: {global_var}") +modify_global() +print(f"Después de modificar: {global_var}") + + +# DIFICULTAD EXTRA (opcional): +# - Crea una función que reciba dos parámetros de tipo cadena de texto y retorne un número. +# - La función imprime todos los números del 1 al 100. Teniendo en cuenta que: +# - Si el número es múltiplo de 3, muestra la cadena de texto del primer parámetro. +# - Si el número es múltiplo de 5, muestra la cadena de texto del segundo parámetro. +# - Si el número es múltiplo de 3 y de 5, muestra las dos cadenas de texto concatenadas. +# - La función retorna el número de veces que se ha impreso el número en lugar de los textos. + +print("\n====> DIFICULTAD EXTRA <====") +def fizz_buzz_extra(text1, text2): + count = 0 + for i in range(1, 101): + is_multiple_of_3 = (i % 3 == 0) + is_multiple_of_5 = (i % 5 == 0) + + if is_multiple_of_3 and is_multiple_of_5: + print(f"{text1}{text2}") + elif is_multiple_of_3: + print(text1) + elif is_multiple_of_5: + print(text2) + else: + print(i) + count += 1 + return count + +# Llamada a la función de dificultad extra +times_printed_number = fizz_buzz_extra("Fizz", "Buzz") +print(f"\nEl número se imprimió un total de {times_printed_number} veces.") \ No newline at end of file From 3a442cd4ee0bc29b347b644dd303bf38d2db9682 Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Mon, 29 Sep 2025 12:31:25 -0500 Subject: [PATCH 34/38] #02 - Ruby --- .../ruby/mysterio-wil.rb | 128 ++++++++++++++++++ 1 file changed, 128 insertions(+) create mode 100644 Roadmap/02 - FUNCIONES Y ALCANCE/ruby/mysterio-wil.rb diff --git a/Roadmap/02 - FUNCIONES Y ALCANCE/ruby/mysterio-wil.rb b/Roadmap/02 - FUNCIONES Y ALCANCE/ruby/mysterio-wil.rb new file mode 100644 index 0000000000..411adc0a72 --- /dev/null +++ b/Roadmap/02 - FUNCIONES Y ALCANCE/ruby/mysterio-wil.rb @@ -0,0 +1,128 @@ +# +# EJERCICIO: +# - Crea ejemplos de funciones básicas que representen las diferentes +# posibilidades del lenguaje: +# Sin parámetros ni retorno, con uno o varios parámetros, con retorno... +# - Comprueba si puedes crear funciones dentro de funciones. +# - Utiliza algún ejemplo de funciones ya creadas en el lenguaje. +# - Pon a prueba el concepto de variable LOCAL y GLOBAL. +# - Debes hacer print por consola del resultado de todos los ejemplos. +# (y tener en cuenta que cada lenguaje puede poseer más o menos posibilidades) +# +# DIFICULTAD EXTRA (opcional): +# - Crea una función que reciba dos parámetros de tipo cadena de texto y retorne un número. +# - La función imprime todos los números del 1 al 100. Teniendo en cuenta que: +# - Si el número es múltiplo de 3, muestra la cadena de texto del primer parámetro. +# - Si el número es múltiplo de 5, muestra la cadena de texto del segundo parámetro. +# - Si el número es múltiplo de 3 y de 5, muestra las dos cadenas de texto concatenadas. +# - La función retorna el número de veces que se ha impreso el número en lugar de los textos. +# +# Presta especial atención a la sintaxis que debes utilizar en cada uno de los casos. +# Cada lenguaje sigue una convenciones que debes de respetar para que el código se entienda. +# + +# --- Variable Global --- +$global_var = "Soy una variable global" + +puts "===> Funciones (métodos) básicas <===" + +# Sin parámetros ni retorno +def greet + puts "Hola, Ruby!" +end +greet + +# Con un parámetro +def greet_person(name) + puts "Hola, #{name}!" +end +greet_person("Wilmer") + +# Con varios parámetros +def add(a, b) + puts "La suma de #{a} y #{b} es #{a + b}" +end +add(5, 3) + +# Con retorno (en Ruby, el retorno es implícito) +def multiply(a, b) + a * b +end +result = multiply(5, 3) +puts "El resultado de la multiplicación es #{result}" + +# Con parámetros por defecto +def greet_default(name, greeting = "Hola") + puts "#{greeting}, #{name}!" +end +greet_default("MoureDev") +greet_default("Wilmer", "Hello") + +# Con parámetros de longitud variable (splat operator) +def print_args(*args) + puts "Argumentos variables (*args, a.k.a. splat operator):" + args.each do |arg| + puts "- #{arg}" + end +end +print_args(1, "texto", true, [1, 2]) + + +puts "\n===> Funciones dentro de funciones (Lambdas) <===" +def outer_function + puts "Esta es la función externa." + # Ruby no tiene funciones anidadas directamente, pero usa lambdas o procs. + inner_function = -> { puts "Esta es una función lambda (interna)." } + inner_function.call +end +outer_function + + +puts "\n===> Métodos del core de Ruby <===" +my_list = [1, 2, 3, 4, 5] +puts "Usando el método .length de un Array: El array tiene #{my_list.length} elementos." +puts "Usando el método .max de un Array: El valor máximo es #{my_list.max}." + + +puts "\n===> Variable LOCAL y GLOBAL <===" +def my_function_scope + local_var = "Soy una variable local" + # Las variables globales ($) son accesibles directamente desde cualquier scope. + puts $global_var + puts local_var +end +my_function_scope + +def modify_global + $global_var = "He modificado la variable global" +end + +puts "Antes de modificar: #{$global_var}" +modify_global +puts "Después de modificar: #{$global_var}" + + +# +# DIFICULTAD EXTRA (opcional): +# +puts "\n====> DIFICULTAD EXTRA <====" +def fizz_buzz_extra(text1, text2) + count = 0 + (1..100).each do |i| + is_multiple_of_3 = (i % 3 == 0) + is_multiple_of_5 = (i % 5 == 0) + + if is_multiple_of_3 && is_multiple_of_5 + puts "#{text1}#{text2}" + elsif is_multiple_of_3 + puts text1 + elsif is_multiple_of_5 + puts text2 + else + puts i + count += 1 + end + end + return count +fizz_buzz_extra("Fizz", "Buzz") +puts "\nEl número se imprimió un total de #{times_printed_number} veces." From 7c8963dbe4734540260f89a9497d4544219d2029 Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Mon, 29 Sep 2025 12:31:29 -0500 Subject: [PATCH 35/38] #02 - Rust --- .../rust/mysterio-wil.rs | 146 ++++++++++++++++++ 1 file changed, 146 insertions(+) create mode 100644 Roadmap/02 - FUNCIONES Y ALCANCE/rust/mysterio-wil.rs diff --git a/Roadmap/02 - FUNCIONES Y ALCANCE/rust/mysterio-wil.rs b/Roadmap/02 - FUNCIONES Y ALCANCE/rust/mysterio-wil.rs new file mode 100644 index 0000000000..03610fe19b --- /dev/null +++ b/Roadmap/02 - FUNCIONES Y ALCANCE/rust/mysterio-wil.rs @@ -0,0 +1,146 @@ +/* + * EJERCICIO: + * - Crea ejemplos de funciones básicas que representen las diferentes + * posibilidades del lenguaje: + * Sin parámetros ni retorno, con uno o varios parámetros, con retorno... + * - Comprueba si puedes crear funciones dentro de funciones. + * - Utiliza algún ejemplo de funciones ya creadas en el lenguaje. + * - Pon a prueba el concepto de variable LOCAL y GLOBAL. + * - Debes hacer print por consola del resultado de todos los ejemplos. + * (y tener en cuenta que cada lenguaje puede poseer más o menos posibilidades) + * + * DIFICULTAD EXTRA (opcional): + * Crea una función que reciba dos parámetros de tipo cadena de texto y retorne un número. + * - La función imprime todos los números del 1 al 100. Teniendo en cuenta que: + * - Si el número es múltiplo de 3, muestra la cadena de texto del primer parámetro. + * - Si el número es múltiplo de 5, muestra la cadena de texto del segundo parámetro. + * - Si el número es múltiplo de 3 y de 5, muestra las dos cadenas de texto concatenadas. + * - La función retorna el número de veces que se ha impreso el número en lugar de los textos. + * + * Presta especial atención a la sintaxis que debes utilizar en cada uno de los casos. + * Cada lenguaje sigue una convenciones que debes de respetar para que el código se entienda. + */ + +// --- Variable Global --- +// Modificar variables estáticas mutables es inseguro en Rust y requiere un bloque `unsafe`. +// La forma segura y recomendada de tener estado global mutable es usando primitivas de concurrencia como Mutex. +static mut GLOBAL_VAR: &str = "Soy una variable global"; + +fn main() { + println!("===> Funciones básicas <==="); + + // Sin parámetros ni retorno + greet(); + + // Con un parámetro (&str es un "string slice", la forma idiomática de pasar texto) + greet_person("Wilmer"); + + // Con varios parámetros + add(5, 3); + + // Con retorno (el retorno sin `return` es implícito si no hay punto y coma) + let result = multiply(5, 3); + println!("El resultado de la multiplicación es {}", result); + + // Rust no soporta parámetros por defecto. + println!("Rust no soporta parámetros por defecto."); + + // Para argumentos variables, la forma idiomática es usar slices (o macros para casos más complejos). + println!("Argumentos variables (pasando un slice):"); + print_args(&[1, 2, 3, 4]); + + + println!("\n===> Funciones dentro de funciones <==="); + outer_function(); + + + println!("\n===> Funciones de la Librería Estándar de Rust <==="); + let my_list = [1, 2, 3, 4, 5]; + println!("Usando el método .len() de un array/slice: El array tiene {} elementos.", my_list.len()); + // .iter().max() devuelve un Option, por eso usamos unwrap() para obtener el valor. + println!("Usando .iter().max(): El valor máximo es {}.\n", my_list.iter().max().unwrap()); + + + println!("\n===> Variable LOCAL y GLOBAL <==="); + my_function_scope(); + + // Modificar o leer una variable `static mut` es una operación `unsafe`. + unsafe { + println!("Antes de modificar: {}", GLOBAL_VAR); + modify_global(); + println!("Después de modificar: {}", GLOBAL_VAR); + } + + + /* + * DIFICULTAD EXTRA (opcional): + */ + println!("\n====> DIFICULTAD EXTRA <===="); + let times_printed_number = fizz_buzz_extra("Fizz", "Buzz"); + println!("\nEl número se imprimió un total de {} veces.", times_printed_number); +} + +// --- Definiciones de funciones --- + +fn greet() { + println!("Hola, Rust!"); +} + +fn greet_person(name: &str) { + println!("Hola, {}!", name); +} + +fn add(a: i32, b: i32) { + println!("La suma de {} y {} es {}", a, b, a + b); +} + +fn multiply(a: i32, b: i32) -> i32 { + a * b // Retorno implícito +} + +fn print_args(args: &[i32]) { + for arg in args { + println!("- {}", arg); + } +} + +fn outer_function() { + println!("Esta es la función externa."); + fn inner_function() { + println!("Esta es la función interna."); + } + inner_function(); +} + +fn my_function_scope() { + let local_var = "Soy una variable local"; + // Leer una `static mut` también es `unsafe`. + unsafe { + println!("{}", GLOBAL_VAR); + } + println!("{}", local_var); +} + +unsafe fn modify_global() { + GLOBAL_VAR = "He modificado la variable global"; +} + +fn fizz_buzz_extra(text1: &str, text2: &str) -> i32 { + let mut count = 0; + for i in 1..=100 { // El rango ..= es inclusivo + let is_multiple_of_3 = i % 3 == 0; + let is_multiple_of_5 = i % 5 == 0; + + if is_multiple_of_3 && is_multiple_of_5 { + println!("{}{}", text1, text2); + } else if is_multiple_of_3 { + println!("{}", text1); + } else if is_multiple_of_5 { + println!("{}", text2); + } else { + println!("{}", i); + count += 1; + } + } + count +} From 3ded8f3c89e6092adcb32134b42e9f3ac1c20898 Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Mon, 29 Sep 2025 12:31:33 -0500 Subject: [PATCH 36/38] #02 - TypeScript --- .../typescript/mysterio-wil.ts | 128 ++++++++++++++++++ 1 file changed, 128 insertions(+) create mode 100644 Roadmap/02 - FUNCIONES Y ALCANCE/typescript/mysterio-wil.ts diff --git a/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/mysterio-wil.ts b/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/mysterio-wil.ts new file mode 100644 index 0000000000..78c45bdd4c --- /dev/null +++ b/Roadmap/02 - FUNCIONES Y ALCANCE/typescript/mysterio-wil.ts @@ -0,0 +1,128 @@ +/* + * EJERCICIO: + * - Crea ejemplos de funciones básicas que representen las diferentes + * posibilidades del lenguaje: + * Sin parámetros ni retorno, con uno o varios parámetros, con retorno... + * - Comprueba si puedes crear funciones dentro de funciones. + * - Utiliza algún ejemplo de funciones ya creadas en el lenguaje. + * - Pon a prueba el concepto de variable LOCAL y GLOBAL. + * - Debes hacer print por consola del resultado de todos los ejemplos. + * (y tener en cuenta que cada lenguaje puede poseer más o menos posibilidades) + * + * DIFICULTAD EXTRA (opcional): + * Crea una función que reciba dos parámetros de tipo cadena de texto y retorne un número. + * - La función imprime todos los números del 1 al 100. Teniendo en cuenta que: + * - Si el número es múltiplo de 3, muestra la cadena de texto del primer parámetro. + * - Si el número es múltiplo de 5, muestra la cadena de texto del segundo parámetro. + * - Si el número es múltiplo de 3 y de 5, muestra las dos cadenas de texto concatenadas. + * - La función retorna el número de veces que se ha impreso el número en lugar de los textos. + * + * Presta especial atención a la sintaxis que debes utilizar en cada uno de los casos. + * Cada lenguaje sigue una convenciones que debes de respetar para que el código se entienda. + */ + +console.log("===> Funciones básicas <==="); + +// Sin parámetros ni retorno +function greet(): void { + console.log("Hola, TypeScript!"); +} +greet(); + +// Con un parámetro +function greetPerson(name: string): void { + console.log(`Hola, ${name}!`); +} +greetPerson("Wilmer"); + +// Con varios parámetros +function add(a: number, b: number): void { + console.log(`La suma de ${a} y ${b} es ${a + b}`); +} +add(5, 3); + +// Con retorno +function multiply(a: number, b: number): number { + return a * b; +} +const result: number = multiply(5, 3); +console.log(`El resultado de la multiplicación es ${result}`); + +// Con parámetros por defecto +function greetDefault(name: string, greeting: string = "Hola"): void { + console.log(`${greeting}, ${name}!`); +} +greetDefault("MoureDev"); +greetDefault("Wilmer", "Hello"); + +// Con parámetros de longitud variable (rest parameters) +function printArgs(...args: any[]): void { + console.log("Argumentos variables (...args):"); + args.forEach(arg => { + console.log(`- ${arg}`); + }); +} +printArgs(1, "texto", true, { framework: "TypeScript" }); + + +console.log("\n===> Funciones dentro de funciones <==="); +function outerFunction(): void { + console.log("Esta es la función externa."); + function innerFunction(): void { + console.log("Esta es la función interna."); + } + innerFunction(); +} +outerFunction(); + + +console.log("\n===> Funciones del lenguaje (built-in) <==="); +const myList: number[] = [1, 2, 3, 4, 5]; +console.log(`Usando la propiedad 'length' de un array: El array tiene ${myList.length} elementos.`); +console.log(`Usando Math.max(): El valor máximo del array es ${Math.max(...myList)}`); + + +console.log("\n===> Variable LOCAL y GLOBAL <==="); +let globalVar: string = "Soy una variable global"; + +function myFunctionScope(): void { + const localVar: string = "Soy una variable local"; + console.log(globalVar); // Acceso a la variable global + console.log(localVar); +} +myFunctionScope(); + +function modifyGlobal(): void { + globalVar = "He modificado la variable global"; +} +console.log(`Antes de modificar: ${globalVar}`); +modifyGlobal(); +console.log(`Después de modificar: ${globalVar}`); + + +/* + * DIFICULTAD EXTRA (opcional): + */ +console.log("\n====> DIFICULTAD EXTRA <===="); +function fizzBuzzExtra(text1: string, text2: string): number { + let count = 0; + for (let i = 1; i <= 100; i++) { + const isMultipleOf3 = (i % 3 === 0); + const isMultipleOf5 = (i % 5 === 0); + + if (isMultipleOf3 && isMultipleOf5) { + console.log(`${text1}${text2}`); + } else if (isMultipleOf3) { + console.log(text1); + } else if (isMultipleOf5) { + console.log(text2); + } else { + console.log(i); + count++; + } + } + return count; +} + +const timesPrintedNumber: number = fizzBuzzExtra("Fizz", "Buzz"); +console.log(`\nEl número se imprimió un total de ${timesPrintedNumber} veces.`); From e1df107045cbc740cf19f5dd7d8354774de492e0 Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Mon, 29 Sep 2025 12:36:02 -0500 Subject: [PATCH 37/38] #02 - C --- .../02 - FUNCIONES Y ALCANCE/c/mysterio-wil.c | 175 ++++++++++++++++++ 1 file changed, 175 insertions(+) create mode 100644 Roadmap/02 - FUNCIONES Y ALCANCE/c/mysterio-wil.c diff --git a/Roadmap/02 - FUNCIONES Y ALCANCE/c/mysterio-wil.c b/Roadmap/02 - FUNCIONES Y ALCANCE/c/mysterio-wil.c new file mode 100644 index 0000000000..42bdf93e9c --- /dev/null +++ b/Roadmap/02 - FUNCIONES Y ALCANCE/c/mysterio-wil.c @@ -0,0 +1,175 @@ +#include +#include +#include // For variable arguments + +/* + * EJERCICIO: + * - Crea ejemplos de funciones básicas que representen las diferentes + * posibilidades del lenguaje: + * Sin parámetros ni retorno, con uno o varios parámetros, con retorno... + * - Comprueba si puedes crear funciones dentro de funciones. + * - Utiliza algún ejemplo de funciones ya creadas en el lenguaje. + * - Pon a prueba el concepto de variable LOCAL y GLOBAL. + * - Debes hacer print por consola del resultado de todos los ejemplos. + * (y tener en cuenta que cada lenguaje puede poseer más o menos posibilidades) + * + * DIFICULTAD EXTRA (opcional): + * Crea una función que reciba dos parámetros de tipo cadena de texto y retorne un número. + * - La función imprime todos los números del 1 al 100. Teniendo en cuenta que: + * - Si el número es múltiplo de 3, muestra la cadena de texto del primer parámetro. + * - Si el número es múltiplo de 5, muestra la cadena de texto del segundo parámetro. + * - Si el número es múltiplo de 3 y de 5, muestra las dos cadenas de texto concatenadas. + * - La función retorna el número de veces que se ha impreso el número en lugar de los textos. + * + * Presta especial atención a la sintaxis que debes utilizar en cada uno de los casos. + * Cada lenguaje sigue una convenciones que debes de respetar para que el código se entienda. + */ + +// --- Declarations of functions --- + +// Basic functions +void greet(void); +void greet_person(const char* name); +void add(int a, int b); +int multiply(int a, int b); +// No default parameters in C, so we define a standard function. +void greet_default(const char* name, const char* greeting); +// Variable arguments +int sum_all(int count, ...); + +// Nested functions are not supported in standard C. + +// Scope +void my_function_scope(void); +void modify_global(void); + +// Extra difficulty +int fizz_buzz_extra(const char* text1, const char* text2); + + +// --- Global variable --- +// Usamos un array de char para que la cadena sea modificable +char global_var_buffer[50] = "Soy una variable global"; +char* global_var = global_var_buffer; + + +// --- Main function --- +int main() { + printf("===> Funciones básicas <===\n"); + + // Sin parámetros ni retorno + greet(); + + // Con un parámetro + greet_person("Wilmer"); + + // Con varios parámetros + add(5, 3); + + // Con retorno + int result = multiply(5, 3); + printf("El resultado de la multiplicación es %d\n", result); + + // Simulating default parameters + printf("No hay parámetros por defecto en C.\n"); + greet_default("MoureDev", "Hola"); + greet_default("Wilmer", "Hello"); + + // Con parámetros de longitud variable + int total = sum_all(4, 10, 20, 30, 5); + printf("Suma variable: %d\n", total); + + + printf("\n===> Funciones dentro de funciones <===\n"); + printf("Standard C no soporta funciones anidadas.\n"); + + + printf("\n===> Funciones de la librería estándar <===\n"); + const char* my_text = "Hola Mundo"; + printf("Usando la función strlen() de :\n"); + printf("El texto \"%s\" tiene %zu caracteres.\n", my_text, strlen(my_text)); + + + printf("\n===> Variable LOCAL y GLOBAL <===\n"); + my_function_scope(); + + // Modificar una variable global + printf("Antes de modificar: %s\n", global_var); + modify_global(); + printf("Después de modificar: %s\n", global_var); + + + /* + * DIFICULTAD EXTRA (opcional): + */ + printf("\n====> DIFICULTAD EXTRA <====\n"); + int times_printed_number = fizz_buzz_extra("Fizz", "Buzz"); + printf("\nEl número se imprimió un total de %d veces.\n", times_printed_number); + + return 0; +} + + +// --- Definitions of functions --- + +void greet(void) { + printf("Hola, C!\n"); +} + +void greet_person(const char* name) { + printf("Hola, %s!\n", name); +} + +void add(int a, int b) { + printf("La suma de %d y %d es %d\n", a, b, a + b); +} + +int multiply(int a, int b) { + return a * b; +} + +void greet_default(const char* name, const char* greeting) { + printf("%s, %s!\n", greeting, name); +} + +int sum_all(int count, ...) { + int total = 0; + va_list args; + va_start(args, count); + for (int i = 0; i < count; i++) { + total += va_arg(args, int); + } + va_end(args); + return total; +} + +void my_function_scope(void) { + const char* local_var = "Soy una variable local"; + printf("%s\n", global_var); // Podemos acceder a la variable global + printf("%s\n", local_var); +} + +void modify_global(void) { + // Copiamos la nueva cadena en el buffer global para modificarla de forma segura + strcpy(global_var_buffer, "He modificado la variable global"); +} + +int fizz_buzz_extra(const char* text1, const char* text2) { + int count = 0; + for (int i = 1; i <= 100; i++) { + int is_multiple_of_3 = (i % 3 == 0); + int is_multiple_of_5 = (i % 5 == 0); + + if (is_multiple_of_3 && is_multiple_of_5) { + printf("%s%s\n", text1, text2); + } else if (is_multiple_of_3) { + printf("%s\n", text1); + } else if (is_multiple_of_5) { + printf("%s\n", text2); + } else { + printf("%d\n", i); + count++; + } + } + return count; +} From 3645f4db806b27718a11a2a2f9821ab65379475a Mon Sep 17 00:00:00 2001 From: Wilmer Gulcochia Date: Mon, 29 Sep 2025 12:36:13 -0500 Subject: [PATCH 38/38] #02 - Swift --- .../swift/mysterio-wil.swift | 134 ++++++++++++++++++ 1 file changed, 134 insertions(+) create mode 100644 Roadmap/02 - FUNCIONES Y ALCANCE/swift/mysterio-wil.swift diff --git a/Roadmap/02 - FUNCIONES Y ALCANCE/swift/mysterio-wil.swift b/Roadmap/02 - FUNCIONES Y ALCANCE/swift/mysterio-wil.swift new file mode 100644 index 0000000000..ff83feadc4 --- /dev/null +++ b/Roadmap/02 - FUNCIONES Y ALCANCE/swift/mysterio-wil.swift @@ -0,0 +1,134 @@ +import Foundation + +/* + * EJERCICIO: + * - Crea ejemplos de funciones básicas que representen las diferentes + * posibilidades del lenguaje: + * Sin parámetros ni retorno, con uno o varios parámetros, con retorno... + * - Comprueba si puedes crear funciones dentro de funciones. + * - Utiliza algún ejemplo de funciones ya creadas en el lenguaje. + * - Pon a prueba el concepto de variable LOCAL y GLOBAL. + * - Debes hacer print por consola del resultado de todos los ejemplos. + * (y tener en cuenta que cada lenguaje puede poseer más o menos posibilidades) + * + * DIFICULTAD EXTRA (opcional): + * Crea una función que reciba dos parámetros de tipo cadena de texto y retorne un número. + * - La función imprime todos los números del 1 al 100. Teniendo en cuenta que: + * - Si el número es múltiplo de 3, muestra la cadena de texto del primer parámetro. + * - Si el número es múltiplo de 5, muestra la cadena de texto del segundo parámetro. + * - Si el número es múltiplo de 3 y de 5, muestra las dos cadenas de texto concatenadas. + * - La función retorna el número de veces que se ha impreso el número en lugar de los textos. + * + * Presta especial atención a la sintaxis que debes utilizar en cada uno de los casos. + * Cada lenguaje sigue una convenciones que debes de respetar para que el código se entienda. + */ + +// --- Variable Global --- +var globalVar = "Soy una variable global" + +print("===> Funciones básicas <===") + +// Sin parámetros ni retorno +func greet() { + print("Hola, Swift!") +} +greet() + +// Con un parámetro. Por defecto, Swift usa el nombre del parámetro como etiqueta en la llamada. +func greetPerson(name: String) { + print("Hola, \(name)!") +} +greetPerson(name: "Wilmer") + +// Con varios parámetros +func add(a: Int, b: Int) { + print("La suma de \(a) y \(b) es \(a + b)") +} +add(a: 5, b: 3) + +// Con retorno +func multiply(a: Int, b: Int) -> Int { + return a * b +} +let result = multiply(a: 5, b: 3) +print("El resultado de la multiplicación es \(result)") + +// Con parámetros por defecto +func greetDefault(name: String, greeting: String = "Hola") { + print("\(greeting), \(name)!") +} +greetDefault(name: "MoureDev") +greetDefault(name: "Wilmer", greeting: "Hello") + +// Con parámetros de longitud variable (variadic) +// El _ omite la etiqueta del argumento en la llamada para una sintaxis más limpia. +func printArgs(_ args: Any...) { + print("Argumentos variables (variadic):") + for arg in args { + print("- \(arg)") + } +} +printArgs(1, "texto", true, 12.5) + + +print("\n===> Funciones dentro de funciones <===") +func outerFunction() { + print("Esta es la función externa.") + func innerFunction() { + print("Esta es la función interna.") + } + innerFunction() +} +outerFunction() + + +print("\n===> Funciones de la Librería Estándar de Swift <===") +let myList = [1, 2, 3, 4, 5] +print("Usando la propiedad .count de un Array: El array tiene \(myList.count) elementos.") +// .max() devuelve un valor opcional, por eso se usa `!` para desempaquetarlo de forma forzada para este ejemplo. +print("Usando .max(): El valor máximo es \(myList.max()!).") + + +print("\n===> Variable LOCAL y GLOBAL <===") +func myFunctionScope() { + let localVar = "Soy una variable local" + print(globalVar) // Acceso directo a la variable global + print(localVar) +} +myFunctionScope() + +func modifyGlobal() { + globalVar = "He modificado la variable global" +} + +print("Antes de modificar: \(globalVar)") +modifyGlobal() +print("Después de modificar: \(globalVar)") + + +/* + * DIFICULTAD EXTRA (opcional): + */ +print("\n====> DIFICULTAD EXTRA <====") +func fizzBuzzExtra(text1: String, text2: String) -> Int { + var count = 0 + for i in 1...100 { // El rango ... es inclusivo en ambos extremos + let isMultipleOf3 = (i % 3 == 0) + let isMultipleOf5 = (i % 5 == 0) + + if isMultipleOf3 && isMultipleOf5 { + print("\(text1)\(text2)") + } else if isMultipleOf3 { + print(text1) + } else if isMultipleOf5 { + print(text2) + } else { + print(i) + count += 1 + } + } + return count +} + +let timesPrintedNumber = fizzBuzzExtra(text1: "Fizz", text2: "Buzz") +print("\nEl número se imprimió un total de \(timesPrintedNumber) veces.")