From 12a4119c5b75afc4db04338fed59ebc3dcc63e00 Mon Sep 17 00:00:00 2001
From: manumafe98 <manumaxerapro@gmail.com>
Date: Mon, 29 Jan 2024 12:21:27 -0300
Subject: [PATCH 1/7] Updating Squeaky Clean

Reformating exercise to not use unicode, control characters and greek letters
Updating docs and tests, and meta reference
---
 .../concept/squeaky-clean/.docs/hints.md      | 19 ++----
 .../squeaky-clean/.docs/instructions.md       | 34 +++-------
 .../squeaky-clean/.docs/introduction.md       |  2 -
 .../src/reference/java/SqueakyClean.java      |  9 +--
 .../src/test/java/SqueakyCleanTest.java       | 62 +++++++++----------
 5 files changed, 47 insertions(+), 79 deletions(-)

diff --git a/exercises/concept/squeaky-clean/.docs/hints.md b/exercises/concept/squeaky-clean/.docs/hints.md
index 953139a70..b3069fd1a 100644
--- a/exercises/concept/squeaky-clean/.docs/hints.md
+++ b/exercises/concept/squeaky-clean/.docs/hints.md
@@ -7,29 +7,22 @@
 - You can retrieve `char`s from a string using the [charAt][char-at] method.
 - You should use a [`StringBuilder`][string-builder] to build the output string.
 - See [this method][iswhitespace] for detecting spaces. Remember it is a static method.
+- See [this method][isdigit] for detecting numbers.
 - `char` literals are enclosed in single quotes.
 
-## 2. Replace control characters with the upper case string "CTRL"
-
-- See [this method][iscontrol] to check if a character is a control character.
-
-## 3. Convert kebab-case to camel-case
+## 2. Convert kebab-case to camel-case
 
 - See [this method][toupper] to convert a character to upper case.
 
-## 4. Omit characters that are not letters
-
-- See [this method][isLetter] to check if a character is a letter.
-
-## 5. Omit Greek lower case letters
+## 3. Omit characters that are not letters
 
-- `char`s support the default equality and comparison operators.
+- See [this method][isletter] to check if a character is a letter.
 
 [chars-docs]: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/Character.html
 [chars-tutorial]: https://docs.oracle.com/javase/tutorial/java/data/characters.html
 [char-at]: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/String.html#charAt(int)
 [string-builder]: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/StringBuilder.html
 [iswhitespace]: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/Character.html#isWhitespace(char)
-[iscontrol]: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/Character.html#isISOControl(char)
 [toupper]: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/Character.html#toUpperCase(char)
-[isLetter]: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/Character.html#isLetter(char)
+[isletter]: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/Character.html#isLetter(char)
+[isdigit]: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/Character.html#isDigit(char)
diff --git a/exercises/concept/squeaky-clean/.docs/instructions.md b/exercises/concept/squeaky-clean/.docs/instructions.md
index 12bbd4902..54a3d6755 100644
--- a/exercises/concept/squeaky-clean/.docs/instructions.md
+++ b/exercises/concept/squeaky-clean/.docs/instructions.md
@@ -10,45 +10,27 @@ In all cases the input string is guaranteed to be non-null. Note that the `clean
 
 ## 1. Replace any spaces encountered with underscores
 
-Implement the (_static_) `SqueakyClean.clean()` method to replace any spaces with underscores. This also applies to leading and trailing spaces.
+Implement the (_static_) `SqueakyClean.clean()` method to replace any spaces or numbers with underscores. This also applies to leading and trailing spaces.
 
 ```java
-SqueakyClean.clean("my   Id");
-// => "my___Id"
+SqueakyClean.clean("my   Id 1");
+// => "my___Id__"
 ```
 
-## 2. Replace control characters with the upper case string "CTRL"
-
-Modify the (_static_) `SqueakyClean.clean()` method to replace control characters with the upper case string `"CTRL"`.
-
-```java
-SqueakyClean.clean("my\0Id");
-// => "myCTRLId",
-```
-
-## 3. Convert kebab-case to camelCase
+## 2. Convert kebab-case to camelCase
 
 Modify the (_static_) `SqueakyClean.clean()` method to convert kebab-case to camelCase.
 
 ```java
