fix existing approaches

Author: Yrahcaz7

exercises/practice/sublist/.approaches/config.json

@@ -1,21 +1,24 @@
 {
   "introduction": {
-    "authors": ["safwansamsudeen"]
+    "authors": ["safwansamsudeen"],
+    "contributors": ["yrahcaz7"]
   },
   "approaches": [
     {
       "uuid": "db47397a-4551-49e8-8775-7e7aad79a38b",
       "slug": "list-manipulation",
       "title": "List manipulation",
       "blurb": "Manipulate and check lists to solve the exercise",
-      "authors": ["safwansamsudeen"]
+      "authors": ["safwansamsudeen"],
+      "contributors": ["yrahcaz7"]
     },
     {
       "uuid": "61366160-c859-4d16-9085-171428209b8d",
       "slug": "using-strings",
       "title": "Using strings",
       "blurb": "Convert the lists to string and use string manipulation to solve the exercise",
-      "authors": ["safwansamsudeen"]
+      "authors": ["safwansamsudeen"],
+      "contributors": ["yrahcaz7"]
     }
   ]
 }

exercises/practice/sublist/.approaches/introduction.md

@@ -1,10 +1,13 @@
 # Introduction
-There are two broad ways to solve Sublist. 
+
+There are two broad ways to solve Sublist.
 
 ## General guidance
-To write the code, you need to branch out (probably with `if`) into the four different possible conditions, and return the appropriate name of the category. 
+
+To write the code, you need to branch out (probably with `if`) into the four different possible conditions, and return the appropriate name of the category.
 
 ## Approach: list manipulation
+
 The direct approach would be to manipulate and check the given lists to solve this.
 This solution uses a helper function, which simplifies things, but the approach can be implemented without it.
 
@@ -18,7 +21,7 @@ def check_sub_sequences(list_one, list_two):
     n1 = len(list_one)
     n2 = len(list_two)
     return any(list_two[i:i+n1] == list_one for i in range(n2 - n1 + 1))
-    
+
 def sublist(list_one, list_two):
     if list_one == list_two:
         return EQUAL
@@ -32,27 +35,29 @@ def sublist(list_one, list_two):
 Read more on the [detail of this approach][approach-list-manipulation].
 
 ## Approach: using strings
-Another seemingly clever approach is to convert the lists to strings and then 
-use the `in` operator to check for sub-sequences.
+
+Another seemingly clever approach is to convert the lists to strings and then use the `in` operator to check for sub-sequences.
 **However, this does not work.**
+
 ```python
 SUBLIST = 1
 SUPERLIST = 2
 EQUAL = 3
 UNEQUAL = 4
 
 def sublist(list_one, list_two):
-    list_one_check = (str(list_one).strip("[]") + ",")
-    list_two_check = (str(list_two).strip("[]") + ",")
-
+    list_one_check = str(list_one).strip("[]") + ","
+    list_two_check = str(list_two).strip("[]") + ","
+    
     if list_one_check == list_two_check:
         return EQUAL
-    elif list_one_check in list_two_check:
+    if list_one_check in list_two_check:
         return SUBLIST
-    elif list_two_check in list_one_check:
+    if list_two_check in list_one_check:
         return SUPERLIST
     return UNEQUAL
 ```
+
 To understand more about this approach and **why it fails**, [read here][approach-using-strings].
 
 [approach-list-manipulation]: https://exercism.org/tracks/python/exercises/sublist/approaches/list-manipulation

exercises/practice/sublist/.approaches/list-manipulation/content.md

@@ -1,4 +1,5 @@
 # List manipulation
+
 The direct approach would be to manipulate and check the given lists to solve this.
 This solution uses a helper function, which simplifies things, but the approach can be implemented without it.
 
@@ -12,7 +13,7 @@ def check_sub_sequences(list_one, list_two):
     n1 = len(list_one)
     n2 = len(list_two)
     return any(list_two[i:i+n1] == list_one for i in range(n2 - n1 + 1))
-    
+
 def sublist(list_one, list_two):
     if list_one == list_two:
         return EQUAL
