From fb77d01dde29243c221fd43909d942e7986abd92 Mon Sep 17 00:00:00 2001
From: danielBuGo <danielbuilesgomez@gmail.com>
Date: Tue, 18 Feb 2025 16:19:37 -0500
Subject: [PATCH 01/16] Estudiando Javascript

---
 .vscode/launch.json                |  18 +++
 Basic/00-helloworld.js             |  29 ++--
 Basic/01-variables.js              |  40 +++---
 Basic/02-datatypes.js              |  72 +++++-----
 Basic/03-beginner-exercises.js     | 123 ++++++++++++++++-
 Basic/04-operators.js              | 154 ++++++++++-----------
 Basic/05-operators-exercises.js    |  81 ++++++++++-
 Basic/06-strings.js                |  82 ++++++++----
 Basic/07-strings-exercises.js      |  85 +++++++++++-
 Basic/08-conditionals.js           |  67 +++++-----
 Basic/09-conditionals-exercises.js | 208 ++++++++++++++++++++++++++++-
 11 files changed, 730 insertions(+), 229 deletions(-)
 create mode 100644 .vscode/launch.json

diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 00000000..18efbe63
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,18 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+    
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Launch Program",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${workspaceFolder}\\Basic\\00-helloworld.js"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/Basic/00-helloworld.js b/Basic/00-helloworld.js
index 23a48e6e..cc033ce7 100644
--- a/Basic/00-helloworld.js
+++ b/Basic/00-helloworld.js
@@ -14,23 +14,24 @@ un comentario
 en varias líneas
 */
 
-console.log("¡Hola, JavaScript!")
-console.log('¡Hola, JavaScript!')
-console.log(`¡Hola, JavaScript!`)
+console.log("Hello World!");
+console.log('Hello Daniel');
 
-// console.log("¡Hola, JavaScript!")
+// Esto es un comentario de una linea
 
 /*
-console.log("¡Hola, JavaScript!")
-console.log('¡Hola, JavaScript!')
-console.log(`¡Hola, JavaScript!`)
+Esto es un
+comentario 
+de varias lineas.
 */
 
-console.log("5")
+console.log("8")
 console.log(5)
-console.log(5 + 2)
-console.log(5 - 2)
-console.log(5 * 2)
-console.log(5 / 2)
-console.log(5 % 2)
-console.log(5 ** 2)
\ No newline at end of file
+console.log(7 * 5);
+console.log(5 + 2);
+console.log(5 - 2);
+console.log(5 * 2);
+console.log(5 / 2);
+console.log(5 % 2);
+console.log(5 ** 2); //Elevado a la dos
+console.log(8 ** 4) // Elevado a la cuatro 
\ No newline at end of file
diff --git a/Basic/01-variables.js b/Basic/01-variables.js
index e1f7b6dd..72eb917d 100644
--- a/Basic/01-variables.js
+++ b/Basic/01-variables.js
@@ -3,27 +3,19 @@ Clase 16 - Variables
 Vídeo: https://youtu.be/1glVfFxj8a4?t=3049
 */
 
-// var
-
-var helloWorld = "¡Hola, JavaScript!"
-console.log(helloWorld)
-
-helloWorld = "¡Hola de nuevo, JavaScript!"
-console.log(helloWorld)
-
-// let
-
-let helloWorld2 = "¡Hola, JavaScript 2!"
-console.log(helloWorld2)
-
-helloWorld2 = "¡Hola de nuevo, JavaScript 2!"
-console.log(helloWorld2)
-
-// const
-
-const helloWorld3 = "¡Hola, JavaScript 3!"
-console.log(helloWorld3)
-
-// Error
-// helloWorld3 = "¡Hola de nuevo, JavaScript 2!"
-// console.log(helloWorld3)
\ No newline at end of file
+//Let
+let myMame =  'hola Daniel';
+console.log(myMame);
+let greetings = 'Hellow ';
+
+myMame = 'hola nuevamente Bella';
+console.log(myMame);
+let message = greetings + myMame;
+console.log(message);
+
+// CONST
+
+const birthDay = '20/07/88';
+console.log(birthDay)
+let mybirthDay = 'Mi cumpleaños es ';
+console.log(mybirthDay + birthDay);
diff --git a/Basic/02-datatypes.js b/Basic/02-datatypes.js
index ab37f6ee..d8988a1d 100644
--- a/Basic/02-datatypes.js
+++ b/Basic/02-datatypes.js
@@ -5,51 +5,49 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=3599
 
 // Tipos de datos primitivos
 
-// Cadenas de texto (string)
-let myName = "Brais Moure"
-let alias = 'MoureDev'
-let email = `braismoure@mouredev.com`
-
-// Números (number)
-let age = 37 // Entero
-let height = 1.77 // Decimal
-
-// Booleanos (boolean)
-let isTeacher = true
-let isStudent = false
+// Stings
+let sport = 'Paragliding ';
+let favoriteBrand = 'Ozone';
+let level = 'EN C'
+console.log(sport + favoriteBrand );
+
+// Numbers
+let age = 36;
+let hight = 1.70;
+let weigth = 73.5;
+console.log(age)
+
+//Boolean
+let heIsInstructor = false;
+let heIsPilot = true;
+console.log(heIsPilot);
 
 // Undefined
-let undefinedValue
-console.log(undefinedValue)
+let undifinedValue 
+console.log(undifinedValue);
 
-// Null
-let nullValue = null
-
-// Symbol
+//Null
+let nullData = null;
+console.log(nullData);
 
-let mySymbol = Symbol("mysymbol")
+//BigInt
 
-// BigInt
+let myBigInt = BigInt(72348975928437957297547928753278279075489237854);
+console.log(myBigInt);
+let myBigInt2 = 273472789589247895789275982734895732897543289787328n;
+console.log(myBigInt2);
 
-let myBigInt = BigInt(817239871289371986589716389471628379612983761289376129)
-let myBigInt2 = 817239871289371986589716389471628379612983761289376129n
-
-// Mostramos los tipos de datos
-console.log(typeof myName)
-console.log(typeof alias)
-console.log(typeof email)
-
-console.log(typeof age)
-console.log(typeof height)
+// Symbol
 
-console.log(typeof isTeacher)
-console.log(typeof isStudent)
+let mySymbol = Symbol("mySymbol"); //estos simbolos son utiles como identificadores de propiedades ( objetos), mas adelante se ve.
 
-console.log(typeof undefinedValue)
+console.log(typeof sport);
+console.log(typeof age);
+console.log(typeof heIsInstructor);
+console.log(typeof myBigInt);
+console.log(typeof mySymbol);
+console.log(typeof undifinedValue);
+console.log(typeof nullData);
 
-console.log(typeof nullValue)
 
-console.log(typeof mySymbol)
 
-console.log(typeof myBigInt)
-console.log(typeof myBigInt2)
\ No newline at end of file
diff --git a/Basic/03-beginner-exercises.js b/Basic/03-beginner-exercises.js
index 2e7dd657..47856e5a 100644
--- a/Basic/03-beginner-exercises.js
+++ b/Basic/03-beginner-exercises.js
@@ -5,20 +5,139 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=4733
 
 // 1. Escribe un comentario en una línea
 
+// Solucion al punto #1
+
 // 2. Escribe un comentario en varias líneas
 
+/* solucion
+al punto 
+numero dos */
+
 // 3. Declara variables con valores asociados a todos los datos de tipo primitivos
+console.log('Punto 3')
+let city =  'Medellin';
+let year =  2025;
+let isBogota = false;
+let bigNumber = 28523975927395792875972750n;
+let haveJob = null;
+let isEngenier 
+let mySymbol = Symbol('mySymbol');
+
+console.log('------------------------------------------------------------------')
 
 // 4. Imprime por consola el valor de todas las variables
+console.log('----Punto 4-----')
+console.log(city);
+console.log(year);
+console.log(isBogota);
+console.log(bigNumber);
+console.log(haveJob);
+console.log(isEngenier);
+console.log(mySymbol);
 
-// 5. Imprime por consola el tipo de todas las variables
 
+// 5. Imprime por consola el tipo de todas las variables
+console.log('----Punto 5-----')
+console.log(typeof city)
+console.log(typeof year)
+console.log(typeof isBogota)
+console.log(typeof bigNumber)
+console.log(typeof haveJob)
+console.log(typeof isEngenier)
+console.log(typeof mySymbol)
+console.log('------------------------------------------------------------------')
 // 6. A continuación, modifica los valores de las variables por otros del mismo tipo
+console.log('----Punto 6-----')
+city = 'Santa Barbara';
+year = 2024;
+isBogota = true;
+bigNumber = 8945892834845289747982798784927289274892798754290784902754n;
+haveJob = null;
+isEngenier
+mySymbol = Symbol('newValue');
+
+console.log(city);
+console.log(year);
+console.log(isBogota);
+console.log(bigNumber);
+console.log(haveJob);
+console.log(isEngenier);
+console.log(mySymbol);
+console.log('------------------------------------------------------------------')
 
 // 7. A continuación, modifica los valores de las variables por otros de distinto tipo
+console.log('----Punto 7-----')
+city = 2893479073749755674676746756847568346n;
+year = 'new daniel';
+isBogota = 876;
+bigNumber = null;
+haveJob
+isEngenier = true
+mySymbol = Symbol('7');
+console.log('------------------------------------------------------------------')
+console.log(city)
+console.log(year)
+console.log(isBogota)
+console.log(bigNumber)
+console.log(haveJob)
+console.log(isEngenier)
+console.log(mySymbol)
+console.log('------------------------------------------------------------------')
+
+console.log(typeof city)
+console.log(typeof year)
+console.log(typeof isBogota)
+console.log(typeof bigNumber)
+console.log(typeof haveJob)
+console.log(typeof isEngenier)
+console.log(typeof mySymbol)
+
+console.log('------------------------------------------------------------------')
 
 // 8. Declara constantes con valores asociados a todos los tipos de datos primitivos
+console.log('----Punto 8-----')
+const continent = 'europa';
+const howMany = 5;
+const isEuropa = true;
+const otherBigNumber = 894589283484528974798279878492728927489279875429078490254n;
+const myJob = null;
+const future = undefined;
+const yourSymbol = Symbol('newValue');
+console.log('------------------------------------------------------------------')
+console.log(continent)
+console.log(howMany)
+console.log(isEuropa)
+console.log(otherBigNumber)
+console.log(myJob)
+console.log(future)
+console.log(yourSymbol)
+console.log('------------------------------------------------------------------')
+console.log(typeof continent)
+console.log(typeof howMany)
+console.log(typeof isEuropa)
+console.log(typeof otherBigNumber)
+console.log(typeof myJob)
+console.log(typeof future)
+console.log(typeof yourSymbol)
 
 // 9. A continuación, modifica los valores de las constantes
+console.log('----Punto 9-----')
+/*const continent = 'america';
+const howMany = 5;
+const isEuropa = false;
+const otherBigNumber = 89458928348452897479827987849272892748927987542907890254n;
+const myJob = undefined;
+const future = null;
+const yourSymbol = Symbol('newValues');
+*/
+console.log('------------------------------------------------------------------')
+console.log(continent)
+console.log(howMany)
+console.log(isEuropa)
+console.log(otherBigNumber)
+console.log(myJob)
+console.log(future)
+console.log(yourSymbol)
 
-// 10. Comenta las líneas que produzcan algún tipo de error al ejecutarse
\ No newline at end of file
+// 10. Comenta las líneas que produzcan algún tipo de error al ejecutarse
+console.log('----Punto 10-----')
\ No newline at end of file
diff --git a/Basic/04-operators.js b/Basic/04-operators.js
index cac42886..51cbe244 100644
--- a/Basic/04-operators.js
+++ b/Basic/04-operators.js
@@ -5,105 +5,87 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=4937
 
 // Operadores Aritméticos
 
-let a = 5
-let b = 10
-
-console.log(a + b) // Suma
-console.log(a - b) // Resta
-console.log(a * b) // Multiplicación
-console.log(a / b) // División
-
-console.log(a % b) // Módulo
-console.log(a ** b) // Exponente
-
-a++ // Incremento
+let a = 8
+let b = 5
+
+console.log(a + b); //suma
+console.log(a - b); // resta
+console.log(a * b); // Multiplicacion
+console.log(a / b); // division
+console.log(a % b); // Mudulo
+console.log(a ** b); // Exponensial
+a++  //incremento
 console.log(a)
-
-b-- // Decremento
+b-- //Decremento
 console.log(b)
 
-// Operadores de asignacion
-
-let myVariable = 2
+// Operdadores de asignacion
+console.log('Operadores de Asignacion')
+let myVariable = 2 // El signo igual es el operador de asignacion
+myVariable += 2 // Es lo mismo que myVariable = myVariable + 2
 console.log(myVariable)
-myVariable += 2 // Suma con asignación
+myVariable -= 3
+console.log(myVariable)
+myVariable *= 5
+console.log(myVariable)
+myVariable /= 2
+console.log(myVariable)
+myVariable %= 6
+console.log(myVariable)
+myVariable **= 4
 console.log(myVariable)
 
-myVariable -= 2 // Resta con asignación
-myVariable *= 2 // Multiplicación con asignación
-myVariable /= 2 // División con asignación
-myVariable %= 2 // Módulo con asignación
-myVariable **= 2 // Exponente con asignación
-
-// Operadores de comparación
-
-console.log(a > b) // Mayor que
-console.log(a < b) // Menor que
-console.log(a >= b) // Mayor o igual que
-console.log(a <= b) // Menor o igual que
-console.log(a == b) // Igualdad por valor
-console.log(a == 6)
-console.log(a == "6")
-console.log(a == a)
-console.log(a === a) // Igualdad por identidad (por tipo y valor) o igualdad estricta
-console.log(a === 6)
-console.log(a === "6")
-console.log(a != 6) // Desigualdad por valor
-console.log(a !== "6") // Desigualdad por identidad (por tipo y valor) o desigualdad estricta
-console.log(0 == false)
-console.log(1 == false)
-console.log(2 == false)
-console.log(0 == "")
-console.log(0 == " ")
-console.log(0 == '')
-console.log(0 == "Hola")
-console.log(0 === "")
-console.log(undefined == null)
-console.log(undefined === null)
-
-/*
-Truthy values (valores verdaderos)
-
-- Todos los numeros positivos y negativos menos el cero
-- Todas las cadenas de texto menos las vacías
-- El boolean true
-*/
+//Operadoeres de comparacion
+console.log('Operadores de comparacion')
+console.log (a > b)
+console.log (a < b)
+console.log (a >= b)
+console.log (a <= b)
+console.log (a == b)
+console.log (a == 9)
+console.log (a == a) //igualdad por valor
+console.log (a === 9) // igualdad por identidad
+console.log (a === '9') // igualdad por identidad
+console.log (a != b) // Desigualdad
+console.log (a !== b) // Desigualdad
+console.log (1 == true) // Desigualdad
+console.log (0 == true) // Desigualdad
 
-/*
-Falsy values (valores falsos)
+console.log(a)
 
-- 0
--  0n
-- null
-- undefined
-- NaN (Not a Number)
-- El boolean false
-- Cadenas de texto vacías 
-*/
+//Truly values
+//Todos los numeros positivos y negativos menos el cero
+//Todas las cadenas de texto menos las vacias
+// El booleano true
 
-// Operadores lógicos
+//Falsy values
+//El cero
+//Null
+//undefined
+//NaN
+//0n
+//El boolean false
+//cadena de texto vacias
 
-// and (&&)
-console.log(5 > 10 && 15 > 20)
-console.log(5 < 10 && 15 < 20)
-console.log(5 < 10 && 15 > 20)
-console.log(5 > 10 && 15 > 20 && 30 > 40)
+//Operadores Logicos
+console.log('Operadores logicos')
 
-// or (||)
-console.log(5 > 10 || 15 > 20)
-console.log(5 < 10 || 15 < 20)
-console.log(5 < 10 || 15 > 20)
-console.log(5 > 10 || 15 > 20 || 30 > 40)
+//Tenemos tres: And (&&) 
+console.log('operador And')
+console.log(5 > 10 && 5 < 20); //false
+console.log(5 < 10 && 5 < 20); // True. ambas condiciones deben ser verdaderas
 
-console.log(5 > 10 && 15 > 20 || 30 < 40)
+// or ||
+console.log('operador OR')
+console.log(2 < 4 || 5 < 10) // una de las dos condiciones debe ser verdadera para ser true
+console.log(2 < 4 && 10 < 20 || 5 < 10) // una de las dos condiciones debe ser verdadera para ser true
 
-// not (!)
-console.log(!true)
-console.log(!false)
-console.log(!(5 > 10 && 15 > 20))
-console.log(!(5 > 10 || 15 > 20))
+//not (!)
 
