some more problems

Author: Narahari-Sundaragopalan

carousel/carousel.md

@@ -0,0 +1,30 @@
+```html
+<div class="carousel slide" id="myCarousel" data-ride="carousel">
+	<ol class="carousel-indicators">
+		<li class="carousel-indicator active" data-slide-to="0" data-target="#myCarousel"></li>
+		<li class="carousel-indicator" data-slide-to="1" data-target="#myCarousel"></li>
+		<li class="carousel-indicator" data-slide-to="2" data-target="#myCarousel"></li>
+	</ol>
+
+	<div class="carousel-images-wrapper">
+		<div class="item active">
+			<img src="sweden.jpg" alt="View of Stockholm Sweden"/>
+		</div>
+		<div class="item">
+			<img src="norway.jpg" alt="Norway image"/>
+		</div>
+		<div class="item">
+			<img src="denmark.jpg" alt="Denmark image"/>
+		</div>
+	</div>
+
+	<a class="carousel-control" href="#myCarousel" data-slide="prev">
+		<span class="icon-left"></span>
+		<span class="control-text">Previous</span>
+	</a>
+	<a class="carousel-control" href="#myCarousel" data-slide="next">
+		<span class="icon-right"></span>
+		<span class="control-text">Next</span>
+	</a>
+</div>
+```

exercises/leetcode/groupAnagrams.js

@@ -0,0 +1,35 @@
+/**
+ * Given an array of strings, group anagrams together.
+
+Example:
+
+Input: ["eat", "tea", "tan", "ate", "nat", "bat"],
+Output:
+[
+  ["ate","eat","tea"],
+  ["nat","tan"],
+  ["bat"]
+]
+Note:
+
+All inputs will be in lowercase.
+The order of your output does not matter.
+ */
+
+
+const groupAnagrams = strs => {
+	// create a map with key as sorted char and value as the array of anagram word sets
+	const anagramMap = new Map();
+
+	for (let s of strs) {
+		let sortedChar = s.split('').sort().join('');
+
+		if (!anagramMap.has(sortedChar)) {
+			anagramMap.set(sortedChar, []);
+		}
+
+		anagramMap.get(sortedChar).push(s);
+	}
+
+	return Array.from(anagramMap.values());
+}

exercises/leetcode/setZeroes.js

@@ -0,0 +1,77 @@
+/**
+ * Given a m x n matrix, if an element is 0, set its entire row and column to 0. Do it in-place.
+
+Example 1:
+
+Input: 
+[
+  [1,1,1],
+  [1,0,1],
+  [1,1,1]
+]
+Output: 
+[
+  [1,0,1],
+  [0,0,0],
+  [1,0,1]
+]
+Example 2:
+
+Input: 
+[
+  [0,1,2,0],
+  [3,4,5,2],
+  [1,3,1,5]
+]
+Output: 
+[
+  [0,0,0,0],
+  [0,4,5,0],
+  [0,3,1,0]
+]
+Follow up:
+
+A straight forward solution using O(mn) space is probably a bad idea.
+A simple improvement uses O(m + n) space, but still not the best solution.
+Could you devise a constant space solution?
+ * @param {*} matrix 
+ */
+
+const setZeroes = matrix => {
+	let isCol = false;
+	const rows = matrix.length;
+	const columns = matrix[0].length;
+
+	for (let i = 0; i < rows; i++) {
+		if (matrix[i][0] === 0) {
+			isCol = true;
+		}
+
+		for (let j = 1; j < columns; j++) {
+			if (matrix[i][j] === 0) {
+				matrix[i][0] = 0;
+				matrix[0][j] = 0;
+			}
+		}
+	}
+
+	for (let i = 0; i < rows; i++) {
+		for (let j = 0; j < columns; j++) {
+			if (matrix[i][0] === 0 || matrix[0][j] === 0) {
+				matrix[i][j] = 0;
+			}
+		}
+	}
+
+	if (matrix[0][0] === 0) {
+		for (let i = 0; i < rows; i++) {
+			matrix[i][0] = 0;
+		}
+	}
+
+	if (isCol) {
+		for (let j = 0; j < columns; j++) {
+			matrix[0][j] = 0;
+		}
+	}
+}

exercises/leetcode/spiralMatrix.js

@@ -0,0 +1,86 @@
+/**
+ * Given a matrix of m x n elements (m rows, n columns), return all elements of the matrix in spiral order.
+
+Example 1:
+
+Input:
+[
+ [ 1, 2, 3 ],
+ [ 4, 5, 6 ],
+ [ 7, 8, 9 ]
+]
+Output: [1,2,3,6,9,8,7,4,5]
+Example 2:
+
+Input:
+[
+  [1, 2, 3, 4],
+  [5, 6, 7, 8],
+  [9,10,11,12]
+]
+Output: [1,2,3,4,8,12,11,10,9,5,6,7]
+ * @param {*} matrix 
+ */
+const spiralMatrix = matrix => {
+	const result = [];
+
+	if (matrix.length === 0) {
+		return [];
+	}
+
+	let startRow = 0;
+	let endRow = matrix.length - 1;
+	let startColumn = 0;
+	let endColumn = matrix[0].length - 1;
+	
+	
+	while (startRow <= endRow && startColumn <= endColumn) {
+		for (let i = startColumn; i <= endColumn; i++) {
+			result.push(matrix[startRow][i]);
+		}
+
+		for (let i = startRow + 1; i <= endRow; i++) {
+			result.push(matrix[i][endColumn]);
+		}
+
+		if (startRow < endRow &&  startColumn < endColumn) {
+			for (let i = endColumn - 1; i > startColumn; i--) {
+				result.push(matrix[endRow][i]);
+			}
+
+			for (let i = endRow; i > startRow; i--) {
+				result.push(matrix[i][startColumn])
+			}
+		}
+		startRow++;
+		endRow--;
+		startColumn++;
+		endColumn--;
+	}
+
+	return result;
+}
+
+/**
+ * startRow = 0 
+ * endColumn = 3 
+ * endRow = 2 
+ * startColumn = 0 
+ */
+
+ /**
+  * [
+  [1, 2, 3, 4],
+  [5, 6, 7, 8],
+  [9,10,11,12]
+]
+  * [
+ [ 1, 2, 3 ],
+ [ 4, 5, 6 ],
+ [ 7, 8, 9 ]
+]
+startRow = 0 => 1 => 2
+endRow = 2 => 1 => 0
+startColumn = 0 => 1 
+endColumn = 2 => 1
+  */

