add more arrays and strings solutions

Author: beck chen

sessions/array and strings/2DArrayDiagonalZigZag.js

@@ -0,0 +1,43 @@
+/* 
+** Print a 2D array in Diagonal ZigZag order
+** example: 
+**      1 2 3 4
+**      5 6 7 8
+**      9 0 1 2
+** should turn into
+**      1 2 5 9 6 3 4 7 0 1 8 
+*/
+
+function zigZag(arr) {
+    let rowIndex = 0, columnIndex = 0, isUp = true;
+
+    while (true) {
+        // print first so we capture first point before our logic runs and updates coordinates
+        console.log(arr[rowIndex][columnIndex]);
+
+        // if we reach top or bottom wall, AND we're not at right wall, go right.
+        // note that this also captures bottom left corner case: in which we go right
+        if (rowIndex === 0 || rowIndex === arr.length - 1 && columnIndex !== arr[0].length - 1) {
+            columnIndex++;
+            console.log(arr[rowIndex][columnIndex]);
+            isUp = !isUp;
+        } else if (columnIndex === 0 || columnIndex === arr[0].length - 1) {
+            // otherwise, if we reach left or right wall, go down
+            rowIndex++;
+            console.log(arr[rowIndex][columnIndex]);
+            isUp = !isUp;
+        }
+
+        // if we're already at destination, exit the loop
+        if (columnIndex === arr[0].length - 1 && rowIndex === arr.length - 1) {
+            break;
+        }
+
+        // we always go up right or down left
+        columnIndex = isUp ? columnIndex + 1 : columnIndex - 1;
+        rowIndex = isUp ? rowIndex - 1 : rowIndex + 1;
+    }
+}
+
+// this should print 1 2 5 9 6 3 4 7 0 1 8 2
+console.log(zigZag([[1, 2, 3, 4], [5, 6, 7, 8], [9, 0, 1, 2]]));

sessions/array and strings/bigIntegerAddition.js

@@ -0,0 +1,54 @@
+// Big Integer Addition
+// Given two arrays that represent numbers, find their sum
+// Example: 
+// a = [1, 6, 4, 3]
+// b = [1, 3, 1]
+
+function bigIntegerAddition(arr1, arr2) {
+    // figure out who's smaller and who's larger first
+    const bigArr = arr1.length > arr2.length ? arr1 : arr2;
+    let smallArr = arr1.length > arr2.length ? arr2 : arr1;
+
+    // since the two arrays could be of different sizes, we'd want to
+    // padd the front of the smallerArr with zeros such that it becomes
+    // the same size as the larger one
+    smallArr = resizeWithZeros(smallArr, bigArr.length);
+
+    // we create a resultArr to store the sum of the two arrays. 
+    // note that it's only ever mathematicaly possible that resultArr be
+    // at most one element longer than bigArr
+    const resultArr = Array(bigArr.length + 1);
+    let carry = 0;
+    // we iterate backwards since that's how addition works
+    for (let ii = bigArr.length - 1; ii >= 0; ii--) {
+        const sum = smallArr[ii] + bigArr[ii];
+        const smallestDigit = sum % 10 + carry;
+        // assign smallestDigit to ii + 1 since resultArr is one element longer than bigArr
+        resultArr[ii + 1] = smallestDigit;
+        carry = Math.floor(sum / 10);
+    }
+
+    return resultArr;
+}
+
+function resizeWithZeros(arr, sizeToBecome) {
+    // we'd like our smaller array to become a certain size 
+    // by padding the front of the array with zeros
+    const resizedArr = Array(sizeToBecome).fill(0);
+    let resizedArrBackwardsIndex = resizedArr.length - 1;
+    let smallArrBackwardsIndex = arr.length - 1;
+
+    // we start assigning smaller array's element to resized array, backwards. 
+    // ex. smallArr = [1, 2], resizedArr = [0, 0, 0, 0], we start by assining element 1 of smallArr
+    // to element 3 of resizedArr, and decrement these two indices at the same time, until
+    // smallArr's index is 0. At this point resizedArr should be [0, 0, 1, 2]
+    while (smallArrBackwardsIndex >= 0) {
+        resizedArr[resizedArrBackwardsIndex] = arr[smallArrBackwardsIndex];
+        resizedArrBackwardsIndex--;
+        smallArrBackwardsIndex--;
+    }
+
+    return resizedArr;
+}
+
+console.log(bigIntegerAddition([3, 2, 4], [1, 9])); // should print 0, 3, 4, 3

sessions/array and strings/bigIntegerMultiplication.js

