14 changed files with 579 additions and 1 deletions
@ -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 |
|||
|
@ -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; |
|||
} |
@ -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; |
|||
}; |
@ -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; |
|||
} |
@ -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; |
|||
}; |
@ -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; |
|||
}; |
@ -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; |
|||
} |
@ -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; |
|||
}; |
@ -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; |
|||
} |
@ -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; |
|||
|
|||
}; |
@ -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; |
|||
} |
@ -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; |
|||
}; |
@ -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; |
|||
} |
|||
}; |
@ -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; |
|||
}; |
Loading…
Reference in new issue