feat: add articles to easy challenges

Author: IbatoLionDev

1-EASY/Python/1-inversing-a-string/article.md

@@ -0,0 +1,54 @@
+# Challenge Description and Solution
+
+## English Version
+
+### Challenge Description
+Given a string, create a function that reverses it without using built-in reverse methods. This challenge helps you practice loops and index handling in Python.
+
+### Code Explanation
+The function `reverse_string` takes a string `s` as input and creates a new string `reversed_str` containing the characters of `s` in reverse order. It uses a `for` loop that iterates from the last character to the first, appending each character to `reversed_str`. Finally, the function returns the reversed string.
+
+Relevant code:
+
+```python
+def reverse_string(s):
+    reversed_str = ""
+    for i in range(len(s) - 1, -1, -1):
+        reversed_str += s[i]
+    return reversed_str
+```
+
+The `if __name__ == "__main__":` block contains an example usage where the string `"hello"` is reversed and the result is printed.
+
+```python
+if __name__ == "__main__":
+    test_string = "hello"
+    print("Original string:", test_string)
+    print("Reversed string:", reverse_string(test_string))
+```
+
+## Versión en Español
+
+### Descripción del Reto
+Dada una cadena de caracteres, crea una función que la invierta sin usar métodos integrados de inversión. Este reto te ayudará a practicar el uso de bucles y el manejo de índices en Python.
+
+### Explicación del Código
+La función `reverse_string` toma una cadena `s` como entrada y crea una nueva cadena `reversed_str` que contiene los caracteres de `s` en orden inverso. Para ello, se utiliza un bucle `for` que recorre la cadena desde el último carácter hasta el primero, agregando cada carácter a `reversed_str`. Finalmente, la función retorna la cadena invertida.
+
+Código relevante:
+
+```python
+def reverse_string(s):
+    reversed_str = ""
+    for i in range(len(s) - 1, -1, -1):
+        reversed_str += s[i]
+    return reversed_str
+```
+
+El bloque `if __name__ == "__main__":` contiene un ejemplo de uso donde se invierte la cadena `"hello"` y se imprime el resultado.
+
+```python
+if __name__ == "__main__":
+    test_string = "hello"
+    print("Cadena original:", test_string)
+    print("Cadena invertida:", reverse_string(test_string))

1-EASY/Python/10-even-or-odd-detector/article.md

@@ -0,0 +1,50 @@
+# Challenge Description and Solution
+
+## English Version
+
+### Challenge Description
+Write a function that determines if a number is even or odd. Test with different types of inputs (positive numbers, negative numbers, and zero) to ensure robustness.
+
+### Code Explanation
+The `is_even` function uses the modulo operator `%` to determine if a number is even. If the remainder of the division of the number by 2 is zero, the number is even; otherwise, it is odd.
+
+Relevant code:
+
+```python
+def is_even(n):
+    return n % 2 == 0
+```
+
+The `if __name__ == "__main__":` block contains an example usage that tests several values and prints whether they are even or odd.
+
+```python
+if __name__ == "__main__":
+    test_values = [0, 1, -1, 2, -2, 15, -15]
+    for val in test_values:
+        result = "even" if is_even(val) else "odd"
+        print(f"{val} is {result}")
+```
+
+## Versión en Español
+
+### Descripción del Reto
+Escribe una función que determine si un número es par o impar. Prueba con diferentes tipos de entradas (números positivos, negativos y cero) para asegurar la robustez.
+
+### Explicación del Código
+La función `is_even` utiliza el operador módulo `%` para determinar si un número es par. Si el residuo de la división entre el número y 2 es cero, el número es par; de lo contrario, es impar.
+
+Código relevante:
+
+```python
+def is_even(n):
+    return n % 2 == 0
+```
+
+El bloque `if __name__ == "__main__":` contiene un ejemplo de uso que prueba varios valores y muestra si son pares o impares.
+
+```python
+if __name__ == "__main__":
+    test_values = [0, 1, -1, 2, -2, 15, -15]
+    for val in test_values:
+        result = "even" if is_even(val) else "odd"
+        print(f"{val} is {result}")

1-EASY/Python/2-check-prime-number/article.md

