fix(curriculum): description improvement case converter program

curriculum/challenges/english/07-scientific-computing-with-python/learn-list-comprehension-by-building-a-case-converter-program/657f43d341a0dd17120cdb08.md

@@ -7,20 +7,20 @@ dashedName: step-17
 
 # --description--
 
-You will need to convert uppercase characters to lowercase and add an underscore before them. 
+You will need to convert uppercase characters to lowercase and add an underscore before them. Before proceeding, join all the elements of the list `snake_cased_char_list` into a single string using an empty string `''` as the separator.
 
-Within the empty list, implement an `if` statement to check whether the character is uppercase. If it is, append `'_' + char.lower()` to the list.
+The using the return statement, return an empty string `''` joined with `snake_cased_char_list` as the argument, and strip any leading or trailing underscores from the result.
 
 # --hints--
 
-You should add `'_' + char.lower() if char.isupper()` within the square braces of `snake_cased_char_list`.
+You should return an empty string `''` joined with `snake_cased_char_list`, and ensure to strip any leading or trailing underscores. Ensure the indentation is correct.
 
 ```js
 const transformedCode = code.replace(/\r/g, "");
 const convert_to_snake_case = __helpers.python.getDef("\n" + transformedCode, "convert_to_snake_case");
 const { function_body } = convert_to_snake_case;
 
-assert.match(function_body, / +snake_cased_char_list\s*=\s*\[\s*("|')_\1\s*\+\s*char\.lower\(\s*\)\s+if\s+char\.isupper\(\s*\)\s*\]/);
+assert.match(function_body, /return\s*''\.join\(snake_cased_char_list\)\.strip\('_'\)/);
 ```
 
 # --seed--
@@ -41,13 +41,10 @@ def convert_to_snake_case(pascal_or_camel_cased_string):
 
     # return clean_snake_cased_string
 
+    snake_cased_char_list = []
 --fcc-editable-region--
-    snake_cased_char_list = [
-
-    ]
---fcc-editable-region--
-
 
+--fcc-editable-region--
 
 def main():
     print(convert_to_snake_case('aLongAndComplexString'))

curriculum/challenges/english/07-scientific-computing-with-python/learn-list-comprehension-by-building-a-case-converter-program/657f456223b8c1187b461987.md

@@ -7,22 +7,22 @@ dashedName: step-18
 
 # --description--
 
-When you start a list comprehension with an `if` statement, Python filters elements based on the condition provided, which means an `else` clause is required to handle the case when the condition is not met.
+A list comprehension is a concise way to create lists in Python. It consists of an expression followed by a `for` clause or more `for` or `if` clauses allowing iteration over elements from an iterable and optional transformations or condition.
 
-In this case, an `else` clause is needed to ensure that if the condition specified in the `if` statement is not met, `char` is appended to the list as is.
+In this step, you will need to convert the empty list `snake_cased_char_list` into a list where each character from `pascal_or_camel_cased_string` is preceded by an underscore and converted to lowercase.
 
-Add an `else` clause that appends `char` to the list.
+Inside the empty list `snake_cased_char_list`, transform each `char` into lowercase and add an underscore before it. Add a `for` loop to iterate over each `char` in `pascal_or_camel_cased_string`. 
 
 # --hints--
 
-You should add `else char` after `'_' + char.lower() if char.isupper()` within the square braces of `snake_cased_char_list`.
+You should add `for char in pascal_or_camel_cased_string` after `'_' + char.lower()` within the square braces of `snake_cased_char_list`.
 
 ```js
 const transformedCode = code.replace(/\r/g, "");
 const convert_to_snake_case = __helpers.python.getDef("\n" + transformedCode, "convert_to_snake_case");
 const { function_body } = convert_to_snake_case;
 
-assert.match(function_body, / +snake_cased_char_list\s*=\s*\[\s*("|')_\1\s*\+\s*char\.lower\(\s*\)\s+if\s+char\.isupper\(\s*\)\s*else\s+char\s*\]/);
+assert.match(function_body, /'_'\s*\+\s*char\.lower\(\s*\)\s+for\s+char\s+in\s+pascal_or_camel_cased_string/);
 ```
 
 # --seed--
@@ -44,13 +44,9 @@ def convert_to_snake_case(pascal_or_camel_cased_string):
     # return clean_snake_cased_string
 
 --fcc-editable-region--
-    snake_cased_char_list = [
-        '_' + char.lower() if char.isupper()
-
-    ]
+    snake_cased_char_list = []
 --fcc-editable-region--
-
-
+     return ''.join(snake_cased_char_list).strip('_')
 
 def main():
     print(convert_to_snake_case('aLongAndComplexString'))

curriculum/challenges/english/07-scientific-computing-with-python/learn-list-comprehension-by-building-a-case-converter-program/657f465f8e718b19c5105ae5.md

@@ -7,26 +7,22 @@ dashedName: step-19
 
 # --description--
 
