Merge pull request 4GeeksAcademy#58 from josemoracard/jose7-28-sequence-of-lines

alesanchezr · web-flow · commit a9a79d934e6c · 2024-01-24T10:44:43.000-05:00
exercises 28-sequence-of-lines to 34-a-aa-aaa-aaaa
diff --git a/exercises/28-sequence-of-lines/README.es.md b/exercises/28-sequence-of-lines/README.es.md
@@ -1,13 +1,21 @@
 # `28` Sequence of lines
 
-Escribe un programa que acepte una secuencia de líneas como entrada y que luego imprima las líneas convirtiendo todos los caracteres en mayúscula.
+## 📝 Instrucciones:
 
-Supongamos le entregamos la siguiente entrada al programa:
-Hello world
-Practice makes perfect
-El resultado debería ser este:
-HELLO WORLD
-PRACTICE MAKES PERFECT
+1. Escribe la función `lines()`. Dado un string, haz que la función retorne todos los caracteres del string en mayúsculas.
 
-Pistas:
-En caso de que se le pasen entradas de datos a la pregunta, deben asumirse como entradas de la consola.
+## 📎 Ejemplo de entrada:
+
+```py
+lines("Hello world, practice makes perfect")
+```
+
+## 📎 Ejemplo de salida:
+
+```text
+HELLO WORLD, PRACTICE MAKES PERFECT
+```
+
+## 💡 Pista:
+
++ Googlea cómo convertir un string a mayúsculas en Python.
diff --git a/exercises/28-sequence-of-lines/README.md b/exercises/28-sequence-of-lines/README.md
@@ -1,14 +1,21 @@
 # `28` Sequence of lines
 
-Write a program that accepts sequence of lines as input and prints the lines after making all characters in the sentence capitalized.
-Suppose the following input is supplied to the program:
-Hello world
-Practice makes perfect
-Then, the output should be:
-HELLO WORLD
-PRACTICE MAKES PERFECT
-
-Hints:
-In case of input data being supplied to the question, it should be assumed to be a console input.
-
-Solution:
+## 📝 Instructions:
+
+1. Write a function `lines()`. Given a string, make the function return all the characters from the string capitalized.
+
+## 📎 Example input:
+
+```py
+lines("Hello world, practice makes perfect")
+```
+
+## 📎 Example output:
+
+```text
+HELLO WORLD, PRACTICE MAKES PERFECT
+```
+
+## 💡 Hint:
+
++ Google how to capitalize a string in Python.
diff --git a/exercises/28-sequence-of-lines/app.py b/exercises/28-sequence-of-lines/app.py
@@ -0,0 +1 @@
+# Your code here
diff --git a/exercises/28-sequence-of-lines/solution.hide.py b/exercises/28-sequence-of-lines/solution.hide.py
@@ -1,4 +1,5 @@
+# Your code here
 def lines(text):
     return text.upper()
 
-print(lines('Hello world'))
+print(lines('Hello world, practice makes perfect'))
diff --git a/exercises/28-sequence-of-lines/test.py b/exercises/28-sequence-of-lines/test.py
@@ -9,6 +9,6 @@ def test_function_existence(capsys, app):
 def test_expected_output(capsys, app):
     assert app.lines("hello world") == "HELLO WORLD"
 
-@pytest.mark.it('The function should return the expected output')
+@pytest.mark.it('The function should return the expected output. Testing with a different value')
 def test_another_output(capsys, app):
     assert app.lines("LeT the WOrld know YoU") == "LET THE WORLD KNOW YOU"
diff --git a/exercises/29-remove-duplicate-words/README.es.md b/exercises/29-remove-duplicate-words/README.es.md
@@ -1,18 +1,23 @@
-# `29`Eliminar los duplicados
+# `29` Remove duplicate words
 
-Escribe un programa que acepte una secuencia de palabras separadas por espacios en blanco como entrada y que imprima luego las palabras eliminando todas las duplicadas y ordenándolas alfanuméricamente.
+## 📝 Instrucciones:
 
-Supongamos que se le entrega la siguiente entrada al programa:
+1. Escribe la función `remove_duplicate_words()` que tome una secuencia de palabras separadas por espacios en blanco como entrada. Luego, retorna las palabras eliminando duplicados y organizándolas alfanuméricamente.
 
-hello world and practice makes perfect and hello world again
+## 📎 Ejemplo de entrada:
 
-El resultado debería ser:
+```py
+remove_duplicate_words("hello world and practice makes perfect and hello world again")
+```
 