@@ -0,0 +1,12 @@
+// Check if a string A is a rotation of another string B
+// For example, “atbobc” is a rotation of “bobcat”
+
+function checkRotation(targetStr, refStr) {
+    if (!targetStr || targetStr.length === 0 || !refStr || refStr.length === 0 || targetStr.length !== refStr.length) {
+        return false;
+    }
+
+    return (refStr + refStr).includes(targetStr);
+}
+
+console.log(checkRotation('atbobc', 'bobcat'));

sessions/array and strings/checkIfStringIsRotationOfAnotherString.js

@@ -0,0 +1,56 @@
+// Find the longest palindromic substring in a string
+// For example:
+// "abcababadef" => "ababa"
+// "ffabbahh" => “abba"
+
+function longestPalindromicSubstring(fullStr) {
+    if (!fullStr || fullStr.length === 0) { return null; }
+    const fullCharsArr = fullStr.split('');
+    let result = [];
+    let currentMaxPalindromeLength = 0;
+
+    // handle odd length string
+    for (let ii = 0; ii < fullCharsArr.length - 1; ii++) {
+        // expand outwards from ii and check for palindrome
+        let offset = 0;
+        while (isValidIndex(ii - offset - 1, fullCharsArr)
+            && isValidIndex(ii + offset + 1, fullCharsArr)
+            && fullCharsArr[ii - offset - 1] === fullCharsArr[ii + offset + 1]) {
+            offset++;
+        }
+
+        const palindromeLengthAtIndex = 2 * offset + 1;
+        if (palindromeLengthAtIndex > currentMaxPalindromeLength) {
+            currentMaxPalindromeLength = palindromeLengthAtIndex;
+            result = [ii - offset, ii + offset];
+        }
+    }
+
+    // handle even length string
+    for (let ii = 0; ii < fullCharsArr.length - 1; ii++) {
+        // expand outwards from ii and check for palindrome
+        let offset = 0;
+        while (isValidIndex(ii - offset, fullCharsArr)
+            && isValidIndex(ii + offset + 1, fullCharsArr)
+            && fullCharsArr[ii - offset] === fullCharsArr[ii + offset + 1]) {
+            offset++;
+        }
+
+        const palindromeLengthAtIndex = 2 * offset;
+        if (palindromeLengthAtIndex > currentMaxPalindromeLength) {
+            currentMaxPalindromeLength = palindromeLengthAtIndex;
+            result = [ii - offset + 1, ii + offset];
+        }
+    }
+
+    return result;
+}
+
+function isValidIndex(index, fullStr) {
+    return index >= 0 && index < fullStr.length;
+}
+
+// this should return [2, 6]
+console.log(longestPalindromicSubstring('abcivicyz'));
+// this should return [2, 5]
+console.log(longestPalindromicSubstring('xybaabop'));

sessions/array and strings/longestPalindromicSubstring.js

@@ -0,0 +1,54 @@
+// Print Elements of a Matrix in Spiral Order
+
+function printElementsSpiralOrder(matrix) {
+    if (!matrix || matrix.length === 0) { return; }
+
+    // note that this is NOT number of layers, but last layer index
+    // picture a 2 x 3 matrix. In that case you would have 2 layers not 3,
+    // with last layer index being 1
+    const lastLayerIndex = Math.floor(matrix.length / 2);
+
+    // dont forget to include your lastLayerIndex in the loop
+    for (let layerIndex = 0; layerIndex <= lastLayerIndex; layerIndex++) {
+        printElementsInLayer(matrix, layerIndex);
+    }
+}
+
+function printElementsInLayer(matrix, layerIndex) {
+    // for every spiral layer, we define the first and last columns and rows
+    let firstColumn = layerIndex,
+        lastColumn = matrix[0].length - 1 - layerIndex,
+        firstRow = layerIndex,
+        lastRow = matrix.length - 1 - layerIndex;
+
+    // print top
+    // note that this does not include the rightmost element of the first row.
+    // that element belongs to the right column
+    for (let ii = firstColumn; ii < lastColumn; ii++) {
+        console.log(matrix[firstRow][ii]);
+    }
+
+    // print right wall
+    // note that this does not include the bottom element of the right column.
+    // that element belongs to the bottom
+    for (let ii = firstRow; ii < lastRow; ii++) {
+        console.log(matrix[ii][lastColumn]);
+    }
+
+    // print bottom
+    // note that this does not include the bottom element of the left column.
+    // that element belongs to the left
+    for (let ii = lastColumn; ii > firstColumn; ii--) {
+        console.log(matrix[lastRow][ii]);
+    }
+
+    // print left
+    // note that this does not include the top element of the left column.
+    // that element belongs to the top
+    for (let ii = lastRow; ii > firstRow; ii--) {
+        console.log(matrix[ii][firstColumn]);
+    }
+}
+
+// this should print 2, 3, 1, 6, 7, 9, 11, 4, 8, 12, 13, 5
+console.log(printElementsSpiralOrder([[2, 3, 1, 6], [12, 13, 5, 7], [8, 4, 11, 9]]));

