Merge branch 'TheAlgorithms:master' into master

Author: zFlxw

DIRECTORY.md

@@ -29,6 +29,7 @@
   * [Is Even](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/is_even.ts)
   * [Is Leap Year](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/is_leap_year.ts)
   * [Is Odd](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/is_odd.ts)
+  * [Is Palindrome](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/is_palindrome.ts)
   * [Is Square Free](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/is_square_free.ts)
   * [Lowest Common Multiple](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/lowest_common_multiple.ts)
   * [Perfect Square](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/perfect_square.ts)

Maths/CalculateMedian.ts

@@ -0,0 +1,25 @@
+/**
+ * @function calculateMedian
+ * @description This function will find the median value of an array of numbers.
+ * @param {number[]} numbers Sorted array of numeric values.
+ * @return {number} The median of input numbers.
+ * @see https://en.wikipedia.org/wiki/Median
+ * @example calculateMedian([1, 2, 4, 5, 8]) = 4
+ * @example calculateMedian([1, 2, 4, 5]) = 3
+ */
+
+export const calculateMedian = (numbers: number[]): number => {
+    if (numbers.length < 1) {
+        throw new TypeError("Input array must contain at least one number.");
+    }
+
+    const totalNumbers = numbers.length;
+
+    if (totalNumbers % 2 === 0) {
+        let index = totalNumbers / 2;
+        return (numbers[index - 1] + numbers[index]) / 2;
+    } else {
+        let index = (totalNumbers + 1) / 2;
+        return numbers[index - 1];
+    }
+};

Maths/test/CalculateMedian.test.ts

@@ -0,0 +1,23 @@
+import { calculateMedian } from "../CalculateMedian";
+
+describe("Tests for CalculateMedian", () => {
+    it("should be a function", () => {
+        expect(typeof calculateMedian).toEqual("function");
+    });
+
+    it("should throw error for invalid input", () => {
+        expect(() => calculateMedian([])).toThrowError(
+            "Input array must contain at least one number."
+        );
+    });
+
+    it("should return the median of an array of numbers - even length", () => {
+        const medianFunction = calculateMedian([1, 2, 3, 4]);
+        expect(medianFunction).toBe(2.5);
+    });
+
+    it("should return the median of an array of numbers - odd length", () => {
+        const medianFunction = calculateMedian([1, 2, 3, 4, 6, 8, 9]);
+        expect(medianFunction).toBe(4);
+    });
+});

data_structures/doubly_linked_list.ts renamed to data_structures/list/doubly_linked_list.ts

@@ -0,0 +1,24 @@
+import { DoublyLinkedList } from "../doubly_linked_list";
+import { testLinkedList } from "./linked_list";
+
+describe("DoublyLinkedList", () => {
+    testLinkedList(DoublyLinkedList);
+
+    it("should reverse the list", () => {
+        const list: DoublyLinkedList<number> = new DoublyLinkedList<number>();
+
+        list.append(1);
+        list.append(2);
+        list.append(3);
+        list.reverse();
+
+        expect(list.get(0)).toBe(3);
+        expect(list.get(1)).toBe(2);
+    });
+
+    it("should return null for reverse when list is empty", () => {
+        const list: DoublyLinkedList<number> = new DoublyLinkedList<number>();
+
+        expect(list.reverse()).toBeNull();
+    });
+});

data_structures/linked_list.ts renamed to data_structures/list/linked_list.ts