-again and hello makes perfect practice world
+## 📎 Ejemplo de salida:
 
-Pistas:
-En caso de que se le entregue entradas de datos a la pregunta, debe asumirse como entrada de la consola.
+```text
+again and hello makes perfect practice world
+```
 
-Usa set container para eliminar los datos duplicados automáticamente y luego usa sorted() para ordenar los datos.
+## 💡 Pistas:
 
++ Puedes convertir tu entrada en el tipo de dato `set` para eliminar automáticamente cualquier duplicado.
 
++ Puedes utilizar `sorted()` para ordenar los elementos de una lista.
diff --git a/exercises/29-remove-duplicate-words/README.md b/exercises/29-remove-duplicate-words/README.md
@@ -1,12 +1,23 @@
 # `29` Remove duplicate words
 
-Write a program that accepts a sequence of whitespace separated words as input and prints the words after removing all duplicate words and sorting them alphanumerically.
-Suppose the following input is supplied to the program:
-hello world and practice makes perfect and hello world again
-Then, the output should be:
+## 📝 Instructions:
+
+1. Write a function called `remove_duplicate_words()` that accepts a sequence of whitespace separated words as input and returns the words after removing all duplicate words and sorting them alphanumerically.
+
+## 📎 Example input:
+
+```py
+remove_duplicate_words("hello world and practice makes perfect and hello world again")
+```
+
+## 📎 Example output:
+
+```text
 again and hello makes perfect practice world
+```
+
+## 💡 Hints:
 
-Hints:
-In case of input data being supplied to the question, it should be assumed to be a console input.
-We use set container to remove duplicated data automatically and then use sorted() to sort the data.
++ You can convert your input into the `set` data type to automatically eliminate duplicates.
 
++ You can use `sorted()` to sort the data from a list.
diff --git a/exercises/29-remove-duplicate-words/app.py b/exercises/29-remove-duplicate-words/app.py
@@ -1,3 +1 @@
-s = input()
-words = [word for word in s.split(" ")]
-print (" ".join(sorted(list(set(words)))))
+# Your code here
diff --git a/exercises/29-remove-duplicate-words/solution.hide.py b/exercises/29-remove-duplicate-words/solution.hide.py
@@ -1,3 +1,6 @@
+# Your code here
 def remove_duplicate_words(text):
     words = text.split()
     return (" ".join(sorted(list(set(words)))))
+
+print(remove_duplicate_words("hello world and practice makes perfect and hello world again"))
diff --git a/exercises/29-remove-duplicate-words/test.py b/exercises/29-remove-duplicate-words/test.py
@@ -8,11 +8,11 @@ def test_function_existence(capsys, app):
 def test_expected_output(capsys, app):
     assert app.remove_duplicate_words("hello world and practice makes perfect and hello world again") == "again and hello makes perfect practice world"
 
-@pytest.mark.it('The function should work with other entries')
+@pytest.mark.it('The function should work with other entries. Testing with different values')
 def test_expected_output_2(capsys, app):
     assert app.remove_duplicate_words("lets try this again with another try") == "again another lets this try with"
 
-@pytest.mark.it('The function should work with other entries')
+@pytest.mark.it('The function should work with other entries. Testing with different values')
 def test_expected_output_3(capsys, app):
     assert app.remove_duplicate_words("Jacke was Named Jacke by his mother") == "Jacke Named by his mother was"
 