sessions/array and strings/printElementOfMatrixInSpiralOrder.js

@@ -0,0 +1,36 @@
+// Reverse the order of the words in a string
+// For example: “what is your name” -> “name your is what”
+
+function reverseOrderOfWords(wordsToReverse) {
+    const wordsToReverseArr = wordsToReverse.split('');
+
+    // first we reverse the whole sentence
+    reverseChars(wordsToReverseArr, 0, wordsToReverseArr.length - 1);
+
+    // loop from beginning of arr to second to last character,
+    // look for start of string, and look for space, and 
+    // reverse the characters in between 
+    let wordStartIndex = 0;
+    for (let ii = 0; ii < wordsToReverseArr.length - 1; ii++) {
+        if (wordsToReverseArr[ii + 1] === ' ') {
+            reverseChars(wordsToReverseArr, wordStartIndex, ii);
+            wordStartIndex = ii + 2;
+        }
+    }
+
+    // reverse the last word
+    reverseChars(wordsToReverseArr, wordStartIndex, wordsToReverseArr.length - 1);
+    return wordsToReverseArr;
+}
+
+function reverseChars(wordsToReverseArr, firstIndex, lastIndex) {
+    while (firstIndex < lastIndex) {
+        [wordsToReverseArr[firstIndex], wordsToReverseArr[lastIndex]]
+            = [wordsToReverseArr[lastIndex], wordsToReverseArr[firstIndex]];
+        firstIndex++;
+        lastIndex--;
+    }
+}
+
+// should print "string a is this"
+console.log(reverseOrderOfWords('this is a string'));

sessions/array and strings/reverseOrderOfWords.js

@@ -3,3 +3,35 @@
 // Also you need to rotate this in-place by modifying the original array, 
 // meaning you cannot create another 2D array to do this
 
+function rotateMatrix(matrix) {
+    if (!matrix || matrix.length === 0 || matrix[0].length !== matrix.length) { return; }
+    // we think of matrix in "layers" wrapping around the center
+    // the main loop is to iterate from the outer layer to the innermost layer 
+    // (which is just the 1 center element)
+    const numberOfLayers = Math.floor(matrix.length / 2);
+    // iterate over the layers
+    for (let layerIndex = 0; layerIndex < numberOfLayers; layerIndex++) {
+        rotateLayerOfMatrix(matrix, layerIndex);
+    }
+
+    return matrix;
+}
+
+function rotateLayerOfMatrix(matrix, layerIndex) {
+    const startIndex = layerIndex;
+    const endIndex = matrix.length - 1 - layerIndex; // ex. for a 5 x 5 matrix, layer 1 ends at 5 - 1 - 1 = 3
+    for (let ii = startIndex; ii < endIndex; ii++) {
+        // store top element
+        const storedTopElem = matrix[startIndex][startIndex + ii];
+        // rotate left to top
+        matrix[startIndex][startIndex + ii] = matrix[endIndex - ii][startIndex];
+        // rotate bottom to left
+        matrix[endIndex - ii][startIndex] = matrix[endIndex][endIndex - ii];
+        // rotate right to bottom
+        matrix[endIndex][endIndex - ii] = matrix[startIndex + ii][endIndex];
+        // top to left
+        matrix[startIndex + ii][endIndex] = storedTopElem;
+    }
+}
+
+console.log(rotateMatrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]));

sessions/array and strings/rotate2DArray.js

@@ -0,0 +1,31 @@
+// Rotate an array by X items
+// For example:
+// A = [1,2,3,4,5,6] and X = 2, Result = [5,6,1,2,3,4]
+// Note that X could be greater than the length of the array
+
+/*
+** The logic here is:
+** 1. Get X % arr.length, in case X is longer than arr
+** 2. reverse the whole array
+** 3. reverse the first X items
+** 4. reverse the rest of the array 
+*/
+function rotateArray(arr, x) {
+    x = x % arr.length;
+    reverseArr(arr, 0, arr.length - 1);
+    reverseArr(arr, 0, x - 1);
+    reverseArr(arr, x, arr.length - 1);
+
+    return arr;
+}
+
+function reverseArr(arr, startIndex, endIndex) {
+    while (startIndex < endIndex) {
+        [arr[startIndex], arr[endIndex]] = [arr[endIndex], arr[startIndex]];
+        startIndex++;
+        endIndex--;
+    }
+}
+
+// should print [4, 5, 1, 2, 3]
+console.log(rotateArray([1, 2, 3, 4, 5], 2));