-// Operadores ternarios
+console.log('Operador NOT (!)')
+console.log(!(2 < 4 || 5 < 10)) //NOt invierte el resultado del booleano, si era false, pasa a ser true
+console.log(!(2 < 4 && 10 < 20 || 5 < 10))
 
+// Operadores ternarios 
 const isRaining = false
-isRaining ? console.log("Está lloviendo") : console.log("No está lloviendo")
\ No newline at end of file
+isRaining ? console.log("Esta lloviendo bebè") : console.log("Hoy podemos volar") 
\ No newline at end of file
diff --git a/Basic/05-operators-exercises.js b/Basic/05-operators-exercises.js
index a6265eac..08d9f554 100644
--- a/Basic/05-operators-exercises.js
+++ b/Basic/05-operators-exercises.js
@@ -5,21 +5,100 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=6458
 
 // 1. Crea una variable para cada operación aritmética
 
+console.log('Ejercicio numero 1')
+
+let a = 5
+let b = 5
+
+let multiplicar = a * b
+console.log('El resultado de la Multiplicacion es: ' + multiplicar)
+let resta = a - b
+console.log('El resultado de la resta es: ' + resta)
+let suma = a + b 
+console.log('El resultado de la suma es: ' + suma)
+let division = a / b
+console.log('El resultado de la division es: ' + division)
+let elevar = a ** b
+console.log('El resultado de la exponencial es: ' + elevar)
+let modulo = a % b
+console.log('El resultado del modulo es: ' + modulo)
+console.log('+++++++++++++++++++++++++++++++++++++++++++++++++++++')
+
 // 2. Crea una variable para cada tipo de operación de asignación,
 //    que haga uso de las variables utilizadas para las operaciones aritméticas
+console.log('Ejercicio numero 1')
+let myOperation = 5
+myOperation += 5
+console.log(myOperation)
+myOperation -= 4
+console.log(myOperation)
+myOperation *= 8
+console.log(myOperation)
+myOperation /= 5
+console.log(myOperation)
+myOperation **= 2
+console.log(myOperation)
+myOperation %= 5
+console.log(myOperation)
+console.log('+++++++++++++++++++++++++++++++++++++++++++++++++++++')
 
 // 3. Imprime 5 comparaciones verdaderas con diferentes operadores de comparación
+console.log('Punto numero 3')
+console.log(8 > 3)
+console.log(8 == 8)
+console.log(5 >=4)
+console.log(4 <= 78)
+console.log(5 === b)
+console.log('+++++++++++++++++++++++++++++++++++++++++++++++++++++')
 
 // 4. Imprime 5 comparaciones falsas con diferentes operadores de comparación
+console.log('Punto numero 4')
+console.log(8 < 3)
+console.log(8 == 10)
+console.log(5 >=7)
+console.log(4 <= 2)
+console.log(5 === 'cinco')
 
 // 5. Utiliza el operador lógico and
+console.log('Punto numero 5')
+console.log(89 == 89 && 4 < 9)
+console.log(89 == 8 && 4 < 9)
+console.log(89 == 8 && 4 > 9)
+console.log(5 == a && 5 == b)
+console.log('+++++++++++++++++++++++++++++++++++++++++++++++++++++')
 
 // 6. Utiliza el operador lógico or
+console.log('Punto numero 6')
+console.log(4 < 9 || a == 5)
+console.log(89 == 8  || 11 > 4)
+console.log(89 == 8  || a == 6)
+console.log(5 == a  || 220 == 5)
+console.log('+++++++++++++++++++++++++++++++++++++++++++++++++++++')
 
 // 7. Combina ambos operadores lógicos
+console.log('Punto numero 7')
+console.log(89 == 89 && 4 < 9 || a == 5)
+console.log(89 == 8 && 4 < 9 || 11 > 4)
+console.log(89 == 8 && 4 > 9 || a == 6)
+console.log(5 == a && 5 == b || 220 == 5)
+console.log('+++++++++++++++++++++++++++++++++++++++++++++++++++++')
 
 // 8. Añade alguna negación
+console.log('Punto numero 8')
+console.log(!(89 == 89 && 4 < 9 || a == 5))
+console.log(89 == 8 && 4 < 9 || 11 > 4)
+console.log(89 == 8 && 4 > 9 || a == 6)
+console.log(!(5 == a && 5 == b || 220 == 5))
+console.log('+++++++++++++++++++++++++++++++++++++++++++++++++++++')
 
 // 9. Utiliza el operador ternario
+console.log('Punto numero 9')
+let sunnyDay = true
+sunnyDay ? console.log('Vamos pa fredonia') : console.log('No se puede volar')
+console.log('+++++++++++++++++++++++++++++++++++++++++++++++++++++')
 
-// 10. Combina operadores aritméticos, de comparáción y lógicas
\ No newline at end of file
+// 10. Combina operadores aritméticos, de comparáción y lógicas
+console.log('Punto numero 10')
+let c = 8
+let d = 9
+console.log(( a * c) < 89 || 89 == 89 )
\ No newline at end of file
diff --git a/Basic/06-strings.js b/Basic/06-strings.js
index 8c257b7b..b4331b0f 100644
--- a/Basic/06-strings.js
+++ b/Basic/06-strings.js
@@ -7,42 +7,70 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=6565
 
 // Concatenación
 
-let myName = "Brais"
-let greeting = "Hola, " + myName + "!"
+let myName = 'Daniel'
+let greeting = 'Hola, ' + myName + ' !';
 console.log(greeting)
 console.log(typeof greeting)
 
-// Longitud
+//Longitud de mi string
 
 console.log(greeting.length)
 
-// Acceso a caracteres
+// Acceso a la caderna de texto
+console.log(greeting [0])
+console.log(greeting[2])
+console.log(greeting[13])
 
-console.log(greeting[0])
-console.log(greeting[11])
+//Metodos Comunes
+console.log(greeting.toUpperCase())// Pone el texto en mayusculas
+console.log(greeting.toLowerCase())// pone el texto en minuscuals
+console.log(greeting.indexOf('Daniel'))// imprime el indice donde encuentra la palabra daniel
+console.log(greeting.includes('Daniel'))// verivica si esta palabra esta en el string
+console.log(greeting.includes('andrea'))
+console.log(greeting.replace('Daniel', 'Andrea'))
 
-// Métodos comunes
+let yourName = 'Lina'
+let otherName = 'Daniel'
+let newMessage = `Hola ${yourName}, te quieres casar con ${otherName}`
+console.log(newMessage)
 
-console.log(greeting.toUpperCase()) // Mayúsculas
-console.log(greeting.toLowerCase()) // Minúsculas
-console.log(greeting.indexOf("Hola")) // Índice
-console.log(greeting.indexOf("Brais"))
-console.log(greeting.indexOf("MoureDev"))
-console.log(greeting.includes("Hola")) // Incluye
-console.log(greeting.includes("Brais"))
-console.log(greeting.includes("MoureDev"))
-console.log(greeting.slice(0, 10)) // Sección
-console.log(greeting.replace("Brais", "MoureDev")) // Reemplazo
+console.log(newMessage.toLocaleLowerCase())
+console.log(newMessage.toLocaleUpperCase())
+console.log(newMessage.indexOf('casar'))
+console.log(newMessage.includes('bella'))
+console.log(newMessage.includes('Lina'))
+console.log(newMessage.length)
+console.log(newMessage.replace('Lina', 'Yesenia'))
+console.log(newMessage)
+console.log(newMessage.slice(3, 10))// muestra las letras que hay entre el 3 y el 9 sin incluir el 10
 
-// Template literals (plantillas literales)
+let otherMessage = `${yourName} y ${otherName}, aman mucho a su perrita`
+console.log(otherMessage.length)
+console.log(otherMessage.slice(0, 20))
+console.log(otherMessage.indexOf ('perrita'))
+console.log(otherMessage.includes('bella'))
+console.log(otherMessage.replace('perrita','bella'))
+console.log(otherMessage)
+console.log(otherMessage.toLocaleUpperCase())
+console.log(otherMessage.includes(`daniel`)) 
+console.log(otherMessage.includes(`Daniel`))
+
+let sport = 'Paragliding'
+let who = 'Daniel'
+let when = 'Weekends'
+let add = `${who}, loves ${sport} every${when}` //a este modo de concatenar strings se le llama interpolar
+console.log(add.slice(3, 11))
+console.log(add.length)
+console.log(add.toLocaleUpperCase())
+console.log(add.indexOf('Paragliding'))
+console.log(add.includes('Daniel'))
+console.log(add.includes('futbol'))
+console.log(add.replace('Paragliding', 'futbol'))// cambia la primera palabra, por la segunda
+console.log(add)
+
+//Templates literal
+let warning = `Hola
+puedo escribir Texto en  varias lineas` //Con las conmillas invertidas podemos escribir texto en varias lineas
+console.log(warning)
 
-// Strings en varias líneas
-let message = `Hola, este
-es mi
-curso de
-JavaScript`
-console.log(message)
 
-// Interpolación de valores
-let email = "braismoure@mouredev.com"
-console.log(`Hola, ${myName}! Tu email es ${email}.`)
\ No newline at end of file
diff --git a/Basic/07-strings-exercises.js b/Basic/07-strings-exercises.js
index c08f0166..4e82948c 100644
--- a/Basic/07-strings-exercises.js
+++ b/Basic/07-strings-exercises.js
@@ -4,21 +4,102 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=7226
 */
 
 // 1. Concatena dos cadenas de texto
