Merge branch 'TheAlgorithms:master' into add-hexagonal-nums

Author: SpiderMath

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,52 @@
+name: Bug report
+description: "Create a report to help us improve"
+title: "[BUG]: "
+labels: ["bug"]
+body:
+  - type: markdown
+    attributes:
+      value: "### Before you open an issue, please verify if a similar one already exists or has been closed before. More details about the process of contributing can be found in [CONTRIBUTING.md](https://github.com/TheAlgorithms/TypeScript/blob/master/CONTRIBUTING.md)."
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: Explain what the problem is.
+    validations:
+      required: true
+  - type: textarea
+    id: expectedbhv
+    attributes:
+      label: Expected Behavior
+      description: Describe what was the expected behavior.
+    validations:
+      required: true
+  - type: textarea
+    id: actualbhv
+    attributes:
+      label: Actual Behavior
+      description: Describe what actually happens.
+    validations:
+      required: true
+  - type: textarea
+    id: steps
+    attributes:
+      label: Steps to reproduce (if applicable)
+      description: List steps to reproduce the behavior.
+      placeholder: |
+        1. 
+        2. 
+        3. 
+        4.
+    validations:
+      required: false
+  - type: textarea
+    id: specifications
+    attributes:
+      label: Specifications
+      description: Specify version, platform, and web browser (if applicable).
+      placeholder: |
+        1. Version:
+        2. Platform:
+        3. Browser:
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,31 @@
+name: Feature request
+description: "Suggest features, propose improvements, discuss new ideas"
+title: "[FEATURE]: "
+labels: ["enhancement"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ## This issue template is not for requesting new algorithms. For new algorithms, PRs should be opened directly.
+        ## Make sure your issue isn't a duplicate and you follow our [contributing guidelines](https://github.com/TheAlgorithms/TypeScript/blob/master/CONTRIBUTING.md)
+  - type: textarea
+    id: description
+    attributes:
+      label: Motivation
+      description: Describe what is the motivation behind this feature.
+    validations:
+      required: true
+  - type: textarea
+    id: examples
+    attributes:
+      label: Examples
+      description: If possible, provide examples of how this feature can be used.
+    validations:
+      required: false
+  - type: textarea
+    id: workarounds
+    attributes:
+      label: Possible workarounds
+      description: If possible, describes possible workarounds to this feature.
+    validations:
+      required: false

.github/workflows/ci.yml

@@ -10,9 +10,9 @@ jobs:
   test:
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
         with:
-          node-version: "16.x"
+          node-version: "18.x"
       - run: npm ci
       - run: npm test

.github/workflows/directory_formatter.yml

@@ -0,0 +1,41 @@
+name: Directory/Filename Formatter workflow
+on: [push, pull_request]
+
+jobs:
+  main:
+    name: (Directory) Formatter
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@main
+      - name: Setup Git configuration
+        run: |
+          git config --global user.name 'autoprettier'
+          git config --global user.email '[email protected]'
+          git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
+      - name: Filename Formatter
+        run: |
+          IFS=$'\n'
+          for fname in `find . -type f -name '*.ts' -o -name '*.ts'`
+          do
+            echo "${fname}"
+            new_fname=`echo ${fname} | tr ' ' '_'`
+            echo "      ${new_fname}"
+            new_fname=`echo ${new_fname} | tr 'A-Z' 'a-z'`
+            echo "      ${new_fname}"
+            new_fname=`echo ${new_fname} | tr '-' '_'`
+            echo "      ${new_fname}"
+            if [ ${fname} != ${new_fname} ]
+            then
+              echo "      ${fname} --> ${new_fname}"
+              git "mv" "${fname}" ${new_fname}
+            fi
+          done
+          git commit -am "Formatting filenames ${GITHUB_SHA::8}" || true
+      - name: Update DIRECTORY.md
+        run: |
+          wget https://raw.githubusercontent.com/TheAlgorithms/scripts/main/build_directory_md.py
+          python3 build_directory_md.py TypeScript . .ts jest.config.ts,sorts/test,search/test,maths/test,dynamic_programming/test,data_structures/test,ciphers/test > DIRECTORY.md
+
+          git diff
+          git commit -m "Update DIRECTORY.md" DIRECTORY.md || true
+          git push --force origin HEAD:$GITHUB_REF || true

CONTRIBUTING.md

@@ -56,9 +56,9 @@ should add unique value.
 
 #### File Naming Convention
 
-- Filenames should use the UpperCamelCase (PascalCase) style.
+- Filenames should use the snake_case style. This is needed for our workflows to work correctly.
 - There should be no spaces in filenames.
-- **Example:** `UserProfile.ts` is allowed. Do not use `userprofile.ts`, `Userprofile.ts`, `user-Profile.ts`, `userProfile.ts`; these naming conventions are discouraged.
+- **Example:** `user_profile.ts` is allowed. Do not use `userprofile.ts`, `Userprofile.ts`, `user-Profile.ts`, `userProfile.ts`, `UserProfile.ts`; these naming conventions are discouraged.
 
 #### Commit Messages Formatting
 

DIRECTORY.md

@@ -0,0 +1,41 @@
+
+## Ciphers
+  * [Xor Cipher](https://github.com/TheAlgorithms/TypeScript/blob/master/ciphers/xor_cipher.ts)
+
+## Data Structures
+  * [Stack](https://github.com/TheAlgorithms/TypeScript/blob/master/data_structures/stack.ts)
+
+## Dynamic Programming
+  * [Knapsack](https://github.com/TheAlgorithms/TypeScript/blob/master/dynamic_programming/knapsack.ts)
+
+## Maths
+  * [Absolute Value](https://github.com/TheAlgorithms/TypeScript/blob/master/maths/absolute_value.ts)
+  * [Aliquot Sum](https://github.com/TheAlgorithms/TypeScript/blob/master/maths/aliquot_sum.ts)
+  * [Armstrong Number](https://github.com/TheAlgorithms/TypeScript/blob/master/maths/armstrong_number.ts)
+  * [Binary Convert](https://github.com/TheAlgorithms/TypeScript/blob/master/maths/binary_convert.ts)
+  * [Calculate Mean](https://github.com/TheAlgorithms/TypeScript/blob/master/maths/calculate_mean.ts)
+  * [Degrees To Radians](https://github.com/TheAlgorithms/TypeScript/blob/master/maths/degrees_to_radians.ts)
+  * [Digit Sum](https://github.com/TheAlgorithms/TypeScript/blob/master/maths/digit_sum.ts)
+  * [Factorial](https://github.com/TheAlgorithms/TypeScript/blob/master/maths/factorial.ts)
+  * [Fibonacci](https://github.com/TheAlgorithms/TypeScript/blob/master/maths/fibonacci.ts)
+  * [Find Min](https://github.com/TheAlgorithms/TypeScript/blob/master/maths/find_min.ts)
+  * [Greatest Common Factor](https://github.com/TheAlgorithms/TypeScript/blob/master/maths/greatest_common_factor.ts)
+  * [Is Divisible](https://github.com/TheAlgorithms/TypeScript/blob/master/maths/is_divisible.ts)
+  * [Is Even](https://github.com/TheAlgorithms/TypeScript/blob/master/maths/is_even.ts)
+  * [Is Leap Year](https://github.com/TheAlgorithms/TypeScript/blob/master/maths/is_leap_year.ts)
+  * [Is Odd](https://github.com/TheAlgorithms/TypeScript/blob/master/maths/is_odd.ts)
+  * [Lowest Common Multiple](https://github.com/TheAlgorithms/TypeScript/blob/master/maths/lowest_common_multiple.ts)
+  * [Perfect Square](https://github.com/TheAlgorithms/TypeScript/blob/master/maths/perfect_square.ts)
+  * [Radians To Degrees](https://github.com/TheAlgorithms/TypeScript/blob/master/maths/radians_to_degrees.ts)
+  * [Sieve Of Eratosthenes](https://github.com/TheAlgorithms/TypeScript/blob/master/maths/sieve_of_eratosthenes.ts)
+
+## Search
+  * [Binary Search](https://github.com/TheAlgorithms/TypeScript/blob/master/search/binary_search.ts)
+  * [Linear Search](https://github.com/TheAlgorithms/TypeScript/blob/master/search/linear_search.ts)
+
+## Sorts
+  * [Bubble Sort](https://github.com/TheAlgorithms/TypeScript/blob/master/sorts/bubble_sort.ts)
+  * [Gnome Sort](https://github.com/TheAlgorithms/TypeScript/blob/master/sorts/gnome_sort.ts)
+  * [Insertion Sort](https://github.com/TheAlgorithms/TypeScript/blob/master/sorts/insertion_sort.ts)
+  * [Merge Sort](https://github.com/TheAlgorithms/TypeScript/blob/master/sorts/merge_sort.ts)
+  * [Quick Sort](https://github.com/TheAlgorithms/TypeScript/blob/master/sorts/quick_sort.ts)

Ciphers/test/XORCipher.test.ts renamed to ciphers/test/xor_cipher.test.ts

@@ -1,4 +1,4 @@
-import { XORCipher } from '../XORCipher';
+import { XORCipher } from '../xor_cipher';
 
 describe('Testing XORCipher function', () => {
   it('passing a string & number as an argument', () => {

Ciphers/XORCipher.ts renamed to ciphers/xor_cipher.ts

@@ -1,4 +1,4 @@
-import { Stack } from '../Stack';
+import { Stack } from '../stack';
 
 describe('Testing Stack data structure', () => {
   it('push should add a new element to the stack', () => {

Data-Structures/Stack.ts renamed to data_structures/stack.ts

@@ -0,0 +1,59 @@
+/**
+ * @function knapsack
+ * @description Given weights and values of n (numberOfItems) items, put these items in a knapsack of capacity to get the maximum total value in the knapsack. In other words, given two integer arrays values[0..n-1] and weights[0..n-1] which represent values and weights associated with n items respectively. Also given an integer capacity which represents knapsack capacity, find out the maximum value subset of values[] such that sum of the weights of this subset is smaller than or equal to capacity. You cannot break an item, either pick the complete item or don’t pick it (0-1 property).
+ * @Complexity_Analysis
+ * Space complexity - O(1)
+ * Time complexity (independent of input) : O(numberOfItems * capacity)
+ *
+ * @return maximum value subset of values[] such that sum of the weights of this subset is smaller than or equal to capacity.
+ * @see [Knapsack](https://www.geeksforgeeks.org/0-1-knapsack-problem-dp-10/)
+ * @example knapsack(3, 8, [3, 4, 5], [30, 50, 60]) = 90
+ */
+export const knapsack = (
+  capacity: number,
+  weights: number[],
+  values: number[]
+) => {
+  if (weights.length != values.length) {
+    throw new Error(
+      "weights and values arrays should have same number of elements"
+    );
+  }
+
+  const numberOfItems = weights.length;
+
+  // Declaring a data structure to store calculated states/values
+  let dp: number[][] = new Array(numberOfItems + 1);
+
+  for (let i = 0; i < dp.length; i++) {
+    // Placing an array at each index of dp to make it a 2d matrix
+    dp[i] = new Array(capacity + 1);
+  }
+
+  // Loop traversing each state of dp
+  for (let i = 0; i < numberOfItems; i++) {
+    for (let j = 0; j <= capacity; j++) {
+      if (i == 0) {
+        if (j >= weights[i]) {
+          // grab the first item if it's weight is less than remaining weight (j)
+          dp[i][j] = values[i];
+        } else {
+          // if weight[i] is more than remaining weight (j) leave it
+          dp[i][j] = 0;
+        }
+      } else if (j < weights[i]) {
+        // if weight of current item (weights[i]) is more than remaining weight (j), leave the current item and just carry on previous items
+        dp[i][j] = dp[i - 1][j];
+      } else {
+        // select the maximum of (if current weight is collected thus adding it's value) and (if current weight is not collected thus not adding it's value)
+        dp[i][j] = Math.max(
+          dp[i - 1][j - weights[i]] + values[i],
+          dp[i - 1][j]
+        );
+      }
+    }
+  }
+
+  // Return the final maximized value at last position of dp matrix
+  return dp[numberOfItems - 1][capacity];
+};

Data-Structures/test/Stack.test.ts renamed to data_structures/test/stack.test.ts

@@ -0,0 +1,23 @@
+import { knapsack } from "../knapsack";
+
+const cases: [number, number[], number[], number][] = [
+  [15, [6, 5, 6, 6, 3, 7], [5, 6, 4, 6, 5, 2], 17],
+  [50, [10, 20, 30], [60, 100, 120], 220],
+  [8, [3, 4, 5], [30, 50, 60], 90],
+  [
+    5,
+    [1, 1, 1, 1, 1],
+    [1000000000, 1000000000, 1000000000, 1000000000, 1000000000],
+    5000000000,
+  ],
+];
+
+describe("Knapsack Algorithm Test", () => {
+  test.each(cases)(
+    "given %p capacity available, with weights %p and values %p, knapsack should return %p",
+    (capacity, weights, values, expectedResult) => {
+      const result = knapsack(capacity, weights, values);
+      expect(result).toBe(expectedResult);
+    }
+  );
+});

dynamic_programming/knapsack.ts

@@ -0,0 +1,58 @@
+/**
+ * @function LowestCommonMultiple
+ * @description Determine the lowest common multiple of a group of numbers.
+ * @param {Number[]} nums - An array of numbers.
+ * @return {Number} - The lowest common multiple.
+ * @see https://www.mathsisfun.com/least-common-multiple.html
+ * @example LowestCommonMultiple(3, 4) = 12
+ * @example LowestCommonMultiple(8, 6) = 24
+ * @example LowestCommonMultiple(5, 8, 3) = 120
+ */
+
+import { greatestCommonFactor } from "./greatest_common_factor";
+
+//A naive solution which requires no additional mathematical algorithm
+
+export const naiveLCM = (nums: number[]): number => {
+  if (nums.some((num) => num < 0)) {
+    throw new Error("numbers must be positive to determine lowest common multiple");
+  }
+
+  if (nums.length === 0) {
+    throw new Error("at least one number must be passed in");
+  }
+
+  const max_num = Math.max(...nums);
+  let current_num = max_num;
+
+  while (true) {
+    if (nums.every((num) => current_num % num === 0)){
+      return current_num;
+    } else {
+      current_num += max_num;
+    }
+  }
+}
+
+//A typically more efficient solution which requires prior knowledge of GCF
+//Note that due to utilizing GCF, which requires natural numbers, this method only accepts natural numbers.
+
+export const binaryLCM = (a: number, b: number): number => {
+  if (a < 0 || b < 0) {
+    throw new Error("numbers must be positive to determine lowest common multiple");
+  }
+
+  if (!Number.isInteger(a) || !Number.isInteger(b)) {
+    throw new Error("this method, which utilizes GCF, requires natural numbers.");
+  }
+
+  return a * b / greatestCommonFactor([a, b]);
+}
+
+export const lowestCommonMultiple = (nums: number[]): number => {
+  if (nums.length === 0) {
+    throw new Error("at least one number must be passed in");
+  }
+
+  return nums.reduce(binaryLCM);
+}

dynamic_programming/test/knapsack.test.ts

@@ -0,0 +1,27 @@
+/**
+ * @function  SieveOfEratosthenes
+ * @description Find the prime numbers between 2 and n 
+ * @param {number} n - numbers set the limit that the algorithm needs to look to find the primes
+ * @return {number[]} - List of prime numbers
+ * @see https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes\
+ * @example SieveOfErastosthenes(5) = [2,3,5] 
+ * @example SieveOfErastosthenes(10) = [2,3,5,7]
+ */
+
+export function SieveOfEratosthenes(n: number): number[] {
+  if (n < 0 || !Number.isInteger(n)) {
+    throw new Error("Only natural numbers are supported");
+  }
+  const numbers = new Array<boolean>(n + 1)
+    .fill(true)
+  const primeNumbers: number[] = [];
+  for (let i = 2; i <= n; i++) {
+    if (numbers[i]) {
+      primeNumbers.push(i);
+      for (let j = i + i; j <= n; j += i) {
+        numbers[j] = false;
+      }
+    }
+  }
+  return primeNumbers;
+}

Maths/AbsoluteValue.ts renamed to maths/absolute_value.ts

@@ -1,4 +1,4 @@
-import { AbsoluteValue } from "../AbsoluteValue";
+import { AbsoluteValue } from "../absolute_value";
 
 describe("AbsoluteValue", () => {
   it("should return the absolute value of zero", () => {

Maths/AliquotSum.ts renamed to maths/aliquot_sum.ts

@@ -1,4 +1,4 @@
-import { AliquotSum } from "../AliquotSum";
+import { AliquotSum } from "../aliquot_sum";
 
 test.each([[15, 9], [18, 21], [28, 28], [100, 117], [169, 14], [1729, 511], [15625, 3906]])("Aliquot Sum of %i is %i", (num, expected) => {
   expect(AliquotSum(num)).toBe(expected)

Maths/ArmstrongNumber.ts renamed to maths/armstrong_number.ts

@@ -1,4 +1,4 @@
-import { ArmstrongNumber } from "../ArmstrongNumber"
+import { ArmstrongNumber } from "../armstrong_number"
 
 test.each([[9, true], [-310, false], [0, false], [407, true], [420, false], [92727, true], [13579, false]])('i is an Armstrong number or not', (num, expected) => {
   expect(ArmstrongNumber(num)).toBe(expected)