Ejerciciologico1

.gitignore

@@ -1 +1,11 @@
-lista.txt
+# Ignorar archivos generados por Elm
+elm-stuff/
+*.dat
+
+# Archivos temporales de sistema
+*.log
+*.tmp
+
+# Archivos de compilación de VS
+bin/
+obj/

Ejemplo Parcial.txt

@@ -0,0 +1,15 @@
+Sección Lógica
+Regla 1: Escriba una regla que, dadas dos listas determine cuantos elementos iguales tienen.
+Regla 2: Defina una regla que remplace un elemento por otro pasado por parámetro.
+Regla 3: Defina una regla que dada una lista retorne otra lista con los primeros n elementos.
+
+Sección funcional
+Realice las siguientes funciones para list:
+getIndex: que retorne un Maybe (tipo opcional), si encuentra el elemento en la posición dada retorna el elemento y si no Nothing.
+foldR: que, dada una función y el valor inicial del acumulador, permita acumular todos los valores en una variable por la izquierda
+map: que permita aplicar una función a cada elemento.
+sort: Permite ordenar por medio de una función pasada por parámetros con el algoritmo Quicksort.
+andThen o flatMap: implementa el operador monádico (andThen o flatMap).
+Escriba una función que tome una lista de números y un número N, y devuelva la lista resultado de eliminar los N números mayores de la lista de entrada.
+
+

funcional/ejemplo_teoria/Maybe.txt

@@ -6,7 +6,7 @@ max: List Int -> Maybe Int
 max lista = 
   case lista of
     [] -> Nothing
-    head::tail -> case Maybe.map (\ x -> x < head) (max tail) of
+    head::tail -> case Maybe.map (\ x -> x < head) (max tail) of 
       Nothing -> Just head
       Just True -> Just head
       _ -> max(tail)

funcional/ejemplo_teoria/eje2.txt

@@ -2,8 +2,8 @@
 2.Agregue un elemento a una lista ordenada, en el lugar que le corresponda. 
 3.Escriba una función llamada "Cantidad-de" que toma como argumentos una lista y una condición (función), y  devuelve la cantidad de elementos de la lista que cumplen con dicha condición.
 4.Defina una función que tome una lista de números y una condición (función) como parámetros y devuelva la sumatoria de los elementos que cumplen dicha condición.
-4.Escriba una función llamada “intercalar-según” que tome dos listas y una función como entrada, y construya una nueva lista resultado de intercalar las dos primeras en el orden establecido por la función (es decir, que la función se aplica a los dos elementos que se comparan en cada momento para determinar cuál es el mayor).
-5.Considere que cada conjunto se representa mediante una lista. Defina funciones para simular:
+5.Escriba una función llamada “intercalar-según” que tome dos listas y una función como entrada, y construya una nueva lista resultado de intercalar las dos primeras en el orden establecido por la función (es decir, que la función se aplica a los dos elementos que se comparan en cada momento para determinar cuál es el mayor).
+6.Considere que cada conjunto se representa mediante una lista. Defina funciones para simular:
     a. Unión de conjuntos.
     b. Intersección de conjuntos.
     c. Diferencia de conjuntos.

funcional/ejercicios/ejercicio1/a.ts

@@ -0,0 +1,4 @@
+function add(a:number, b:number):number {
+    if (b === 0) return a;
+    return add(a+1, b-1);
+}

funcional/ejercicios/ejercicio1/src/Main.elm

@@ -1,6 +1,6 @@
 module Main exposing (..)
 
-import Html exposing (Html, a, text)
+import Html exposing (Html, text)
 
 
 main : Html msg
@@ -10,170 +10,126 @@ main =
 
 add : Int -> Int -> Int
 add a b =
-    if b == 0 then
-        a
-
-    else
-        add (a + 1) (b - 1)
+    a + b
 
 
 multiply : Int -> Int -> Int
 multiply a b =
-    if b == 0 then
-        0
-
-    else if b == 1 then
-        a
-
-    else
-        a + multiply a (b - 1)
-
-
-multiply2 : Int -> Int -> Int -> Int
-multiply2 a b acc =
-    if b == 0 then
-        acc
-
-    else
-        multiply2 a (b - 1) (acc + a)
-
+    a * b
 
 
 -- Ejercicio 1: Función Potencia
-
-
 power : Int -> Int -> Int
 power a b =
-    if b == 0 then
-        1
-
-    else
-        a * power a (b - 1)
-
+    a ^ b
 
 
 -- Ejercicio 2: Factorial
-
-
-factorial : Int -> Int
+factorial : Int -> Int      -- recibe un entero y devuelve un entero
 factorial n =
-    if n <= 1 then
+    if n == 0 then           -- si n vale 0, el factorial es 1
         1
-
     else
-        n * factorial (n - 1)
-
+        n * factorial (n - 1)  -- en otro caso, n! se calcula multiplicando n por el factorial de n-1
 
 
 -- Ejercicio 3: Fibonacci
-
-
-fibonacciExponential : Int -> Int
+fibonacciExponential : Int -> Int        -- recibe un número y devuelve el n-ésimo Fibonacci
 fibonacciExponential n =
-    if n <= 1 then
-        n
-
+    if n == 0 then                       -- primer caso: fib(0) = 0
+        0
+    else if n == 1 then                  -- segundo caso: fib(1) = 1
+        1
     else