-SqueakyClean.clean("à-ḃç");
-// => "àḂç"
+SqueakyClean.clean("a-bc");
+// => "aBc"
 ```
 
-## 4. Omit characters that are not letters
+## 3. Omit characters that are not letters
 
 Modify the (_static_) `SqueakyClean.clean()` method to omit any characters that are not letters.
 
 ```java
-SqueakyClean.clean("a1😀2😀3😀b");
+SqueakyClean.clean("a$#.b");
 // => "ab"
 ```
-
-## 5. Omit Greek lower case letters
-
-Modify the (_static_) `SqueakyClean.clean()` method to omit any Greek letters in the range 'α' to 'ω'.
-
-```java
-SqueakyClean.clean("MyΟβιεγτFinder");
-// => "MyΟFinder"
-```
diff --git a/exercises/concept/squeaky-clean/.docs/introduction.md b/exercises/concept/squeaky-clean/.docs/introduction.md
index 26dbb9fba..15e81f074 100644
--- a/exercises/concept/squeaky-clean/.docs/introduction.md
+++ b/exercises/concept/squeaky-clean/.docs/introduction.md
@@ -6,8 +6,6 @@ The Java `char` type represents the smallest addressable components of text.
 Multiple `char`s can comprise a string such as `"word"` or `char`s can be processed independently.
 Their literals have single quotes e.g. `'A'`.
 
-Java `char`s support Unicode encoding so in addition to the Latin character set pretty much all the writing systems in use worldwide can be represented, e.g. the Greek letter `'β'`.
-
 There are many builtin library methods to inspect and manipulate `char`s.
 These can be found as static methods of the `java.lang.Character` class.
 
diff --git a/exercises/concept/squeaky-clean/.meta/src/reference/java/SqueakyClean.java b/exercises/concept/squeaky-clean/.meta/src/reference/java/SqueakyClean.java
index d400586f7..87b20c5d0 100644
--- a/exercises/concept/squeaky-clean/.meta/src/reference/java/SqueakyClean.java
+++ b/exercises/concept/squeaky-clean/.meta/src/reference/java/SqueakyClean.java
@@ -4,13 +4,11 @@ static String clean(String identifier) {
         boolean kebab = false;
         for (int i = 0; i < identifier.length(); i++) {
             final char ch = identifier.charAt(i);
-            if (Character.isSpaceChar(ch)) {
+            if (Character.isSpaceChar(ch) || Character.isDigit(ch)) {
                 cleanIdentifier.append("_");
-            } else if (Character.isISOControl(ch)) {
-                cleanIdentifier.append("CTRL");
             } else if (ch == '-') {
                 kebab = true;
-            } else if (isLetter(ch)) {
+            } else if (Character.isLetter(ch)) {
                 cleanIdentifier.append(
                         kebab ? Character.toUpperCase(ch) : ch
                 );
@@ -19,7 +17,4 @@ static String clean(String identifier) {
         }
         return cleanIdentifier.toString();
     }
-    private static boolean isLetter(char ch) {
-        return Character.isLetter(ch) && !(ch >= 'α' && ch <= 'ω');
-    }
 }
diff --git a/exercises/concept/squeaky-clean/src/test/java/SqueakyCleanTest.java b/exercises/concept/squeaky-clean/src/test/java/SqueakyCleanTest.java
index 4768c482a..604dcc58d 100644
--- a/exercises/concept/squeaky-clean/src/test/java/SqueakyCleanTest.java
+++ b/exercises/concept/squeaky-clean/src/test/java/SqueakyCleanTest.java
@@ -24,14 +24,21 @@ public void single_letter() {
     @Tag("task:1")
     @DisplayName("The clean method returns the same string when invoked on a string of three letters")
     public void string() {
-        assertThat(SqueakyClean.clean("àḃç")).isEqualTo("àḃç");
+        assertThat(SqueakyClean.clean("abc")).isEqualTo("abc");
+    }
+    
+    @Test
+    @Tag("task:1")
+    @DisplayName("The clean method replaces numbers with underscores")
+    public void numbers() {
+        assertThat(SqueakyClean.clean("4bcd3")).isEqualTo("_bcd_");
     }
 
     @Test
     @Tag("task:1")
     @DisplayName("The clean method replaces whitespaces with underscores in the middle of the string")
     public void spaces() {
-        assertThat(SqueakyClean.clean("my   Id")).isEqualTo("my___Id");
+        assertThat(SqueakyClean.clean("my   Id 1")).isEqualTo("my___Id__");
     }
 
     @Test
@@ -40,53 +47,46 @@ public void spaces() {
     public void leading_and_trailing_spaces() {
         assertThat(SqueakyClean.clean(" myId ")).isEqualTo("_myId_");
     }
-
+    
     @Test
-    @Tag("task:2")
-    @DisplayName("The clean method replaces control characters with CTRL")
-    public void ctrl() {
-        assertThat(SqueakyClean.clean("my\0\r\u007FId")).isEqualTo("myCTRLCTRLCTRLId");
-    }
-
-    @Test
-    @Tag("task:4")
-    @DisplayName("The clean method returns an empty string when invoked on a string with no letters")
-    public void string_with_no_letters() {
-        assertThat(SqueakyClean.clean("\uD83D\uDE00\uD83D\uDE00\uD83D\uDE00")).isEmpty();
+    @Tag("task:1")
+    @DisplayName("The clean method replaces numbers and spaces with underscores")
+    public void numbers_and_spaces() {
+        assertThat(SqueakyClean.clean("my id 123")).isEqualTo("my_id____");
     }
 
     @Test
-    @Tag("task:3")
+    @Tag("task:2")
     @DisplayName("The clean method converts kebab to camel case after removing a dash")
     public void kebab_to_camel_case() {
         assertThat(SqueakyClean.clean("à-ḃç")).isEqualTo("àḂç");
     }
 
     @Test
-    @Tag("task:3")
-    @DisplayName("The clean method returns a string in camel case after removing a dash and a number")
-    public void kebab_to_camel_case_no_letter() {
-        assertThat(SqueakyClean.clean("a-1C")).isEqualTo("aC");
+    @Tag("task:2")
+    @DisplayName("The clean method returns a string in camel case after removing a dash and replacing the number")
+    public void kebab_to_camel_case_and_number() {
+        assertThat(SqueakyClean.clean("a-C1")).isEqualTo("aC_");
     }
 
     @Test
-    @Tag("task:4")
-    @DisplayName("The clean method removes all characters that are not letters")
-    public void keep_only_letters() {
-        assertThat(SqueakyClean.clean("a1\uD83D\uDE002\uD83D\uDE003\uD83D\uDE00b")).isEqualTo("ab");
+    @Tag("task:2")
+    @DisplayName("The clean method returns a string in camel case after removing a dash and replaces whitespaces")
+    public void kebab_to_camel_case_and_spaces() {
+        assertThat(SqueakyClean.clean(" hello-world ")).isEqualTo("_helloWorld_");
     }
 
     @Test
-    @Tag("task:5")
-    @DisplayName("The clean method removes all lowercase greek letters")
-    public void omit_lower_case_greek_letters() {
-        assertThat(SqueakyClean.clean("MyΟβιεγτFinder")).isEqualTo("MyΟFinder");
+    @Tag("task:3")
+    @DisplayName("The clean method removes all characters that are not letters")
+    public void special_characters() {
+        assertThat(SqueakyClean.clean("a$#.b")).isEqualTo("ab");
     }
 
     @Test
-    @Tag("task:5")
-    @DisplayName("The clean method returns the correct result after performing a few cleaning operations")
-    public void combine_conversions() {
-        assertThat(SqueakyClean.clean("9 -abcĐ\uD83D\uDE00ω\0")).isEqualTo("_AbcĐCTRL");
+    @Tag("task:3")
+    @DisplayName("The clean method removes all characters that are not letters and replaces spaces and numbers")
+    public void special_characters_with_numbers_and_spaces() {
+        assertThat(SqueakyClean.clean("h3llo world!. ")).isEqualTo("h_llo_world_");
     }
 }

From b3e4b4110749b53e1e4ab35857bcd1be0bec0f96 Mon Sep 17 00:00:00 2001
From: manumafe98 <manumaxerapro@gmail.com>
Date: Tue, 30 Jan 2024 16:52:41 -0300
Subject: [PATCH 2/7] Adding extra exercise to convert leetspeak into normal
 text

---
 .../concept/squeaky-clean/.docs/hints.md      |  7 +++-
 .../squeaky-clean/.docs/instructions.md       | 19 +++++++--
 .../src/reference/java/SqueakyClean.java      | 15 ++++++-
 .../src/test/java/SqueakyCleanTest.java       | 42 +++++++++----------
 4 files changed, 55 insertions(+), 28 deletions(-)

diff --git a/exercises/concept/squeaky-clean/.docs/hints.md b/exercises/concept/squeaky-clean/.docs/hints.md
index b3069fd1a..7981ff47e 100644
--- a/exercises/concept/squeaky-clean/.docs/hints.md
+++ b/exercises/concept/squeaky-clean/.docs/hints.md
@@ -7,14 +7,17 @@
 - You can retrieve `char`s from a string using the [charAt][char-at] method.
 - You should use a [`StringBuilder`][string-builder] to build the output string.
 - See [this method][iswhitespace] for detecting spaces. Remember it is a static method.
-- See [this method][isdigit] for detecting numbers.
 - `char` literals are enclosed in single quotes.
 
 ## 2. Convert kebab-case to camel-case
 
 - See [this method][toupper] to convert a character to upper case.
 
-## 3. Omit characters that are not letters
+## 3. Convert leetspeak to normal text
+
+- See [this method][isdigit] for detecting numbers.
+
+## 4. Omit characters that are not letters
 
 - See [this method][isletter] to check if a character is a letter.
 
diff --git a/exercises/concept/squeaky-clean/.docs/instructions.md b/exercises/concept/squeaky-clean/.docs/instructions.md
index 54a3d6755..a03248414 100644
--- a/exercises/concept/squeaky-clean/.docs/instructions.md
+++ b/exercises/concept/squeaky-clean/.docs/instructions.md
@@ -10,11 +10,11 @@ In all cases the input string is guaranteed to be non-null. Note that the `clean
 
 ## 1. Replace any spaces encountered with underscores
 
