Everything

Author: philmander

.gitignore

@@ -0,0 +1,51 @@
+# Created by .ignore support plugin (hsz.mobi)
+### Node template
+# Logs
+logs
+*.log
+npm-debug.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (http://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules
+jspm_packages
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+

package.json

@@ -0,0 +1,15 @@
+{
+  "name": "typescript-algorithms",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "benchmark": "^2.1.2",
+    "chart": "github:jstrace/chart"
+  }
+}

src/big-o/o-1.js

@@ -0,0 +1,22 @@
+import { generateArray, runBenchmark } from '../helpers';
+let arrays = [
+    generateArray(10),
+    generateArray(20),
+    generateArray(30),
+    generateArray(40),
+    generateArray(50),
+    generateArray(60),
+    generateArray(70),
+    generateArray(80),
+    generateArray(90),
+    generateArray(100)
+];
+//O(1)
+function biggerThan(numbers, biggerThan) {
+    return numbers.length > biggerThan;
+}
+const suite = new Benchmark.Suite('O(1) will always execute in the same time regardless of the input size:');
+for (let i = 0; i < arrays.length; i++) {
+    suite.add(`${arrays[i].length}`, () => biggerThan(arrays[i], 1));
+}
+runBenchmark(suite);

src/big-o/o-1.ts

@@ -0,0 +1,26 @@
+import Benchmark = require('benchmark');
+import { generateArray, runBenchmark } from '../helpers';
+
+let arrays = [
+    generateArray(10),
+    generateArray(20),
+    generateArray(30),
+    generateArray(40),
+    generateArray(50),
+    generateArray(60),
+    generateArray(70),
+    generateArray(80),
+    generateArray(90),
+    generateArray(100)
+];
+
+//O(1)
+function biggerThan(numbers:Array<number>, biggerThan:number): boolean {
+    return numbers.length > biggerThan;
+}
+
+const suite = new Benchmark.Suite('O(1) will always execute in the same time regardless of the input size:');
+for(let i = 0; i < arrays.length; i++) {
+    suite.add(`${arrays[i].length}`, () => biggerThan(arrays[i], 1));
+}
+runBenchmark(suite);

src/big-o/o-2n.js

@@ -0,0 +1,16 @@
+import { runBenchmark } from '../helpers';
+let arrays = [
+    1, 2, 3, 4, 5, 6
+];
+//O(2n)
+function fibonacci(num) {
+    if (num <= 1) {
+        return num;
+    }
+    return fibonacci(num - 2) + fibonacci(num - 1);
+}
+const suite = new Benchmark.Suite('O(2^n) will perform in exponentially in proportion to size of the data set');
+for (let i = 0; i < arrays.length; i++) {
+    suite.add(`${arrays[i]}`, () => fibonacci(arrays[i]));
+}
+runBenchmark(suite);

src/big-o/o-2n.ts

@@ -0,0 +1,21 @@
+import Benchmark = require('benchmark');
+import { runBenchmark } from '../helpers';
+
+let arrays = [
+    1, 2, 3, 4, 5, 6
+];
+
+//O(2n)
+function fibonacci(num:number):number {
+    if (num <= 1) {
+        return num;
+    }
+    return fibonacci(num - 2) + fibonacci(num - 1);
+}
+
+const suite = new Benchmark.Suite('O(2^n) will perform in exponentially in proportion to size of the data set');
+for(let i = 0; i < arrays.length; i++) {
+    suite.add(`${arrays[i]}`, () => fibonacci(arrays[i]));
+}
+
+runBenchmark(suite);

src/big-o/o-logn.js

@@ -0,0 +1,21 @@
+import { generateArray, runBenchmark } from '../helpers';
+import binarySeach from '../binary-search/iterative';
+let arrays = [
+    generateArray(1000),
+    generateArray(2000),
+    generateArray(3000),
+    generateArray(4000),
+    generateArray(5000),
+    generateArray(6000),
+    generateArray(7000),
+    generateArray(8000),
+    generateArray(9000),
+    generateArray(10000)
+];
+//O(log(2, n)
+const suite = new Benchmark.Suite('O(2, n) will perform logarithmically in proportion to the size of the data set:');
+for (let i = 0; i < arrays.length; i++) {
+    let toFind = arrays[i][Math.round(arrays[i].length * 0.3)];
+    suite.add(`${arrays[i].length}`, () => binarySeach(toFind, arrays[i]));
+}
+runBenchmark(suite);

src/big-o/o-logn.ts

@@ -0,0 +1,23 @@
+import Benchmark = require('benchmark');
+import { generateArray, runBenchmark } from '../helpers';
+import  binarySeach  from '../binary-search/iterative';
+
+let arrays = [
+    generateArray(1000),
+    generateArray(2000),
+    generateArray(3000),
+    generateArray(4000),
+    generateArray(5000),
+    generateArray(6000),
+    generateArray(7000),
+    generateArray(8000),
+    generateArray(9000),
+    generateArray(10000)
+];
+//O(log(2, n)
+const suite = new Benchmark.Suite('O(2, n) will perform logarithmically in proportion to the size of the data set:');
+for(let i = 0; i < arrays.length; i++) {
+    let toFind = arrays[i][Math.round(arrays[i].length * 0.3)];
+    suite.add(`${arrays[i].length}`, () => binarySeach(toFind, arrays[i]));
+}
+runBenchmark(suite);

