git migration

README.md

@@ -1,2 +1,35 @@
-# leetcode
+# Leetcode Solutions
 
+Collection of submitted (accepted) leetcode solutions
+
+# Easy
+
+  Two Sum
+
+  Reverse Integer
+  
+  Palindrome Number
+  
+  Roman to Integer
+
+
+# Medium
+
+  Add Two Numbers
+  
+  Longest Substring Without Repeating Characters
+  
+  Longest Palindromatic Substring
+  
+  ZigZag Conversion
+  
+  String to Integer
+  
+  Container With Most Water
+  
+  Integer to Roman
+
+
+# Hard
+
+  Median of Two Sorted Arrays

easy/palindromeNumber.js

@@ -0,0 +1,46 @@
+/**
+ * @param {number} x
+ * @return {boolean}
+ */
+var isPalindrome = function(x) {
+  
+  if (x < 0 || x === null){
+    return false;
+  }
+  
+  let s = x.toString(10);
+  
+  if (s.length % 2 === 0){
+    return validPalindrome(s, true);
+  } else {
+    return validPalindrome(s, false);
+  }
+};
+
+function validPalindrome(s, even){
+  
+  let valid = false;
+  
+  //Start as same char for odd lengths
+  let i = Math.floor(s.length / 2);
+  let j = i;
+  
+  //Middle is between chars for even lengths
+  if (even){
+    //Start i to the left of j
+    --i;
+  }
+  
+  while(i >= 0 && j < s.length){
+    if (s.charAt(i) === s.charAt(j)){
+      valid = true;
+      --i;
+      ++j;
+    } else {
+      valid = false;
+      break;
+    }
+  }
+  
+  return valid;
+}

easy/removeElement.js

@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @param {number} val
+ * @return {number}
+ */
+var removeElement = function(nums, val) {
+  for (let i = 0; i < nums.length; ++i){
+    if (nums[i] === val){
+      nums.splice(i,1);
+      --i;
+    }
+  }
+  
+  return nums.length;
+};

easy/reverseInteger.js

@@ -0,0 +1,47 @@
+/**
+ * @param {number} x
+ * @return {number}
+ */
+var reverse = function(x) {
+  var sign = 1;
+  var magnitude = 1;
+  var reverse = 0;
+  var digits = [];
+  
+  if (x < 0){
+    sign = -1;
+    x = x * sign;
+  }
+  
+  if (x === 0){
+    return reverse;
+  }
+  
+  while (x > 0){
+    digits.push(getTensDigit(x));
+    x = popDigit(x);
+  }
+  
+  for (var i = digits.length -1; i >= 0; --i){
+    reverse += (digits[i] * magnitude);
+    magnitude *= 10;
+  }
+  
+  if (reverse > 2147483647){
+    return 0;
+  }
+  
+  reverse = reverse * sign;
+  
+  return reverse;
+};
+
+function getTensDigit(value){
+  var digit = value % 10;
+  return digit;
+}
+
+function popDigit(value){
+  value = Math.floor(value / 10);
+  return value;
+}

easy/romanToInteger.js

@@ -0,0 +1,28 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+
+var romanToInt = function(s) {
+  let numerals = {};
+  numerals['M'] = 1000;
+  numerals['D'] = 500;
+  numerals['C'] = 100;
+  numerals['L'] = 50;
+  numerals['X'] = 10;
+  numerals['V'] = 5;
+  numerals['I'] = 1;
+  
+  let number = 0;
+  
+  for (let i = 0; i < s.length; ++i){
+    let inRange = (i+1 < s.length);
+    if (numerals[s.charAt(i+1)] > numerals[s.charAt(i)]){
+      number -= numerals[s.charAt(i)];
+    } else {
+      number += numerals[s.charAt(i)];
+    }
+  }
+  
+  return number;
+};

easy/twoSum.js

@@ -0,0 +1,13 @@
+var twoSum = function(nums, target) {
+  var i = 0;
+  var j = 0;
+  for (i = nums.length-1; i >= 0; i--){
+    for (j = i-1; j >= 0; j--){
+      if (nums[i] + nums[j] === target){
+        return [j, i];
+      }
+    }
+  }
+    
+  return null;
+};

hard/medianOfSortedArrays.js