@@ -0,0 +1,70 @@
+# Challenge Description and Solution
+
+## English Version
+
+### Challenge Description
+Implement a function that determines if a number is prime. Pay attention to edge cases such as negative values and the number 1.
+
+### Code Explanation
+The `is_prime` function checks if a number `n` is prime. It first excludes numbers less than or equal to 1, which are not prime. Then, it considers 2 and 3 as prime numbers. Next, it eliminates multiples of 2 and 3. Finally, it uses a loop that checks divisors starting from 5, skipping multiples of 6, to optimize the search. If a divisor is found, it returns `False`; otherwise, it returns `True`.
+
+Relevant code:
+
+```python
+def is_prime(n):
+    if n <= 1:
+        return False
+    if n <= 3:
+        return True
+    if n % 2 == 0 or n % 3 == 0:
+        return False
+    i = 5
+    while i * i <= n:
+        if n % i == 0 or n % (i + 2) == 0:
+            return False
+        i += 6
+    return True
+```
+
+The `if __name__ == "__main__":` block contains an example usage that tests several numbers and prints whether they are prime or not.
+
+```python
+if __name__ == "__main__":
+    test_numbers = [-1, 0, 1, 2, 3, 4, 5, 29, 35]
+    for num in test_numbers:
+        print(f"{num} is prime: {is_prime(num)}")
+```
+
+## Versión en Español
+
+### Descripción del Reto
+Implementa una función que determine si un número es primo. Presta atención a casos especiales como valores negativos y el número 1.
+
+### Explicación del Código
+La función `is_prime` verifica si un número `n` es primo. Primero descarta números menores o iguales a 1, que no son primos. Luego, considera los números 2 y 3 como primos. Después, elimina múltiplos de 2 y 3. Finalmente, utiliza un bucle que verifica divisores desde 5 en adelante, saltando múltiplos de 6, para optimizar la búsqueda. Si encuentra un divisor, retorna `False`; si no, retorna `True`.
+
+Código relevante:
+
+```python
+def is_prime(n):
+    if n <= 1:
+        return False
+    if n <= 3:
+        return True
+    if n % 2 == 0 or n % 3 == 0:
+        return False
+    i = 5
+    while i * i <= n:
+        if n % i == 0 or n % (i + 2) == 0:
+            return False
+        i += 6
+    return True
+```
+
+El bloque `if __name__ == "__main__":` contiene un ejemplo de uso que prueba varios números y muestra si son primos o no.
+
+```python
+if __name__ == "__main__":
+    test_numbers = [-1, 0, 1, 2, 3, 4, 5, 29, 35]
+    for num in test_numbers:
+        print(f"{num} is prime: {is_prime(num)}")

1-EASY/Python/3-fibonacci-sequence-generator/article.md

@@ -0,0 +1,84 @@
+# Challenge Description and Solution
+
+## English Version
+
+### Challenge Description
+Create a generator that returns the Fibonacci sequence up to n terms. You can explore iterative and recursive approaches to solve the problem.
+
+### Code Explanation
+The code presents two generator functions for the Fibonacci sequence:
+
+- `fibonacci_iterative(n)`: Uses a `for` loop to generate the first n terms of the Fibonacci sequence iteratively. It initializes two variables `a` and `b` with 0 and 1 respectively, and in each iteration yields the current value of `a` and updates `a` and `b`.
+
+- `fibonacci_recursive(n, a=0, b=1)`: Generates the Fibonacci sequence recursively. If `n` is 0, it ends the recursion. Otherwise, it yields the current value `a` and recursively calls itself with `n-1`, `b`, and `a+b`.
+
+Relevant code:
+
+```python
+def fibonacci_iterative(n):
+    a, b = 0, 1
+    for _ in range(n):
+        yield a
+        a, b = b, a + b
+
+def fibonacci_recursive(n, a=0, b=1):
+    if n == 0:
+        return
+    yield a
+    yield from fibonacci_recursive(n-1, b, a + b)
+```
+
+The `if __name__ == "__main__":` block shows an example usage that prints the Fibonacci sequence generated by both methods for n=10.
+
+```python
+if __name__ == "__main__":
+    n = 10
+    print("Iterative Fibonacci sequence:")
+    for num in fibonacci_iterative(n):
+        print(num, end=" ")
+    print("\nRecursive Fibonacci sequence:")
+    for num in fibonacci_recursive(n):
+        print(num, end=" ")
+    print()
+```
+
+## Versión en Español
+
+### Descripción del Reto
+Crea un generador que devuelva la secuencia de Fibonacci hasta n términos. Puedes explorar enfoques iterativos y recursivos para resolver el problema.
+
+### Explicación del Código
+El código presenta dos funciones generadoras para la secuencia de Fibonacci:
+
+- `fibonacci_iterative(n)`: Utiliza un bucle `for` para generar los primeros n términos de la secuencia de Fibonacci de manera iterativa. Inicializa dos variables `a` y `b` con 0 y 1 respectivamente, y en cada iteración produce el valor actual de `a` y actualiza `a` y `b`.
+
+- `fibonacci_recursive(n, a=0, b=1)`: Genera la secuencia de Fibonacci de forma recursiva. Si `n` es 0, termina la recursión. De lo contrario, produce el valor actual `a` y llama recursivamente a sí misma con `n-1`, `b` y `a+b`.
+
+Código relevante:
+
+```python
+def fibonacci_iterative(n):
+    a, b = 0, 1
+    for _ in range(n):
+        yield a
+        a, b = b, a + b
+
+def fibonacci_recursive(n, a=0, b=1):
+    if n == 0:
+        return
+    yield a
+    yield from fibonacci_recursive(n-1, b, a + b)
+```
+
+El bloque `if __name__ == "__main__":` muestra un ejemplo de uso que imprime la secuencia de Fibonacci generada por ambos métodos para n=10.
+
+```python
+if __name__ == "__main__":
+    n = 10
+    print("Iterative Fibonacci sequence:")
+    for num in fibonacci_iterative(n):
+        print(num, end=" ")
+    print("\nRecursive Fibonacci sequence:")
+    for num in fibonacci_recursive(n):
+        print(num, end=" ")
+    print()