diff --git a/exercises/30-divisable-binary/README.es.md b/exercises/30-divisable-binary/README.es.md
@@ -0,0 +1,28 @@
+# `30` Divisable binary
+
+## 📝 Instrucciones:
+
+1. Escribe la función `divisible_binary()` que tome una secuencia de números binarios de 4 dígitos separados por comas como entrada y verifique si son divisibles por 5. Imprime los números que son divisibles por 5 en una secuencia separada por comas.
+
+## 📎 Ejemplo de entrada:
+
+```py
+divisible_binary("0100,0011,1010,1001")
+```
+
+## 📎 Ejemplo de salida:
+
+```py
+1010
+```
+
+## 💡 Pista:
+
++ Para convertir números binarios en nuestros números enteros cotidianos (base 10 o decimal), es necesario incluir la base del número que ingresamos en el primer argumento (en este caso, base 2 o binario), y la función `int()` se encargará del resto. Sería así:
+
+```py
+binary = '0101'
+decimal = int(binary, 2)
+
+print(decimal)  # Output: 5
+```
diff --git a/exercises/30-divisable-binary/README.md b/exercises/30-divisable-binary/README.md
@@ -1,9 +1,28 @@
-Write a program which accepts a sequence of comma separated 4 digit binary numbers as its input and then check whether they are divisible by 5 or not. The numbers that are divisible by 5 are to be printed in a comma separated sequence.
-Example:
-0100,0011,1010,1001
-Then the output should be:
+# `30` Divisable binary
+
+## 📝 Instructions:
+
+1. Write a function `divisible_binary()` that takes a sequence of comma-separated 4-digit binary numbers as input and checks if they are divisible by 5. Print the numbers that are divisible by 5 in a comma-separated sequence.
+
+## 📎 Example input:
+
+```py
+divisible_binary("0100,0011,1010,1001")
+```
+
+## 📎 Example output:
+
+```py
 1010
-Notes: Assume the data is input by console.
+```
+
+## 💡 Hint:
+
++ To convert binary numbers into our everyday integer numbers (base 10 or decimal), you have to include the base of the number we input in the first argument (in this case, base 2 or binary), and the function `int()` will take care of the rest. Like this:
+
+```py
+binary = '0101'
+decimal = int(binary, 2)
 
-Hints:
-In case of input data being supplied to the question, it should be assumed to be a console input.
+print(decimal)  # Output: 5
+```
diff --git a/exercises/30-divisable-binary/app.py b/exercises/30-divisable-binary/app.py
@@ -0,0 +1 @@
+# Your code here
diff --git a/exercises/30-divisable-binary/solution.hide.py b/exercises/30-divisable-binary/solution.hide.py
@@ -1,9 +1,12 @@
-def divisable_binary(text):
-    value=[]
-    items=[x for x in text.split(',')]
-    for p in items:
-        intp = int(p, 2)
-        if not intp%5:
-            value.append(p)
+# Your code here
+def divisible_binary(binary_sequence):
+    divisible_numbers = []
+    binary_numbers = [x for x in binary_sequence.split(',')]
+    for binary_num in binary_numbers:
+        int_binary_num = int(binary_num, 2)
+        if not int_binary_num % 5:
+            divisible_numbers.append(binary_num)
 
-    return (','.join(value))
+    return ','.join(divisible_numbers)
+
+print(divisible_binary("1000,1100,1010,1111"))
diff --git a/exercises/30-divisable-binary/test.py b/exercises/30-divisable-binary/test.py
@@ -1,17 +1,17 @@
 import pytest, io, sys, json, mock, re, os
 
-@pytest.mark.it('The function divisable_binary must exist')
+@pytest.mark.it('The function divisible_binary must exist')
 def test_function_existence(capsys, app):
-    assert app.divisable_binary
+    assert app.divisible_binary
 
 @pytest.mark.it('The function should return the expected output')
 def test_expected_output(capsys, app):
-    assert app.divisable_binary("0100,0011,1010,1001") == "1010"
+    assert app.divisible_binary("0100,0011,1010,1001") == "1010"
 
 @pytest.mark.it('The function should work with other parameters. testing with 1111,1000,0101,0000')
 def test_expected_output_2(capsys, app):
-    assert app.divisable_binary("1111,1000,0101,0000") == "1111,0101,0000"
+    assert app.divisible_binary("1111,1000,0101,0000") == "1111,0101,0000"
 
 @pytest.mark.it("The function should work with other parameters. Testing with 1000")
 def test_expected_output_3(capsys, app):
-    assert app.divisable_binary("1000,1000,1000,1000") == ""
+    assert app.divisible_binary("1000,1000,1000,1000") == ""
diff --git a/exercises/31-sum-eigth-digit/README.es.md b/exercises/31-sum-eigth-digit/README.es.md
@@ -0,0 +1,5 @@
+# `31` All digits even
+
+## 📝 Instrucciones:
+
+1. Define una función llamada `all_digits_even()` para identificar e imprimir todos los números entre 1000 y 3000 (inclusive) en los que cada dígito es un número par. Muestra los números resultantes en una secuencia separada por comas en una sola línea.
diff --git a/exercises/31-sum-eigth-digit/README.md b/exercises/31-sum-eigth-digit/README.md
@@ -1,7 +1,5 @@
-Write a program, which will find all such numbers between 1000 and 3000 (both included) such that each digit of the number is an even number.
-The numbers obtained should be printed in a comma-separated sequence on a single line.
+# `31` All digits even
 
-Hints:
-In case of input data being supplied to the question, it should be assumed to be a console input.
+## 📝 Instructions:
 
