merge javascript leetcode exercises into the repository

Author: mnikander

javascript/README.md

@@ -0,0 +1,24 @@
+# Learning Javascript
+
+A collection of leetcode solutions in JavaScript.
+The emphasis is NOT on efficient solutions, but on learning the basics of JavaScript.
+The code was run locally using nodejs.
+
+## Getting started
+
+System dependencies:
+```bash
+sudo apt install nodejs npm
+```
+
+```bash
+git clone ...  # this repo
+cd leetcode_js
+npm run hello  # run the hello_world example
+npm test       # execute unit tests
+```
+
+## Learning resources
+- More info on [unit testing in nodejs](https://nodejs.org/api/test.html)
+- [W3 schools JavaScript tutorial](https://www.w3schools.com/js/default.asp)
+- [W3 schools JavaScript language reference](https://www.w3schools.com/jsref/default.asp)

javascript/package-lock.json

@@ -0,0 +1,25 @@
+{
+  "name": "leetcode_javascript",
+  "version": "1.0.0",
+  "description": "",
+  "main": "src/hello_world.js",
+  "scripts": {
+    "hello": "node src/hello_world.js",
+    "test":  "node --test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mnikander/leetcode_javascript.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/mnikander/leetcode_javascript/issues"
+  },
+  "homepage": "https://github.com/mnikander/leetcode_javascript#readme",
+  "dependencies": {
+    "node-assert": "^0.0.1",
+    "node-test": "^1.4.6"
+  }
+}

javascript/package.json

@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function(nums, target) {
+    for(let i = 0; i < nums.length; i++) {
+        for (let j = i+1; j < nums.length; j++) {
+            let sum = nums[i] + nums[j];
+            if (sum == target) {
+                return [i, j];
+            }
+        }
+    }
+};
+
+let r1 = twoSum([2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41], 42);
+console.log(r1[0] + " " + r1[1]);
+
+let r2 = twoSum([2, 1, 11, 7, 5, 3], 4)
+console.log(r2[0] + " " + r2[1]);

javascript/src/0001-two-sum.js

@@ -0,0 +1,18 @@
+/**
+ * @param {number} x
+ * @return {boolean}
+ */
+var isPalindrome = function(x) {
+    let str = "" + x;
+    for (let i = 0; i < str.length / 2; i++) {
+        if (str[i] != str[str.length - i - 1]) {
+            return false;
+        }
+    }
+    return true;
+};
+
+console.log(isPalindrome(22));
+console.log(isPalindrome(242));
+console.log(isPalindrome(13));
+console.log(isPalindrome(133));

javascript/src/0009-palindrome.js

@@ -0,0 +1,36 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var romanToInt = function(s) {
+    let unigrams = {M: 1000, D: 500, C: 100, L: 50, X: 10, V: 5, I: 1};
+    let bigrams  = {CM: 900, CD: 400, XC: 90, XL: 40, IX: 9, IV: 4};
+
+    let sum = 0;
+    let i = 0;
+
+    while (i < s.length) {
+        let oneChar  = s[i];
+        let twoChars = "";
+        if (i < s.length - 1) {
+            twoChars = s[i] + s[i+1];
+        }
+
+        if (bigrams[twoChars] != undefined) {
+            sum = sum + bigrams[twoChars];
+            i = i + 2;
+        }
+        else {
+            sum = sum + unigrams[oneChar];
+            i = i + 1;
+        }
+    }
+
+    // console.log(s + " = " + sum);
+    return sum;
+};
+
+module.exports = { romanToInt };
+
+// Notes:
+// - since the input consists of valid roman numerals, we don't need to worry about things like VV == X or LL == C

javascript/src/0013-roman-to-integer.js

@@ -0,0 +1,37 @@
+isMatch = (leftChar, rightChar) => {
+    return (leftChar == '(' && rightChar == ')')
+        || (leftChar == '[' && rightChar == ']')
+        || (leftChar == '{' && rightChar == '}');
+}
+
+isOpening = (parenthesis) => {
+    return parenthesis == '(' || parenthesis == '[' || parenthesis == '{';
+}
+
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isValid = function(s) {
+    const stack = [];
+    
+    for (let i = 0; i < s.length; i++)
+    {
+        let parenthesis = s.charAt(i);
+        if(isOpening(parenthesis)) {
+            stack.push(parenthesis);
+        }
+        else if (stack.length == 0) {
+            return false;
+        }
+        else {
+            let predecessor = stack.pop();
+            if(!isMatch(predecessor, parenthesis)) {
+                return false;
+            }
+        }
+    }
+    return stack.length == 0;
+};
+
+module.exports = { isValid };

javascript/src/0020-valid-parentheses.js

@@ -0,0 +1 @@
+console.log('Hello, Node.js');

javascript/src/hello_world.js

@@ -0,0 +1,45 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const { romanToInt } = require('../src/0013-roman-to-integer')
+
+test('roman to integer, 1-20', (t) => {
+    assert.strictEqual(romanToInt("I")    ,  1);
+    assert.strictEqual(romanToInt("II")   ,  2);
+    assert.strictEqual(romanToInt("III")  ,  3);
+    assert.strictEqual(romanToInt("IV")   ,  4);
+    assert.strictEqual(romanToInt("V")    ,  5);
+    assert.strictEqual(romanToInt("VI")   ,  6);
+    assert.strictEqual(romanToInt("VII")  ,  7);
+    assert.strictEqual(romanToInt("VIII") ,  8);
+    assert.strictEqual(romanToInt("IX")   ,  9);
+    assert.strictEqual(romanToInt("X")    , 10);
+    assert.strictEqual(romanToInt("XI")   , 11);
+    assert.strictEqual(romanToInt("XII")  , 12);
+    assert.strictEqual(romanToInt("XIII") , 13);
+    assert.strictEqual(romanToInt("XIV")  , 14);
+    assert.strictEqual(romanToInt("XV")   , 15);
+    assert.strictEqual(romanToInt("XVI")  , 16);
+    assert.strictEqual(romanToInt("XVII") , 17);
+    assert.strictEqual(romanToInt("XVIII"), 18);
+    assert.strictEqual(romanToInt("XIX")  , 19);
+    assert.strictEqual(romanToInt("XX")   , 20);
+});
+
+test('roman to integer, unigrams', (t) => {
+    assert.strictEqual(romanToInt("I"),    1);
+    assert.strictEqual(romanToInt("V"),    5); // no repitition or prefixing of V is allowed
+    assert.strictEqual(romanToInt("X"),   10);
+    assert.strictEqual(romanToInt("L"),   50); // no repitition or prefixing of L is allowed
+    assert.strictEqual(romanToInt("C"),  100);
+    assert.strictEqual(romanToInt("D"),  500); // no repitition or prefixing of D is allowed
+    assert.strictEqual(romanToInt("M"), 1000);
+});
+
+test('roman to integer, bigrams', (t) => {
+    assert.strictEqual(romanToInt("IV"),    4);
+    assert.strictEqual(romanToInt("IX"),    9);
+    assert.strictEqual(romanToInt("XL"),   40);
+    assert.strictEqual(romanToInt("XC"),   90);
+    assert.strictEqual(romanToInt("CD"),  400);
+    assert.strictEqual(romanToInt("CM"),  900);
+});

javascript/test/0013-roman-to-integer.test.js

@@ -0,0 +1,47 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const { isValid } = require('../src/0020-valid-parentheses')
+
+test('valid parenthesis, empty', (t) => {
+    assert.strictEqual(isValid(""), true);
+});
+
+test('valid parenthesis, simple parenthesis', (t) => {
+    assert.strictEqual(isValid("()"), true);
+});
+
+test('valid parenthesis, each kind', (t) => {
+    assert.strictEqual(isValid("()[]{}"), true);
+});
+
+test('valid parenthesis, nested', (t) => {
+    assert.strictEqual(isValid("([])"), true);
+});
+
+test('valid parenthesis, deeply nested', (t) => {
+    assert.strictEqual(isValid("([](){()})"), true);
+});
+
+test('valid parenthesis, simple unclosed', (t) => {
+    assert.strictEqual(isValid("("), false);
+});
+
+test('valid parenthesis, nested unclosed', (t) => {
+    assert.strictEqual(isValid("{(}"), false);
+});
+
+test('valid parenthesis, mismatch', (t) => {
+    assert.strictEqual(isValid("(]"), false);
+});
+
+test('valid parenthesis, nested mismatch', (t) => {
+    assert.strictEqual(isValid("([](])"), false);
+});
+
+test('valid parenthesis, reversed order', (t) => {
+    assert.strictEqual(isValid(")("), false);
+});
+
+test('valid parenthesis, interleaved order', (t) => {
+    assert.strictEqual(isValid("([)]"), false);
+});