1-EASY/Python/4-factorial-calculator/article.md

@@ -0,0 +1,82 @@
+# Challenge Description and Solution
+
+## English Version
+
+### Challenge Description
+Develop a recursive or iterative function to calculate the factorial of a non-negative integer. Consider handling special cases.
+
+### Code Explanation
+The code presents two functions to calculate the factorial:
+
+- `factorial_recursive(n)`: Calculates the factorial recursively. If `n` is negative, it raises an error. If `n` is 0 or 1, it returns 1. Otherwise, it returns `n` multiplied by the factorial of `n-1`.
+
+- `factorial_iterative(n)`: Calculates the factorial iteratively. If `n` is negative, it raises an error. It initializes `result` to 1 and successively multiplies by each number from 2 to `n`.
+
+Relevant code:
+
+```python
+def factorial_recursive(n):
+    if n < 0:
+        raise ValueError("Factorial is not defined for negative numbers")
+    if n == 0 or n == 1:
+        return 1
+    return n * factorial_recursive(n - 1)
+
+def factorial_iterative(n):
+    if n < 0:
+        raise ValueError("Factorial is not defined for negative numbers")
+    result = 1
+    for i in range(2, n + 1):
+        result *= i
+    return result
+```
+
+The `if __name__ == "__main__":` block contains an example usage that calculates the factorial of several values using both methods.
+
+```python
+if __name__ == "__main__":
+    test_values = [0, 1, 5, 7]
+    for val in test_values:
+        print(f"Factorial of {val} (recursive): {factorial_recursive(val)}")
+        print(f"Factorial of {val} (iterative): {factorial_iterative(val)}")
+```
+
+## Versión en Español
+
+### Descripción del Reto
+Desarrolla una función recursiva o iterativa para calcular el factorial de un número entero no negativo. Considera el manejo de casos especiales como números negativos.
+
+### Explicación del Código
+El código presenta dos funciones para calcular el factorial:
+
+- `factorial_recursive(n)`: Calcula el factorial de forma recursiva. Si `n` es negativo, lanza un error. Si `n` es 0 o 1, retorna 1. En otro caso, retorna `n` multiplicado por el factorial de `n-1`.
+
+- `factorial_iterative(n)`: Calcula el factorial de forma iterativa. Si `n` es negativo, lanza un error. Inicializa `result` en 1 y multiplica sucesivamente por cada número desde 2 hasta `n`.
+
+Código relevante:
+
+```python
+def factorial_recursive(n):
+    if n < 0:
+        raise ValueError("Factorial is not defined for negative numbers")
+    if n == 0 or n == 1:
+        return 1
+    return n * factorial_recursive(n - 1)
+
+def factorial_iterative(n):
+    if n < 0:
+        raise ValueError("Factorial is not defined for negative numbers")
+    result = 1
+    for i in range(2, n + 1):
+        result *= i
+    return result
+```
+
+El bloque `if __name__ == "__main__":` contiene un ejemplo de uso que calcula el factorial de varios valores usando ambos métodos.
+
+```python
+if __name__ == "__main__":
+    test_values = [0, 1, 5, 7]
+    for val in test_values:
+        print(f"Factorial of {val} (recursive): {factorial_recursive(val)}")
+        print(f"Factorial of {val} (iterative): {factorial_iterative(val)}")