-Implement the (_static_) `SqueakyClean.clean()` method to replace any spaces or numbers with underscores. This also applies to leading and trailing spaces.
+Implement the (_static_) `SqueakyClean.clean()` method to replace any spaces with underscores. This also applies to leading and trailing spaces.
 
 ```java
-SqueakyClean.clean("my   Id 1");
-// => "my___Id__"
+SqueakyClean.clean("my   Id");
+// => "my___Id"
 ```
 
 ## 2. Convert kebab-case to camelCase
@@ -26,7 +26,16 @@ SqueakyClean.clean("a-bc");
 // => "aBc"
 ```
 
-## 3. Omit characters that are not letters
+## 3. Convert leetspeak to normal text
+
+Modify the (_static_) `SqueakyClean.clean()` method to convert [leetspeak][leet-speak] to normal text.
+
+```java
+SqueakyClean.clean("H3ll0 W0rld");
+// => "Hello_World"
+```
+
+## 4. Omit characters that are not letters
 
 Modify the (_static_) `SqueakyClean.clean()` method to omit any characters that are not letters.
 
@@ -34,3 +43,5 @@ Modify the (_static_) `SqueakyClean.clean()` method to omit any characters that
 SqueakyClean.clean("a$#.b");
 // => "ab"
 ```
+
+[leet-speak]: https://en.wikipedia.org/wiki/Leet
diff --git a/exercises/concept/squeaky-clean/.meta/src/reference/java/SqueakyClean.java b/exercises/concept/squeaky-clean/.meta/src/reference/java/SqueakyClean.java
index 87b20c5d0..a2d12d080 100644
--- a/exercises/concept/squeaky-clean/.meta/src/reference/java/SqueakyClean.java
+++ b/exercises/concept/squeaky-clean/.meta/src/reference/java/SqueakyClean.java
@@ -1,11 +1,24 @@
+import java.util.Map;
+import java.util.HashMap;
+
 class SqueakyClean {
+    private static Map<Character, Character> leetSpeakMap = new HashMap<>() {{
+            put('3', 'e');
+            put('4', 'a');
+            put('0', 'o');
+            put('1', 'l');
+            put('7', 't');
+        }};
+
     static String clean(String identifier) {
         final StringBuilder cleanIdentifier = new StringBuilder();
         boolean kebab = false;
         for (int i = 0; i < identifier.length(); i++) {
             final char ch = identifier.charAt(i);
-            if (Character.isSpaceChar(ch) || Character.isDigit(ch)) {
+            if (Character.isSpaceChar(ch)) {
                 cleanIdentifier.append("_");
+            } else if (Character.isDigit(ch)) {
+                cleanIdentifier.append(leetSpeakMap.get(ch));
             } else if (ch == '-') {
                 kebab = true;
             } else if (Character.isLetter(ch)) {
diff --git a/exercises/concept/squeaky-clean/src/test/java/SqueakyCleanTest.java b/exercises/concept/squeaky-clean/src/test/java/SqueakyCleanTest.java
index 604dcc58d..80527d519 100644
--- a/exercises/concept/squeaky-clean/src/test/java/SqueakyCleanTest.java
+++ b/exercises/concept/squeaky-clean/src/test/java/SqueakyCleanTest.java
@@ -26,19 +26,12 @@ public void single_letter() {
     public void string() {
         assertThat(SqueakyClean.clean("abc")).isEqualTo("abc");
     }
-    
-    @Test
-    @Tag("task:1")
-    @DisplayName("The clean method replaces numbers with underscores")
-    public void numbers() {
-        assertThat(SqueakyClean.clean("4bcd3")).isEqualTo("_bcd_");
-    }
 
     @Test
     @Tag("task:1")
     @DisplayName("The clean method replaces whitespaces with underscores in the middle of the string")
     public void spaces() {
-        assertThat(SqueakyClean.clean("my   Id 1")).isEqualTo("my___Id__");
+        assertThat(SqueakyClean.clean("my   Id")).isEqualTo("my___Id");
     }
 
     @Test
@@ -47,13 +40,6 @@ public void spaces() {
     public void leading_and_trailing_spaces() {
         assertThat(SqueakyClean.clean(" myId ")).isEqualTo("_myId_");
     }
-    
-    @Test
-    @Tag("task:1")
-    @DisplayName("The clean method replaces numbers and spaces with underscores")
-    public void numbers_and_spaces() {
-        assertThat(SqueakyClean.clean("my id 123")).isEqualTo("my_id____");
-    }
 
     @Test
     @Tag("task:2")
@@ -64,9 +50,9 @@ public void kebab_to_camel_case() {
 
     @Test
     @Tag("task:2")
-    @DisplayName("The clean method returns a string in camel case after removing a dash and replacing the number")
+    @DisplayName("The clean method returns a string in camel case after removing a dash and replacing the whitespace")
     public void kebab_to_camel_case_and_number() {
-        assertThat(SqueakyClean.clean("a-C1")).isEqualTo("aC_");
+        assertThat(SqueakyClean.clean("a-C ")).isEqualTo("aC_");
     }
 
     @Test
@@ -78,15 +64,29 @@ public void kebab_to_camel_case_and_spaces() {
 
     @Test
     @Tag("task:3")
+    @DisplayName("The clean method converts leetspeak to normal text after reeplacing numbers with chars")
+    public void leetspeak_to_normal_text() {
+        assertThat(SqueakyClean.clean("H3ll0 W0rld")).isEqualTo("Hello_World");
+    }
+
+    @Test
+    @Tag("task:3")
+    @DisplayName("The clean method converts leetspeak to normal text with spaces and special characters")
+    public void leetspeak_to_normal_text_with_spaces_and_special_characters() {
+        assertThat(SqueakyClean.clean("¡1337sp34k is fun!")).isEqualTo("leetspeak_is_fun");
+    }
+
+    @Test
+    @Tag("task:4")
     @DisplayName("The clean method removes all characters that are not letters")
     public void special_characters() {
         assertThat(SqueakyClean.clean("a$#.b")).isEqualTo("ab");
     }
 
     @Test
-    @Tag("task:3")
-    @DisplayName("The clean method removes all characters that are not letters and replaces spaces and numbers")
-    public void special_characters_with_numbers_and_spaces() {
-        assertThat(SqueakyClean.clean("h3llo world!. ")).isEqualTo("h_llo_world_");
+    @Tag("task:4")
+    @DisplayName("The clean method removes all characters that are not letters and replaces spaces")
+    public void special_characters_and_spaces() {
+        assertThat(SqueakyClean.clean("¡hello world!. ")).isEqualTo("hello_world_");
     }
 }

From c2c145cbf3241169112bf54a9ce2110c7be31af9 Mon Sep 17 00:00:00 2001
From: manumafe98 <manumaxerapro@gmail.com>
Date: Tue, 30 Jan 2024 17:50:04 -0300
Subject: [PATCH 3/7] Applying suggestions

---
 concepts/chars/introduction.md                |  2 --
 .../squeaky-clean/.docs/instructions.md       |  1 +
 .../src/reference/java/SqueakyClean.java      | 31 ++++++++++++-------
 .../src/test/java/SqueakyCleanTest.java       |  6 ++--
 4 files changed, 24 insertions(+), 16 deletions(-)

diff --git a/concepts/chars/introduction.md b/concepts/chars/introduction.md
index c78f90c0a..12fdaf086 100644
--- a/concepts/chars/introduction.md
+++ b/concepts/chars/introduction.md
@@ -4,8 +4,6 @@ The Java `char` type represents the smallest addressable components of text.
 Multiple `char`s can comprise a string such as `"word"` or `char`s can be processed independently.
 Their literals have single quotes e.g. `'A'`.
 
-Java `char`s support Unicode encoding so in addition to the Latin character set pretty much all the writing systems in use worldwide can be represented, e.g. the Greek letter `'β'`.
-
 There are many builtin library methods to inspect and manipulate `char`s.
 These can be found as static methods of the `java.lang.Character` class.
 
diff --git a/exercises/concept/squeaky-clean/.docs/instructions.md b/exercises/concept/squeaky-clean/.docs/instructions.md
index a03248414..20ff2fb7e 100644
--- a/exercises/concept/squeaky-clean/.docs/instructions.md
+++ b/exercises/concept/squeaky-clean/.docs/instructions.md
@@ -29,6 +29,7 @@ SqueakyClean.clean("a-bc");
 ## 3. Convert leetspeak to normal text
 
 Modify the (_static_) `SqueakyClean.clean()` method to convert [leetspeak][leet-speak] to normal text.
+For simplicity will only be using `4`, `3`, `0`, `1` and `7` from the table.
 
 ```java
 SqueakyClean.clean("H3ll0 W0rld");
diff --git a/exercises/concept/squeaky-clean/.meta/src/reference/java/SqueakyClean.java b/exercises/concept/squeaky-clean/.meta/src/reference/java/SqueakyClean.java
index a2d12d080..e88e02316 100644
--- a/exercises/concept/squeaky-clean/.meta/src/reference/java/SqueakyClean.java
+++ b/exercises/concept/squeaky-clean/.meta/src/reference/java/SqueakyClean.java
@@ -1,14 +1,23 @@
-import java.util.Map;
-import java.util.HashMap;
-
 class SqueakyClean {
-    private static Map<Character, Character> leetSpeakMap = new HashMap<>() {{
-            put('3', 'e');
-            put('4', 'a');
-            put('0', 'o');
-            put('1', 'l');
-            put('7', 't');
-        }};
+
+    private static char replaceDigit(char digit) {
+        if (digit == '3') {
+            return 'e';
+        }
+
+        if (digit == '4') {
+            return 'a';
+        }
+
+        if (digit == '0') {
+            return 'o';
+        }
+
+        if (digit == '1') {
+            return 'l';
+        }
+        return 't';
+    }
 
     static String clean(String identifier) {
         final StringBuilder cleanIdentifier = new StringBuilder();
@@ -18,7 +27,7 @@ static String clean(String identifier) {
             if (Character.isSpaceChar(ch)) {
                 cleanIdentifier.append("_");
             } else if (Character.isDigit(ch)) {
-                cleanIdentifier.append(leetSpeakMap.get(ch));
+                cleanIdentifier.append(SqueakyClean.replaceDigit(ch));
             } else if (ch == '-') {
                 kebab = true;
             } else if (Character.isLetter(ch)) {
diff --git a/exercises/concept/squeaky-clean/src/test/java/SqueakyCleanTest.java b/exercises/concept/squeaky-clean/src/test/java/SqueakyCleanTest.java
index 80527d519..91b29e634 100644
--- a/exercises/concept/squeaky-clean/src/test/java/SqueakyCleanTest.java
+++ b/exercises/concept/squeaky-clean/src/test/java/SqueakyCleanTest.java
@@ -45,19 +45,19 @@ public void leading_and_trailing_spaces() {
     @Tag("task:2")
     @DisplayName("The clean method converts kebab to camel case after removing a dash")
     public void kebab_to_camel_case() {
-        assertThat(SqueakyClean.clean("à-ḃç")).isEqualTo("àḂç");
+        assertThat(SqueakyClean.clean("a-bc")).isEqualTo("aBc");
     }
 
     @Test
     @Tag("task:2")
-    @DisplayName("The clean method returns a string in camel case after removing a dash and replacing the whitespace")
+    @DisplayName("The clean method returns a string in camel case after removing a dash and replaces a whitespace")
     public void kebab_to_camel_case_and_number() {
         assertThat(SqueakyClean.clean("a-C ")).isEqualTo("aC_");
     }
 
     @Test
     @Tag("task:2")
-    @DisplayName("The clean method returns a string in camel case after removing a dash and replaces whitespaces")
+    @DisplayName("The clean method returns a string in camel case and replaces leading and trailing whitespaces")
     public void kebab_to_camel_case_and_spaces() {
         assertThat(SqueakyClean.clean(" hello-world ")).isEqualTo("_helloWorld_");
     }

From 04fe4de54d149b37c66b4e1ddb1309336b6e0ab0 Mon Sep 17 00:00:00 2001
From: Manuel Maxera <95315128+manumafe98@users.noreply.github.com>
Date: Tue, 30 Jan 2024 17:58:48 -0300
Subject: [PATCH 4/7] Update
 exercises/concept/squeaky-clean/src/test/java/SqueakyCleanTest.java

Co-authored-by: Sander Ploegsma <sanderploegsma@gmail.com>
---
 .../concept/squeaky-clean/src/test/java/SqueakyCleanTest.java   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/exercises/concept/squeaky-clean/src/test/java/SqueakyCleanTest.java b/exercises/concept/squeaky-clean/src/test/java/SqueakyCleanTest.java
index 91b29e634..19688de55 100644
--- a/exercises/concept/squeaky-clean/src/test/java/SqueakyCleanTest.java
+++ b/exercises/concept/squeaky-clean/src/test/java/SqueakyCleanTest.java
@@ -64,7 +64,7 @@ public void kebab_to_camel_case_and_spaces() {
 
     @Test
     @Tag("task:3")
-    @DisplayName("The clean method converts leetspeak to normal text after reeplacing numbers with chars")
+    @DisplayName("The clean method converts leetspeak to normal text after replacing numbers with chars")
     public void leetspeak_to_normal_text() {
         assertThat(SqueakyClean.clean("H3ll0 W0rld")).isEqualTo("Hello_World");
     }

From 4e38ffe1e012076db79f60b462f745b53c05040d Mon Sep 17 00:00:00 2001
From: Manuel Maxera <95315128+manumafe98@users.noreply.github.com>
Date: Tue, 30 Jan 2024 17:59:00 -0300
Subject: [PATCH 5/7] Update
 exercises/concept/squeaky-clean/.docs/instructions.md

Co-authored-by: Sander Ploegsma <sanderploegsma@gmail.com>
---
 exercises/concept/squeaky-clean/.docs/instructions.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/exercises/concept/squeaky-clean/.docs/instructions.md b/exercises/concept/squeaky-clean/.docs/instructions.md
index 20ff2fb7e..5b092e56a 100644
--- a/exercises/concept/squeaky-clean/.docs/instructions.md
+++ b/exercises/concept/squeaky-clean/.docs/instructions.md
@@ -29,7 +29,7 @@ SqueakyClean.clean("a-bc");
 ## 3. Convert leetspeak to normal text
 
 Modify the (_static_) `SqueakyClean.clean()` method to convert [leetspeak][leet-speak] to normal text.
-For simplicity will only be using `4`, `3`, `0`, `1` and `7` from the table.
+For simplicity we will only be using `4`, `3`, `0`, `1` and `7` from the table.
 
 ```java
 SqueakyClean.clean("H3ll0 W0rld");

From 5b4eaeb6b8b001197ae289d64075f40d503b7a3f Mon Sep 17 00:00:00 2001
From: Sander Ploegsma <sanderploegsma@gmail.com>
Date: Tue, 30 Jan 2024 22:00:24 +0100
Subject: [PATCH 6/7] Add myself as contributor

---
 exercises/concept/squeaky-clean/.meta/config.json | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/exercises/concept/squeaky-clean/.meta/config.json b/exercises/concept/squeaky-clean/.meta/config.json
index 5440c20fb..76f75e0fa 100644
--- a/exercises/concept/squeaky-clean/.meta/config.json
+++ b/exercises/concept/squeaky-clean/.meta/config.json
@@ -2,6 +2,9 @@
   "authors": [
     "ystromm"
   ],
+  "contributors": [
+    "sanderploegsma"
+  ],
   "files": {
     "solution": [
       "src/main/java/SqueakyClean.java"

From 0316556dd6c4cef6b6cc25787935f2daa70d4282 Mon Sep 17 00:00:00 2001
From: manumafe98 <manumaxerapro@gmail.com>
Date: Tue, 30 Jan 2024 18:03:17 -0300
Subject: [PATCH 7/7] Add myself as contributor

---
 exercises/concept/squeaky-clean/.meta/config.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/exercises/concept/squeaky-clean/.meta/config.json b/exercises/concept/squeaky-clean/.meta/config.json
index 76f75e0fa..0750fd7af 100644
--- a/exercises/concept/squeaky-clean/.meta/config.json
+++ b/exercises/concept/squeaky-clean/.meta/config.json
@@ -3,7 +3,8 @@
     "ystromm"
   ],
   "contributors": [
-    "sanderploegsma"
+    "sanderploegsma",
+    "manumafe98"
   ],
   "files": {
     "solution": [