Merge branch 'TheAlgorithms:master' into add-ugly

Author: SpiderMath

backtracking/all-combinations-of-size-k.ts

@@ -0,0 +1,38 @@
+/**
+ * This generates an array of unique sub"sets" (represented by ascendingly sorted subarrays)
+ * of size k out of n+1 numbers from 1 to n.
+ *
+ * By using a backtracking algorithm we can incrementally build sub"sets" while dropping candidates
+ * that cannot contribute anymore to a valid solution.
+ * Steps:
+ * - From the starting number (i.e. "1") generate all combinations of k numbers.
+ * - Once we got all combinations for the given number we can discard it (“backtracks”)
+ *   and repeat the same process for the next number.
+ */
+export function generateCombinations(n: number, k: number): number[][] {
+  let combinationsAcc: number[][] = [];
+  let currentCombination: number[] = [];
+
+  function generateAllCombos(
+    n: number,
+    k: number,
+    startCursor: number
+  ): number[][] {
+    if (k === 0) {
+      if (currentCombination.length > 0) {
+        combinationsAcc.push(currentCombination.slice());
+      }
+      return combinationsAcc;
+    }
+
+    const endCursor = n - k + 2;
+    for (let i = startCursor; i < endCursor; i++) {
+      currentCombination.push(i);
+      generateAllCombos(n, k - 1, i + 1);
+      currentCombination.pop();
+    }
+    return combinationsAcc;
+  }
+
+  return generateAllCombos(n, k, 1);
+}

backtracking/generateParentheses.ts

@@ -0,0 +1,31 @@
+/**
+ * Given a number n pairs of parentheses, generate all combinations of valid parentheses
+ * @param {number} n: Number of given parentheses
+ * @return {string[]} result: Array that contains all valid parentheses
+ * @see https://leetcode.com/problems/generate-parentheses/
+ */
+
+const generateParentheses = (n: number): string[] => {
+  const result: string[] = [];
+
+  const solve = (chars: string, openParentheses: number, closedParentheses: number) => {
+    if (openParentheses === n && closedParentheses === n) {
+      result.push(chars);
+      return;
+    }
+
+    if (openParentheses <= n) {
+      solve(chars + "(", openParentheses + 1, closedParentheses);
+    }
+
+    if (closedParentheses < openParentheses) {
+      solve(chars + ")", openParentheses, closedParentheses + 1);
+    }
+  };
+
+  solve("", 0, 0);
+
+  return result;
+};
+
+export { generateParentheses };

backtracking/test/all-combinations-of-size-k.test.ts

@@ -0,0 +1,26 @@
+import { generateCombinations } from "../all-combinations-of-size-k";
+
+const cases = [
+  [
+    3,
+    2,
+    [
+      [1, 2],
+      [1, 3],
+      [2, 3],
+    ],
+  ],
+  [4, 2, [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]],
+  [0, 0, []],
+  [2, 3, []],
+] as const;
+
+describe("AllCombinationsOfSizeK", () => {
+  it.each(cases)(
+    "create all combinations given n=%p and k=%p",
+    (n, k, expectedCombos) => {
+      const combinations = generateCombinations(n, k);
+      expect(combinations).toEqual(expectedCombos);
+    }
+  );
+});

backtracking/test/generateParentheses.test.ts