@@ -0,0 +1,47 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+var findMedianSortedArrays = function(nums1, nums2) {
+  
+  var merged = mergeSortedArrays(nums1, nums2);
+  var median = 0;
+  
+  if (merged.length % 2 === 0){
+    var index1 = Math.floor( (merged.length-1) / 2);
+    var index2 = index1 + 1;
+    median = ( (merged[index1] + merged[index2]) / 2);
+  } else {
+    var index = Math.floor( (merged.length) / 2);
+    median = merged[index];
+  }
+  
+  return median;
+  
+};
+
+function mergeSortedArrays(sorted1, sorted2){
+  
+  var merged = [];
+  
+  while(sorted1.length > 0 || sorted2.length > 0){
+    if (sorted1.length === 0){
+      merged.push(sorted2.shift());
+      continue;
+    }
+    
+    if (sorted2.length === 0){
+      merged.push(sorted1.shift());
+      continue;
+    }
+    
+    if (sorted1[0] > sorted2[0]){
+      merged.push(sorted2.shift());
+    } else {
+      merged.push(sorted1.shift());
+    }
+  }
+  
+  return merged;
+}

medium/addTwoNumbers.js

@@ -0,0 +1,77 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+var addTwoNumbers = function(l1, l2) {
+  
+  var carry = 0;
+  var sum;
+  var startNode = null;
+  var prevNode = null;
+  var node = null;
+  
+  while(true){
+    
+    if (l1 !== null){
+      if (l2 !== null){
+        sum = l1.val + l2.val + carry;
+      } else {
+        sum = l1.val + carry;
+      }
+    } else {
+      if (l2 === null){
+        break;
+      } else {
+        sum = l2.val + carry;
+      }
+    }
+    
+    if (sum >= 10){
+      sum = sum - 10;
+      carry = 1;
+    } else {
+      carry = 0;
+    }
+    
+    node = {
+      val: sum,
+      next: null
+    }
+    
+    if (prevNode !== null){
+      prevNode.next = node;
+    }
+    
+    if (startNode === null){
+      startNode = node;
+    }
+    
+    prevNode = node;
+    if (l1 !== null){
+      l1 = l1.next;
+    }
+    if (l2 !== null){
+      l2 = l2.next;
+    }
+    
+  }
+  
+  if (carry === 1){
+    node = {
+      val: 1,
+      next: null
+    }
+    
+    prevNode.next = node;
+  }
+  
+  return startNode;
+};

medium/containerWithMostWater.js

@@ -0,0 +1,35 @@
+/**
+ * @param {number[]} height
+ * @return {number}
+ */
+
+/*
+  volume = maxHeight * distance
+*/
+var maxArea = function(height) {
+  let maxVolume = 0;
+  let maxA = 0;
+  let maxB = 1;
+  
+  for (let i = 0; i < height.length -1; ++i){
+    for (let j = i+1; j < height.length; ++j){
+      let volume = getVolume(height[i], height[j], j - i);
+
+      if (volume > maxVolume){
+        maxVolume = volume;
+        maxA = i;
+        maxB = j;
+      }
+    }
+  }
+  
+  return maxVolume;
+};
+
+function getVolume(a, b, distance){
+  let height = Math.min(a, b);
+  
+  let volume = height * distance;
+  
+  return volume;
+}

medium/integerToRoman.js

@@ -0,0 +1,55 @@
+/**
+ * @param {number} num
+ * @return {string}
+ */
+var intToRoman = function(num) {
+  //1499
+  let roman = '';
+  
+  while (num > 0){
+    
+    if (num >= 1000){
+      num -= 1000;
+      roman += ('M');
+    } else if (num >= 900){
+      num -= 900;
+      roman += ('CM');
+    } else if (num >= 500){
+      num -= 500;
+      roman += ('D');
+    } else if (num >= 400){
+      num -= 400;
+      roman += ('CD');
+    } else if (num >= 100){
+      num -= 100;
+      roman += ('C');
+    } else if (num >= 90){
+      num -= 90;
+      roman += ('XC');
+    } else if (num >= 50){
+      num -= 50;
+      roman += ('L');
+    } else if (num >= 40){
+      num -= 40;
+      roman += ('XL');
+    } else if (num >= 10){
+      num -= 10;
+      roman += ('X');
+    } else if (num >= 9){
+      num -= 9;
+      roman += ('IX');
+    } else if (num >= 5){
+      num -= 5;
+      roman += ('V');
+    } else if (num >= 4){
+      num -= 4;
+      roman += ('IV');
+    } else if (num >= 1){
+      num -= 1;
+      roman += ('I');
+    }
+  }
+  
+  return roman;
+    
+};