@@ -23,16 +24,16 @@ def sublist(list_one, list_two):
     return UNEQUAL
 ```
 
-We first check for equality using the `==` operator, if so, then we return `EQUAL`. 
-A common way to do this differently would be to return `1` directly, but this is better practice as we  [remove magic values][magic values].
+We first check for equality using the `==` operator, if so, then we return `EQUAL`.
+A common way to do this differently would be to return `1` directly, but this is better practice as we [remove magic values][magic values].
 
 After that we call `check_sub_sequences` passing in `list_one` and `list_two`.
 In the helper function, we check if `any` of the possible sub-sequences in `list_two` of length `n1` (the length of the first list) are equal to the first list.
-If so, then we conclude that `list_one` is a `SUBLIST` of `list_two`. 
+If so, then we conclude that `list_one` is a `SUBLIST` of `list_two`.
 
 To find whether `list_one` is a `SUPERLIST` of `list_two`, we just reverse this process - pass in the lists in the opposite order.
 Thus, we check if `any` of the possible sub-sequences in `list_one` of length `n2` (the length of the second list) are equal to the second list.
 
 If none of the above conditions are true, we conclude that the two lists are unequal.
 
-[magic values]: https://stackoverflow.com/questions/47882/what-is-a-magic-number-and-why-is-it-bad
+[magic values]: https://stackoverflow.com/questions/47882/what-is-a-magic-number-and-why-is-it-bad

exercises/practice/sublist/.approaches/using-strings/content.md

@@ -1,13 +1,13 @@
 # Using strings
+
 ~~~~exercism/caution
-**This approach does not work, and this document exists to explain that.** 
+**This approach does not work, and this document exists to explain that.**
 Please do not use it in your code.
 ~~~~
 
-Another seemingly clever solution is to convert the lists to strings and then 
-use the `in` operator to check for sub-sequences.
-Note that this approach, even if it worked, is not as performant as the 
-previous one.
+Another seemingly clever solution is to convert the lists to strings and then use the `in` operator to check for sub-sequences.
+Note that this approach, even if it worked, is not as performant as the previous one.
+
 ```python
 SUBLIST = 1
 SUPERLIST = 2
@@ -20,28 +20,36 @@ def sublist(list_one, list_two):
 
     if list_one_check == list_two_check:
         return EQUAL
-    elif list_one_check in list_two_check:
+    if list_one_check in list_two_check:
         return SUBLIST
-    elif list_two_check in list_one_check:
+    if list_two_check in list_one_check:
         return SUPERLIST
     return UNEQUAL
 ```
+
 Let's parse the code to see what it does.
-In this approach, we convert the lists to strings, so `[1, 2, 3]` becomes `"[1, 2, 3]"`, remove the brackets `"1, 2, 3"`, and add a comma `"1, 2, 3,"`. 
+In this approach, we convert the lists to strings, so `[1, 2, 3]` becomes `"[1, 2, 3]"`, remove the brackets `"1, 2, 3"`, and add a comma `"1, 2, 3,"`.
 We check equality and then use the `in` operator to check for `SUBLIST` or `SUPERLIST`, and finally return `UNEQUAL`.
 
-We add a comma because, say, we call `sublist` with `[1, 2]` and `[1, 22]`. `"1, 2" in "1, 22"` evaluates to `True`, so 
-the **function would wrongly mark it as `SUBLIST`**. 
+We add a comma because, say, we call `sublist` with `[1, 2]` and `[1, 22]`. `"1, 2" in "1, 22"` evaluates to `True`, so the **function would wrongly mark it as `SUBLIST`**.
+
+This case can be handled by changing the code like this:
+
+```python
+list_one_check = str(list_one).strip("[]") + ","
+list_two_check = str(list_two).strip("[]") + ","
+```
+
+Yet, even though the code would pass all of the tests in the Exercism test suite, it would still fail in some cases.
+For example, if we call `sublist` with `[1, 2]` and `[5, "1, 2,", 7]`, the function would return `SUBLIST` when it should actually return `UNEQUAL`.
+
+This could be avoided by changing the code to use a separator that isn't the default one:
 
-This test can be overridden by changing the code like this:
 ```python
-list_one_check = str(list_one).strip("[]") + ','
-list_two_check = str(list_two).strip("[]") + ','
+list_one_check = "|".join(str(item) for item in list_one) + "|"
+list_two_check = "|".join(str(item) for item in list_two) + "|"
 ```
-Yet, the test case (which doesn't exist in the Exercism test suite) `["1", "2"]` and `["5", "'1', '2',", "7"]` would 
-fail.
 
-Students can add any arbitrary string into the representation to try to "defeat" this test - `list_one_check = str
-(list_one) + TOKEN`. The test suite currently test `TOKEN = ''`, but not others.
+However, this only avoids the (theoretical) test and does not fix the solution. For example, a test with the inputs `[1, 2]` and `[5, "1|2|", 7]` would now fail.
 
-[gen-exp]: https://www.programiz.com/python-programming/generator
+No matter what separator is chosen, there will always be at least one input for which the function will return the wrong result. **This is why no approach that converts the lists to strings can ever be correct for all possible inputs.**

exercises/practice/sublist/.approaches/using-strings/snippet.txt

@@ -2,7 +2,7 @@
 def sublist(list_one, list_two):
     list_one_check = str(list_one).strip("[]")
     ...
-    elif list_one_check in list_two_check:
+    if list_one_check in list_two_check:
         return SUBLIST
     ...
     return UNEQUAL