-        fibonacciExponential (n - 1) + fibonacciExponential (n - 2)
+        fibonacciExponential (n - 1) + fibonacciExponential (n - 2) -- sumamos los dos anteriores
 
 
-fibonacciLinear : Int -> Int
+--Fibonacci lineal con acumuladores
+fibonacciLinear : Int -> Int              -- recibe un número y devuelve el n-ésimo Fibonacci
 fibonacciLinear n =
-    fibonacciHelper n 0 1
+    if n == 0 then                        -- si n es 0, el resultado es 0
+        0
+    else
+        fibonacciHelper n 0 1             -- empezamos con 0 y 1 como primeros valores de Fibonacci
 
 
+-- Función auxiliar con acumuladores
 fibonacciHelper : Int -> Int -> Int -> Int
 fibonacciHelper n acc1 acc2 =
-    if n == 0 then
-        acc1
-
-    else if n == 1 then
+    if n == 1 then                        -- cuando llegamos a 1 devolvemos el acumulador acc2
         acc2
-
     else
         fibonacciHelper (n - 1) acc2 (acc1 + acc2)
-
+        -- avanzamos: el segundo acumulador pasa a ser el primero
+        -- y el nuevo segundo es la suma de ambos
 
 
 -- Ejercicio 4: Triángulo de Pascal
-
-
-pascalTriangle : Int -> Int -> Int
+pascalTriangle : Int -> Int -> Int          -- recibe la fila (x) y la columna (y)
 pascalTriangle x y =
-    if x == 0 || x == y then
+    if y == 0 || y == x then                -- si estamos en el borde devolvemos 1
         1
-
     else
-        pascalTriangle (x - 1) (y - 1) + pascalTriangle x (y - 1)
-
-
+        pascalTriangle (x - 1) (y - 1)      -- sumamos el de arriba a la izquierda
+        + pascalTriangle (x - 1) y          -- y el de arriba a la derecha
 
 -- Ejercicio 5: Máximo Común Divisor (MCD)
-
-
-gcd : Int -> Int -> Int
+gcd : Int -> Int -> Int              -- recibe dos enteros y devuelve el mayor divisor común
 gcd a b =
-    if b == 0 then
-        abs a
-
+    if b == 0 then                    -- si el segundo número llega a 0, el resultado es a
+        a
     else
-        gcd b (modBy b a)
-
+        gcd b (modBy b a)             -- de lo contrario seguimos con b y el resto de a dividido b
 
 
 -- Ejercicio 6: Contar Dígitos
-
-
-countDigits : Int -> Int
+countDigits : Int -> Int              -- recibe un número entero y devuelve la cantidad de dígitos
 countDigits n =
-    if n < 0 then
-        countDigits (-1 * n)
-
-    else if n < 10 then
+    if n < 10 then                    -- si el número es menor que 10, tiene un solo dígito
         1
-
     else
-        1 + countDigits (n // 10)
-
+        1 + countDigits (n // 10)     -- en otro caso, quitamos un dígito dividiendo por 10 y sumamos 1
 
 
 -- Ejercicio 7: Suma de Dígitos
-
-
-sumDigits : Int -> Int
+sumDigits : Int -> Int                -- recibe un número entero y devuelve la suma de sus dígitos
 sumDigits n =
-    if n < 0 then
-        sumDigits (-1 * n)
-
-    else if n < 10 then
+    if n < 10 then                    -- si es un número de un solo dígito, lo devolvemos tal cual
         n
-
     else
-        modBy 10 n + sumDigits (n // 10)
-
+        (modBy 10 n) + sumDigits (n // 10) -- tomamos el último dígito y lo sumamos con el resto
 
 
 -- Ejercicio 8: Verificar Palíndromo
-
-
-isPalindrome : Int -> Bool
+isPalindrome : Int -> Bool            -- recibe un número y devuelve True si es palíndromo
 isPalindrome n =
-    n >= 0 && n == reverseNumber n
+    n == reverseNumber n              -- un número es palíndromo si es igual a su inverso
 
 
+-- Función principal para invertir un número
 reverseNumber : Int -> Int
 reverseNumber n =
-    reverseHelper n 0
+    reverseHelper n 0                  -- empezamos con el acumulador en 0
 
 
+-- Función auxiliar con acumulador
 reverseHelper : Int -> Int -> Int
 reverseHelper n acc =
-    if n < 10 then
-        acc * 10 + n
-
+    if n == 0 then                     -- cuando no quedan más dígitos, devolvemos el acumulador
+        acc
     else
-        let
-            digit =
-                modBy 10 n
-        in
-        reverseHelper (n // 10) (acc * 10 + digit)
+        reverseHelper (n // 10) (acc * 10 + modBy 10 n)
+        -- dividimos entre 10 para avanzar y agregamos el último dígito al acumulador
+
+
+-- Ejercicio 9: Paréntesis Balanceados
+isBalanced : String -> Bool
+isBalanced str =
+    -- TODO: Implementar verificador de paréntesis balanceados
+    False
+
+
+isBalancedHelper : List Char -> Int -> Bool
+isBalancedHelper chars counter =
+    -- TODO: Función auxiliar para verificar paréntesis balanceados
+    False