refactor: update test cases

Author: pragusga25

easy/concatenation-of-array.test.ts

@@ -3,10 +3,18 @@
 const getConcatenation = (nums: number[]): number[] => [...nums, ...nums];
 
 describe('Concatenation of Array', () => {
-  it('should return the concatenated array', () => {
-    expect(getConcatenation([1])).toEqual([1, 1]);
-    expect(getConcatenation([1, 1])).toEqual([1, 1, 1, 1]);
-    expect(getConcatenation([1, 2, 1])).toEqual([1, 2, 1, 1, 2, 1]);
-    expect(getConcatenation([1, 3, 2, 1])).toEqual([1, 3, 2, 1, 1, 3, 2, 1]);
+  it('#1 should return [1, 2, 1, 1, 2, 1]', () => {
+    const nums = [1, 2, 1];
+    expect(getConcatenation(nums)).toStrictEqual([1, 2, 1, 1, 2, 1]);
+  });
+
+  it('#2 should return [1, 3, 2, 1, 1, 3, 2, 1]', () => {
+    const nums = [1, 3, 2, 1];
+    expect(getConcatenation(nums)).toStrictEqual([1, 3, 2, 1, 1, 3, 2, 1]);
+  });
+
+  it('#3 should return [1, 2, 3, 1, 2, 3]', () => {
+    const nums = [1, 2, 3];
+    expect(getConcatenation(nums)).toStrictEqual([1, 2, 3, 1, 2, 3]);
   });
 });

easy/contains-duplicate.test.ts

@@ -14,14 +14,28 @@ const containsDuplicate = (nums: number[]): boolean => {
 };
 
 describe('Contains Duplicate', () => {
-  it('should return true if the array contains duplicates', () => {
-    expect(containsDuplicate([1, 2, 3, 4, 1])).toBe(true);
-    expect(containsDuplicate([1, 1, 1, 3, 3, 4, 3, 2, 4, 2])).toBe(true);
+  it('#1 should return true', () => {
+    const nums = [1, 2, 3, 1];
+    expect(containsDuplicate(nums)).toBe(true);
   });
 
-  it('should return false if the array does not contain duplicates', () => {
-    expect(containsDuplicate([])).toBe(false);
-    expect(containsDuplicate([0])).toBe(false);
-    expect(containsDuplicate([1, 2, 3, 4])).toBe(false);
+  it('#2 should return false', () => {
+    const nums = [1, 2, 3, 4];
+    expect(containsDuplicate(nums)).toBe(false);
+  });
+
+  it('#3 should return true', () => {
+    const nums = [1, 1, 1, 3, 3, 4, 3, 2, 4, 2];
+    expect(containsDuplicate(nums)).toBe(true);
+  });
+
+  it('#4 should return false', () => {
+    const nums = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+    expect(containsDuplicate(nums)).toBe(false);
+  });
+
+  it('#5 should return true', () => {
+    const nums = [1, 1];
+    expect(containsDuplicate(nums)).toBe(true);
   });
 });

easy/crawler-log-folder.test.ts

@@ -14,9 +14,28 @@ const minOperations = (logs: string[]): number => {
 };
 
 describe('Crawler Log Folder', () => {
-  it('should return the minimum number of operations', () => {
-    expect(minOperations(['d1/', 'd2/', './', 'd3/', '../', 'd31/'])).toBe(3);
-    expect(minOperations(['d1/', '../', '../', '../'])).toBe(0);
-    expect(minOperations(['../'])).toBe(0);
+  it('#1 should return 2', () => {
+    const logs = ['d1/', 'd2/', '../', 'd21/', './'];
+    expect(minOperations(logs)).toBe(2);
+  });
+
+  it('#2 should return 3', () => {
+    const logs = ['d1/', 'd2/', './', 'd3/', '../', 'd31/'];
+    expect(minOperations(logs)).toBe(3);
+  });
+
+  it('#3 should return 0', () => {
+    const logs = ['d1/', '../', '../', '../'];
+    expect(minOperations(logs)).toBe(0);
+  });
+
+  it('#4 should return 0', () => {
+    const logs = ['./', './', './'];
+    expect(minOperations(logs)).toBe(0);
+  });
+
+  it('#5 should return 1', () => {
+    const logs = ['d1/', './', './', './'];
+    expect(minOperations(logs)).toBe(1);
   });
 });

easy/happy-number.test.ts

@@ -20,15 +20,28 @@ const isHappy = (n: number): boolean => {
 };
 
 describe('Happy Number', () => {
-  it('should return true if the number is happy', () => {
-    expect(isHappy(19)).toBeTruthy();
-    expect(isHappy(1)).toBeTruthy();
-    expect(isHappy(7)).toBeTruthy();
+  it('#1 should return true', () => {
+    const n = 19;
+    expect(isHappy(n)).toBe(true);
   });
 
-  it('should return false if the number is not happy', () => {
-    expect(isHappy(2)).toBeFalsy();
-    expect(isHappy(3)).toBeFalsy();
-    expect(isHappy(4)).toBeFalsy();
+  it('#2 should return false', () => {
+    const n = 2;
+    expect(isHappy(n)).toBe(false);
+  });
+
+  it('#3 should return false', () => {
+    const n = 3;
+    expect(isHappy(n)).toBe(false);
+  });
+
+  it('#4 should return true', () => {
+    const n = 7;
+    expect(isHappy(n)).toBe(true);
+  });
+
+  it('#5 should return true', () => {
+    const n = 1111111;
+    expect(isHappy(n)).toBe(true);
   });
 });

easy/majority-element.test.ts

@@ -18,8 +18,28 @@ const majorityElement = (nums: number[]): number => {
 };
 
 describe('Majority Element', () => {
-  it('should return the majority element', () => {
-    expect(majorityElement([3, 2, 3])).toBe(3);
-    expect(majorityElement([2, 2, 1, 1, 1, 2, 2])).toBe(2);
+  it('#1 should return 3', () => {
+    const nums = [3, 2, 3];
+    expect(majorityElement(nums)).toBe(3);
+  });
+
+  it('#2 should return 2', () => {
+    const nums = [2, 2, 1, 1, 1, 2, 2];
+    expect(majorityElement(nums)).toBe(2);
+  });
+
+  it('#3 should return 3', () => {
+    const nums = [3, 3, 4];
+    expect(majorityElement(nums)).toBe(3);
+  });
+
+  it('#4 should return 3', () => {
+    const nums = [3, 3, 3, 3, 3, 3, 3];
+    expect(majorityElement(nums)).toBe(3);
+  });
+
+  it('#5 should return 1', () => {
+    const nums = [1];
+    expect(majorityElement(nums)).toBe(1);
   });
 });

easy/number-of-good-pairs.test.ts

@@ -34,22 +34,22 @@ const numIdenticalPairs = (nums: number[]): number => {
 };
 
 describe('Number of Good Pairs', () => {
-  it('should return 4', () => {
+  it('#1 should return 4', () => {
     const nums = [1, 2, 3, 1, 1, 3];
     expect(numIdenticalPairs(nums)).toBe(4);
   });
 
-  it('should return 6', () => {
+  it('#2 should return 6', () => {
     const nums = [1, 1, 1, 1];
     expect(numIdenticalPairs(nums)).toBe(6);
   });
 
-  it('should return 0', () => {
+  it('#3 should return 0', () => {
     const nums = [1, 2, 3];
     expect(numIdenticalPairs(nums)).toBe(0);
   });
 
-  it('should return 5', () => {
+  it('#4 should return 5', () => {
     const nums = [1, 2, 3, 1, 1, 3, 2];
     expect(numIdenticalPairs(nums)).toBe(5);
   });

easy/pascals-triangle.test.ts

@@ -20,14 +20,24 @@ const generate = (numRows: number): number[][] => {
 };
 
 describe("Pascal's Triangle", () => {
-  it('should return the pascal triangle', () => {
-    expect(generate(5)).toEqual([
+  it('#1 should return [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]', () => {
+    const numRows = 5;
+    expect(generate(numRows)).toStrictEqual([
       [1],
       [1, 1],
       [1, 2, 1],
       [1, 3, 3, 1],
       [1, 4, 6, 4, 1],
     ]);
-    expect(generate(1)).toEqual([[1]]);
+  });
+
+  it('#2 should return [[1],[1,1],[1,2,1]]', () => {
+    const numRows = 3;
+    expect(generate(numRows)).toStrictEqual([[1], [1, 1], [1, 2, 1]]);
+  });
+
+  it('#3 should return [[1],[1,1]]', () => {
+    const numRows = 2;
+    expect(generate(numRows)).toStrictEqual([[1], [1, 1]]);
   });
 });

easy/remove-element.test.ts

@@ -14,13 +14,35 @@ const removeElement = (nums: number[], val: number): number => {
 };
 
 describe('Remove Element', () => {
-  it('should remove the element from the array', () => {
-    const arr1 = [3, 2, 2, 3];
-    expect(removeElement(arr1, 3)).toBe(2);
-    expect(arr1.slice(0, 2)).toEqual([2, 2]);
+  it('#1 should return 2 and array should be [2, 2]', () => {
+    const nums = [3, 2, 2, 3];
+    const val = 3;
+    const result = removeElement(nums, val);
+    expect(result).toBe(2);
+    expect(nums.slice(0, result)).toEqual([2, 2]);
+  });
+
+  it('#2 should return 5 and array should be [0, 1, 3, 0, 4]', () => {
+    const nums = [0, 1, 2, 2, 3, 0, 4, 2];
+    const val = 2;
+    const result = removeElement(nums, val);
+    expect(result).toBe(5);
+    expect(nums.slice(0, result)).toEqual([0, 1, 3, 0, 4]);
+  });
+
+  it('#3 should return 0 and array should be []', () => {
+    const nums = [];
+    const val = 0;
+    const result = removeElement(nums, val);
+    expect(result).toBe(0);
+    expect(nums.slice(0, result)).toEqual([]);
+  });
 
-    const arr2 = [0, 1, 2, 2, 3, 0, 4, 2];
-    expect(removeElement(arr2, 2)).toBe(5);
-    expect(arr2.slice(0, 5)).toEqual([0, 1, 3, 0, 4]);
+  it('#4 should return 0 and array should be []', () => {
+    const nums = [1];
+    const val = 1;
+    const result = removeElement(nums, val);
+    expect(result).toBe(0);
+    expect(nums.slice(0, result)).toEqual([]);
   });
 });

easy/sqrtx.test.ts

@@ -22,19 +22,28 @@ const mySqrt = (x: number): number => {
 };
 
 describe('Sqrt(x)', () => {
-  it('should return the square root of x', () => {
-    expect(mySqrt(0)).toBe(0);
-    expect(mySqrt(1)).toBe(1);
-    expect(mySqrt(2)).toBe(1);
-    expect(mySqrt(4)).toBe(2);
-    expect(mySqrt(8)).toBe(2);
-    expect(mySqrt(9)).toBe(3);
-    expect(mySqrt(16)).toBe(4);
-    expect(mySqrt(25)).toBe(5);
-    expect(mySqrt(36)).toBe(6);
-    expect(mySqrt(49)).toBe(7);
-    expect(mySqrt(64)).toBe(8);
-    expect(mySqrt(81)).toBe(9);
-    expect(mySqrt(100)).toBe(10);
+  it('#1 should return 2', () => {
+    const x = 4;
+    expect(mySqrt(x)).toBe(2);
+  });
+
+  it('#2 should return 2', () => {
+    const x = 8;
+    expect(mySqrt(x)).toBe(2);
+  });
+
+  it('#3 should return 1', () => {
+    const x = 1;
+    expect(mySqrt(x)).toBe(1);
+  });
+
+  it('#4 should return 46340', () => {
+    const x = 2147395600;
+    expect(mySqrt(x)).toBe(46340);
+  });
+
+  it('#5 should return 0', () => {
+    const x = 0;
+    expect(mySqrt(x)).toBe(0);
   });
 });

easy/two-sum.test.ts

@@ -18,9 +18,27 @@ export const twoSum = (nums: number[], target: number): number[] => {
 };
 
 describe('Two Sum', () => {
-  it('should return the indices of the two numbers that add up to the target', () => {
-    expect(twoSum([2, 7, 11, 15], 9)).toEqual([0, 1]);
-    expect(twoSum([3, 3], 6)).toEqual([0, 1]);
-    expect(twoSum([2, 7, 11, 15], 17)).toEqual([0, 3]);
+  it('#1 should return [0, 1]', () => {
+    const nums = [2, 7, 11, 15];
+    const target = 9;
+    expect(twoSum(nums, target)).toEqual([0, 1]);
+  });
+
+  it('#2 should return [1, 2]', () => {
+    const nums = [3, 2, 4];
+    const target = 6;
+    expect(twoSum(nums, target)).toEqual([1, 2]);
+  });
+
+  it('#3 should return [0, 1]', () => {
+    const nums = [3, 3];
+    const target = 6;
+    expect(twoSum(nums, target)).toEqual([0, 1]);
+  });
+
+  it('#4 should return [0, 1]', () => {
+    const nums = [3, 2, 3];
+    const target = 6;
+    expect(twoSum(nums, target)).toEqual([0, 2]);
   });
 });

easy/valid-anagram.test.ts

@@ -30,17 +30,33 @@ const isAnagram = (s: string, t: string): boolean => {
 };
 
 describe('Valid Anagram', () => {
-  it('should return true if the strings are anagrams', () => {
-    expect(isAnagram('anagram', 'nagrama')).toBe(true);
-    expect(isAnagram('', '')).toBe(true);
-    expect(isAnagram('a', 'a')).toBe(true);
-    expect(isAnagram('kasur', 'rusak')).toBe(true);
+  it('#1 should return true', () => {
+    const s = 'anagram';
+    const t = 'nagaram';
+    expect(isAnagram(s, t)).toBe(true);
   });
 
-  it('should return false if the strings are not anagrams', () => {
-    expect(isAnagram('anagram', 'nagram')).toBe(false);
-    expect(isAnagram('', 'a')).toBe(false);
-    expect(isAnagram('a', '')).toBe(false);
-    expect(isAnagram('kasur', 'sura')).toBe(false);
+  it('#2 should return false', () => {
+    const s = 'rat';
+    const t = 'car';
+    expect(isAnagram(s, t)).toBe(false);
+  });
+
+  it('#3 should return false', () => {
+    const s = 'a';
+    const t = 'ab';
+    expect(isAnagram(s, t)).toBe(false);
+  });
+
+  it('#4 should return false', () => {
+    const s = 'a';
+    const t = 'b';
+    expect(isAnagram(s, t)).toBe(false);
+  });
+
+  it('#5 should return true', () => {
+    const s = 'a';
+    const t = 'a';
+    expect(isAnagram(s, t)).toBe(true);
   });
 });