d

.jest.config.json

@@ -2,7 +2,7 @@
     "clearMocks": true,
     "moduleNameMapper": {
         "@code/(.*)": [
-            "<rootDir>/src/day2/$1"
+            "<rootDir>/src/day1/$1"
         ]
     },
     "preset": "ts-jest"

package.json

@@ -14,7 +14,7 @@
         "typescript": "^4.7.4"
     },
     "scripts": {
-        "test": "jest DFSOnBST LRU LinearSearchList BinarySearchList TwoCrystalBalls BubbleSort DoublyLinkedList Queue Stack ArrayList MazeSolver QuickSort BTPreOrder BTInOrder BTPostOrder BTBFS CompareBinaryTrees DFSOnBST DFSGraphList Trie BFSGraphMatrix Map MinHeap",
+        "test": "jest DFSOnBST LRU LinearSearchList BinarySearchList TwoCrystalBalls BubbleSort SinglyLinkedList DoublyLinkedList Queue Stack ArrayList MazeSolver QuickSort BTPreOrder BTInOrder BTPostOrder BTBFS CompareBinaryTrees DFSOnBST DFSGraphList Trie BFSGraphMatrix Map MinHeap",
         "clear": "node ./scripts/clear.js",
         "prettier": "prettier --write ./src",
         "generate": "node ./scripts/generate.js",

src/__tests__/ListTest.ts

@@ -2,7 +2,7 @@ export function test_list(list: List<number>): void {
     list.append(5);
     list.append(7);
     list.append(9);
-
+    console.log('aaaaaaaaaaaaa', list)
     expect(list.get(2)).toEqual(9);
     expect(list.removeAt(1)).toEqual(7);
     expect(list.length).toEqual(2);

src/__tests__/Queue.ts

@@ -25,6 +25,7 @@ test("queue", function () {
 
     // just wanted to make sure that I could not blow up myself when i remove
     // everything
+
     list.enqueue(69);
     expect(list.peek()).toEqual(69);
     expect(list.length).toEqual(1);

src/day1/ArrayList.ts

@@ -0,0 +1,28 @@
+export default class ArrayList<T> {
+
+    public length: number;
+
+
+
+    constructor() {
+    }
+
+    prepend(item: T): void {
+
+}
+    insertAt(item: T, idx: number): void {
+
+}
+    append(item: T): void {
+
+}
+    remove(item: T): T | undefined {
+
+}
+    get(idx: number): T | undefined {
+
+}
+    removeAt(idx: number): T | undefined {
+
+}
+}

src/day1/BFSGraphMatrix.ts

@@ -0,0 +1,3 @@
+export default function bfs(graph: WeightedAdjacencyMatrix, source: number, needle: number): number[] | null {
+
+}

src/day1/BTBFS.ts

@@ -0,0 +1,3 @@
+export default function bfs(head: BinaryNode<number>, needle: number): boolean {
+
+}

src/day1/BTInOrder.ts

@@ -0,0 +1,3 @@
+export default function in_order_search(head: BinaryNode<number>): number[] {
+
+}

src/day1/BTPostOrder.ts

@@ -0,0 +1,3 @@
+export default function post_order_search(head: BinaryNode<number>): number[] {
+
+}

src/day1/BTPreOrder.ts

@@ -0,0 +1,3 @@
+export default function pre_order_search(head: BinaryNode<number>): number[] {
+
+}

src/day1/BinarySearchList.ts

@@ -0,0 +1,37 @@
+export default function bs_list(haystack: number[], needle: number  ): boolean {
+  let lo = 0;
+  let hi = haystack.length;
+  while (lo < hi) {
+    let me = Math.floor(lo + (hi - lo) / 2)
+    let med = haystack[me];
+    if (med === needle) {
+        return true
+    } else if (med < needle) {
+      lo = me + 1
+    } else  {
+      hi = me
+     }
+  }
+  return false
+}
+
+
+function binaryS(arr: number[], num: number) {
+  let left = 0;
+  let right = arr.length - 1;
+  //dont forget to sort
+
+  while (left < right) {
+    let middle = Math.floor(right - left) / 2;
+    let med = arr[middle];
+
+    if (num === med) {
+      return true;
+    } else if (num < med) {
+      right = middle - 1;
+    } else {
+      left = middle + 1
+    }
+  }
+  return false
+}

src/day1/BubbleSort.ts

@@ -0,0 +1,13 @@
+export default function bubble_sort(arr: number[]): number[] {
+
+  let length = arr.length
+  while (length) {
+    for (let i = 0; i < length; i++) {
+      if (arr[i] > arr[i + 1]) {
+        [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]]
+      }
+    }
+    length--
+  }
+  return arr
+}

src/day1/CompareBinaryTrees.ts

@@ -0,0 +1,3 @@
+export default function compare(a: BinaryNode<number> | null, b: BinaryNode<number> | null): boolean {
+
+}

src/day1/DFSGraphList.ts

@@ -0,0 +1,3 @@
+export default function dfs(graph: WeightedAdjacencyList, source: number, needle: number): number[] | null {
+
+}

src/day1/DFSOnBST.ts

@@ -0,0 +1,3 @@
+export default function dfs(head: BinaryNode<number>, needle: number): boolean {
+
+}

src/day1/DoublyLinkedList.ts

@@ -0,0 +1,118 @@
+type Node<T> = {
+    value: T,
+    prev?: Node<T>,
+    next?:Node<T>
+}
+
+
+export default class DoublyLinkedList<T> {
+
+    public length: number;
+    private head?: Node<T>
+    private tail?: Node<T>
+
+
+    constructor() {
+        this.length = 0;
+        this.head = undefined;
+        this.tail = undefined
+    }
+
+    prepend(item: T): void {
+    const node = {value: item } as Node<T>
+    if (!this.length) {
+        this.head = this.tail = node;
+        this.length++
+    } else {
+        (this.head) ? this.head.prev = node : undefined;
+        node.next = this.head;
+        this.head = node;
+        this.length++
+        return
+    }
+}
+    insertAt(item: T, idx: number): void {
+
+        if (idx > this.length) {
+            throw new Error('not valid');
+
+        } else if (idx === this.length) {
+            this.append(item);
+            return
+        } else if (idx === 0) {
+            this.prepend(item);
+            return
+        }
+          this.length++
+        let curr = this.head;
+
+        for (let i = 0; curr && i < idx; i++){
+            curr = curr.next
+        }
+        curr = curr as Node<T>;
+        const node = {value: item} as Node<T>
+        node.next = curr;
+        node.prev = curr.prev;
+        curr.prev = node
+
+        if (curr.prev) {
+            curr.prev.next = curr
+        }
+}
+    append(item: T): void {
+
+      this.length++;
+        const node = {value: item} as Node<T>
+        if (!this.tail) {
+            this.head = this.tail = node;
+            return
+        }
+        node.prev = this.tail;
+        this.tail.next = node;
+        this.tail = node
+
+}
+    remove(item: T): T | undefined {
+
+        let curr = this.head;
+        for (let i = 0; curr && i < this.length; i++){
+            if (curr.value === item) {
+                break;
+            }
+            curr = curr.next
+        }
+        if (!curr) {
+            return
+        }
+
+        if (this.length === 0) {
+            this.head = this.tail = undefined;
+            return
+        }
+
+        const previousNode = curr.prev;
+        const nextNode = curr.next;
+        const node: Node<T> = { value: previousNode?.value as T, prev: previousNode?.prev, next: nextNode }
+        this.head = node;
+        this.length--;
+
+
+
+}
+    get(idx: number): T | undefined {
+        return this.getAt(idx)?.value
+
+}
+    removeAt(idx: number): T | undefined {
+        const node = this.getAt(idx);
+        if (!node) {
+            return undefined;
+
+        }
+
+    }
+
+    private getAt(idx: number) {
+
+    }
+}

src/day1/LRU.ts

@@ -0,0 +1,15 @@
+export default class LRU<K, V> {
+    private length: number;
+
+
+
+    constructor() {
+    }
+
+    update(key: K, value: V): void {
+
+}
+    get(key: K): V | undefined {
+
+}
+}

src/day1/LinearSearchList.ts

@@ -0,0 +1,9 @@
+export default function linear_search(haystack: number[], needle: number): boolean {
+
+  for (let i = 0; i < haystack.length; i++){
+    if (needle === haystack[i]) {
+      return true
+    }
+  }
+  return false;
+}

src/day1/Map.ts

@@ -0,0 +1,21 @@
+export default class Map<T extends (string | number), V> {
+
+
+
+
+    constructor() {
+    }
+
+    get(key: T): V | undefined {
+
+}
+    set(key: T, value: V): void {
+
+}
+    delete(key: T): V | undefined {
+
+}
+    size(): number {
+
+}
+}

src/day1/MazeSolver.ts

@@ -0,0 +1,14 @@
+export default function solve(maze: string[], wall: string, start: Point, end: Point): Point[] {
+  //base case
+  //it is a wall, invalid
+  //off the map
+  //its the end
+  //if we have seen it before, we have already iterated there
+
+
+  if ()
+
+
+
+
+}

src/day1/MinHeap.ts

@@ -0,0 +1,15 @@
+export default class MinHeap {
+    public length: number;
+
+
+
+    constructor() {
+    }
+
+    insert(value: number): void {
+
+}
+    delete(): number {
+
+}
+}