exercises/leetcode/trapRainWater.js

@@ -0,0 +1,30 @@
+/**
+ * Given n non-negative integers representing an elevation map where the width of each bar is 1, 
+ * compute how much water it is able to trap after raining.
+ */
+
+const maxTrap = height => {
+	let leftMax = [];
+	let rightMax = [];
+	let ans = 0;
+
+	if (!height || height.length === 0) {
+		return 0;
+	}
+
+	leftMax[0] = height[0];
+	for (let i = 1; i < height.length - 1; i++) {
+		leftMax[i] = Math.max(height[i], leftMax[i - 1]);
+	}
+
+	rightMax[height.length - 1] = height[height.length - 1];
+	for (let i = height.length - 2; i >=0; i--) {
+		rightMax[i] = Math.max(height[i], rightMax[i + 1]);
+	}
+
+	for (let i = 0; i < height.length - 1; i++) {
+		ans += Math.min(rightMax[i], leftMax[i]) - height[i];
+	}
+
+	return ans;
+}

exercises/leetcode/validParenthesis.js

@@ -0,0 +1,37 @@
+/**
+ * Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.
+
+An input string is valid if:
+
+Open brackets must be closed by the same type of brackets.
+Open brackets must be closed in the correct order.
+Note that an empty string is also considered valid.
+ */
+
+const validParenthesis = str => {
+	const bracketMap = new Map();
+
+	bracketMap.set(')', '(');
+	bracketMap.set('}', '{');
+	bracketMap.set(']', '[');
+
+	const strStack = [];
+
+	for (let ch of str.split('')) {
+		// check if the char is a closing bracket
+		if (bracketMap.has(ch)) {
+			// find the top element from the stack
+			let top = strStack.length === 0 ? '#' : strStack.pop();
+
+			// if top element is not an opening bracket, expression is invalid
+			if (top !== bracketMap.get(ch)) {
+				return false;
+			}
+		} else {
+			// its an opening bracket, push it to the stack
+			strStack.push(ch);
+		}
+	}
+
+	return strStack.length === 0;
+}

exercises/linkedlist/removeDuplicateLinkedList.js

@@ -15,24 +15,13 @@ class LinkedList {
 
 function removeDuplicates(head) {
   let node = head;
-  while (node) {
-    if (node.next && checkDuplicates(head, node.next)) {
-      node.next = node.next.next;
-    }
-    node = node.next;
+  while (node && node.next) {
+    if (node.next.data === node.data) {
+      	node.next = node.next.next;
+    } else {
+		node = node.next;
+	}
   }
 
   return head;
 }
-
-function checkDuplicates(head, node) {
-  let currentNode = head;
-  while (currentNode !== node) {
-    if (currentNode.data === node.data) {
-      return true;
-    }
-    currentNode = currentNode.next;
-  }
-
-  return false;
-}

exercises/strings/isPalindrome.js

@@ -0,0 +1,22 @@
+/**
+ * Given a string, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.
+
+Note: For the purpose of this problem, we define empty string as valid palindrome.
+
+Example 1:
+
+Input: "A man, a plan, a canal: Panama"
+Output: true
+Example 2:
+
+Input: "race a car"
+Output: false
+ */
+
+const isPalindrome = s => {
+	// replace all punctuations and chars other than alpha numeric to check if reversed str is a palindrome
+	s = s.replace(/[^A-Z0-9+$]/gi, '').toLowerCase();
+	const rev = s.split('').reverse().join('');
+
+	return s === rev;
+}

exercises/strings/reverseEachWord.js

@@ -55,3 +55,9 @@ const reverse = word => {
 
 	return result;
 }
+
+
+/**If its function to only reverse words of a sentence and not words individually */
+var reverseWords = function(s) {
+    return s.split(' ').reverse().filter(word => word !== '').join(' ').trim();
+};

exercises/strings/reverseString.js

@@ -31,3 +31,16 @@ function reverse(str) {
 function reverse(str) {
   return str.split('').reduce((rev, char) => char + rev, '');
 }
+
+function reverse(str) {
+	let left = 0;
+	let right = str.length - 1;
+
+	while (left < right) {
+		let tmp = str[left];
+		str[left] = str[right];
+		str[right] = tmp;
+	}
+
+	return str;
+}