src/big-o/o-n.js

@@ -0,0 +1,27 @@
+import { generateArray, runBenchmark } from '../helpers';
+let arrays = [
+    generateArray(100),
+    generateArray(200),
+    generateArray(300),
+    generateArray(400),
+    generateArray(500),
+    generateArray(600),
+    generateArray(700),
+    generateArray(800),
+    generateArray(900),
+    generateArray(1000)
+];
+//O(n)
+function search(numbers, toFind) {
+    for (let i of numbers) {
+        if (toFind === i) {
+            return i;
+        }
+    }
+    return -1;
+}
+const suite = new Benchmark.Suite('O(n) will perform linearly in proportion to the size of the data set:');
+for (let i = 0; i < arrays.length; i++) {
+    suite.add(`${arrays[i].length}`, () => search(arrays[i], arrays[i][arrays[i].length - 1]));
+}
+runBenchmark(suite);

src/big-o/o-n.ts

@@ -0,0 +1,30 @@
+import Benchmark = require('benchmark');
+import { generateArray, runBenchmark } from '../helpers';
+
+let arrays = [
+    generateArray(100),
+    generateArray(200),
+    generateArray(300),
+    generateArray(400),
+    generateArray(500),
+    generateArray(600),
+    generateArray(700),
+    generateArray(800),
+    generateArray(900),
+    generateArray(1000)
+];
+//O(n)
+function search(numbers:Array<number>, toFind:number): number {
+    for(let i of numbers) {
+        if (toFind === i) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+const suite = new Benchmark.Suite('O(n) will perform linearly in proportion to the size of the data set:');
+for(let i = 0; i < arrays.length; i++) {
+    suite.add(`${arrays[i].length}`, () => search(arrays[i], arrays[i][arrays[i].length-1]));
+}
+runBenchmark(suite);

src/big-o/o-n2.js

@@ -0,0 +1,29 @@
+import { generateArray, runBenchmark } from '../helpers';
+let arrays = [
+    generateArray(11),
+    generateArray(21),
+    generateArray(31),
+    generateArray(41),
+    generateArray(51),
+    generateArray(61),
+    generateArray(71),
+    generateArray(81),
+    generateArray(91)
+];
+//O(n^2)
+function searchForProduct(numbers, moreNumbers, toFind) {
+    for (let i of numbers) {
+        for (let j of moreNumbers) {
+            if (i * j === toFind) {
+                return [i, j];
+            }
+        }
+    }
+    return [-1, -1];
+}
+const suite = new Benchmark.Suite('O(n^2) will perform in proportion to the square of the data set');
+for (let i = 0; i < arrays.length; i++) {
+    let toFind = arrays[i][arrays[i].length - 1] * arrays[i][arrays[i].length - 1];
+    suite.add(`${arrays[i].length}`, () => searchForProduct(arrays[i], arrays[i].slice(0), toFind));
+}
+runBenchmark(suite);

src/big-o/o-n2.ts

@@ -0,0 +1,33 @@
+import Benchmark = require('benchmark');
+import { generateArray, runBenchmark } from '../helpers';
+
+let arrays = [
+    generateArray(11),
+    generateArray(21),
+    generateArray(31),
+    generateArray(41),
+    generateArray(51),
+    generateArray(61),
+    generateArray(71),
+    generateArray(81),
+    generateArray(91)
+];
+
+//O(n^2)
+function searchForProduct(numbers:Array<number>, moreNumbers:Array<number>, toFind:number):Array<number> {
+    for(let i of numbers) {
+        for(let j of moreNumbers) {
+            if(i * j === toFind) {
+                return [i, j];
+            }
+        }
+    }
+    return [-1, -1];
+}
+
+const suite = new Benchmark.Suite('O(n^2) will perform in proportion to the square of the data set');
+for(let i = 0; i < arrays.length; i++) {
+    let toFind = arrays[i][arrays[i].length-1] * arrays[i][arrays[i].length-1];
+    suite.add(`${arrays[i].length}`, () => searchForProduct(arrays[i], arrays[i].slice(0), toFind));
+}
+runBenchmark(suite);

src/binary-search/iterative.js

@@ -0,0 +1,36 @@
+'use strict';
+import { runBenchmark } from '../helpers';
+import { generateArray } from './random';
+let arrays = [
+    generateArray(1000, 1, 1000),
+    generateArray(2000, 1, 2000),
+    generateArray(3000, 1, 3000),
+    generateArray(4000, 1, 4000),
+    generateArray(5000, 1, 5000)
+];
+export default function binarySearch(key, arr, sorted = false) {
+    if (!sorted) {
+        arr.sort((a, b) => a - b);
+    }
+    let lo = 0;
+    let hi = arr.length - 1;
+    while (lo <= hi) {
+        let mid = lo + (Math.floor((hi - lo) / 2));
+        if (key < arr[mid]) {
+            hi = mid - 1;
+        }
+        else if (key > arr[mid]) {
+            lo = mid + 1;
+        }
+        else {
+            return mid;
+        }
+    }
+    return -1;
+}
+const suite = new Benchmark.Suite('Binary search (iterative implementation)');
+for (let i = 0; i < arrays.length; i++) {
+    let toFind = arrays[i][Math.floor(arrays[i].length * 0.3)];
+    suite.add(`${arrays[i].length}`, () => binarySearch(toFind, arrays[i], true));
+}
+runBenchmark(suite);