-The final piece of the puzzle is the input string itself. The list comprehension needs to know about the object it'll iterate upon. 
+List comprehensions are more than just transformation, they can also filter elements based on conditions using `if` statements. You can add an `if` statement within a list comprehension to filter elements based on a given condition.
 
-In this case, it will iterate upon all the characters of the string, and this can be achieved by making use of a `for` loop.
+In the previous step, you generated a list of characters from `pascal_or_camel_cased_string`, with each character converted to lowercase and preceded by an underscore. Now, you need to filter out characters that are not uppercase.
 
-After the `else` clause, add a `for` loop to iterate over the `char` variable in the `pascal_or_camel_cased_string` string.
+Inside the list comprehension after the `for` clause, add an `if` statement to check if `char` is uppercase.
 
 # --hints--
 
-You should add `for char in pascal_or_camel_cased_string` after `else char` within the square braces of `snake_cased_char_list`.
+You should add `if` statement after the `for` clause within the square braces of `snake_cased_char_list` to check if `char` is uppercase.
 
 ```js
-({
-    test: () => {
-        const transformedCode = code.replace(/\r/g, "");
-        const convert_to_snake_case = __helpers.python.getDef("\n" + transformedCode, "convert_to_snake_case");
-        const { function_body } = convert_to_snake_case;
+const transformedCode = code.replace(/\r/g, "");
+const convert_to_snake_case = __helpers.python.getDef("\n" + transformedCode, "convert_to_snake_case");
+const { function_body } = convert_to_snake_case;
 
-        assert.match(function_body, / +snake_cased_char_list\s*=\s*\[\s*'_'\s*\+\s*char\.lower\(\s*\)\s+if\s+char\.isupper\(\s*\)\s*else\s*char\s*for\s+char\s+in\s+pascal_or_camel_cased_string\s*\]/);
-    }
-})
+assert.match(function_body, /if\s*char\.isupper\(\)/);
 ```
 
 # --seed--
@@ -48,14 +44,9 @@ def convert_to_snake_case(pascal_or_camel_cased_string):
     # return clean_snake_cased_string
 
 --fcc-editable-region--
-    snake_cased_char_list = [
-        '_' + char.lower() if char.isupper()
-        else char
-
-    ]
+    snake_cased_char_list = ['_' + char.lower()  for char in pascal_or_camel_cased_string]
 --fcc-editable-region--
-
-
+    return ''.join(snake_cased_char_list).strip('_')
 
 def main():
     print(convert_to_snake_case('aLongAndComplexString'))

curriculum/challenges/english/07-scientific-computing-with-python/learn-list-comprehension-by-building-a-case-converter-program/657f47b12c51e41b3149e584.md

@@ -7,28 +7,22 @@ dashedName: step-20
 
 # --description--
 
-You will still need to join the list elements into a string, strip off any dangling underscores and return the string. Even though you can do that like you did earlier, here is a shorter alternative.
+List comprehensions not only have the ability to filter elements based on conditions but also perform different transformations depending on the condition. This can be achieved by the use of an `if/else` statement within a list comprehension.
 
-```py
-return ''.join(snake_cased_char_list).strip('_')
-```
+Previously, you filtered out lowercase characters by adding an `if` statement to check if `char` is uppercase. Now, you will extend the comprehension to handle both cases.
 
-Add this line on the same level as the `snake_cased_char_list` variable and inside the `convert_to_snake_case()` function.
+Inside the list comprehension, add an `else` clause to ensure that if `char` is not uppercase, it remains unchanged.
 
 # --hints--
 
-You should return `''.join(snake_cased_char_list).strip('_')` at the end of `convert_to_snake_case()` function.
+You should add an `else` clause after the `if char.isupper()` statement that ensures `char` is unchanged if it's not uppercase.
 
 ```js
-({
-    test: () => {
-        const transformedCode = code.replace(/\r/g, "");
-        const convert_to_snake_case = __helpers.python.getDef("\n" + transformedCode, "convert_to_snake_case");
-        const { function_body } = convert_to_snake_case;
+const transformedCode = code.replace(/\r/g, "");
+const convert_to_snake_case = __helpers.python.getDef("\n" + transformedCode, "convert_to_snake_case");
+const { function_body } = convert_to_snake_case;
 
-        assert.match(function_body, / +return\s+('|")\1\.join\(\s*snake_cased_char_list\s*\)\.strip\(\s*("|')_\2\s*\)/);
-    }
-})
+assert.match(function_body, /else\s*char/);
 ```
 
 # --seed--
@@ -50,15 +44,9 @@ def convert_to_snake_case(pascal_or_camel_cased_string):
     # return clean_snake_cased_string
 
 --fcc-editable-region--
-    snake_cased_char_list = [
-        '_' + char.lower() if char.isupper()
-        else char
-        for char in pascal_or_camel_cased_string
-    ]
-
+    snake_cased_char_list = ['_' + char.lower() if char.isupper()  for char in pascal_or_camel_cased_string]
 --fcc-editable-region--
-
-
+    return ''.join(snake_cased_char_list).strip('_')
 
 def main():
     print(convert_to_snake_case('aLongAndComplexString'))