medium/longestPalindromaticSubString.js

@@ -0,0 +1,40 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var longestPalindrome = function(s) {
+  if (s === null || s.length < 1){
+    return "";
+  }
+  
+  if (s.length === 1){
+    return s;
+  }
+  
+  let start = 0;
+  let end = 0;
+  
+  for (let i = 0; i < s.length; i++){
+    let len1 = expandAroundCenter(s, i, i);
+    let len2 = expandAroundCenter(s, i, i + 1);
+    let len = Math.max(len1, len2);
+    if (len > end - start) {
+      start = Math.round(i - (len - 1) / 2);
+      end = i + len / 2;
+    }
+  }
+  
+  return s.substring(start, end+1)
+};
+
+function expandAroundCenter(s, left, right) {
+  let L = left;
+  let R = right;
+  
+  while (L >= 0 && R < s.length && s.charAt(L) === s.charAt(R)){
+    L--;
+    R++;
+  }
+  
+  return R - L - 1;
+}

medium/longestSubStringWithoutRepeats.js

@@ -0,0 +1,28 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var lengthOfLongestSubstring = function(s) {
+  let n = s.length;
+  
+  let charSet = new Set();
+  
+  let longest = 0;
+  let i = 0;
+  let j = 0;
+  
+  while (i < n && j < n){
+    if (!charSet.has(s.charAt(j))){
+      charSet.add(s.charAt(j));
+      ++j;
+      if (j - i > longest){
+        longest = j - i;
+      }
+    } else {
+      charSet.delete(s.charAt(i));
+      ++i;
+    }
+  }
+  
+  return longest;
+};

medium/stringToInteger.js

@@ -0,0 +1,88 @@
+/**
+ * @param {string} str
+ * @return {number}
+ */
+
+const numeric = /^[0-9]+$/;
+
+var myAtoi = function(str) {
+  let value = 0;
+  let number = "";
+  
+  if (str === null || str === ""){
+    return value;
+  }
+  
+  let validNumber = true;
+  let positive = true;
+  let startParsing = false;
+  
+  for (let i = 0; i < str.length; ++i){
+    
+    let isSpace = /\s/.test(str.charAt(i));
+    let isNegative = (str.charAt(i) === '-');
+    let isPositive = (str.charAt(i) === '+');
+    let isNumeric = (numeric.test(str.charAt(i)));
+    
+    let validChar = (isSpace || isNegative || isPositive || isNumeric);
+    
+    if (validChar){
+      if (isNegative){
+        if (startParsing){
+          break;
+        }
+        positive = false;
+        startParsing = true;
+      }
+      
+      if (isPositive){
+        if (startParsing){
+          break;
+        }
+        positive = true;
+        startParsing = true;
+      }
+      
+      if (isSpace){
+        if (startParsing){
+          break;
+        }
+      }
+      
+      if (isNumeric){
+        number += str.charAt(i);
+        startParsing = true;
+      }
+    } else {
+      if (!startParsing){
+        validNumber = false;
+      }
+      break;
+    }
+  }
+  
+  if (validNumber){
+    
+    if (number.length === 0){
+      return 0;
+    }
+  
+    let output = parseInt(number, 10);
+    
+    if (output >= 2147483648){
+      if (positive){
+        output = 2147483647;
+      } else {
+       output = 2147483648; 
+      }
+    }
+    
+    if (!positive){
+      output *= -1;
+    }
+
+    return output;
+  } else {
+    return 0;
+  }
+};

medium/zigZagConversion.js

@@ -0,0 +1,26 @@
+/**
+ * @param {string} s
+ * @param {number} numRows
+ * @return {string}
+ */
+
+var convert = function(s, numRows) {
+  if (numRows === 1){
+    return s;
+  }
+  
+  let output = "";
+  let n = s.length;
+  let cycleLen = 2 * numRows - 2;
+  
+  for (let i = 0; i < numRows; i++){
+    for (let j = 0; j + i < n; j += cycleLen) {
+      output += s.charAt(j+i);
+      if (i !== 0 && i !== numRows-1 && j + cycleLen - i < n){
+        output += s.charAt(j + cycleLen -i);
+      }
+    }
+  }
+  
+  return output;
+};