-Solution:
+1. Define a function named `all_digits_even()` to identify and print all numbers between 1000 and 3000 (inclusive) where each digit is an even number. Display the resulting numbers in a comma-separated sequence on a single line.
diff --git a/exercises/31-sum-eigth-digit/app.py b/exercises/31-sum-eigth-digit/app.py
@@ -0,0 +1 @@
+# Your code here
diff --git a/exercises/31-sum-eigth-digit/solution.hide.py b/exercises/31-sum-eigth-digit/solution.hide.py
@@ -1,6 +1,11 @@
-values = []
-for i in range(1000, 3001):
-    s = str(i)
-    if (int(s[0])%2==0) and (int(s[1])%2==0) and (int(s[2])%2==0) and (int(s[3])%2==0):
-        values.append(s)
-print ",".join(values)
+# Your code here
+def all_digits_even():
+    values = []
+    for i in range(1000, 3001):
+        s = str(i)
+        if (int(s[0]) % 2 == 0) and (int(s[1]) % 2 == 0) and (int(s[2]) % 2 == 0) and (int(s[3]) % 2 == 0):
+            values.append(s)
+
+    return ",".join(values)
+
+print(all_digits_even())
diff --git a/exercises/32-numbers-of-letters-and-digits/README.es.md b/exercises/32-numbers-of-letters-and-digits/README.es.md
@@ -0,0 +1,22 @@
+# `32` Number of letters and digits
+
+## 📝 Instrucciones:
+
+1. Escribe una función llamada `letters_and_digits()` que tome una oración como entrada y calcule la cantidad de letras y dígitos presentes en ella.
+
+## 📎 Ejemplo de entrada:
+
+```py
+letters_and_digits("hello world! 123")
+```
+
+## 📎 Ejemplo de salida:
+
+```text
+LETTERS 10
+DIGITS 3
+```
+
+## 💡 Pista:
+
++ Declara un diccionario para guardar ambas cuentas en una sola variable.
diff --git a/exercises/32-numbers-of-letters-and-digits/README.md b/exercises/32-numbers-of-letters-and-digits/README.md
@@ -1,9 +1,22 @@
-Write a program that accepts a sentence and calculate the number of letters and digits.
-Suppose the following input is supplied to the program:
-hello world! 123
-Then, the output should be:
+# `32` Number of letters and digits
+
+## 📝 Instructions:
+
+1. Write a function named `letters_and_digits()` that takes a sentence as input and calculates the number of letters and digits present in it.
+
+## 📎 Example input:
+
+```py
+letters_and_digits("hello world! 123")
+```
+
+## 📎 Example output:
+
+```text
 LETTERS 10
 DIGITS 3
+```
+
+## 💡 Hint:
 
-Hints:
-In case of input data being supplied to the question, it should be assumed to be a console input.
++ Declare a dictionary for storing both counts in one variable.
diff --git a/exercises/32-numbers-of-letters-and-digits/app.py b/exercises/32-numbers-of-letters-and-digits/app.py
@@ -0,0 +1 @@
+# Your code here
diff --git a/exercises/32-numbers-of-letters-and-digits/solution.hide.py b/exercises/32-numbers-of-letters-and-digits/solution.hide.py
diff --git a/exercises/32-numbers-of-letters-and-digits/test.py b/exercises/32-numbers-of-letters-and-digits/test.py
diff --git a/exercises/33-number-of-uppercase/README.es.md b/exercises/33-number-of-uppercase/README.es.md
diff --git a/exercises/33-number-of-uppercase/README.md b/exercises/33-number-of-uppercase/README.md
diff --git a/exercises/33-number-of-uppercase/app.py b/exercises/33-number-of-uppercase/app.py
diff --git a/exercises/33-number-of-uppercase/solution.hide.py b/exercises/33-number-of-uppercase/solution.hide.py
diff --git a/exercises/34-a_aa_aaa_aaaa/README.es.md b/exercises/34-a_aa_aaa_aaaa/README.es.md
diff --git a/exercises/34-a_aa_aaa_aaaa/README.md b/exercises/34-a_aa_aaa_aaaa/README.md
diff --git a/exercises/34-a_aa_aaa_aaaa/app.py b/exercises/34-a_aa_aaa_aaaa/app.py
diff --git a/exercises/34-a_aa_aaa_aaaa/solution.hide.py b/exercises/34-a_aa_aaa_aaaa/solution.hide.py
diff --git a/exercises/34-a_aa_aaa_aaaa/test.py b/exercises/34-a_aa_aaa_aaaa/test.py