@@ -1,4 +1,4 @@
-import { Map } from "../map";
+import { Map } from "./map";
 
 /**
  * Represents a hash map.

data_structures/singly_linked_list.ts renamed to data_structures/list/singly_linked_list.ts

@@ -1,4 +1,4 @@
-import { HashMapEntry } from "./hashing/hash_map";
+import { HashMapEntry } from "./hash_map";
 
 /**
  * This interface is a representation of the Map data structure.

data_structures/list/test/doubly_linked_list.test.ts

@@ -1,4 +1,4 @@
-import { HashMap } from "../hash_map";
+import { HashMap } from "../../map/hash_map";
 
 describe("Hash Map", () => {
     let hashMap: HashMap<string, number>;

data_structures/test/linked_list.ts renamed to data_structures/list/test/linked_list.ts

@@ -0,0 +1,109 @@
+/**
+ * Circular Queue implementation using array.
+ *
+ * @template T The type of the elements in the queue.
+ * @param {T[]} queue The array that holds the elements of the queue.
+ * @param {number} frontIndex The index of the front element of the queue.
+ * @param {number} rearIndex The index of the rear element of the queue.
+ * @param {number} size The size of the queue.
+ */
+export class CircularQueue<T> {
+    private queue: T[];
+    private frontIndex: number;
+    private rearIndex: number;
+    private size: number;
+
+    constructor(size: number) {
+        this.queue = new Array(size);
+        this.frontIndex = -1;
+        this.rearIndex = -1;
+        this.size = size;
+    }
+
+    /**
+     * Adds an item to the queue.
+     *
+     * @param item The item being added to the queue.
+     */
+    enqueue(item: T): void {
+        if (
+            (this.frontIndex == 0 && this.rearIndex == this.size - 1) ||
+            this.rearIndex == (this.frontIndex - 1) % (this.size - 1)
+        ) {
+            throw new Error("Queue is full");
+        } else if (this.frontIndex == -1) {
+            this.frontIndex = 0;
+            this.rearIndex = 0;
+            this.queue[this.rearIndex] = item;
+        } else if (this.rearIndex == this.size - 1 && this.frontIndex != 0) {
+            this.rearIndex = 0;
+            this.queue[this.rearIndex] = item;
+        } else {
+            this.rearIndex++;
+            this.queue[this.rearIndex] = item;
+        }
+    }
+
+    /**
+     * Removes an item from the queue and returns it.
+     *
+     * @throws Queue Underflow if the queue is empty.
+     * @returns The item that was removed from the queue.
+     */
+    dequeue(): T | undefined {
+        if (this.frontIndex == -1) {
+            throw new Error("Queue is empty");
+        }
+
+        const item = this.queue[this.frontIndex];
+        if (this.frontIndex == this.rearIndex) {
+            this.frontIndex = -1;
+            this.rearIndex = -1;
+        } else if (this.frontIndex == this.size - 1) {
+            this.frontIndex = 0;
+        } else {
+            this.frontIndex++;
+        }
+
+        return item;
+    }
+
+    /**
+     * Returns the item at the front of the queue.
+     *
+     * @returns The item at the front of the queue or null if the queue is empty.
+     */
+    peek(): T | null | undefined {
+        if (this.frontIndex == -1) {
+            return null;
+        }
+
+        return this.queue[this.frontIndex];
+    }
+
+    /**
+     * Checks if the queue is empty.
+     *
+     * @returns {boolean} Whether the queue is empty or not.
+     */
+    isEmpty(): boolean {
+        return this.frontIndex == -1;
+    }
+
+    /**
+     * Returns the number of items in the queue.
+     *
+     * @returns {number} The number of items in the queue.
+     */
+    length(): number {
+        if (this.frontIndex == -1) {
+            return 0;
+        }
+
+        if (this.rearIndex >= this.frontIndex) {
+            return this.rearIndex - this.frontIndex + 1;
+        }
+
+        return this.size - (this.frontIndex - this.rearIndex - 1);
+    }
+}

data_structures/test/singly_linked_list.test.ts renamed to data_structures/list/test/singly_linked_list.test.ts

@@ -1,17 +1,16 @@
 /**
- * A Stack Based Queue Implementation. 
- * The Queue data structure which follows the FIFO (First in First Out) rule. 
- * The dequeue operation in a normal stack based queue would be o(n), as the entire has to be shifted 
- * With the help of two stacks, the time complexity of this can be brought down to amortized-O(1). 
- * Here, one stack acts as an Enqueue stack where elements are added. 
+ * A Stack Based Queue Implementation.
+ * The Queue data structure which follows the FIFO (First in First Out) rule.
+ * The dequeue operation in a normal stack based queue would be o(n), as the entire has to be shifted
+ * With the help of two stacks, the time complexity of this can be brought down to amortized-O(1).
+ * Here, one stack acts as an Enqueue stack where elements are added.
  * The other stack acts as a dequeue stack which helps in dequeuing the elements
  */
 