@@ -0,0 +1,83 @@
+import { generateParentheses } from "../generateParentheses";
+
+const cases: [number, string[]][] = [
+  [0, [""]],
+  [1, ["()"]],
+  [2, ["(())", "()()"]],
+  [3, ["((()))", "(()())", "(())()", "()(())", "()()()"]],
+  [
+    4,
+    [
+      "(((())))",
+      "((()()))",
+      "((())())",
+      "((()))()",
+      "(()(()))",
+      "(()()())",
+      "(()())()",
+      "(())(())",
+      "(())()()",
+      "()((()))",
+      "()(()())",
+      "()(())()",
+      "()()(())",
+      "()()()()",
+    ],
+  ],
+  [
+    5,
+    [
+      "((((()))))",
+      "(((()())))",
+      "(((())()))",
+      "(((()))())",
+      "(((())))()",
+      "((()(())))",
+      "((()()()))",
+      "((()())())",
+      "((()()))()",
+      "((())(()))",
+      "((())()())",
+      "((())())()",
+      "((()))(())",
+      "((()))()()",
+      "(()((())))",
+      "(()(()()))",
+      "(()(())())",
+      "(()(()))()",
+      "(()()(()))",
+      "(()()()())",
+      "(()()())()",
+      "(()())(())",
+      "(()())()()",
+      "(())((()))",
+      "(())(()())",
+      "(())(())()",
+      "(())()(())",
+      "(())()()()",
+      "()(((())))",
+      "()((()()))",
+      "()((())())",
+      "()((()))()",
+      "()(()(()))",
+      "()(()()())",
+      "()(()())()",
+      "()(())(())",
+      "()(())()()",
+      "()()((()))",
+      "()()(()())",
+      "()()(())()",
+      "()()()(())",
+      "()()()()()",
+    ],
+  ],
+];
+
+describe("Generate Parentheses", () => {
+  test.each(cases)(
+    "generate all valid parentheses of input %n",
+    (n: number, expected: string[]) => {
+      expect(generateParentheses(n)).toStrictEqual(expected);
+    }
+  );
+});

bit_manipulation/is_power_of_2.ts

@@ -0,0 +1,25 @@
+/**
+ * This code will check whether the given number is a power of two or not.
+ * @author dev-madhurendra<https://github.com/dev-madhurendra>
+ * @explanation
+
+    A number will be a power of two if only one bit is set and rest are unset.
+    This is true for all the cases except 01 because (2^0 = 1) which is not a power of 2.
+    For eg: 10 (2^1 = 2), 100 (2^2 = 4), 10000 (2^4 = 16)
+
+    @see: https://www.hackerearth.com/practice/notes/round-a-number-to-the-next-power-of-2/
+
+    If we will subtract 1 from a number that is a power of 2 we will get it's 
+    1's complement.And we know that 1's complement is just opp. of that number.
+    So, (n & (n-1)) will be 0.
+
+    For eg:    (1000 & (1000-1))
+                1 0 0 0     // Original Number (8)
+                0 1 1 1     // After Subtracting 1 (8-1 = 7)
+                _______
+                0 0 0 0     // will become 0
+ * @param {number}
+ * @returns {boolean}
+ */
+
+export const isPowerOfTwo = (n: number): boolean => n > 0 && (n & (n - 1)) === 0

bit_manipulation/is_power_of_4.ts

@@ -0,0 +1,15 @@
+/**
+ * @author : dev-madhurendra<https://github.com/dev-madhurendra>
+ * Checks whether the given number is a power of four or not.
+ *
+ * A number is considered a power of four if and only if there is a single '1' bit in its binary representation,
+ * and that '1' bit is at the first position, followed by an even number of '0' bits.
+ *
+ * @param {number} n - The input number to check.
+ * @returns {boolean} True if the number is a power of four, false otherwise.
+ *
+ * @example
+ * const result = isPowerOfFour(16); // Returns true (16 is 4^2)
+ * const result2 = isPowerOfFour(5);  // Returns false (5 is not a power of four)
+ */
+export const isPowerOfFour = (n: number): boolean => ((n > 0) && ((n & n - 1) === 0) && (n % 3 === 1))

bit_manipulation/test/is_power_of_2.test.ts

@@ -0,0 +1,14 @@
+import { isPowerOfTwo } from "../is_power_of_2"
+
+
+describe('IsPowerOfTwo' , () => {
+    it.each([
+        [0, false],
+        [1, true],
+        [4, true],
+        [1024, true],
+        [1025, false],
+      ])('Check if %i is a power of 2 or not', (number, expected) => {
+        expect(isPowerOfTwo(number)).toBe(expected);
+    });    
+})

bit_manipulation/test/is_power_of_4.test.ts

