From efb9921bd6a46883915f2c1b960617d02537a7f4 Mon Sep 17 00:00:00 2001
From: Aklilu Mihtsun <mihtsun.app@gmail.com>
Date: Tue, 13 Oct 2026 19:10:27 +0100
Subject: [PATCH 01/18] added statement that counts number repeated char in
 string

---
 practice-tdd/count.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/practice-tdd/count.js b/practice-tdd/count.js
index 5518c5712..6167d6444 100644
--- a/practice-tdd/count.js
+++ b/practice-tdd/count.js
@@ -1,3 +1,3 @@
 export function countChar(stringOfCharacters, findCharacter) {
-  return 5
+  return stringOfCharacters.split(findCharacter).length - 1;
 }

From 89df6b35794a83ab530b728ca43072ea4b0cedd2 Mon Sep 17 00:00:00 2001
From: Aklilu Mihtsun <mihtsun.app@gmail.com>
Date: Tue, 13 Oct 2026 19:11:18 +0100
Subject: [PATCH 02/18] add test case for counting zero occurrences of a
 character

---
 practice-tdd/count.test.js | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/practice-tdd/count.test.js b/practice-tdd/count.test.js
index cb3aaae59..0575330cc 100644
--- a/practice-tdd/count.test.js
+++ b/practice-tdd/count.test.js
@@ -22,3 +22,10 @@ test("should count multiple occurrences of a character", () => {
 // And a character `char` that does not exist within `str`.
 // When the function is called with these inputs,
 // Then it should return 0, indicating that no occurrences of `char` were found.
+
+test("should count multiple occurrences of a character", () => {
+  const str = "aaaaa";
+  const char = "b";
+  const count = countChar(str, char);
+  expect(count).toEqual(0);
+});

From 9d9553e0a52c92bf15df9c963b1b5898ee704485 Mon Sep 17 00:00:00 2001
From: Aklilu Mihtsun <mihtsun.app@gmail.com>
Date: Tue, 13 Oct 2026 23:24:33 +0100
Subject: [PATCH 03/18] implement repeatStr function to concatenate string n
 times

---
 practice-tdd/repeat-str.js | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/practice-tdd/repeat-str.js b/practice-tdd/repeat-str.js
index af273f3b0..343878eea 100644
--- a/practice-tdd/repeat-str.js
+++ b/practice-tdd/repeat-str.js
@@ -1,5 +1,9 @@
-export function repeatStr() {
+export function repeatStr(word, n) {
   // Your implementation of this function must *not* call String.prototype.repeat (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat).
   // The goal is to re-implement that function, not to use it.
-  return "hellohellohello";
+  let nWords = "";
+  for (let i = 0; i < n; i++) {
+    nWords = nWords + word;
+  }
+  return nWords;
 }

From 6e8bd151b0553bc103d3f82a9389c0f032874c98 Mon Sep 17 00:00:00 2001
From: Aklilu Mihtsun <mihtsun.app@gmail.com>
Date: Tue, 13 Oct 2026 23:26:58 +0100
Subject: [PATCH 04/18] add test case for repeating string one time

---
 practice-tdd/repeat-str.test.js | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/practice-tdd/repeat-str.test.js b/practice-tdd/repeat-str.test.js
index 8a7036102..0bec51e40 100644
--- a/practice-tdd/repeat-str.test.js
+++ b/practice-tdd/repeat-str.test.js
@@ -21,6 +21,13 @@ test("should repeat the string count times", () => {
 // When the repeatStr function is called with these inputs,
 // Then it should return the original `str` without repetition.
 
+test("should repeat the string one time", () => {
+  const str = "hello";
+  const count = 1;
+  const repeatedStr = repeatStr(str, count);
+  expect(repeatedStr).toEqual("hello");
+});
+
 // Case: Handle count of 0:
 // Given a target string `str` and a `count` equal to 0,
 // When the repeatStr function is called with these inputs,

From 1d038500ab0e5bc1fb79ac542aa46ed3e0542fea Mon Sep 17 00:00:00 2001
From: Aklilu Mihtsun <mihtsun.app@gmail.com>
Date: Tue, 13 Oct 2026 23:48:36 +0100
Subject: [PATCH 05/18] refactor repeatStr function to improve error handling
 and maintain structure

---
 practice-tdd/repeat-str.js | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/practice-tdd/repeat-str.js b/practice-tdd/repeat-str.js
index 343878eea..e6393e171 100644
--- a/practice-tdd/repeat-str.js
+++ b/practice-tdd/repeat-str.js
@@ -1,9 +1,12 @@
 export function repeatStr(word, n) {
   // Your implementation of this function must *not* call String.prototype.repeat (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat).
   // The goal is to re-implement that function, not to use it.
-  let nWords = "";
-  for (let i = 0; i < n; i++) {
-    nWords = nWords + word;
+  if (n >= 0) {
+    let nWords = "";
+    for (let i = 0; i < n; i++) {
+      nWords = nWords + word;
+    }
+    return nWords;
   }
-  return nWords;
+  throw new Error("Error");
 }

From 56d5d435798347b580132f58e62212104e6f4120 Mon Sep 17 00:00:00 2001
From: Aklilu Mihtsun <mihtsun.app@gmail.com>
Date: Tue, 13 Oct 2026 23:49:33 +0100
Subject: [PATCH 06/18] add tests for handling zero and negative counts in
 repeatStr function

---
 practice-tdd/repeat-str.test.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/practice-tdd/repeat-str.test.js b/practice-tdd/repeat-str.test.js
index 0bec51e40..3347b54f8 100644
--- a/practice-tdd/repeat-str.test.js
+++ b/practice-tdd/repeat-str.test.js
@@ -33,7 +33,22 @@ test("should repeat the string one time", () => {
 // When the repeatStr function is called with these inputs,
 // Then it should return an empty string.
 
+test("should return empty string if count is zero", () => {
+  const str = "hello";
+  const count = 0;
+  const repeatedStr = repeatStr(str, count);
+  expect(repeatedStr).toEqual("");
+});
+
 // Case: Handle negative count:
 // Given a target string `str` and a negative integer `count`,
 // When the repeatStr function is called with these inputs,
 // Then it should throw an error, as negative counts are not valid.
+
+test("should throw an error when count is negative integer", () => {
+  const str = "hello";
+  const count = -5;
+  expect(() => {
+    repeatStr(str, count);
+  }).toThrow("Error");
+});

From b63687d83fbbffae024292050d76f5d85f6161e8 Mon Sep 17 00:00:00 2001
From: Aklilu Mihtsun <mihtsun.app@gmail.com>
Date: Wed, 14 Oct 2026 00:34:45 +0100
Subject: [PATCH 07/18] implement function to return ordinal suffixes for
 numbers ending with 1, 2, and 3

---
 practice-tdd/get-ordinal-number.js | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/practice-tdd/get-ordinal-number.js b/practice-tdd/get-ordinal-number.js
index 5c6291f5e..1ab02cdf4 100644
--- a/practice-tdd/get-ordinal-number.js
+++ b/practice-tdd/get-ordinal-number.js
@@ -1,3 +1,13 @@
 export function getOrdinalNumber(num) {
-  return "1st";
+  const numStr = num.toString();
+  const numLength = numStr.length;
+  if (numStr[numLength - 1] == "1" && numStr[numLength - 2] != "1") {
+    return `${numStr}st`;
+  } else if (numStr[numLength - 1] == "2" && numStr[numLength - 2] != "1") {
+    return `${numStr}nd`;
+  } else if (numStr[numLength - 1] == "3" && numStr[numLength - 2] != "1") {
+    return `${numStr}rd`;
+  }
+
+  //return "1st";
 }

From 2c0fb31b75565d34d81c27d1f9672e6a0fb8d3f2 Mon Sep 17 00:00:00 2001
From: Aklilu Mihtsun <mihtsun.app@gmail.com>
Date: Wed, 14 Oct 2026 00:35:01 +0100
Subject: [PATCH 08/18] add tests for ordinal suffixes for numbers ending with
 1, 2 and 3

---
 practice-tdd/get-ordinal-number.test.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/practice-tdd/get-ordinal-number.test.js b/practice-tdd/get-ordinal-number.test.js
index e23174a18..f3c337f07 100644
--- a/practice-tdd/get-ordinal-number.test.js
+++ b/practice-tdd/get-ordinal-number.test.js
@@ -18,3 +18,15 @@ test("should append 'st' for numbers ending with 1, except those ending with 11"
   expect(getOrdinalNumber(21)).toEqual("21st");
   expect(getOrdinalNumber(131)).toEqual("131st");
 });
+
+test("should append 'nd' for numbers ending with 2, except those ending with 12", () => {
+  expect(getOrdinalNumber(2)).toEqual("2nd");
+  expect(getOrdinalNumber(22)).toEqual("22nd");
+  expect(getOrdinalNumber(132)).toEqual("132nd");
+});
+
+test("should append 'rd' for numbers ending with 3, except those ending with 13", () => {
+  expect(getOrdinalNumber(3)).toEqual("3rd");
+  expect(getOrdinalNumber(33)).toEqual("33rd");
+  expect(getOrdinalNumber(143)).toEqual("143rd");
+});

From 044c4bf94847771a5846b7d488f6e2478d88d4b3 Mon Sep 17 00:00:00 2001
From: Aklilu Mihtsun <mihtsun.app@gmail.com>
Date: Wed, 14 Oct 2026 02:06:43 +0100
Subject: [PATCH 09/18] refactor function to improve ordinal suffix handling
 for 0 [4-9] [11-13]

---
 practice-tdd/get-ordinal-number.js | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/practice-tdd/get-ordinal-number.js b/practice-tdd/get-ordinal-number.js
index 1ab02cdf4..2610dc26c 100644
--- a/practice-tdd/get-ordinal-number.js
+++ b/practice-tdd/get-ordinal-number.js
@@ -1,13 +1,23 @@
 export function getOrdinalNumber(num) {
   const numStr = num.toString();
   const numLength = numStr.length;
+  const pattern1 = /^(11|12|13)$/;
+  const pattern2 = /^0$/;
+  const pattern3 = /^(4|5|6|7|8|9)$/;
+  const last2digits = numStr.slice(-2);
+  const last1digit = numStr.slice(-1);
+
   if (numStr[numLength - 1] == "1" && numStr[numLength - 2] != "1") {
     return `${numStr}st`;
   } else if (numStr[numLength - 1] == "2" && numStr[numLength - 2] != "1") {
     return `${numStr}nd`;
   } else if (numStr[numLength - 1] == "3" && numStr[numLength - 2] != "1") {
     return `${numStr}rd`;
+  } else if (
+    pattern1.test(last2digits) ||
+    pattern2.test(last1digit) ||
+    pattern3.test(last1digit)
+  ) {
+    return `${numStr}th`;
   }
-
-  //return "1st";
 }

From 5ad739afe91fded867bb85b63d048d7205a5860e Mon Sep 17 00:00:00 2001
From: Aklilu Mihtsun <mihtsun.app@gmail.com>
Date: Wed, 14 Oct 2026 02:07:04 +0100
Subject: [PATCH 10/18] add test for ordinal suffix 'th' for numbers ending
 with 0, 4-9, and 11-13

---
 practice-tdd/get-ordinal-number.test.js | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/practice-tdd/get-ordinal-number.test.js b/practice-tdd/get-ordinal-number.test.js
index f3c337f07..2129d3efb 100644
--- a/practice-tdd/get-ordinal-number.test.js
+++ b/practice-tdd/get-ordinal-number.test.js
@@ -30,3 +30,9 @@ test("should append 'rd' for numbers ending with 3, except those ending with 13"
   expect(getOrdinalNumber(33)).toEqual("33rd");
   expect(getOrdinalNumber(143)).toEqual("143rd");
 });
+
+test("should append 'th' for numbers ending with [0][4-9] and [11-13]", () => {
+  expect(getOrdinalNumber(111)).toEqual("111th");
+  expect(getOrdinalNumber(120)).toEqual("120th");
+  expect(getOrdinalNumber(134)).toEqual("134th");
+});

From a7d33f4a8ac1a93288636761f86ad335f484c13b Mon Sep 17 00:00:00 2001
From: Aklilu Mihtsun <mihtsun.app@gmail.com>
Date: Sat, 24 Oct 2026 00:18:14 +0100
Subject: [PATCH 11/18] refactor repeatStr function to improve error handling
 and code structure

---
 practice-tdd/repeat-str.js | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/practice-tdd/repeat-str.js b/practice-tdd/repeat-str.js
index e6393e171..8e56763a9 100644
--- a/practice-tdd/repeat-str.js
+++ b/practice-tdd/repeat-str.js
@@ -1,12 +1,14 @@
 export function repeatStr(word, n) {
   // Your implementation of this function must *not* call String.prototype.repeat (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat).
   // The goal is to re-implement that function, not to use it.
-  if (n >= 0) {
-    let nWords = "";
-    for (let i = 0; i < n; i++) {
-      nWords = nWords + word;
-    }
-    return nWords;
+  if (n < 0) {
+    throw new Error("Error");
+  } else if (n === 0) {
+    return "";
   }
-  throw new Error("Error");
+  let nWords = "";
+  for (let i = 0; i < n; i++) {
+    nWords = nWords + word;
+  }
+  return nWords;
 }

From a1bae1303de172b7120906ade441de195cff0dca Mon Sep 17 00:00:00 2001
From: Aklilu Mihtsun <mihtsun.app@gmail.com>
Date: Sat, 24 Oct 2026 00:30:00 +0100
Subject: [PATCH 12/18] update test for 'th' suffix to include additional cases
 for numbers ending with 0, 4-9, and 11-13

---
 practice-tdd/get-ordinal-number.test.js | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/practice-tdd/get-ordinal-number.test.js b/practice-tdd/get-ordinal-number.test.js
index 2129d3efb..e67a97119 100644
--- a/practice-tdd/get-ordinal-number.test.js
+++ b/practice-tdd/get-ordinal-number.test.js
@@ -31,8 +31,11 @@ test("should append 'rd' for numbers ending with 3, except those ending with 13"
   expect(getOrdinalNumber(143)).toEqual("143rd");
 });
 
-test("should append 'th' for numbers ending with [0][4-9] and [11-13]", () => {
+test("should append 'th' for numbers ending with 0, range 4-9 or range 11-13", () => {
   expect(getOrdinalNumber(111)).toEqual("111th");
   expect(getOrdinalNumber(120)).toEqual("120th");
   expect(getOrdinalNumber(134)).toEqual("134th");
+  expect(getOrdinalNumber(234547)).toEqual("234547th");
+  expect(getOrdinalNumber(123900)).toEqual("123900th");
+  expect(getOrdinalNumber(90485)).toEqual("90485th");
 });

From 39191eeb112bfc660ffc75fdaeb51644713ee764 Mon Sep 17 00:00:00 2001
From: Aklilu Mihtsun <mihtsun.app@gmail.com>
Date: Sat, 24 Oct 2026 00:35:51 +0100
Subject: [PATCH 13/18] refactor getOrdinalNumber function to simplify 'th'
 suffix handling

---
 practice-tdd/get-ordinal-number.js | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/practice-tdd/get-ordinal-number.js b/practice-tdd/get-ordinal-number.js
index 2610dc26c..1c036f565 100644
--- a/practice-tdd/get-ordinal-number.js
+++ b/practice-tdd/get-ordinal-number.js
@@ -13,11 +13,6 @@ export function getOrdinalNumber(num) {
     return `${numStr}nd`;
   } else if (numStr[numLength - 1] == "3" && numStr[numLength - 2] != "1") {
     return `${numStr}rd`;
-  } else if (
-    pattern1.test(last2digits) ||
-    pattern2.test(last1digit) ||
-    pattern3.test(last1digit)
-  ) {
-    return `${numStr}th`;
   }
+  return `${numStr}th`;
 }

From 101e3fcc6051a1dfff02886c76d669388173527a Mon Sep 17 00:00:00 2001
From: Aklilu Mihtsun <mihtsun.app@gmail.com>
Date: Sat, 24 Oct 2026 00:37:21 +0100
Subject: [PATCH 14/18] remove unused regex patterns from getOrdinalNumber
 function

---
 practice-tdd/get-ordinal-number.js | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/practice-tdd/get-ordinal-number.js b/practice-tdd/get-ordinal-number.js
index 1c036f565..2c11ad376 100644
--- a/practice-tdd/get-ordinal-number.js
+++ b/practice-tdd/get-ordinal-number.js
@@ -1,9 +1,6 @@
 export function getOrdinalNumber(num) {
   const numStr = num.toString();
   const numLength = numStr.length;
-  const pattern1 = /^(11|12|13)$/;
-  const pattern2 = /^0$/;
-  const pattern3 = /^(4|5|6|7|8|9)$/;
   const last2digits = numStr.slice(-2);
   const last1digit = numStr.slice(-1);
 

From af8f0bbf3c7ff6e27e5fc4ee77224983bb3a5880 Mon Sep 17 00:00:00 2001
From: Aklilu Mihtsun <mihtsun.app@gmail.com>
Date: Sat, 24 Oct 2026 00:58:27 +0100
Subject: [PATCH 15/18] refactor getOrdinalNumber function to correctly slice
 last two digits for suffix determination

---
 practice-tdd/get-ordinal-number.js | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/practice-tdd/get-ordinal-number.js b/practice-tdd/get-ordinal-number.js
index 2c11ad376..4f2916160 100644
--- a/practice-tdd/get-ordinal-number.js
+++ b/practice-tdd/get-ordinal-number.js
@@ -1,14 +1,14 @@
 export function getOrdinalNumber(num) {
   const numStr = num.toString();
   const numLength = numStr.length;
-  const last2digits = numStr.slice(-2);
+  const last2digits = numStr.slice(-2, -1);
   const last1digit = numStr.slice(-1);
 
-  if (numStr[numLength - 1] == "1" && numStr[numLength - 2] != "1") {
+  if (last1digit == "1" && last2digits != "1") {
     return `${numStr}st`;
-  } else if (numStr[numLength - 1] == "2" && numStr[numLength - 2] != "1") {
+  } else if (last1digit == "2" && last2digits != "1") {
     return `${numStr}nd`;
-  } else if (numStr[numLength - 1] == "3" && numStr[numLength - 2] != "1") {
+  } else if (last1digit == "3" && last2digits != "1") {
     return `${numStr}rd`;
   }
   return `${numStr}th`;

From bd684b198fa3f061152d62daf25f83e5d0eba293 Mon Sep 17 00:00:00 2001
From: Aklilu Mihtsun <mihtsun.app@gmail.com>
Date: Mon, 26 Oct 2026 13:51:49 +0000
Subject: [PATCH 16/18] add early return for empty character check in countChar
 function

---
 practice-tdd/count.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/practice-tdd/count.js b/practice-tdd/count.js
index 6167d6444..e439447b2 100644
--- a/practice-tdd/count.js
+++ b/practice-tdd/count.js
@@ -1,3 +1,6 @@
 export function countChar(stringOfCharacters, findCharacter) {
+  if (findCharacter === "") {
+    return 0;
+  }
   return stringOfCharacters.split(findCharacter).length - 1;
 }

From 31d6e6c5527e4fc17b3643a72c7961d19307cc74 Mon Sep 17 00:00:00 2001
From: Aklilu Mihtsun <mihtsun.app@gmail.com>
Date: Mon, 26 Oct 2026 13:51:58 +0000
Subject: [PATCH 17/18] refactor countChar tests to improve coverage for case
 sensitivity and empty character scenarios

---
 practice-tdd/count.test.js | 39 +++++++++++++++++++++++++++++++++++++-
 1 file changed, 38 insertions(+), 1 deletion(-)

diff --git a/practice-tdd/count.test.js b/practice-tdd/count.test.js
index 0575330cc..3eb8035df 100644
--- a/practice-tdd/count.test.js
+++ b/practice-tdd/count.test.js
@@ -23,9 +23,46 @@ test("should count multiple occurrences of a character", () => {
 // When the function is called with these inputs,
 // Then it should return 0, indicating that no occurrences of `char` were found.
 
-test("should count multiple occurrences of a character", () => {
+test("should return 0 for no occurrences of a specific character in the string ", () => {
   const str = "aaaaa";
   const char = "b";
   const count = countChar(str, char);
   expect(count).toEqual(0);
 });
+
+test("should return 0 if case of a specific character is not the same as in the string", () => {
+  const str = "AAAAA";
+  const char = "a";
+  const count = countChar(str, char);
+  expect(count).toEqual(0);
+});
+
+test("should return 0 if the string contains empty char and vice versa", () => {
+  let str = "AAAAA";
+  let char = "";
+  let count = countChar(str, char);
+  expect(count).toEqual(0);
+  str = "";
+  char = "c";
+  count = countChar(str, char);
+  expect(count).toEqual(0);
+});
+
+test("should count multiple occurrences of a non-english character", () => {
+  const str = "AAA%&&&0";
+  const char = "%";
+  const count = countChar(str, char);
+  expect(count).toEqual(1);
+});
+
+test("should count occurrences multiple characters in a string sequentially", () => {
+  let str = "AbCdEfGh";
+  let char = "Ab";
+  let count = countChar(str, char);
+  expect(count).toEqual(1);
+
+  str = "AbCdEfGh";
+  char = "AC";
+  count = countChar(str, char);
+  expect(count).toEqual(0);
+});

From a999b4c0982dd4a74370f5bc255ae6a032c63b8d Mon Sep 17 00:00:00 2001
From: Aklilu Mihtsun <mihtsun.app@gmail.com>
Date: Mon, 26 Oct 2026 14:46:12 +0000
Subject: [PATCH 18/18] refactor getOrdinalNumber function to improve variable
 naming for clarity

---
 practice-tdd/get-ordinal-number.js | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/practice-tdd/get-ordinal-number.js b/practice-tdd/get-ordinal-number.js
index 4f2916160..f3404aa1c 100644
--- a/practice-tdd/get-ordinal-number.js
+++ b/practice-tdd/get-ordinal-number.js
@@ -1,14 +1,13 @@
 export function getOrdinalNumber(num) {
   const numStr = num.toString();
-  const numLength = numStr.length;
-  const last2digits = numStr.slice(-2, -1);
-  const last1digit = numStr.slice(-1);
+  const last2ndDigit = numStr.slice(-2, -1);
+  const last1stDigit = numStr.slice(-1);
 
-  if (last1digit == "1" && last2digits != "1") {
+  if (last1stDigit == "1" && last2ndDigit != "1") {
     return `${numStr}st`;
-  } else if (last1digit == "2" && last2digits != "1") {
+  } else if (last1stDigit == "2" && last2ndDigit != "1") {
     return `${numStr}nd`;
-  } else if (last1digit == "3" && last2digits != "1") {
+  } else if (last1stDigit == "3" && last2ndDigit != "1") {
     return `${numStr}rd`;
   }
   return `${numStr}th`;