+console.log('Ejercicio 1')
+let sport = 'Paragliding'
+let who = 'Daniel'
+let when = 'Weekends'
+let add = `${who}, loves ${sport} every${when}`
+console.log('Concatena dos cadenas de texto: ' + add)
+console.log('+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
+let mycity = 'Medellín'
+let me = 'I'
+console.log(`${me} Live in ${mycity}`)
+console.log('+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
+let neighborhood = 'La mota'
+let adress = 'Car 75da'
+console.log('I live in Medellin, my neighborhood is ' + neighborhood + 'and my adress is ' + adress)
 
 // 2. Muestra la longitud de una cadena de texto
+console.log('Ejercicio 2')
+console.log('Muestra la longitud de una cadena de texto: ' + add.length)
+console.log('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
+console.log(adress.length)
+console.log('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
+console.log(neighborhood.length)
+console.log('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
 
 // 3. Muestra el primer y último carácter de un string
+console.log('Ejercicio 3')
+let yourName = 'Lina'
+let otherName = 'Daniel'
+let otherMessage = `${yourName} y ${otherName}, aman mucho a su perrita`
+console.log(otherMessage)
+console.log(otherMessage.length)
+console.log('El primer caracter es ' + otherMessage.slice(0,1))
+console.log('El ultimo caracter es ' + otherMessage.slice(37,38))
 
 // 4. Convierte a mayúsculas y minúsculas un string
+console.log('Ejercicio 4')
+console.log('Convierte el string en mayusculas: ' + otherMessage.toLocaleUpperCase())
 
 // 5. Crea una cadena de texto en varias líneas
+console.log('Ejercicio 5')
+let warning = `Hola
+puedo escribir Texto en  varias lineas` //Con las comillas invertidas podemos escribir texto en varias lineas
+console.log('Cadena de texto en varias lineas: ' + warning)
+console.log(warning.slice(7, 6))
+console.log(warning.slice(9, 11))
 
 // 6. Interpola el valor de una variable en un string
+console.log('Ejercicio 6')
+let myAge = 36
+let message = `my age is ${myAge}`
+console.log(`Variable interpolada: ${message}`)
 
 // 7. Reemplaza todos los espacios en blanco de un string por guiones
+console.log('Ejercicio 7')
+console.log(`Reemplaza todos los espacios en blanco de un string por guiones: ${otherMessage.replace(/\s/g, '-')}`)
 
 // 8. Comprueba si una cadena de texto contiene una palabra concreta
+console.log('Ejercicio 8')
+console.log(`comproba si la cadena tiene una palabra en concreto: ${message.includes('age')} si esta incluida`)
+console.log(message.includes('bella'))
 
 // 9. Comprueba si dos strings son iguales
-
-// 10. Comprueba si dos strings tienen la misma longitud
\ No newline at end of file
+console.log('Ejercicio 9')
+console.log(typeof message)
+console.log(typeof otherMessage)
+let sameType = ((typeof message) === (typeof otherMessage))
+sameType ? console.log('those strings are same type') : console.log('Thos strings are different type')
+ console.log('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
+ let year = 2025
+ let mounth = 'february'
+ let areTheSame = ((typeof year) === (typeof mounth))
+ areTheSame ? console.log('they are the same type ') : console.log(`They are diferent type: ${year} is number and ${mounth} is string`)
+console.log('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
+let isRaining = 'Yes'
+let city = 'Medellin'
+let comparation = (typeof isRaining)=== (typeof city)
+comparation ? console.log(`The value ${isRaining} is same type of ${city}`) : console.log('They are differents')
+console.log('+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
+// 10. Comprueba si dos strings tienen la misma longitud
+console.log('Ejercicio 10')
+console.log(message.length)
+console.log(otherMessage.length)
+let areSame = message.length === otherMessage.length;
+areSame ? console.log(` imaginate que es igual`): console.log('No tienen la misma longitud')
+console.log('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
+let boy = 'novio'
+let girl = 'novia'
+let length = boy.length === girl.length
+length ? console.log(`${boy} has same length than ${girl}`) : console.log('the have different length')
+console.log('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
+let number1 = 1
+let number2 = 2
+let numbers = number1.length === number2.length
+numbers ? console.log(`the ${number1} and ${number2} have same long`) : console.log('the numbers have not same length')
+console.log('+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
+let word1 = 'Daniel'
+let word2 = 'bella'
+let twoWords = word1.length === word2.length
+twoWords ? console.log(`both words have same length`) : console.log(`the words have different length`)
\ No newline at end of file
diff --git a/Basic/08-conditionals.js b/Basic/08-conditionals.js
index 22bfcfa2..649c3ca4 100644
--- a/Basic/08-conditionals.js
+++ b/Basic/08-conditionals.js
@@ -6,65 +6,70 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=7277
 // if, else if, else
 
 // if (si)
+let age = 36
 
-let age = 37
-
-if (age == 37) {
-    console.log("La edad es 37")
+if (age == 36){
+    console.log(`La edad es ${age}`)
 }
 
-// else (si no)
-
-if (age == 37) {
-    console.log("La edad es 37")
+// else if (si no)
+if (age == 36){
+    console.log(`La edad es ${age}`)
 } else {
-    console.log("La edad no es 37")
+    console.log('La edad es diferente a 37')
 }
 
 // else if (si no, si)
-
-if (age == 37) {
-    console.log("La edad es 37")
-} else if (age < 18) {
-    console.log("Es menor de edad")
+if (age == 36){
+    console.log(`La edad es ${age}`)
+} else if (age <= 18){
+    console.log('el usuario es menor de edad')
 } else {
-    console.log("La edad no es 37 ni es menor de edad")
+    console.log('LA edad es diferente a 18 y 37')
 }
 
 // Operador ternario
+const theMessage = age == 36 ? "La edad es 36" : "La edad es diferente a 36" //Se ingresa la condicion antes del ?
+console.log(theMessage)
+let myAge = 18
+const theMes = myAge >= 18 ? "Is over age" : "is under age "
+console.log(theMes)
+let yourGlider = "C"
+const pilotLevel = yourGlider == 'C' ? "You are an expert pilot" : "You are not in expert level"
+console.log(pilotLevel)
+let brandGlider ='ozone'
+let yourBrand = brandGlider == "advance" ? "your brannd is advance" : "your brand is ozone"
+console.log(yourBrand)
 
-const message = age == 37 ? "La edad es 37" : "La edad no es 37"
-console.log(message)
-
-// switch
-
-let day = 3
+//Switch: Compara varios eventos con una sola variable
+let day = 7
 let dayName
 
-switch (day) {
+switch(day){
     case 0:
-        dayName = "Lunes"
+        dayName = 'Monday'
         break
     case 1:
-        dayName = "Martes"
+        dayName = 'Tuesday'
         break
     case 2:
-        dayName = "Miércoles"
+        dayName = 'Wednesday'
         break
     case 3:
-        dayName = "Jueves"
+        dayName = 'Thursday'
         break
     case 4:
-        dayName = "Viernes"
+        dayName = 'Friday'
         break
     case 5:
-        dayName = "Sábado"
+        dayName = 'Saturday'
         break
     case 6:
-        dayName = "Domingo"
+        dayName = 'Sunday'
         break
     default:
-        dayName = "Número de día incorrecto"
+        dayName = 'Introduce a correct value'                        
+
 }
+console.log(dayName)
 
-console.log(dayName)
\ No newline at end of file
diff --git a/Basic/09-conditionals-exercises.js b/Basic/09-conditionals-exercises.js
index 380e6542..1a989ea0 100644
--- a/Basic/09-conditionals-exercises.js
+++ b/Basic/09-conditionals-exercises.js
@@ -6,24 +6,222 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=8652
 // if/else/else if/ternaria
 
 // 1. Imprime por consola tu nombre si una variable toma su valor
+console.log('Exercise 1')
+let myName = 'Daniel'
+let myLastName = 'Builes'
+let youNameIs = `Hi ${myName} how you're doing?`
+if(myName == 'Daniel'){
+    console.log(youNameIs)
+}
+if (myLastName == 'Builes'){
+    console.log(`Your last name is ${myLastName}`)
+}
+console.log('---------------------------------------------------------')
 
 // 2. Imprime por consola un mensaje si el usuario y contraseña concide con unos establecidos
+console.log('Exercise 2')
+let user = 'dani'
+let password = '123'
+if(user == 'dani' && password == '123'){
+    console.log('welcome mr')
+} else{
+    console.log('You user or password are incorrect')
+}
+console.log('---------------------------------------------------------') 
 
 // 3. Verifica si un número es positivo, negativo o cero e imprime un mensaje
-
+console.log('Exercise 3')
+let number = -7
+if(number == 0){
+    console.log('your number is 0')
+} else if(number < 0){
+    console.log('You put a negative number')
+} else{
+    console.log('your put a positive number')
+}
+console.log('--------------------------------------------------------------------------------------')
 // 4. Verifica si una persona puede votar o no (mayor o igual a 18) e indica cuántos años le faltan
+console.log('Exercise 4')
+let age = 15
+let legalAge = 18
+let ageNecesary = legalAge - age
+let message = `You will be able to vote in ${ageNecesary} years more`
+if (age >= legalAge){
+    console.log('You are able to vote')
+} else if (age < 0){
+    console.log('Please enter  a correct value')
+} else{
+    console.log(message)
+}
+console.log('------------------------------------------------------------------------------------------------')
 
 // 5. Usa el operador ternario para asignar el valor "adulto" o "menor" a una variable
 //    dependiendo de la edad 
+console.log('Exercise 5')
+let yourAge = 16;
+// usaré la varialble legalAge del ejercicio anterior
+let youAre = yourAge >= legalAge ? 'You are over age' : 'You are under age'
+console.log(youAre)
+console.log('----------------------------------------------------------------------------------------------------')
 
 // 6. Muestra en que estación del año nos encontramos dependiendo del valor de una variable "mes"
-
+console.log('Exercise 6')
+let mounth = 2
+if (mounth >= 1 && mounth <= 3){
+    console.log('You chose Winter season')
+} else if (mounth > 3 && mounth <= 6){
+    console.log('You chose Spring season')
+} else if (mounth > 6 && mounth <= 9){
+    console.log('You chose Summer season')
+} else if (mounth <= 0 || mounth > 12){
+    console.log('Please enter a correct value')
+} else{
+    console.log('You chose Atumn season')
+}
+console.log('------------------------------------------------------------------------------------------------------')
 // 7. Muestra el número de días que tiene un mes dependiendo de la variable del ejercicio anterior
-
+console.log('Exercise 7')
+let actualYear = 2024
+if (mounth <=0 || mounth >12){
+    console.log('Please enter a correct value')
+} else if(mounth == 2){
+    if(actualYear % 4 === 0){
+        console.log(`You chose February and we are in a leap year (${actualYear}), therefore February has 29 days`)
+    } else {
+        console.log(`You chose February, we are not in a leap year, therefore February has 28 days`)
+    }
+} else if (mounth == 4 || mounth == 6 || mounth == 9 || mounth == 11){
+    console.log('You chose between april, june september or november mounths, each of this mounths has 30 days')
+} else{
+    console.log('You chose between january, march, july, august, october or december mounths, each of this mounths has 31 days')
+}
+console.log('----------------------------------------------------------------------------------------------------------')
 // switch
-
+console.log('Switch Exercises')
 // 8. Usa un switch para imprimir un mensaje de saludo diferente dependiendo del idioma
+console.log('Excersise 8')
+let idiom = 'dutch'
+let theMessage 
 
+switch (idiom){
+    case 'spanish':
+        theMessage = 'Hola a todos y todas!'
+        break
+    case 'english':
+        theMessage = 'Hi everyone!!'
+        break
+    case 'dutch':
+        theMessage = 'Hallo allemaal!' 
+        break 
+    case 'french':
+        theMessage = 'Bonjour à tous !' 
+        break
+    case 'japanese':
+        theMessage = '皆さん、こんにちは'    
+        break
+    default:
+        if(idiom != typeof String){
+            theMessage = 'Please enter a correct value'
+        }             
+}
+console.log(theMessage)
+console.log('----------------------------------------------------------------------------------------------')
 // 9. Usa un switch para hacer de nuevo el ejercicio 6
+console.log('Exercise 9')
+let youMounth = 4
+let theSeasonIs
+
+switch(youMounth){
+    case 1:
+        theSeasonIs = 'The season is Winter' @
+        break
+    case 2:
+        theSeasonIs = 'The season is Winter'
+        break 
+    case 3:
+        theSeasonIs = 'The season is Winter'
+        break
+    case 4:
+        theSeasonIs = 'The season is Spring'
+        break
+    case 5:
+        theSeasonIs = 'The season is Spring'
+        break
+    case 6:
+        theSeasonIs = 'The season is Spring'
+        break 
+    case 7:
+        theSeasonIs = 'You chose Summer season'
+        break
+    case 8: 
+        theSeasonIs = 'You chose Summer season'
+        break  
+    case 9:
+        theSeasonIs = 'You chose Summer season'
+        break 
+    case 10: 
+        theSeasonIs = 'You chose Summer Autumn'
+        break  
+    case 11: 
+        theSeasonIs = 'You chose Summer Autumn'
+        break
+    case 12:
+        theSeasonIs = 'You chose Summer Autumn'
+        break  
+    default:
+        theSeasonIs = 'Please enter a correct value'                    
+}
+console.log(theSeasonIs)
+console.log('-----------------------------------------------------------------------------------------------------')
+// 10. Usa un switch para hacer de nuevo el ejercicio 7
+console.log('exercise 10')
+let thisMounth = 10
+let days
+let thisYear = 2024
 
-// 10. Usa un switch para hacer de nuevo el ejercicio 7
\ No newline at end of file
+switch(thisMounth){
+    case 1:
+        days = 'January has 31 days'
+        break
+    case 2:
+        if(thisYear % 4 === 0){
+            days = `You chose February and we are in a leap year (${thisYear}), therefore February has 29 days`
+        } else {
+             days = `You chose February, we are not in a leap year, therefore February has 28 days`
+        }
+        
+        break 
+    case 3:
+        days = 'March has 31 days'
+        break
+    case 4:
+        days = 'april has 30 days'
+        break
+    case 5:
+        days = 'May has 31 days'
+        break
+    case 6:
+        days = 'june has 30 days'
+        break 
+    case 7:
+        days = 'July has 31 days'
+        break
+    case 8: 
+        days = 'August  has 31 days'
+        break  
+    case 9:
+        days = 'September has 30 days'
+        break 
+    case 10: 
+        days = 'October has 31 days'
+        break  
+    case 11: 
+        days = 'November has 30 days'
+        break
+    case 12:
+        days = 'December has 31 days'
+        break  
+    default:
+        days = 'Please enter a correct value'                    
+}
+console.log(days)

From c4ae14d941418a18fd5acbfd8b81a082742159d8 Mon Sep 17 00:00:00 2001
From: danielBuGo <danielbuilesgomez@gmail.com>
Date: Wed, 5 Mar 2025 09:37:51 -0500
Subject: [PATCH 02/16] first half

---
 Basic/10-array.js                | 112 ++++++++++++--------------
 Basic/11-set.js                  | 130 ++++++++++++++++++++++++-------
 Basic/12-map.js                  | 125 +++++++++++++++++++++--------
 Basic/13-structures-exercises.js |  93 +++++++++++++++++++++-
 Basic/14-loops.js                | 108 ++++++++++++++-----------
 Basic/15-loops-exercises.js      | 114 +++++++++++++++++++++++++--
 6 files changed, 504 insertions(+), 178 deletions(-)

diff --git a/Basic/10-array.js b/Basic/10-array.js
index b9028147..d9e53aa6 100644
--- a/Basic/10-array.js
+++ b/Basic/10-array.js
@@ -5,100 +5,86 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=8741
 
 // Array
 
+
 // Declaración
+let myArray = []; //forma comun de declarar un array
+let myArray2 = new Array();// antigua forma de declarar una Array
+let yourArray = []
 
-let myArray = []
-let myArray2 = new Array()
-
-console.log(myArray)
-console.log(myArray2)
 
 // Inicialización
-
-myArray = [3]
-myArray2 = new Array(3)
-
-console.log(myArray)
-console.log(myArray2)
-
 myArray = [1, 2, 3, 4]
-myArray2 = new Array(1, 2, 3, 4)
-
+yourArray = ['attack on titan']
+console.log(yourArray)
 console.log(myArray)
+myArray2 = new Array(5)
 console.log(myArray2)
 
-myArray = ["Brais", "Moure", "mouredev", 37, true]
-myArray2 = new Array("Brais", "Moure", "mouredev", 37, true)
-
+myArray = ['Daniel', 'Lina', 36, 'bella', true]
 console.log(myArray)
+myArray2 = new Array('Manuela', 'Mariana', 18, false)
 console.log(myArray2)
 
-myArray2 = new Array(3)
-myArray2[2] = "Brais"
-// myArray2[0] = "Moure"
-myArray2[1] = "mouredev"
-myArray2[4] = "mouredev"
-
+myArray2[0] = 'paragliding'
+myArray2[1] = 'futbol'
+myArray2[2] = 'motocross'
 console.log(myArray2)
 
-myArray = []
-myArray[2] = "Brais"
-// myArray[0] = "Moure"
-myArray[1] = "mouredev"
-
-console.log(myArray)
-
 // Métodos comunes
-
 myArray = []
-
 // push y pop
-
-myArray.push("Brais")
-myArray.push("Moure")
-myArray.push("mouredev")
-myArray.push(37)
-
+myArray.push('ozone') //push te permite agragar elemnto al array
+myArray.push('swing')
+myArray.push('advance')
+myArray.push('skyparagliders')
+myArray.push('niviuk')
 console.log(myArray)
-
-console.log(myArray.pop()) // Elimina el último y lo devuelve
 myArray.pop()
+myArray.pop()
+myArray.pop()
+console.log(myArray)//te borra el ultimo elemnto del array
 
-console.log(myArray)
+console.log('+++++++++++++++++++++++++++++++++++++++++++++++++++++++')
 
-// shift y unshift
+console.log(yourArray.push('death Note'))
+console.log(yourArray.push('Demond slayer'))
+yourArray.unshift('solo leveling', 'the hero of the shield', 'full metal alchemist', 'Detective conan')//añade al inicio de la lista
+console.log(yourArray.length)
+console.log(yourArray)
+console.log('-------------------------------------------------')
+console.log(yourArray.shift())//  borra le primero de la lista
+console.log(yourArray.pop()) // borra el ultimo de la lista
+console.log(yourArray)
 
-console.log(myArray.shift())
-console.log(myArray)
+console.log('___________________________________________________________')
+let creatingArray = yourArray.slice(1,6)
+console.log(creatingArray)
 
-myArray.unshift("Brais", "mouredev")
+// shift y unshift
+console.log(myArray.shift()) //te borre el primer elemnto del array
+myArray.unshift('swing', 'advance', 'skyparagliders', 'niviuk') //añade elementos al inicio de la lista
 console.log(myArray)
-
 // length
-
 console.log(myArray.length)
+console.log(yourArray.length)
 
-// clear
 
-myArray = []
-myArray.length = 0 // alternativa
-console.log(myArray)
+// clear
+//myArray = []
 
 // slice
 
-myArray = ["Brais", "Moure", "mouredev", 37, true]
-
-let myNewArray = myArray.slice(1, 3)
-
-console.log(myArray)
-console.log(myNewArray)
-
+let newArray = myArray.slice(1, 2)// cree un array con el elemnto 1 de mi array (no toma el segundo valor)
+myArray.push(37);
+console.log(newArray);
 // splice
-
-myArray.splice(1, 3)
+myArray.splice(1, 3) //elimino los elementos asignados
 console.log(myArray)
 
-myArray = ["Brais", "Moure", "mouredev", 37, true]
+let otherArray = [3, 5, 7, 8, 9, 20]
+console.log(otherArray)
+otherArray.splice(3, 4, 5) // añade el ultimo argumento al array
+otherArray.splice(3,4)
+console.log(otherArray)
+
 
-myArray.splice(1, 2, "Nueva entrada")
-console.log(myArray)
\ No newline at end of file
diff --git a/Basic/11-set.js b/Basic/11-set.js
index aab6cf3f..ffaf3b3e 100644
--- a/Basic/11-set.js
+++ b/Basic/11-set.js
@@ -6,56 +6,126 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=9952
 // Set
 
 // Declaración
-
 let mySet = new Set()
+let yourSet = new Set()
 
+// Inicialización
+mySet = new Set(['delta', 'alpina', 'swift5'])
 console.log(mySet)
+console.log('___________________________________________________-')
+yourSet = new Set([3, 345, 5567, 4,8,19,20,832774389,3])
+console.log(yourSet.size)
+console.log(yourSet)
 
-// Inicialización
 
-mySet = new Set(["Brais", "Moure", "mouredev", 37, true, "braismoure@mouredev.com"])
 
-console.log(mySet)
 
 // Métodos comunes
 
 // add y delete
-
-mySet.add("https://moure.dev")
-
+mySet.add('danielbuilesgomez@gmail.com')
+mySet.add('sphera')
+mySet.add('nyos')
+mySet.add('zeno2')
 console.log(mySet)
 
-mySet.delete("https://moure.dev")
-
+mySet.delete('sphera') //se borra el item con el nombre exacto
+mySet.delete('delta') //se borra el item con el nombre exacto, si existe la consola muestra true, sino flase
+console.log(mySet.delete('delta')) //se borra el item con el nombre exacto
 console.log(mySet)
-
-console.log(mySet.delete("Brais"))
-console.log(mySet.delete(4))
-
-console.log(mySet)
-
-// has
-
-console.log(mySet.has("Moure"))
-console.log(mySet.has("Brais"))
-
-// size
-
+console.log('_______________________________________________________________________')
+console.log('++++++Borrando y agregando elementos con el metodo "add" y "delete"++++++++++++')
+yourSet.add(45)
+yourSet.add(58)
+yourSet.add(58)// set no deja repetir datos
+yourSet.delete(45)// para borrar debe ponserse exacto el nombre del elemnto
+yourSet.delete(832774389)
+console.log(yourSet)
+console.log('__________________________________________________________________________')
+console.log('+++++++++Comprobando si el dato existe con el metodo "has')
+console.log(yourSet.has(345))
+console.log(yourSet.has(34))
+console.log(yourSet.has(2))
+console.log(yourSet.has(58))
+
+console.log('-------------------------------------------------------------------------------------')
+
+// has comprueba si el item se encuentra en mi lista set
+console.log(mySet.has('nyos'))
+console.log(mySet.has('alpina'))
+console.log(mySet.has('sphera'))
+console.log(mySet.has('delta'))
+console.log(mySet.has('swift5'))
+
+// size muestra la cantidad de items en mi set
 console.log(mySet.size)
-
 // Convertir un set a array
 let myArray = Array.from(mySet)
 console.log(myArray)
+let otherSet = new Set (['toyota', 'hammer', 'renault', 'chevrolet', 'ferrari'])
+console.log(otherSet)
+console.log(otherSet.size)
+otherSet.add('hero')
+console.log(otherSet)
+console.log(otherSet.has('hero'))
+let otherArray = Array.from(otherSet)
+console.log(otherArray)
 
-// Convertir un array a set
+console.log('_________________________________________________________________-')
+console.log('+++++++Convirtiendo set en array++++++++++++')
+let convertionArray = Array.from(yourSet)
+console.log(convertionArray)
 
+
+console.log('-----------------------------------------------')
+
+
+// Convertir un array a set
+console.log('+++++++++++Convirtiendo El array en Set')
+let setAgain = new Set(convertionArray)
+console.log(setAgain)
+console.log('_________________________________________________________')
+otherSet = new Set (otherArray)
+console.log(otherSet)
 mySet = new Set(myArray)
 console.log(mySet)
 
 // No admite duplicados
-
-mySet.add("braismoure@mouredev.com")
-mySet.add("braismoure@mouredev.com")
-mySet.add("braismoure@mouredev.com")
-mySet.add("BraisMoure@mouredev.com")
-console.log(mySet)
\ No newline at end of file
+//esta es la diferencia principal entre array y set
+
+console.log('______________________________________________________________-')
+console.log('++++++ Crear 5 arrays y pasarlas a set+++++++')
+let colombianBrands = ['Haceb', 'Tres Cordilleras', 'Noel', 'Postobon', 'Colanta']
+colombianBrands.push('Haceb')
+colombianBrands.unshift('Haceb')
+console.log(colombianBrands)
+let soccerTeams = ['Atl Nacional', 'Medellín', 'America', 'Millonarios', 'Envigado']
+console.log(soccerTeams)
+let countriesVisited = ['United States', 'Panamá', 'Puerto Rico', 'Netherlands']
+console.log(countriesVisited)
+let stadiumsVisited = ['atanasio', 'El Campin', 'polideportivo Sur', 'Palogrande', 'Ditaires']
+console.log(stadiumsVisited)
+let airlinesVisited = ['Avianca', 'American Airlines', 'Click', 'Spirit', 'Copa Airlines']
+console.log(airlinesVisited)
+console.log('+++Convirtiendo a set+++++')
+let colombianBrandsToSet = new Set(colombianBrands) //Al convertirlo a SET, solo aparece uno de los elementos repetidos
+console.log(colombianBrandsToSet)
+let soccerTeamsToSet = new Set(soccerTeams)
+console.log(soccerTeamsToSet)
+let countriesVisitedToSet = new Set (countriesVisited)
+console.log(countriesVisitedToSet)
+let stadiumsVisitedToSet = new Set(stadiumsVisited)
+console.log(stadiumsVisitedToSet)
+let airlinesVisitedToSet = new Set(airlinesVisited)
+console.log(airlinesVisitedToSet)
+
+console.log('++++++ Pasar los SEt nuevamente a Array')
+let colombianBrandsToArray = Array.from(colombianBrandsToSet)
+console.log(colombianBrandsToArray)
+let soccerTeamsToArray = Array.from(soccerTeamsToSet)
+console.log(soccerTeamsToArray)
+let countriesVisitedToArray = Array.from(countriesVisitedToSet)
+console.log(countriesVisitedToArray)
+let stadiumsVisitedToArray = Array.from(stadiumsVisitedToSet)
+let airlinesVisitedToArray = Array.from(airlinesVisitedToSet)
+console.log(airlinesVisitedToArray)
diff --git a/Basic/12-map.js b/Basic/12-map.js
index b91f3d6c..11016014 100644
--- a/Basic/12-map.js
+++ b/Basic/12-map.js
@@ -3,64 +3,125 @@ Clase 27 - Maps
 Vídeo: https://youtu.be/1glVfFxj8a4?t=10755
 */
 
-// Map
+// Map se crean datos por pares (clave y dato)
 
 // Declaración
-
 let myMap = new Map()
-
 console.log(myMap)
 
-// Inicialiación
 
+// Inicialiación 
+console.log('++++++Inicializando Cinco mapas++++++++++')
 myMap = new Map([
-    ["name", "Brais"],
-    ["email", "braismoure@mouredev.com"],
-    ["age", 37]
+    ['Brand', 'Ozone'],
+    ['name', 'Daniel'],
+    ['age', 36],
+    ['adress', 'Cr 75da']
 ])
-
 console.log(myMap)
+console.log('____________________________________-')
+let myMAp2 = new Map([
+    ['City', 'Medellín'],
+    ['Country', 'Colombia'],
+    ['Neighberhood', 'Ditaires']
+])
+console.log(myMAp2)
+console.log('_________________________________________________')
+let myMap3 = new Map([
+    ['Brand Glider', 'Ozone'],
+    ['Level', 'EN C'],
+    ['Reference', 'Swift 5'],
+    ['Color', 'Purple & red']
+])
+console.log(myMap3)
+console.log('______________________________________________________')
+let myMap4 = new Map([
+    ['University', 'Cesde'],
+    ['School', 'San Marcos'],
+    ['Work Name', 'Emtelco']
+])
+console.log(myMap4)
 
 // Métodos y propiedades
-
 // set
-
-myMap.set("alias", "mouredev")
-myMap.set("name", "Brais Moure")
-
+console.log('++++++El metodo Set++++++++')
+myMap.set('alias', 'fourloquillo')
+myMap.set('Email', 'Daniel@gmail.com')
+myMap.set('name', 'lina') //Si trato de poner  otro nombre con la misma clave, solo cambia el nombre, no se añade otro
 console.log(myMap)
+console.log('----------------------------------------------')
+myMAp2.set('Neighberhood', 'La mota') //Si pongo la misma clave, se modifica su valor inicial
+myMAp2.set('Number', 5)
+console.log(myMAp2)
+console.log('_____________________________________________________________________-')
+myMap3.set('Second glider', 'Argos')
+console.log(myMap3)
+console.log('+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
 
 // get
-
-console.log(myMap.get("name"))
-console.log(myMap.get("surname"))
+console.log('++++++++Metodo get++++++++') //El metodo get busca unicamente las claves, no los elementos asociados e estas
+console.log(myMap4.get('University'))
+console.log(myMap4.get('Work Name'))
+console.log(myMap3.get('Level'))
+console.log(myMap3.get('EN C'))// no Ubica Elementos, solo claves
+console.log('____________________________________________________________________')
 
 // has
-
-console.log(myMap.has("surname"))
-console.log(myMap.has("age"))
-
-// delete
-
-myMap.delete("email")
-
+console.log('+++++++ Metodo Has +++++++++++') // Devuelve True or False si la clave q buscas esta o no en el mapa
+console.log(myMap.has('Brand'))
+console.log(myMap.has('Adress')) //la clave tiene que ser identicamente copiada
 console.log(myMap)
+console.log('________________________________________________-')
+console.log(myMap4.has('School'))
+console.log(`El valor de la escuela es ${myMap4.get('School')} y el se encuentra en la lista ${myMap4.has('School')}`)
+console.log('_____________________________________________________________________________________________________-')
 
-// keys, values y entries
-
+// delete
+console.log('++++++ Metodo Delete +++++++++') //borra la dupla de la llave que escojamos
+myMap3.delete('Second glider')
+myMap3.delete('Level')
+console.log(myMap3)
+console.log('____________________________________________________________')
+
+//clear
+console.log('+++++ Metodo clear +++++++') // lo uso para borrar todo lo que esta en el mapa
+myMap4.clear()
+console.log(myMap4)
+console.log('________________________________________________________________')
+
+// keys
+console.log('++++ Metodo Keys ++++++')//devuelve listado de las keys del mapa
 console.log(myMap.keys())
+console.log(myMap4.keys())
+console.log(myMap3.keys())
+console.log('____________________________________________-')
+// size
+console.log('+++++++ Metodo size +++++++++')// muestra el tamaño del mapa
+console.log(myMap3.size)
+console.log(myMap4.size)
+console.log(myMAp2.size)
+console.log('______________________________________________-')
+console.log('++++ Metodo Values ++++++++')// devuelve los valores sin las claves
 console.log(myMap.values())
+console.log(myMAp2.values())
+console.log(myMap3.values())
+console.log(myMap4.values())
+console.log('__________________________________________________________________________-')
+//Entries
+console.log('+++++ Metodo Entries +++++')//muestra las entrada o la dupla completa
 console.log(myMap.entries())
-
-// size
-
-console.log(myMap.size)
+console.log(myMAp2.entries())
+console.log(myMap3.entries())
+console.log(myMap4.entries())
+console.log('___________________________________________________________________')
 
 // clear
+console.log('++++++++ borrar el mapa +++++++')
+myMAp2.clear()
+console.log(myMAp2)
+
 
-myMap.clear()
 
-console.log(myMap)
 
 
 
diff --git a/Basic/13-structures-exercises.js b/Basic/13-structures-exercises.js
index 1b094502..3f6e7335 100644
--- a/Basic/13-structures-exercises.js
+++ b/Basic/13-structures-exercises.js
@@ -4,21 +4,110 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=11451
 */
 
 // 1. Crea un array que almacene cinco animales
+console.log('++++++ 1 Crea un array que almacene cinco animales +++++ ')
+let myAnimals = ['Lion', 'Tiger', 'Horse', 'Cow', 'Seal']
+console.log(myAnimals)
+console.log('______________________________________________________________')
 
 // 2. Añade dos más. Uno al principio y otro al final
-
+console.log('++++++ 2. Añade dos más. Uno al principio y otro al final +++++ ')
+myAnimals.unshift('Bear')
+myAnimals.push('Eagle')
+console.log(myAnimals)
+console.log('__________________________________________________________________________')
 // 3. Elimina el que se encuentra en tercera posición
+console.log('3. Elimina el que se encuentra en tercera posición')
+myAnimals.splice(2,3)
+console.log(myAnimals)
+console.log('______________________________________________________________________________________')
 
 // 4. Crea un set que almacene cinco libros
+console.log('4. Crea un set que almacene cinco libros')
+let books = new Set(['Lord of the rings', 'Harry Potter', 'Jurassic Park', 'The witcher', 'The odisey'])
+console.log(books)
+console.log('______________________________________________________________________________-')
 
 // 5. Añade dos más. Uno de ellos repetido
+console.log('5. Añade dos mas. Uno de ellos Repetido')
+books.add('Narnia cronicles')
+books.add('The odisey')
+console.log(books)
+console.log('__________________________________________________')
 
 // 6. Elimina uno concreto a tu elección
+console.log('6. Elimina uno en concreto de tu eleccion')
+books.delete('Lord of the rings')
+console.log(books)
+console.log('___________________________________________________________________')
 
 // 7. Crea un mapa que asocie el número del mes a su nombre
+console.log('7. crea un mapa que asocie el numero del mes a su nombre')
+let mounth = new Map([
+    [1, 'January'],
+    [2, 'February'],
+    [3, 'March'],
+    [4, 'April'],
+    [5, 'May'],
+    [6, 'Jane'],
+    [7, 'July'],
+    [8, 'August'],
+    [9, 'September'],
+    [10,'October'],
+    [11, 'November'],
+    [12, 'December']
+
+])
+console.log(mounth)
+console.log('________________________________________________________________________-')
 
 // 8. Comprueba si el mes número 5 existe en el map e imprime su valor
+console.log('8. Comprueebe si el mes 5 existe en el mapa e imprima su valor')
+console.log(`Is the mount 5 in the list?: ${mounth.has(5)}`)
+console.log(`What is the mounth 5?: ${mounth.get(5)}`)
+
 
 // 9. Añade al mapa una clave con un array que almacene los meses de verano
+console.log('9. Añade al mapa una clave con un array que almacene los meses de verano')
+mounth.set('summer', ['july', 'august', 'september'])
+console.log(mounth)
+console.log('_________________________________________________________________________________________________')
+
+// 10. Crea un Array, transfórmalo a un Set y almacénalo en un Map
+console.log('10. Crea un array, tranformalo en set y almacenalo en un Map')
+let homeWork = [];
+homeWork = [5, 6, 8];
+console.log(homeWork);
+let newHomeWork = new Set(homeWork)
+console.log(newHomeWork)
+let roomMap = new Map([
+    ['numbers', newHomeWork]
+])
+console.log(roomMap)
+console.log('______________________________________')
+//Array
+let linasArray = []
+linasArray = ['mariana', 'manuela', 'bella']
+console.log(linasArray)
+//Set
+let newLinasSet = new Set(linasArray)
+console.log(newLinasSet)
+//Guardar en Map
+let newLinasMap = new Map([
+    ['Family Members', newLinasSet]
+])
+console.log(newLinasMap)
+console.log('________________________________________________-')
+//Array
+let myFamily = ['Luz', 'Nico', 'Andrea', 'bella']
+console.log(myFamily)
+console.log('__________________________________________________')
+// Set
+let myFamilySet = new Set(myFamily)
+console.log(myFamilySet)
+console.log('________________________________________________________')
+//Map
+let myFamilyMap = new Map([
+    ['My family members', myFamilySet]
+])
+console.log(myFamilyMap)
 
-// 10. Crea un Array, transfórmalo a un Set y almacénalo en un Map
\ No newline at end of file
diff --git a/Basic/14-loops.js b/Basic/14-loops.js
index 3d1361d6..257b11e0 100644
--- a/Basic/14-loops.js
+++ b/Basic/14-loops.js
@@ -6,74 +6,90 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=11575
 // Loops o bucles
 
 // for
-
-for (let i = 0; i < 5; i++) {
-    console.log(`Hola ${i}`)
+console.log('++++ Bucle For ++++++')
+for (let i = 0; i < 5; i++){//La variable se inicialia dentro del ciclo for "let i = 0" y la condicion final tambien "i++"
+    console.log(`Hello ${i}`)
 }
-
+console.log('__________________________________________________________________')
+for(let j = 0; j <= 15; j ++){
+    console.log(`Este es el mensaje número ${j}`)
+}
+console.log('_________________________________________________________________________')
+//Recorrer una array con cilco For
 const numbers = [1, 2, 3, 4, 5, 6, 7, 8]
 
-for (let i = 0; i < numbers.length; i++) {
-    console.log(`Elemento: ${numbers[i]}`)
+for(let i = 0; i < numbers.length;i++){//numbers.length es el tamaño del array
+    console.log(`Este  es el listado de numbers: ${numbers[i]}`) //
 }
+console.log('_______________________________________________________________________________')
 
 // while
-
-let i = 0
-while (i < 5) {
-    console.log(`Hola ${i}`)
-    i++
+console.log('++++++ Bucle While +++++++++')
+let i = 0; //la variable se inicializa fuera del ciclo while
+while (i < 5){
+    console.log(`Solicité este mensaje ${i}`)
+    i++//La condicion final va dentro del Bucle
+};
+console.log('____________________________________________________________-')
+let myLoop = 0
+while (myLoop < 6){
+    console.log(`Mostrando la lista ${myLoop}`)
+    myLoop++
+}
+console.log('________________________________________________________________________')
+let caca = 0
+while ( caca <=4){
+    console.log(`caca número ${caca}`)
+    caca++
 }
+console.log('_________________________________________________________________________-')
 
 // Bucle infinito
 // while(true) {
 // }
 
-// do while
+// do while: El codigo se ejecuta minimo una vez antes de pasar a validar
+console.log('Bucle Do While')
+ caca = 0
 
-i = 6
-do {
-    console.log(`Hola ${i}`)
-    i++
-} while (i < 5)
+do{
+    console.log(`Hola ${caca}`)
+    caca++
 
-// for of
+}while(caca < 6)
+console.log('_________________________________________________________________________________________')
+console.log('+++++++++ ciclo For of +++++++++')//para iterar map,set array
 
-myArray = [1, 2, 3, 4]
-
-mySet = new Set(["Brais", "Moure", "mouredev", 37, true, "braismoure@mouredev.com"])
-
-myMap = new Map([
-    ["name", "Brais"],
-    ["email", "braismoure@mouredev.com"],
-    ["age", 37]
+let myArray = [1, 5, 8, 9, 10]
+let mySet = new Set(['muñeca', 'roberto', 'bella'])
+let myMap = new Map([
+    ['name', 'Daniel'],
+    ['Last Name', 'Builes'],
+    ['City', 'Medellín']
 ])
-
-myString = "¡Hola, JavaScript!"
-
-for (let value of myArray) {
+for (const value of myArray) {//El value es el nombre de la variable puedes ponerle el que sea
     console.log(value)
+    
 }
-
-for (let value of mySet) {
-    console.log(value)
+console.log('_________________________________________________________-')
+for (const element of mySet) {
+    console.log(element)
 }
-
-for (let value of myMap) {
-    console.log(value)
-}
-
-for (let value of myString) {
-    console.log(value)
+console.log('_______________________________________________________________')
+for (const map of myMap) {
+    console.log(map)
 }
+console.log('________________________________________________________________-')
 
+console.log('++++Buenas practicas ++++++')
 // break y continue
-
-for (let i = 0; i < 10; i++) {
-    if (i == 5) {
+for (let i = 0; i < 10; i++){
+    if(i == 4){
         continue
-    } else if (i == 7) {
+    }else if (i == 9){
         break
     }
-    console.log(`Hola ${i}`)
-}
\ No newline at end of file
+     console.log(`hola ${i}`)   
+        
+}
+
diff --git a/Basic/15-loops-exercises.js b/Basic/15-loops-exercises.js
index 2a27cdd0..9394e7c1 100644
--- a/Basic/15-loops-exercises.js
+++ b/Basic/15-loops-exercises.js
@@ -6,19 +6,123 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=12732
 // NOTA: Explora diferentes sintaxis de bucles para resolver los ejercicios
 
 // 1. Crea un bucle que imprima los números del 1 al 20
+console.log('1. Crea un bucle que muestre numeros del 1 al 20')
+console.log('+++ Ciclo for +++')
+for(let i = 1; i <= 20; i++){
+    console.log(`Número ${i}`)
+}
+console.log('+++ Cilco While +++')
+let i = 1
+while(i <= 20){
+    console.log(`Con ciclo while número ${i}`)
+    i++
+}
+console.log('+++++++ Ciclo Do While ++++++++++')
+i = 1
+do{
+    console.log(`Con do While número: ${i}`)
+    i++
+}while(i  <= 20 )
+console.log('_________________________________________________________________________________--')    
+console.log('2. Crea un bucle que sume todos los números del 1 al 100 y muestre el resultado')
+console.log('Ciclo For')
+let suma = 0
+for (let i = 1; i <= 100; i++ ){
+    suma += i;   
 
-// 2. Crea un bucle que sume todos los números del 1 al 100 y muestre el resultado
+}
+console.log(`La suma es: ${suma}`)
+console.log('+++ Ciclo While +++')
+suma = 0
+i = 1
+while(i <= 100){
+    suma += i
+    i++
+}
+console.log(`La suma con el ciclo while: ${suma}`)
+suma = 0
+i = 1
+console.log('+++ Ciclo Do While +++')
+do {
+    suma += i
+    i++
+}while(i <= 100)
+console.log(`Utilizando el cliclo do while la suma es: ${suma}`)
+console.log('________________________________________________________________________________________')
+console.log('3. Crea un bucle que imprima todos los números pares entre 1 y 50')
+console.log('+++++ Ciclo For +++++')
+for (let i = 0; i <= 50; i+=2) {
+    console.log(`los números pares son: ${i}`)    
+}
+console.log('+++++ Con cilo While +++++')
+i = 0
 
-// 3. Crea un bucle que imprima todos los números pares entre 1 y 50
+while(i < 50){
+    console.log(`Número par: ${i}`)
+    i += 2  
 
-// 4. Dado un array de nombres, usa un bucle para imprimir cada nombre en la consola
+}
+console.log('++++++ Usando Ciclo Do While')
+i = 0
+do{
+    console.log(`Pares usando Do While: ${i} `)
+    i += 2
+}while(i < 50)
+console.log('___________________________________________________________________________________________-')
 
-// 5. Escribe un bucle que cuente el número de vocales en una cadena de texto
 
-// 6. Dado un array de números, usa un bucle para multiplicar todos los números y mostrar el producto
+console.log('4. Dado un array de nombres, usa un bucle para imprimir cada nombre en la consola')
+console.log('+++ Ciclo For of +++')
 
+let names = ['daniel', 'bella', 'lina']
+for (const element of names) {
+    console.log(`My name is: ${element}`)    
+}
+console.log('+++ Bucle For +++')
+
+for (i = 0;i < names.length; i++){
+    console.log(names)
+};
+console.log('+++ Ciclo While +++')
+ i = 0
+ while(i < names.length){
+    console.log(`my name is: ${names[i]}`)// Debemos entrar a la pocision del array
+    i++
+ };
+ console.log('+++ Do While +++')
+ i = 0
+do{
+    console.log(`Mu name is: ${names[i]}`)
+    i++
+}while(i < names.length)
+    console.log('_______________________________________________________________')
+
+let string = 'how many vocal can you see'
+let vocals = 'aeiouAEIOU'
+let counter = 0
+for (const char of string) {
+    if(vocals.includes(char))
+        counter++    
+    
+}
+console.log(counter)
+
+console.log('6. Dado un array de números, usa un bucle para multiplicar todos los números y mostrar el producto')
+
+
+console.log('_______________________________________________________________________________________-')
+// Lo habia entendido mal e hice esto
+let myNumbers = [5, 2, 4, 8]
+for (let i = 0; i < myNumbers.length; i++){
+    console.log(`${myNumbers[i]} * ${myNumbers[0]} = ` + myNumbers[i]*myNumbers[0])
+    console.log(`${myNumbers[i]} * ${myNumbers[1]} = ` + myNumbers[i]*myNumbers[1])
+    console.log(`${myNumbers[i]} * ${myNumbers[2]} = ` + myNumbers[i]*myNumbers[2])
+    console.log(`${myNumbers[i]} * ${myNumbers[3]} = ` + myNumbers[i]*myNumbers[3])
+    
+}
 // 7. Escribe un bucle que imprima la tabla de multiplicar del 5
 
+
 // 8. Usa un bucle para invertir una cadena de texto
 
 // 9. Usa un bucle para generar los primeros 10 números de la secuencia de Fibonacci

From 8531b07fe705646e1eb8b02d14053a79d95ceb30 Mon Sep 17 00:00:00 2001
From: danielBuGo <danielbuilesgomez@gmail.com>
Date: Wed, 5 Mar 2025 11:47:43 -0500
Subject: [PATCH 03/16] new changes

---
 Basic/.bash   | 1 +
 Basic/.bashrc | 1 +
 2 files changed, 2 insertions(+)
 create mode 100644 Basic/.bash
 create mode 100644 Basic/.bashrc

diff --git a/Basic/.bash b/Basic/.bash
new file mode 100644
index 00000000..806977e2
--- /dev/null
+++ b/Basic/.bash
@@ -0,0 +1 @@
+eval "$(oh-my-posh init bash --config ~/AppData/Local/Programs/oh-my-posh/themes/cobalt2.omp.json)"
diff --git a/Basic/.bashrc b/Basic/.bashrc
new file mode 100644
index 00000000..2bfa7540
--- /dev/null
+++ b/Basic/.bashrc
@@ -0,0 +1 @@
+eval "$(oh-my-posh init bash)"

From 34a666d1af11999d2d4099193116f547d05f2d4e Mon Sep 17 00:00:00 2001
From: danielBuGo <danielbuilesgomez@gmail.com>
Date: Fri, 7 Mar 2025 13:10:23 -0500
Subject: [PATCH 04/16] just finished loops exercises

---
 Basic/15-loops-exercises.js | 102 ++++++++++++++++++++++++++++++++++--
 1 file changed, 98 insertions(+), 4 deletions(-)

diff --git a/Basic/15-loops-exercises.js b/Basic/15-loops-exercises.js
index 9394e7c1..1374fe88 100644
--- a/Basic/15-loops-exercises.js
+++ b/Basic/15-loops-exercises.js
@@ -108,7 +108,13 @@ for (const char of string) {
 console.log(counter)
 
 console.log('6. Dado un array de números, usa un bucle para multiplicar todos los números y mostrar el producto')
+const theArray = [3, 6, 9, 12]
+let product = 1
 
+for (let i = 0; i < theArray.length; i++) {
+     product *= theArray[i];    
+}
+console.log(product)
 
 console.log('_______________________________________________________________________________________-')
 // Lo habia entendido mal e hice esto
@@ -120,11 +126,99 @@ for (let i = 0; i < myNumbers.length; i++){
     console.log(`${myNumbers[i]} * ${myNumbers[3]} = ` + myNumbers[i]*myNumbers[3])
     
 }
-// 7. Escribe un bucle que imprima la tabla de multiplicar del 5
+console.log("______________________________________________________________________")
+console.log("7. Escribe un bucle que imprima la tabla de multiplicar del 5")
+for (let i = 1; i  < 11; i++) {
+   console.log(`5 * ${i} = ` + (5 *  [i]))    
+}
+console.log("Tabla del 5 con bucle while")
+let result = 1; 
+while (result < 11) {
+    console.log((5*result))
+    result++
+}
+console.log("Tabla del 5 con bucle do while")
+let result2 = 1
+do {
+    console.log((5*result2))
+    result2++
+    
+} while (result2 < 11);
+console.log("________________________________________________________________________________-")
+
+console.log("8. Usa un bucle para invertir una cadena de texto")
+let text = "Quiero invertir esto"
+let newText =  ""
+for (let i = text.length -1; i >= 0; i--) {
+    newText += text[i]
+    
+}
+console.log(newText)
+console.log("________________________________________________________________________________________")
+console.log("Invirtiendo otra cadena de texto")
+let theText = "This will be inverted"
+let inverted = ""
+for (let i = theText.length-1; i >= 0; i--) {
+    inverted += theText[i]
+    
+}
+console.log(inverted)
+
+console.log("_____________________________________________________________________________________")
+console.log("9. Usa un bucle para generar los primeros 10 números de la secuencia de Fibonacci")
+let n = 10;
+let secuence = []
+if(n <= 0){
+    counter.log(secuence)
+} else if(n === 1){
+    console.log([0])
+} else{
+    secuence[0] = 0
+    secuence[1] = 1
+
+    for (let i = 2; i < n; i++) {
+        secuence[i] = secuence[i - 1] + secuence[i - 2]
+        
+    }
+    console.log(`Los primeros ${n} de la secuencia de Fegunacci son ${secuence}`)
+}
+console.log("___________________________________________________________________________________--")
+
+
+console.log("10. Dado un array de números, usa un bucle para crear un nuevo array que contenga solo los números mayores a 10")
+let lotOfNumbers = [4,8,12,16,20,24,28];
+let newBucle = [];
+
+console.log(newBucle)
+for(i = 0; i < lotOfNumbers.length;i++){
+    if(lotOfNumbers[i] > 10){        
+        newBucle.push(lotOfNumbers[i])            
+    }   
+}
+console.log(newBucle)
+console.log("________________________________________________-")
+console.log("Realizar el mismo ejercicio anterior pero el nuevo array debe tener numeros > 20")
+let thisArray = [8, 16, 24, 32, 40, 48, 56]
+let theNewOne = []
+for (let i = 0; i < thisArray.length; i++) {
+    if(thisArray[i] > 20){
+        theNewOne.push(thisArray[i])
+    } 
+   
+}
+console.log(theNewOne)
+console.log("_______________________________________________________________________________________-")
+console.log("El mismo ejercicio pero menores que 30")
+let thisArray2 = [4, 8, 12, 16, 20, 24, 28, 32, 36, 40]
+let theNewOne2 = []
+for (let i = 0; i < thisArray2.length; i++) {
+    if(thisArray2[i] <= 30){
+        theNewOne2.push(thisArray2[i])
+    }
+    
+}
+console.log(theNewOne2)
 
 
-// 8. Usa un bucle para invertir una cadena de texto
 
-// 9. Usa un bucle para generar los primeros 10 números de la secuencia de Fibonacci
 
-// 10. Dado un array de números, usa un bucle para crear un nuevo array que contenga solo los números mayores a 10
\ No newline at end of file

From 0e95387caa01935e298c1c59fce11e938f4ff5dc Mon Sep 17 00:00:00 2001
From: danielBuGo <danielbuilesgomez@gmail.com>
Date: Fri, 7 Mar 2025 14:59:11 -0500
Subject: [PATCH 05/16] Finished the functions class

---
 Basic/16-functions.js | 171 +++++++++++++++++++++---------------------
 1 file changed, 85 insertions(+), 86 deletions(-)

diff --git a/Basic/16-functions.js b/Basic/16-functions.js
index e5d3dec5..2dfc272b 100644
--- a/Basic/16-functions.js
+++ b/Basic/16-functions.js
@@ -3,115 +3,114 @@ Clase 31 - Funciones
 Vídeo: https://youtu.be/1glVfFxj8a4?t=12829
 */
 
-// Funciones
-
+// Funciones: 
 // Simple
-
-function myFunc() {
-    console.log("¡Hola, función!")
+function myFunction (){
+    console.log("Hi my  first function ")
 }
-
-for (let i = 0; i < 5; i++) {
-    myFunc()
+myFunction()
+for (let i = 1; i < 6; i++) {
+    myFunction()
+    
 }
 
-// Con parámetros
+console.log("Funcion con parametros")
+function withParams(name){
+    console.log(`Hello Mr ${name}`)
 
-function myFuncWithParams(name) {
-    console.log(`¡Hola, ${name}!`)
 }
-
-myFuncWithParams("Brais")
-myFuncWithParams("MoureDev")
-
-// Funciones anónimas
-
-const myFunc2 = function (name) {
-    console.log(`¡Hola, ${name}!`)
+withParams("Anderson")
+console.log("______________________________________")
+let twoTimes = 2
+do {
+    withParams("Anderson")
+    twoTimes++
+} while (twoTimes <= 3);
+
+console.log("_____________________________________________")
+console.log("Funciones anonimas")
+const anonyFunction = function(lastName){
+    console.log(`Hello Mr ${lastName}`)
 }
-
-myFunc2("Brais Moure")
-
-// Arrow functions
-
-const myFunc3 = (name) => {
-    console.log(`¡Hola, ${name}!`)
+let threeTimes = 1
+while (threeTimes < 4) {
+   anonyFunction("Builes")
+    threeTimes++
+    
 }
+console.log("__________________________________________________")
 
-const myFunc4 = (name) => console.log(`¡Hola, ${name}!`)
-
-myFunc3("Brais Moure")
-myFunc4("Brais Moure")
+console.log("Arrow Functions")
+const age = (age) => {
+    console.log(`Daniel´s age is ${age} years old`)
+}
+age(36)
+const dogName = (dogName) => {
+    console.log(`My Dog´s name is ${dogName}`)
+}
+for(let i = 0;i < 6; i++){
+    dogName("Bella")
+}
+const country = (country) => console.log(`My favorite country is ${country}`)
 
-// Parámetros
+country("United States")
 
-function sum(a, b) {
+console.log("________________________________---")
+console.log("Functions with params")
+function add(a = 0, b = 0){
     console.log(a + b)
 }
+add(10, 20)
+add() // Si no pongo parametros la funcion me arroja NaN
+const product = (a = 0, b = 0) => console.log(a * b)
+product(5,11)
 
-sum(5, 10)
-sum(5)
-sum()
 
-function defaultSum(a = 0, b = 0) {
-    console.log(a + b)
-}
 
 // Por defecto
+product()
+product(5)
+product(5,4)
+product(8, 6)
 
-defaultSum()
-defaultSum(5)
-defaultSum(5, 10)
-defaultSum(b = 5)
 
-// Retorno de valores
-
-function mult(a, b) {
-    return a * b
+console.log("__________________-")
+console.log("Funcion con retorno")
+function resta(a=0, b=0) {
+    return a - b /** en ves de imprimirlo por consola
+    se lo retorno al usuario para que lo vea **/
 }
-
-let result = mult(5, 10)
+let result = resta(10,4)
 console.log(result)
+console.log("+++++++++++++++++++++++")
+console.log("Funciones anidadas")
 
-// Funciones anidadas
-
-function extern() {
-    console.log("Función externa")
-    function intern() {
-        console.log("Función interna")
+function externa(){
+    console.log("Esta es la externa")
+    function interna(){   
+        console.log("Esta es la interna")     
     }
-    intern()
+    interna() //Se debe ejecutar la interna dentro del scope de la externa
 }
-
-extern()
-// intern() Error: fuera del scope
-
-// Funciones de orden superior
-
-function applyFunc(func, param) {
-    func(param)
+externa()
+console.log("++++++++++++++++++++++")
+console.log("Funciones de orden superior")
+function bigFunction(func, param){
+    country(param)
 }
-
-applyFunc(myFunc4, "función de orden superior")
-
-// forEach
-
-myArray = [1, 2, 3, 4]
-
-mySet = new Set(["Brais", "Moure", "mouredev", 37, true, "braismoure@mouredev.com"])
-
-myMap = new Map([
-    ["name", "Brais"],
-    ["email", "braismoure@mouredev.com"],
-    ["age", 37]
-])
-
-myArray.forEach(function (value) {
-    console.log(value)
-})
-
-myArray.forEach((value) => console.log(value))
-
+bigFunction(country("Italy"))
+console.log("+++++++++++++++++++++++")
+console.log("For each")
+let hisArray = [3, 6, 9, 12]
+hisArray.forEach((i) => console.log(i) )
+console.log("+++ For Each con Map+++")
+let myMap = new Map([
+    ["name", "Daniel"],
+    ["Las Name", "Builes"]
+
+]
+);
+myMap.forEach((i) => console.log(i))
+console.log("+++ For Each con Set +++")
+let mySet = new Set ([5, 10, 15, 20])
 mySet.forEach((value) => console.log(value))
-
-myMap.forEach((value) => console.log(value))
\ No newline at end of file

From 6b45d17291999aad815a516b10a71f4da5365e87 Mon Sep 17 00:00:00 2001
From: danielBuGo <danielbuilesgomez@gmail.com>
Date: Fri, 7 Mar 2025 17:04:53 -0500
Subject: [PATCH 06/16] doing the functions exercises

---
 Basic/17-functions-exercises.js | 64 +++++++++++++++++++++++++++------
 1 file changed, 54 insertions(+), 10 deletions(-)

diff --git a/Basic/17-functions-exercises.js b/Basic/17-functions-exercises.js
index fb7eb4e5..c8ce6d90 100644
--- a/Basic/17-functions-exercises.js
+++ b/Basic/17-functions-exercises.js
@@ -5,22 +5,66 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=14146
 
 // NOTA: Explora diferentes sintaxis de funciones para resolver los ejercicios
 
-// 1. Crea una función que reciba dos números y devuelva su suma
+console.log("1. Crea una función que reciba dos números y devuelva su suma") 
+//Funcion simple:
+function add(a=0, b=0){
+    console.log(a+b)
+}
+add(10,10)
+//Funcion Anonima
+let anonymAdd = function (a=0, b=0){
+    console.log(a+b)
+}
+anonymAdd(5,8)
+//arrow function
+let arrowAdd = (a=0,b=0) => console.log(a+b)
+arrowAdd(8,8)
+console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 
-// 2. Crea una función que reciba un array de números y devuelva el mayor de ellos
+console.log("2. Crea una función que reciba un array de números y devuelva el mayor de ellos")
+const numbers = [7,14,21,28]
+function theBigOne (array) {
+         
+    for (let i = 0; i < numbers.length; i++) {
+        let max = 0; 
+       
+       if(max > numbers[i]){
+       max = numbers[i]            
+       }
+       return max        
+    }
+}
+const data = theBigOne(numbers)
+console.log(data)
+theBigOne()
+console.log("++++++++++++++++++++++++++++++++++++++++++++++++++")
+/**function theChoosenOne (){
+    const numbers = [500, 6, 245, 76, 89]
+    let max = 0
+    for (const i of numbers) {
+        console.log(i)
+    } 
 
-// 3. Crea una función que reciba un string y devuelva el número de vocales que contiene
-
-// 4. Crea una función que reciba un array de strings y devuelva un nuevo array con las strings en mayúsculas
+}**/
+console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 
+// 3. Crea una función que reciba un string y devuelva el número de vocales que contiene
+console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
+console.log("4. Crea una función que reciba un array de strings y devuelva un nuevo array con las strings en mayúsculas")
+let words = "Give it back in Uppers"
+let toUpper = function (string) {
+   console.log(string.toUpperCase())
+}
+toUpper(words)
+console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 // 5. Crea una función que reciba un número y devuelva true si es primo, y false en caso contrario
-
+console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 // 6. Crea una función que reciba dos arrays y devuelva un nuevo array que contenga los elementos comunes entre ambos
-
+console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 // 7. Crea una función que reciba un array de números y devuelva la suma de todos los números pares
-
+console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 // 8. Crea una función que reciba un array de números y devuelva un nuevo array con cada número elevado al cuadrado
-
+console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 // 9. Crea una función que reciba una cadena de texto y devuelva la misma cadena con las palabras en orden inverso
-
+console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 // 10. Crea una función que calcule el factorial de un número dado
\ No newline at end of file

From 2daf517adf75184a96c27c7b2f6c98e58435717f Mon Sep 17 00:00:00 2001
From: danielBuGo <danielbuilesgomez@gmail.com>
Date: Fri, 7 Mar 2025 17:19:25 -0500
Subject: [PATCH 07/16] Keeping in the exercises

---
 Basic/17-functions-exercises.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/Basic/17-functions-exercises.js b/Basic/17-functions-exercises.js
index c8ce6d90..301735e4 100644
--- a/Basic/17-functions-exercises.js
+++ b/Basic/17-functions-exercises.js
@@ -56,6 +56,10 @@ let toUpper = function (string) {
    console.log(string.toUpperCase())
 }
 toUpper(words)
+console.log("+++Mismo ejercicio pero para minusculas+++")
+words = "GIVE IT LOWER"
+let toLower =  (string) => console.log(string.toLowerCase()) //pendiente por corregir
+toLower(words)
 console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 // 5. Crea una función que reciba un número y devuelva true si es primo, y false en caso contrario
 console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")

From 74c420f6c049cf7ae4ec2fdbf3d4d6db4de10086 Mon Sep 17 00:00:00 2001
From: danielBuGo <danielbuilesgomez@gmail.com>
Date: Sat, 8 Mar 2025 08:34:36 -0500
Subject: [PATCH 08/16] I just finished exercise 3 of functions

---
 Basic/17-functions-exercises.js | 70 ++++++++++++++++++---------------
 1 file changed, 38 insertions(+), 32 deletions(-)

diff --git a/Basic/17-functions-exercises.js b/Basic/17-functions-exercises.js
index 301735e4..49027e9b 100644
--- a/Basic/17-functions-exercises.js
+++ b/Basic/17-functions-exercises.js
@@ -5,6 +5,20 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=14146
 
 // NOTA: Explora diferentes sintaxis de funciones para resolver los ejercicios
 
+console.log("Repaso de lo anterior Map, Set, Array")
+//Map
+let theMap = new Map ([
+    ["dog", true],
+    ["Male", false],
+    ["Age", 3]
+])
+console.log(theMap)
+let theSet = new Set ([
+    "Daniel",
+    "Luz",
+    "Andrea"
+])
+console.log(theSet)
 console.log("1. Crea una función que reciba dos números y devuelva su suma") 
 //Funcion simple:
 function add(a=0, b=0){
@@ -23,43 +37,35 @@ console.log("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 console.log("2. Crea una función que reciba un array de números y devuelva el mayor de ellos")
 const numbers = [7,14,21,28]
-function theBigOne (array) {
-         
-    for (let i = 0; i < numbers.length; i++) {
-        let max = 0; 
-       
-       if(max > numbers[i]){
-       max = numbers[i]            
-       }
-       return max        
-    }
-}
-const data = theBigOne(numbers)
-console.log(data)
-theBigOne()
-console.log("++++++++++++++++++++++++++++++++++++++++++++++++++")
-/**function theChoosenOne (){
-    const numbers = [500, 6, 245, 76, 89]
-    let max = 0
-    for (const i of numbers) {
-        console.log(i)
-    } 
 
-}**/
+
+
 console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 
-// 3. Crea una función que reciba un string y devuelva el número de vocales que contiene
+console.log("3. Crea una función que reciba un string y devuelva el número de vocales que contiene")
+let phrase = "ooeeiiaaeo"
+let vocals = "aeiouAEIOU"
+let counter = 0
+
+function letsCountVocals(string){
+    for (const value of string) {        
+        if(vocals.includes(value)){
+            counter++                      
+        }   
+         
+    }
+    console.log(counter)   
+}
+letsCountVocals(phrase)
 console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 console.log("4. Crea una función que reciba un array de strings y devuelva un nuevo array con las strings en mayúsculas")
-let words = "Give it back in Uppers"
-let toUpper = function (string) {
-   console.log(string.toUpperCase())
-}
-toUpper(words)
-console.log("+++Mismo ejercicio pero para minusculas+++")
-words = "GIVE IT LOWER"
-let toLower =  (string) => console.log(string.toLowerCase()) //pendiente por corregir
-toLower(words)
+let words = ["Give it back in Uppers", "Give back this one"]
+let toUpper = function (string){
+    for (const value of string) {
+        console.log(value.toLocaleUpperCase())        
+    }
+};
+toUpper(words);
 console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 // 5. Crea una función que reciba un número y devuelva true si es primo, y false en caso contrario
 console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")

From be8516a961f073bae38f493a15b59f89dcbb2a60 Mon Sep 17 00:00:00 2001
From: danielBuGo <danielbuilesgomez@gmail.com>
Date: Mon, 10 Mar 2025 12:04:25 -0500
Subject: [PATCH 09/16] Finished point 7 of exercises

---
 Basic/15-loops-exercises.js     |   3 +-
 Basic/17-functions-exercises.js | 128 +++++++++++++++++++++++++++++---
 2 files changed, 119 insertions(+), 12 deletions(-)

diff --git a/Basic/15-loops-exercises.js b/Basic/15-loops-exercises.js
index 1374fe88..2b0cd1d1 100644
--- a/Basic/15-loops-exercises.js
+++ b/Basic/15-loops-exercises.js
@@ -203,8 +203,7 @@ let theNewOne = []
 for (let i = 0; i < thisArray.length; i++) {
     if(thisArray[i] > 20){
         theNewOne.push(thisArray[i])
-    } 
-   
+    }    
 }
 console.log(theNewOne)
 console.log("_______________________________________________________________________________________-")
diff --git a/Basic/17-functions-exercises.js b/Basic/17-functions-exercises.js
index 49027e9b..bbea61d9 100644
--- a/Basic/17-functions-exercises.js
+++ b/Basic/17-functions-exercises.js
@@ -22,23 +22,23 @@ console.log(theSet)
 console.log("1. Crea una función que reciba dos números y devuelva su suma") 
 //Funcion simple:
 function add(a=0, b=0){
-    console.log(a+b)
+    console.log(`${a} + ${b} = ` + (a+b))
 }
 add(10,10)
 //Funcion Anonima
 let anonymAdd = function (a=0, b=0){
-    console.log(a+b)
+    console.log(`La suma de ${a} y ${b} es ` + (a+b))
 }
 anonymAdd(5,8)
 //arrow function
-let arrowAdd = (a=0,b=0) => console.log(a+b)
+let arrowAdd = (a=0,b=0) => console.log(`${a} + ${b} = ` + (a+b))
 arrowAdd(8,8)
 console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 
 console.log("2. Crea una función que reciba un array de números y devuelva el mayor de ellos")
 const numbers = [7,14,21,28]
 
-
+//PENDIENTE
 
 console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 
@@ -54,26 +54,134 @@ function letsCountVocals(string){
         }   
          
     }
-    console.log(counter)   
-}
-letsCountVocals(phrase)
+    console.log("El número de vocales que contiene es: " + counter)  
+};
+letsCountVocals(phrase);
 console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 console.log("4. Crea una función que reciba un array de strings y devuelva un nuevo array con las strings en mayúsculas")
 let words = ["Give it back in Uppers", "Give back this one"]
 let toUpper = function (string){
     for (const value of string) {
-        console.log(value.toLocaleUpperCase())        
+        console.log(`Este es el array en minusculas: ${value}`)
+        console.log("Este es el array en mayusculas: " + value.toLocaleUpperCase())        
     }
 };
 toUpper(words);
 console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
-// 5. Crea una función que reciba un número y devuelva true si es primo, y false en caso contrario
+console.log("5. Crea una función que reciba un número y devuelva true si es primo, y false en caso contrario")
+
+let isItPrime = function (number){
+   
+    if (number <= 1 ) {
+        console.log(`El número ${number} es primo?: ${false}`)
+        return;
+    } else if(number <= 3){
+        console.log(`El número ${number} es primo?: ${true}`)
+        return;
+    } else if(number % 2 === 0 || number % 3 === 0){
+        console.log(`El número ${number} es primo?: ${false}`)
+        return;
+    } else{
+        for (let i = 5; i * i <= number; i += 6) {
+            if (number % i === 0 || number % (i + 2) === 0) {
+                console.log(`El número ${number} es primo?: ${false}`)
+                return;
+            }
+          }
+          console.log(`El número ${number} es primo?: ${true}`)
+          return;
+    }       
+   
+}
+isItPrime(368)
 console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
-// 6. Crea una función que reciba dos arrays y devuelva un nuevo array que contenga los elementos comunes entre ambos
+console.log("6. Crea una función que reciba dos arrays y devuelva un nuevo array que contenga los elementos comunes entre ambos")
+let pets1 = ["Dog", "Cat", "Horse", "Parrot"]
+let pets2 = ["Lion", "Tiger", "Cat", "Horse"]
+let commonAnimals = []
+let giveMeAnimalsInCommon2 = function(array1, array2){
+    let array3 = array1.concat(array2)    
+    let vistos = new Set ();
+    let duplicados = new Set();
+    let duplicateElements = array3.filter((element) =>{
+        if(vistos.has(element)){
+            duplicados.add(element)
+            return true;
+        }else {
+            vistos.add(element)
+            return false;
+        }
+    }) 
+    duplicateElements = Array.from(duplicados)
+    console.log(`Los elementos duplicados son: ${duplicateElements}`)
+}
+giveMeAnimalsInCommon2(pets1,pets2)
+/* Creé una funcion que pasa los valores de las arrays a un MAp
+y elimina los valores repetidos */
+let giveMeAnimalsInCommon = function (array1, array2){   
+    commonAnimals = array1.concat(array2)    
+    let commonAnimalsSet = new Set (commonAnimals)
+    let $commonAnimals = Array.from(commonAnimalsSet)
+    console.log(`Lista con los elementos repetidos eliminados: ${$commonAnimals}`)    
+}
+giveMeAnimalsInCommon(pets1, pets2)
+
+
 console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 // 7. Crea una función que reciba un array de números y devuelva la suma de todos los números pares
+let $numbers = [6, 7, 5, 4, 1, 0, 9, 10, 12, 24, 35, 77, 89]
+let isEven = []
+function addEvenNumbers(array){
+    let suma = 0
+    for (const even of array) {
+        if(even % 2 === 0){
+            isEven.push(even)           
+        }        
+    }
+    console.log(`The list of even numbers are: ${isEven}`)
+    for (const element of isEven) {
+            suma += element
+    }
+    console.log(`the result of it adds is : ${suma}`)
+};
+addEvenNumbers($numbers);
+$numbers = [5, 25, 15, 10, 4, 6]
+isEven = []
+let addEven = function(array){
+    let add = 0
+    array.forEach(element => {
+        if(element % 2 === 0){
+            isEven.push(element)            
+        }                
+    });
+    console.log(`Los números pares son: ${isEven}`)
+    for (const even of isEven) {
+        add += even        
+    }
+    console.log(`La suma de estos es: ${add}`)
+};
+addEven($numbers);
+console.log("__________________________________________________")
+$numbers = [2,7,4,5,9,10,10]
+isEven = []
+let addEven2 = function(array){
+    let suma = 0
+    array.forEach(element => {
+        if(element % 2 === 0){
+            isEven.push(element) 
+        }               
+    });
+    console.log(`The even elements are: ${isEven}`)
+    for (const even of isEven) {
+        suma += even
+    }
+    console.log(`the add of all items are: ${suma}`)
+}
+addEven2($numbers)
 console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 // 8. Crea una función que reciba un array de números y devuelva un nuevo array con cada número elevado al cuadrado
+$numbers = [2, 3, 5, 8]
+
 console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 // 9. Crea una función que reciba una cadena de texto y devuelva la misma cadena con las palabras en orden inverso
 console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")

From c93769293d09d7812c6fdfc6ef10870602a5ac7b Mon Sep 17 00:00:00 2001
From: danielBuGo <danielbuilesgomez@gmail.com>
Date: Tue, 11 Mar 2025 12:41:02 -0500
Subject: [PATCH 10/16] Just finished all function  exercises

---
 Basic/17-functions-exercises.js | 105 +++++++++++++++++++++++++++++---
 1 file changed, 97 insertions(+), 8 deletions(-)

diff --git a/Basic/17-functions-exercises.js b/Basic/17-functions-exercises.js
index bbea61d9..f3479511 100644
--- a/Basic/17-functions-exercises.js
+++ b/Basic/17-functions-exercises.js
@@ -36,9 +36,31 @@ arrowAdd(8,8)
 console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 
 console.log("2. Crea una función que reciba un array de números y devuelva el mayor de ellos")
-const numbers = [7,14,21,28]
-
-//PENDIENTE
+const numbers = [7,14,700,21,28]
+let bigOne = numbers[0]
+function theBig (array){
+    for (let i = 1; i < array.length; i++){
+        if(array[i] > bigOne){
+            bigOne = array[i]
+        }
+        
+    }
+    console.log(`the biggest number is: ${bigOne}`)
+};
+theBig(numbers)
+console.log("________________________________________________-")
+//Lo haré  otra vez:
+const newNumbers = [1,45,7,10,3456,589]
+bigOne = newNumbers[0]
+let newBig = (array) => {
+    for (let i = 1; i < array.length;i++) {
+        if(array[i] > bigOne){
+            bigOne = array[i];
+        }        
+    }
+    console.log(`the biggest number is: ${bigOne}`)
+}
+newBig(newNumbers)
 
 console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 
@@ -128,7 +150,7 @@ giveMeAnimalsInCommon(pets1, pets2)
 
 
 console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
-// 7. Crea una función que reciba un array de números y devuelva la suma de todos los números pares
+console.log(" 7. Crea una función que reciba un array de números y devuelva la suma de todos los números pares")
 let $numbers = [6, 7, 5, 4, 1, 0, 9, 10, 12, 24, 35, 77, 89]
 let isEven = []
 function addEvenNumbers(array){
@@ -178,11 +200,78 @@ let addEven2 = function(array){
     console.log(`the add of all items are: ${suma}`)
 }
 addEven2($numbers)
+console.log("__________________________________")
+//Voy a sumar los impares
+$numbers = [2,4,5,7,9,12,14]
+let isOdd = []
+let addOddNumber = (array) => {
+    let add = 0
+    for (const element of array) {
+        if(element % 2 === 1){
+            console.log(`The add numbers are: ${element}`)
+            add += element
+        }
+        
+    }
+    
+    console.log(`The sumatory of odd numbers is: ${add}`)
+};
+addOddNumber($numbers);
 console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
-// 8. Crea una función que reciba un array de números y devuelva un nuevo array con cada número elevado al cuadrado
+console.log("8. Crea una función que reciba un array de números y devuelva un nuevo array con cada número elevado al cuadrado")
 $numbers = [2, 3, 5, 8]
-
+let numberSqr = []
+let numbPow = function (array){
+    array.forEach(element => {
+        
+        let elevator = Math.pow(element, 2) // etambien funciona asi: element ** 2
+        numberSqr.push(elevator)       
+        
+    });
+    console.log(`The original array is: ${$numbers}`)
+    console.log(`The numbers elevated to 2 are: ${numberSqr}`)
+};
+numbPow($numbers)
+console.log("________________________________________________________")
+let myArray = [8, 9, 5, 4, 3, 2,]
+let myNewArray = []
+let elevatingNumbers = (array) => {
+    array.forEach(element => {
+        let sqr = Math.pow(element,2)
+        myNewArray.push(sqr)
+    });
+    console.log(`The new array with elements to sqr is: ${myNewArray}`)
+};
+elevatingNumbers(myArray)
+console.log("___________________________________________________________________")
+let $myArray = [50, 8, 2, 2, 6, 7, 9]
+let $myNewArray = []
+let sqr = 0
+let elevatingNumbers2 = (array) => {
+    for (const element of array) {
+        sqr = Math.pow(element, 2)
+        $myNewArray.push(sqr)
+    }
+    console.log(`The new array with elements to sqr is: ${$myNewArray}`)
+};
+elevatingNumbers2($myArray)
 console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
-// 9. Crea una función que reciba una cadena de texto y devuelva la misma cadena con las palabras en orden inverso
+console.log(" 9. Crea una función que reciba una cadena de texto y devuelva la misma cadena con las palabras en orden inverso")
+let $string = "please, invert this word"
+let letsInvert = (string) => {
+    console.log(string.split("").reverse().join(""))
+}
+letsInvert($string)
 console.log("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
-// 10. Crea una función que calcule el factorial de un número dado
\ No newline at end of file
+console.log("10. Crea una función que calcule el factorial de un número dado") 
+let num = 8
+function factoriza (num){
+    if(num < 0){
+        console.log(-1)
+    }else if(num == 0){
+        console.log(1)
+    }else{
+        console.log((num * factoriza(num - 1)))
+    }
+};
+factoriza(num)
\ No newline at end of file

From 202f441fe151a10a880df24121adf70950e5ec99 Mon Sep 17 00:00:00 2001
From: danielBuGo <danielbuilesgomez@gmail.com>
Date: Tue, 11 Mar 2025 13:06:12 -0500
Subject: [PATCH 11/16] object calss

---
 Basic/09-conditionals-exercises.js |  2 +-
 Basic/18-objects.js                | 79 +++---------------------------
 2 files changed, 8 insertions(+), 73 deletions(-)

diff --git a/Basic/09-conditionals-exercises.js b/Basic/09-conditionals-exercises.js
index 1a989ea0..52c49951 100644
--- a/Basic/09-conditionals-exercises.js
+++ b/Basic/09-conditionals-exercises.js
@@ -133,7 +133,7 @@ let theSeasonIs
 
 switch(youMounth){
     case 1:
-        theSeasonIs = 'The season is Winter' @
+        theSeasonIs = 'The season is Winter' 
         break
     case 2:
         theSeasonIs = 'The season is Winter'
diff --git a/Basic/18-objects.js b/Basic/18-objects.js
index 4e71a6b2..d0700eaa 100644
--- a/Basic/18-objects.js
+++ b/Basic/18-objects.js
@@ -6,114 +6,49 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=14229
 // Objetos
 
 // Sintaxis
-
 let person = {
-    name: "Brais",
-    age: 37,
-    alias: "MoureDev"
+    name: "Daniel",
+    age: 36,
+    email: "danielb@gmail.com"
 }
-
 // Acceso a propiedades
 
 // Notación punto
-console.log(person.name)
+console.log(person.email)
+
 
 // Notación de corchetes
-console.log(person["name"])
+
 
 // Modificación de propiedades
 
-person.name = "Brais Moure"
-console.log(person.name)
 
-console.log(typeof person.age)
-person.age = "37"
-console.log(person.age)
-console.log(typeof person.age)
 
 // Eliminación de propiedades
 
-delete person.age
-
-console.log(person)
 
 // Nueva propiedad
 
-person.email = "braismoure@mouredev.com"
-person["age"] = 37
 
-console.log(person)
 
 // Métodos (funciones)
 
-let person2 = {
-    name: "Brais",
-    age: 37,
-    alias: "MoureDev",
-    walk: function () {
-        console.log("La persona camina.")
-    }
-}
-person2.walk()
 
 // Anidación de objetos
 
-let person3 = {
-    name: "Brais",
-    age: 37,
-    alias: "MoureDev",
-    walk: function () {
-        console.log("La persona camina.")
-    },
-    job: {
-        name: "Programador",
-        exp: 15,
-        work: function () {
-            console.log(`La persona de ${this.age} años de experiencia trabaja.`)
-        }
-    }
-}
 
-console.log(person3)
 
-console.log(person3.name)
-console.log(person3.job)
-console.log(person3.job.name)
-person3.job.work()
 
 // Igualdad de objetos
 
-let person4 = {
-    name: "Brais Moure",
-    alias: "MoureDev",
-    email: "braismoure@mouredev.com",
-    age: 37
-}
-
-console.log(person)
-console.log(person4)
 
-console.log(person == person4)
-console.log(person === person4)
 
-console.log(person.name == person4.name)
 
 // Iteración
 
-for (let key in person4) {
-    console.log(key + ": " + person4[key])
-}
+
 
 // Funciones como objetos
 
-function Person(name, age) { // Debería ser una clase
-    this.name = name
-    this.age = age
-}
 
-let person5 = new Person("Brais", 37)
-console.log(person5)
-console.log(person5.name)
 
-console.log(typeof person5)
-console.log(typeof person4)
\ No newline at end of file

From 4e4ea86d385828dbad508e85e64b0e419a83a7be Mon Sep 17 00:00:00 2001
From: danielBuGo <danielbuilesgomez@gmail.com>
Date: Tue, 11 Mar 2025 17:22:29 -0500
Subject: [PATCH 12/16] finished objects class

---
 Basic/18-objects.js | 93 +++++++++++++++++++++++++++++++++++----------
 1 file changed, 72 insertions(+), 21 deletions(-)

diff --git a/Basic/18-objects.js b/Basic/18-objects.js
index d0700eaa..ef1e0c11 100644
--- a/Basic/18-objects.js
+++ b/Basic/18-objects.js
@@ -15,40 +15,91 @@ let person = {
 
 // Notación punto
 console.log(person.email)
-
-
 // Notación de corchetes
+console.log(person["age"])
 
 
 // Modificación de propiedades
-
-
-
+person.name = "Bella"
+console.log(person.name)
+person.email = "dabugo@hotmail.com"
+console.log(person.email)
 // Eliminación de propiedades
-
-
+delete person.age
+delete person.email
+console.log(person)
 // Nueva propiedad
-
-
-
+person.age = 36
+person["LastName"] = "Builes"
+person["Adress"] = "Cr 75Da 2B sur 50"
+person.doesHeHaveDog = true
+console.log(person)
 // Métodos (funciones)
-
-
+console.log("_____________________")
+let person2 ={
+    name: "Angulo",
+    age: 42,
+    lastName: "Cuchei",
+    email: "elcuchei@gmail.com",
+    walk: function(){
+        console.log("this guy is walking")
+    }
+};
+person2.walk()
 // Anidación de objetos
-
-
-
-
+console.log("___________________")
+let person3 ={
+    name: "Luz",
+    age: 42,
+    lastName: "gomez",
+    email: "elcuchei@gmail.com",
+    walk: function(){
+        console.log(`Miss ${this.name}  ${this.lastName} is great`)
+    },
+    job: {
+        name: "Visa manager",
+        exp: 5,
+        work: function(){
+            console.log(`This person has ${this.exp} years of experience`)
+        }
+    }
+};
+
+person3.walk()
+console.log(person3.name)
+console.log(person3.job)
+person3.job.work()
+console.log("______________________")
 // Igualdad de objetos
-
-
-
-
+let person4 = {
+    name: 'Bella',
+    age: 36,
+    LastName: 'Builes',
+    Adress: 'Cr 75Da 2B sur 50',
+    doesHeHaveDog: true
+};
+console.log(person)
+person3.walk()
+console.log(person4)
+console.log(person == person4)
+console.log(person === person4)
+console.log(person.name == person4.name)
 // Iteración
+for (let key in person4) {
+    console.log(key + ": " + person4[key])    
+}
 
+// Funciones como objetos
+function Person(name, age){ //Debería ser una clase
+    this.name = name
+    this.age = age
+}
+console.log("_____________________________")
+let person5 = new Person("Lina", 36)
+console.log(person5)
+person5.name
 
 
-// Funciones como objetos
 
 
 

From b46cba11342c783faadbfe4512fb1997e86325af Mon Sep 17 00:00:00 2001
From: danielBuGo <danielbuilesgomez@gmail.com>
Date: Tue, 11 Mar 2025 18:05:56 -0500
Subject: [PATCH 13/16] finished all objects exercides

---
 Basic/19-objects-exercises.js | 77 +++++++++++++++++++++++++++--------
 1 file changed, 61 insertions(+), 16 deletions(-)

diff --git a/Basic/19-objects-exercises.js b/Basic/19-objects-exercises.js
index 5dbbd628..d05abe62 100644
--- a/Basic/19-objects-exercises.js
+++ b/Basic/19-objects-exercises.js
@@ -2,23 +2,68 @@
 Clase 34 - Ejercicios: Objetos
 Vídeo: https://youtu.be/1glVfFxj8a4?t=15675
 */
+ console.log("1. Crea un objeto con 3 propiedades")
+ let car = {
+    brand: "Ferrari",
+    model: 2000,
+    color: "red"
+ }
+ console.log(car)
+ console.log("-------------------------------------------------")
 
-// 1. Crea un objeto con 3 propiedades
+console.log("2. Accede y muestra su valor")
+for (let key in car) {
+    console.log(key + ": " + car[key])
+    
+}
+console.log("-------------------------------------------------")
 
-// 2. Accede y muestra su valor
+console.log("3. Agrega una nueva propiedad")
+car.hp = 550
+car["hasInsurance"] = true
+console.log(car)
+console.log("-------------------------------------------------")
+console.log("4. Elimina una de las 3 primeras propiedades")
+delete car.model
+for (let key in car) {
+    console.log(key + ": " + car[key])        
+    }
 
-// 3. Agrega una nueva propiedad
+console.log("-------------------------------------------------")
+console.log("5. Agrega una función e invócala") 
+car.isOn =  function(){
+    console.log(`the ${this.brand} is on`)
+}
+car.isOn()
+for (const key in car) {
+    console.log(`${key}: ${car[key]}`)
+}
+console.log("-------------------------------------------------")
+console.log("6. Itera las propiedades del objeto")
+for (const key in car) {
+    console.log(`${key}: ${car[key]}`)
+}
+console.log("-------------------------------------------------")
+console.log("7. Crea un objeto anidado") 
+car.data = {maxSpeed: "350Kh", 
+    fuelCapacity: "35Gls"
+}
+let car2 = {
+    brand: "Mercedez",
+    color: "Silver",
+    hp: 650,
+    hasInsurance: false    
+}
+console.log("-------------------------------------------------")
+console.log("8. Accede y muestra el valor de las propiedades anidadas")
+console.log(car.data)
+console.log("-------------------------------------------------")
+console.log("9. Comprueba si los dos objetos creados son iguales")
+console.log(car === car2)
+console.log(car == car2)
 
-// 4. Elimina una de las 3 primeras propiedades
-
-// 5. Agrega una función e invócala
-
-// 6. Itera las propiedades del objeto
-
-// 7. Crea un objeto anidado
-
-// 8. Accede y muestra el valor de las propiedades anidadas
-
-// 9. Comprueba si los dos objetos creados son iguales
-
-// 10. Comprueba si dos propiedades diferentes son iguales
\ No newline at end of file
+console.log("-------------------------------------------------")
+ console.log("10. Comprueba si dos propiedades diferentes son iguales")
+ console.log(car.color === car2.color)
+ console.log(car.brand === car2.brand)
+ console.log("-------------------------------------------------")
\ No newline at end of file

From fef8152616c02726c8e06ef209bd98738db0976d Mon Sep 17 00:00:00 2001
From: danielBuGo <danielbuilesgomez@gmail.com>
Date: Wed, 12 Mar 2025 12:04:48 -0500
Subject: [PATCH 14/16] Update 20-destructuring-spreading.js

finished destrucring-spreading class
---
 Basic/20-destructuring-spreading.js | 164 ++++++++++++++--------------
 1 file changed, 81 insertions(+), 83 deletions(-)

diff --git a/Basic/20-destructuring-spreading.js b/Basic/20-destructuring-spreading.js
index 385cb24d..03c8ae41 100644
--- a/Basic/20-destructuring-spreading.js
+++ b/Basic/20-destructuring-spreading.js
@@ -3,119 +3,117 @@ Clase 35 - Desestructuración y propagación
 Vídeo: https://youtu.be/1glVfFxj8a4?t=15747
 */
 
-let myArray = [1, 2, 3, 4]
 
-let person = {
-    name: "Brais",
-    age: 37,
-    alias: "MoureDev"
+let array = ["daniel", "Lina", "Bella"]
+let gliderBrands = ["Ozone", "Advanced", "Swing"]
+let car = {
+    brand: "Gmc",
+    model: "Hammer",
+    color: "Blue"
 }
+let myValue = array[1]
+console.log(`Mi novia es ${myValue}`)
 
-let myValue = myArray[1]
-console.log(myValue)
+let myCar = car.model
+console.log(`Mi carro es un ${myCar}`)
 
-let myName = person.name
-console.log(myName)
 
 // Desestructuración
-
 // Sintaxis arrays
+let [myName0, myName1, myName2] = array
+console.log(myName0)
+console.log(myName2)
+console.log(myName1)
 
-let [myValue0, myValue1, myValue2, myValue3, myValue4] = myArray
-console.log(myValue0)
-console.log(myValue1)
-console.log(myValue2)
-console.log(myValue3)
-console.log(myValue4)
+let [glider1, glider2, glider3] = gliderBrands
+console.log(glider1)
+console.log(glider2)
+console.log(glider3)
 
 // Sintaxis arrays con valores predeterminados
-
-let [myValue5 = 0, myValue6 = 0, myValue7 = 0, myValue8 = 0, myValue9 = 0] = myArray
-console.log(myValue5)
-console.log(myValue6)
-console.log(myValue7)
-console.log(myValue8)
-console.log(myValue9)
-
+let [myName3 = 0, myName4= 0,myName5 = 0, myName6 = 0, myName7 = 0, myName8 =0] = array
+console.log(myName8)
+console.log("__________________________________-")
 // Ignorar elementos array
-
-let [myValue10, , , myValue13] = myArray
-console.log(myValue10)
-console.log(myValue13)
-
+let [myName9, , myName11] = array
+console.log(myName9)
+console.log(myName11)
+let [ ,glider4, glider5] = gliderBrands
+console.log(glider5)
+console.log(glider4)
+console.log("________________________________________")
 // Sintaxis objects
-
-let { name, age, alias } = person
-console.log(name)
-console.log(age)
-console.log(alias)
-
+let {brand, model, color} = car
+console.log(brand)
+console.log(color)
+console.log(model)
 // Sintaxis objects con valores predeterminados
+let {brand2, color2, model2, year = 2020} = array
+console.log(brand2)// No existe
+console.log(color2)// No existe
+console.log(model2)// No existe
+console.log(year)
 
-let { name2, age2, alias2, email = "email@email.com" } = person
-console.log(name2) // No existe
-console.log(age2)  // No existe
-console.log(alias2)  // No existe
-console.log(email)
 
 // Sintaxis objects con nuevos nombres de variables
-
-let { alias: alias3, name: name3, age: age3 } = person
-console.log(name3)
-console.log(age3)
-console.log(alias3)
+let {brand: brand3, color: color3, model: model3, year: year3} = car
+console.log(brand3)
+console.log(color3)
+console.log(model3)
+console.log(year)
 
 // Objects anidados
-
-let person3 = {
-    name: "Brais",
-    age: 37,
-    alias: "MoureDev",
-    walk: function () {
-        console.log("La persona camina.")
-    },
+let person = {
+    name: "Lina",
+    LastName: "Castro",
+    Gender: "Male",
     job: {
-        name: "Programador",
-        exp: 15,
-        work: function () {
-            console.log(`La persona de ${this.age} años de experiencia trabaja.`)
+        Profession: "Manager",
+        Exp: 13,
+        work: function(){
+            console.log(`${person.name} has ${this.Exp} years experience working as a ${this.Profession}`)
         }
     }
+};
+for (let key in person) {
+    console.log(key + ": " + person[key])
+            
 }
-
-let { name: name4, job: { name: jobName } } = person3
-
+person.job.work()
+let {name: name4, job: {Profession: jobName}} = person
 console.log(name4)
 console.log(jobName)
+jobName = "Software Developer"
+console.log(jobName)
+console.log(person)
 
-// Propagación (...)
+let pilot = {
+    name: "Daniel",
+    exp: 13,
+    glider: "Swift 5",
+    brand: "Ozone"
+}
+let {name: newName, exp: newExp, glider: newGlider} = pilot
+newName = "Cuchei"
+newGlider = "Advanced"
+console.log(`the pilot ${newName} flies ${newGlider}`)
+console.log(`the pilot ${pilot.name} flies ${pilot.glider} of ${pilot.brand}`)
 
-// Sintaxis arrays
 
-let myArray2 = [...myArray, 5, 6]
 
-console.log(myArray2)
+// Propagación (...)
+// Sintaxis arrays
 
+let gliderBrands3 = [...gliderBrands, "Gin", "Sky Paragliders"]
+console.log(gliderBrands3)
+console.log("_______________________________")
 // Copia de arrays
-
-let myArray3 = [...myArray]
-
-console.log(myArray3)
-
+let gliderBrands2 = [...gliderBrands] //asi se copia un array
+console.log(gliderBrands2)
 // Combinación de arrays
-
-let myArray4 = [...myArray, ...myArray2, ...myArray3]
-
-console.log(myArray4)
-
+let gliderBrands4 = [...gliderBrands, ...gliderBrands3]
+console.log(gliderBrands4)
 // Sintaxis objects
-
-let person4 = { ...person, email: "braismoure@mouredev.com" }
-
-console.log(person4)
-
+let person2 = {...person, ...car, year: 2020}
+    console.log(person2)
 // Copia de objects
-
-let person5 = { ...person }
-
-console.log(person5)
\ No newline at end of file

From f590ed42ccca5a2685688e8d4b9fbca39c8c0b5a Mon Sep 17 00:00:00 2001
From: danielBuGo <danielbuilesgomez@gmail.com>
Date: Wed, 12 Mar 2025 16:40:35 -0500
Subject: [PATCH 15/16] finished destructuring exercises

---
 Basic/21-destructuring-spreading-exercises.js | 156 ++++++++++++++++--
 1 file changed, 140 insertions(+), 16 deletions(-)

diff --git a/Basic/21-destructuring-spreading-exercises.js b/Basic/21-destructuring-spreading-exercises.js
index feadceb3..179a96df 100644
--- a/Basic/21-destructuring-spreading-exercises.js
+++ b/Basic/21-destructuring-spreading-exercises.js
@@ -3,23 +3,147 @@ Clase 36 - Ejercicios: Desestructuración y propagación
 Vídeo: https://youtu.be/1glVfFxj8a4?t=16802
 */
 
-// 1. Usa desestructuración para extraer los dos primeros elementos de un array 
+console.log("1. Usa desestructuración para extraer los dos primeros elementos de un array")
+let videoGames = ["Call of Duty", "RDR2", "Assasins Creed", "Battlefiedl"]
+let [game1, game2, , ] = videoGames
+console.log("the first game is " + game1)
+console.log("The second game is: " + game2)
+console.log(videoGames)
+console.log("----------------------------------------------------------")
+console.log("2. Usa desestructuración en un array y asigna un valor predeterminado a una variable")
+let array = [1,2,3,4]
+let [arr0 , arr1 , arr2 , arr3, arr4 = 0, arr5 = 0] = array
+console.log(arr2)
+console.log(arr0)
+console.log(arr4)
+console.log(arr5)
+console.log("----------------------------------------------------------")
+console.log("3. Usa desestructuración para extraer dos propiedades de un objeto")
+let hardware = {
+    brand: "Xbox",
+    edition: "black Ops Edition",
+    memory: 128
+};
+console.log(hardware)
+let {brand, memory} = hardware
+console.log(brand)
+console.log(memory)
+console.log("----------------------------------------------------------")
+console.log("4. Usa desestructuración para extraer dos propiedades de un objeto y asígnalas a nuevas variables con nombres diferentes")
+let dog = {
+    kind: "Cocker Spaniel",
+    color: "Brown",
+    age: 3,
+    Gender: "Male"
+};
+let {kind: kind1, color: color2, hungry: hungry = "No"} = dog
+kind1 = "Labrador"
+color2 = "Black"
+console.log(`the new dog is a ${color2} ${kind1} ${hungry}`)
+console.log("----------------------------------------------------------")
+console.log("5. Usa desestructuración para extraer dos propiedades de un objeto anidado")
 
-// 2. Usa desestructuración en un array y asigna un valor predeterminado a una variable
+let motorcycle = {
+    brand: "Hero",
+    color: "Blue",
+    model: "X-Pulse200",
+    data: {
+        power: 550,  
+        maxSpeed: 100, 
+        turnOn: function(){
+            console.log(`the motorcycle is on`)
+        }   
+    }
+}
+let {brand: brand3, data: {power: power2}, data:{minSpeed: minSpeed = 20}} = motorcycle
+console.log(power2)
+console.log(minSpeed)
+console.log("----------------------------------------------------------")
+console.log("6. Usa propagación para combinar dos arrays en uno nuevo") 
+let gliderBrands = ["Ozone", "Advanced", "Swing"]
+let fusionArray = [...videoGames, ...gliderBrands]
+console.log("The two arrays fusionated are: " + fusionArray)
+console.log("----------------------------------------------------------")
+console.log("7. Usa propagación para crear una copia de un array")
+let copyArr = [...fusionArray]
+console.log("This is the copy: " + copyArr)
+console.log("----------------------------------------------------------")
+console.log("8. Usa propagación para combinar dos objetos en uno nuevo")
+let objectsFusion = {...dog, ...motorcycle, year: 2024}
+for (const key in objectsFusion) {
+    console.log(key + ": " + objectsFusion[key])
+}
+console.log(objectsFusion)
+motorcycle.data.turnOn()
+console.log("----------------------------------------------------------")
+console.log("9. Usa propagación para crear una copia de un objeto")
+let objectCopy = {...hardware}
+console.log(objectCopy)
+console.log("----------------------------------------------------------")
+console.log("10. Combina desestructuración y propagación")
+//Combinacion con objetos:
+let southAmerica = {
+    howManyCountrys: 12,
+    religion: "Christianity",
+    area: "17840000 km**2",
+    Languages: {
+        lan1: "spanis",
+        lan2: "Portuguese",
+        lan3: "French",
+        lan4: "English"
+    }
+}
+let Europe = {
+    alias: "Old Continent",
+    wars: 15,
+    neightberhood: "Africa"
+    
+}
+//spreading
+let twoContinent = {...Europe, ...southAmerica}
+console.log(twoContinent)
+// Destructuring
+let {area: area2, religion: religion2} = twoContinent
+console.log(area2)
+religion2 = "islam"
+console.log("One of the mains religions in Euprope is the: " + religion2)
+//Spreading with array
+let arra1 = [2, 3, 4, 5, 6, ]
+let array2 = [10,35]
+let arra3 = [...arra1, ...array2, 34, 45]
+for (const element of arra3) {
+    console.log(element)
+}
+//Destructuring
+let [n0, n1, n2, n3, n4, n5, n6, n7, n8, n9 =0] = arra3
+console.log(n9)
+console.log(arra3.pop())
+console.log(arra3)
+arra3.unshift(100)
+arra3.push(567)
 
-// 3. Usa desestructuración para extraer dos propiedades de un objeto
+// Turning array into  set
+let myMap = new Map([
+    ["My continents", twoContinent]
+])
+let mySet = new Set(arra3)
+console.log(mySet)
+console.log(myMap)
+console.log(myMap.has("area"))
+console.log(myMap.has("My continents"))
+console.log(myMap.get("My continents"))
+myMap.set("Other continent", "Oceania")
+console.log(myMap)
+console.log(myMap.keys())
+console.log("8. Crea una función que reciba un array de números y devuelva un nuevo array con cada número elevado al cuadrado")
 
-// 4. Usa desestructuración para extraer dos propiedades de un objeto y asígnalas
-//    a nuevas variables con nombres diferentes
+let newArray = []
 
-// 5. Usa desestructuración para extraer dos propiedades de un objeto anidado
-
-// 6. Usa propagación para combinar dos arrays en uno nuevo
-
-// 7. Usa propagación para crear una copia de un array
-
-// 8. Usa propagación para combinar dos objetos en uno nuevo
-
-// 9. Usa propagación para crear una copia de un objeto
-
-// 10. Combina desestructuración y propagación
\ No newline at end of file
+let sqr = (array) => {
+    array.forEach(element => {
+        let elevat = Math.pow(element, 2)
+        newArray.push(elevat)
+    });
+    console.log(newArray)
+};
+sqr(arra3)
\ No newline at end of file

From 99a8d59ed6fa00efa16b5cdeb9cd4b1700e12785 Mon Sep 17 00:00:00 2001
From: danielBuGo <danielbuilesgomez@gmail.com>
Date: Sat, 15 Mar 2025 17:29:16 -0500
Subject: [PATCH 16/16] Update 22-classes.js

finished
---
 Basic/22-classes.js | 237 ++++++++++++++++++++------------------------
 1 file changed, 108 insertions(+), 129 deletions(-)

diff --git a/Basic/22-classes.js b/Basic/22-classes.js
index b95ddc26..f5a8a772 100644
--- a/Basic/22-classes.js
+++ b/Basic/22-classes.js
@@ -4,190 +4,169 @@ Vídeo: https://youtu.be/1glVfFxj8a4?t=16864
 */
 
 // Clases
+let person = {
+    name: "Mariana",
+    age: 15,
+    alias: "Mari"
+};
 
-class Person {
-
+class Person {//Las clases inician con la primera leta  en mayus
     constructor(name, age, alias) {
         this.name = name
         this.age = age
         this.alias = alias
     }
-
-}
+};
+let subject = new Person ("Manuela", 13, "Mamu") //con el new se llama la clase
+let subject2 = new Person("Lina", 36, "reina")
+console.log(subject)
+console.log(subject2)
+console.log(typeof subject)
 
 // Sintaxis
-
-let person = new Person("Brais", 37, "MoureDev")
-let person2 = new Person("Brais", 37, "MoureDev")
-
-console.log(person)
-console.log(person2)
-
-console.log(typeof person)
-
 // Valores por defecto
 
 class DefaultPerson {
-
-    constructor(name = "Sin nombre", age = 0, alias = "Sin alias") {
+    constructor(name = "Sin nombre", age = 0, alias = "sin alias"){
         this.name = name
         this.age = age
         this.alias = alias
     }
-
-}
-
-let person3 = new DefaultPerson("Brais", 37)
-
-console.log(person3)
-
-// Acceso a propiedades
-
-console.log(person3.alias)
-console.log(person3["alias"])
-
-person3.alias = "MoureDev"
-
-console.log(person3.alias)
+};
+let subject3 = new DefaultPerson("madabeski", 50) //de esta manera se deben agregar propiedades en orden
+console.log(subject3)
+//Acceso a propiedades
+console.log("+++ Acceso a propiedades +++")
+console.log(subject3.alias)
+console.log(subject2.age)
+console.log(subject.name)
+console.log("+++ Agregar valores +++")
+subject3.alias = "Mada" // de esta manera se asigna proipedades a cada variable
+console.log(subject3)
 
 // Funciones en clases
-
-class PersonWithMethod {
-
+class PersonWithMetod {//Las clases inician con la primera leta  en mayus
     constructor(name, age, alias) {
         this.name = name
         this.age = age
         this.alias = alias
     }
-
-    walk() {
-        console.log("La persona camina.")
-    }
-
-}
-
-let person4 = new PersonWithMethod("Brais", 37, "MoureDev")
-person4.walk()
-
-// Propiedades privadas
-
-class PrivatePerson {
-
-    #bank
-
-    constructor(name, age, alias, bank) {
+    walk(){
+         console.log("the person is walking")
+    }
+};
+let subject4 = new PersonWithMetod("Jorge", 44, "Angulo")
+console.log("__________________________________")
+console.log(subject4)
+subject4.walk()
+
+class CarWithMetod {
+    constructor(brand, model, year){
+        this.brand = brand
+        this.model = model
+        this.year = year
+    }
+    carIsON(){
+        console.log("The car is turning on")
+    }
+};
+let car1 = new CarWithMetod("GMC", "Hammer", 2020)
+console.log(car1)
+car1.carIsON()
+car1.brand = "ferrari"
+console.log(car1)
+
+console.log("+++ Propiedades privadas +++")
+class PrivatePerosn {
+    #bank //Asi se especifica que un dato es privado
+    constructor(name, age, alias, bank){
         this.name = name
-        this.age = age
         this.alias = alias
-        this.#bank = bank
+        this.age = age
+        this.#bank = bank //Dato privado
     }
-
-    pay() {
+    pay(){
         this.#bank
-    }
-
-}
-
-let person5 = new PrivatePerson("Brais", 37, "MoureDev", "IBAN123456789")
-
+        console.log("Function ")
+    }
+};
+let subject5 = new PrivatePerosn("Julian", 46, "divino", "Ju345879")
+console.log(subject5) //Se muestran todos los datos menos los privados
+subject5.pay()
+subject5.bank = "this is a different bank"
+console.log(subject5)
 // No podemos acceder
 // console.log(person5.bank) 
 // person5.bank = "new IBAN123456789" // bank no es #bank
-
-console.log(person5)
-
-// Getters y Setters
-
-class GetSetPerson {
-
+console.log("+++ Getter and Setter +++")
+class GetPerson {
     #name
     #age
     #alias
+    #Id
     #bank
-
-    constructor(name, age, alias, bank) {
+    constructor(name, age, alias, Id, bank){
         this.#name = name
         this.#age = age
         this.#alias = alias
+        this.#Id = Id
         this.#bank = bank
     }
-
-    get name() {
-        return this.#name
-    }
-
-    set bank(bank) {
-        this.#bank = bank
+    get name(){ //Por medio de un Get podemos acceder al nombre
+        return this.#name       
     }
-
-}
-
-person6 = new GetSetPerson("Brais", 37, "MoureDev", "IBAN123456789")
-
-console.log(person6)
-console.log(person6.name)
-
-person6.bank = "new IBAN123456789"
+    set name(newBank){
+        this.#name = newBank //Se uede modificar el dato privado por medio del set
+    } 
+};
+let subject6 = new GetPerson("Nicolas", 59, "Nico", 1039448690, "bancolombia")
+console.log(subject6)
+console.log(subject6.name)
+subject6.name = "otherbank"
+console.log(subject6.name)
 
 /*
 Clase 38 - Herencia de clases
 Vídeo: https://youtu.be/1glVfFxj8a4?t=17999
 */
-
-// Herencia
-
+console.log("+++ Herencia de clases +++")
 class Animal {
-
-    constructor(name) {
-        this.name = name
+    constructor(nombre){
+        this.nombre = nombre
     }
-
-    sound() {
-        console.log("El animal emite un sonido genérico")
+    sound (){
+        console.log("Make a sound")
     }
-
-}
-
+};
 class Dog extends Animal {
 
-    sound() {
-        console.log("Guau!")
-    }
-
-    run() {
-        console.log("El perro corre")
+    run(){
+        console.log("the dog is running")
     }
+};
+let mydog = new Dog("Bella")
+console.log(mydog)
+mydog.sound()
+mydog.run()
 
-}
-
-class Fish extends Animal {
-
-    constructor(name, size) {
+class Bird extends Animal {
+    constructor (name, size){
         super(name)
-        this.size = size
+        this.size =size
     }
-
-    swim() {
-        console.log("El pez nada")
+    fly(){
+        console.log("The bird is flying")
     }
-
-}
-
-let myDog = new Dog("MoureDog")
-myDog.run()
-myDog.sound()
-
-let myFish = new Fish("MoureFish", 10)
-myFish.swim()
-myFish.sound()
+};
+let myBird = new Bird("Gallinazi", 10)
+console.log(myBird) 
+myBird.sound()
+myBird.fly()
 
 // Métodos estáticos
-
-class MathOperations {
-
-    static sum(a, b) {
+class MathOperators {
+    static sum(a, b){ //El static nos permite llamar directamente la funcion
         return a + b
     }
-}
-
-console.log(MathOperations.sum(5, 10))
\ No newline at end of file
+};
+console.log(MathOperators.sum(5,5))