@@ -0,0 +1,14 @@
+import { isPowerOfFour } from "../is_power_of_4"
+
+describe('IsPowerOfFour', () => {
+  it.each([
+    [0, false],
+    [4, true],
+    [16, true],
+    [12, false],
+    [64, true],
+    [-64, false]
+  ])('should return the number %i is power of four or not', (n, expected) => {
+    expect(isPowerOfFour(n)).toBe(expected)
+  })
+})

data_structures/tries/test/tries.test.ts

@@ -0,0 +1,40 @@
+import { Trie } from "../tries"; 
+
+describe('Trie', () => {
+  let trie: Trie;
+
+  beforeEach(() => {
+    trie = new Trie();
+  });
+
+  it('should add and find a word', () => {
+    trie.add('apple');
+    expect(trie.find('apple')).toBe(true);
+  });
+
+  it('should not find a word that was not added', () => {
+    trie.add('apple');
+    expect(trie.find('banana')).toBe(false);
+  });
+
+  it('should not find a partial word', () => {
+    trie.add('apple');
+    expect(trie.find('app')).toBe(false);
+  });
+
+  it('should add and find multiple words', () => {
+    trie.add('apple');
+    trie.add('banana');
+    trie.add('cherry');
+    expect(trie.find('apple')).toBe(true);
+    expect(trie.find('banana')).toBe(true);
+    expect(trie.find('cherry')).toBe(true);
+  });
+
+  it('should find words with a common prefix', () => {
+    trie.add('apple');
+    trie.add('appetizer');
+    expect(trie.find('app', true)).toBe(true);
+    expect(trie.find('app', false)).toBe(false);
+  });
+});

data_structures/tries/tries.ts

@@ -0,0 +1,91 @@
+/**
+ * Represents a node in a Trie data structure.
+ */
+class TrieNode {
+  /**
+   * An object that stores child nodes for each character in the alphabet.
+   */
+  children: { [key: string]: TrieNode } = {};
+
+  /**
+   * Indicates whether the node represents the end of a word.
+   */
+  isWord: boolean = false;
+}
+
+/**
+ * Trie Data structure for storing and searching words.
+ */
+export class Trie {
+  /**
+   * The root node of the Trie.
+   */
+  root: TrieNode = new TrieNode();
+
+  /**
+   * Creates a new Trie instance.
+   */
+  constructor() {}
+
+  /**
+   * Inserts a word into the Trie.
+   *
+   * @param word - The word to insert into the Trie.
+   */
+  private insertNode(node: TrieNode, word: string): void {
+    for (const char of word) {
+      if (!node.children[char]) {
+        node.children[char] = new TrieNode();
+      }
+      node = node.children[char];
+    }
+    node.isWord = true;
+  }
+
+  /**
+   * Searches for a word in the Trie.
+   *
+   * @param word - The word to search for.
+   * @param isPrefixMatch - Indicates whether to perform a prefix match (default: false).
+   *   If true, the method returns true if the Trie contains words with the specified prefix.
+   *   If false, the method returns true only if an exact match is found.
+   * @returns True if the word (or prefix) is found in the Trie; otherwise, false.
+   */
+  public find(word: string, isPrefixMatch: boolean = false): boolean {
+    return this.searchNode(this.root, word, isPrefixMatch);
+  }
+
+  /**
+   * Adds a word to the Trie.
+   *
+   * @param word - The word to add to the Trie.
+   * @returns The Trie instance, allowing for method chaining.
+   */
+  public add(word: string): this {
+    this.insertNode(this.root, word);
+    return this;
+  }
+
+  /**
+   * Searches for a word in the Trie.
+   *
+   * @param node - The current Trie node being examined.
+   * @param word - The word to search for.
+   * @param prefixMatch - Indicates whether to perform a prefix match.
+   * @returns True if the word (or prefix) is found in the Trie; otherwise, false.
+   * @private
+   */
+  private searchNode(
+    node: TrieNode,
+    word: string,
+    prefixMatch: boolean
+  ): boolean {
+    for (const char of word) {
+      if (!node.children[char]) {
+        return false;
+      }
+      node = node.children[char];
+    }
+    return prefixMatch || node.isWord;
+  }
+}