-import { Queue } from './queue';
-import { Stack } from './stack';
-
-export class StackQueue<T> implements Queue<T>{
+import { Stack } from "../stack/stack";
+import { Queue } from "./queue";
 
+export class StackQueue<T> implements Queue<T> {
     private enqueueStack: Stack<T> = new Stack<T>();
     private dequeueStack: Stack<T> = new Stack<T>();
 
@@ -44,7 +43,7 @@ export class StackQueue<T> implements Queue<T>{
 
     /**
      * Shifts the elements from the enqueueStack to the dequeueStack
-     * In the worst case, all the elements from the enqueue stack needs to shifted, which needs O(n) time. 
+     * In the worst case, all the elements from the enqueue stack needs to shifted, which needs O(n) time.
      * However, after the shift, elements can de dequeued at O(1).
      * This helps in dequeuing the elements in amortized O(1) time.
      */

data_structures/hashing/hash_map.ts renamed to data_structures/map/hash_map.ts

@@ -0,0 +1,65 @@
+import { CircularQueue } from "../circular_queue";
+
+describe("Circular Queue", () => {
+    let queue: CircularQueue<number>;
+
+    beforeEach(() => {
+        queue = new CircularQueue(5);
+    });
+
+    it("should enqueue an element", () => {
+        queue.enqueue(1);
+
+        expect(queue.peek()).toBe(1);
+    });
+
+    it("should throw an error on enqueue when queue is full", () => {
+        queue.enqueue(1);
+        queue.enqueue(2);
+        queue.enqueue(3);
+        queue.enqueue(4);
+        queue.enqueue(5);
+
+        expect(() => queue.enqueue(6)).toThrowError("Queue is full");
+    });
+
+    it("should dequeue an element", () => {
+        queue.enqueue(1);
+        queue.enqueue(2);
+
+        expect(queue.dequeue()).toBe(1);
+    });
+
+    it("should throw an error on dequeue when queue is empty", () => {
+        expect(() => queue.dequeue()).toThrowError("Queue is empty");
+    });
+
+    it("should peek an element", () => {
+        queue.enqueue(1);
+        queue.enqueue(2);
+
+        expect(queue.peek()).toBe(1);
+    });
+
+    it("should return null on peek when queue is empty", () => {
+        expect(queue.peek()).toBeNull();
+    });
+
+    it("should return true on isEmpty when queue is empty", () => {
+        expect(queue.isEmpty()).toBeTruthy();
+    });
+
+    it("should return false on isEmpty when queue is not empty", () => {
+        queue.enqueue(1);
+
+        expect(queue.isEmpty()).toBeFalsy();
+    });
+
+    it("should return the correct length", () => {
+        queue.enqueue(1);
+        queue.enqueue(2);
+        queue.enqueue(3);
+
+        expect(queue.length()).toBe(3);
+    });
+});

data_structures/map.ts renamed to data_structures/map/map.ts

@@ -1,4 +1,5 @@
 import { Queue } from '../queue';
+
 type QueueConstructor = new <T>() => Queue<T>
 export function testQueue(Queue: QueueConstructor) {
 	it("enqueue should add a new element to the queue", () => {

data_structures/hashing/test/hash_map.test.ts renamed to data_structures/map/test/hash_map.test.ts

@@ -1,6 +1,6 @@
-import { Map } from "../map";
-import { MapSet } from "../map_set";
-import { HashMap } from "./hash_map";
+import { Map } from "../map/map";
+import { HashMap } from "../map/hash_map";
+import { MapSet } from "./map_set";
 
 /**
  * This class is a representation of the Set data structure based on a hash map.

data_structures/array_queue.ts renamed to data_structures/queue/array_queue.ts

@@ -1,4 +1,4 @@
-import { SinglyLinkedList } from "./singly_linked_list";
+import { SinglyLinkedList } from "../list/singly_linked_list";
 
 /**
  * This is an implementation of a stack, based on a linked list.

data_structures/queue/circular_queue.ts

@@ -0,0 +1,21 @@
+/**
+ * A function to see if a number is a palindrome.
+ * Note that if the reversed number is larger than MAX_SAFE_INTEGER, rounding errors may occur and the result may be incorrect.
+ * Time Complexity: O(log(n))
+ *
+ * @param number The input number.
+ * @return {boolean} Wether the number is a Palindrome or not.
+ */
+export const IsPalindrome = (number: number): boolean => {
+    if (number < 0 || (number % 10 === 0 && number !== 0)) {
+        return false;
+    }
+
+    let reversed: number = 0;
+    while (number > reversed) {
+        reversed = reversed * 10 + (number % 10);
+        number = Math.floor(number / 10);
+    }
+
+    return number === reversed || number === Math.floor(reversed / 10);
+};

data_structures/linked_queue.ts renamed to data_structures/queue/linked_queue.ts

@@ -0,0 +1,10 @@
+import { IsPalindrome } from "../is_palindrome";
+
+describe("IsPalindrome", () => {
+  test.each([[5, true], [1234, false], [12321, true], [31343, false]])(
+    "correct output for %i",
+    (nums, expected) => {
+        expect(IsPalindrome(nums)).toBe(expected);
+      },
+  );
+});