Merge remote-tracking branch 'upstream/master'

Author: miguelHx

JavaScript/chapter01/1.2 - Check Perm/rroque98_sol.js

@@ -1,37 +1,34 @@
 /*Given two strings, write a method to decide
 if one is apermutation of the other permutation:*/
 
-const isPermutation = (str1, str2) =>{
+const isPermutation = (str1, str2) => {
   if (str1.length !== str2.length) {
     return false;
   }
-  const obj1 = determineCharCount(str1);
-  const obj2 = determineCharCount(str2);
-  for (let char of str1) {
-    if (obj1[char] !== obj2[char]) {
+  const freq1 = determineCharCount(str1);
+  const freq2 = determineCharCount(str2);
+  for (const [char, count] of freq1) {
+    if (count !== freq2.get(char)) {
       return false;
     }
   }
   return true;
   //******** helper function ******
   function determineCharCount(string) {
-    const obj = {};
-    for (let char of string) {
-      if (obj[char] !== undefined) {
-        obj[char]++;
-      } else {
-        obj[char] = 1;
-      }
-    }
-    return obj;
+    return string
+      .split('')
+      .reduce(
+        (acc, char) => acc.set(char, (acc.get(char) || 0) + 1),
+        new Map()
+      );
   }
-}
+};
 
 // Tests:
-  console.log(isPermutation('abc', 'abb') === false);
-  console.log(isPermutation('abb', 'abc') === false);
-  console.log(isPermutation('aaa', 'abc') === false);
-  console.log(isPermutation('abc', 'abcd') === false);
-  console.log(isPermutation('abc', 'bac') === true);
-  console.log(isPermutation('', '') === true);
-  console.log(isPermutation('12', '21') === true);
+console.log(isPermutation('abc', 'abb') === false);
+console.log(isPermutation('abb', 'abc') === false);
+console.log(isPermutation('aaa', 'abc') === false);
+console.log(isPermutation('abc', 'abcd') === false);
+console.log(isPermutation('abc', 'bac') === true);
+console.log(isPermutation('', '') === true);
+console.log(isPermutation('12', '21') === true);

JavaScript/chapter01/1.3 - URLify/rroque98_sol.js

@@ -1,8 +1,8 @@
 // Write a method to replace all spaces within a string with '%20'
 
-const URLify = (string) => string.split(' ').join('%20');
+const encodeSpaces = (string) => string.replace(/ /g, '%20');
 
 // Tests:
-console.log(URLify('Hello World') === 'Hello%20World');
-console.log(URLify('') === '');
-console.log(URLify('This is an example') === 'This%20is%20an%20example');
+console.log(encodeSpaces('Hello World') === 'Hello%20World');
+console.log(encodeSpaces('') === '');
+console.log(encodeSpaces('This is an example') === 'This%20is%20an%20example');

JavaScript/chapter01/1.4 - PalinPerm/rroque98_sol.js

@@ -1,20 +1,17 @@
 // Given a string, write a function to check if it is a permutation of a palindrome
 
 const isPalindromePermutation = (str) => {
-  const strNoSpaces = str.split(' ').join('');
-  const obj = {};
+  const strNoSpaces = str.replace(/ /g, '');
   var oddCount = 0;
+  const frequencies = new Map();
   for (let char of strNoSpaces) {
-    if (obj[char] !== undefined) {
-      obj[char]++;
-    } else {
-      obj[char] = 1;
-    }
+    frequencies.set(char, 1 + (frequencies.get(char) || 0));
   }
-  for (let key in obj) {
-    if (obj[key] % 2) {
-      oddCount++;
+  for (let frequency of frequencies.values()) {
+    if (frequency % 2 === 0) {
+     continue;
     }
+    oddCount++;
     if (oddCount > 1) {
       return false;
     }

JavaScript/chapter01/1.5 - OneAway/rroque98_sol.js

@@ -4,40 +4,69 @@ Given 2 strings write a function that will check if it is
 1 or 0 edits away*/
 
 const isOneAway = (str1, str2) => {
+  const diffInLen = Math.abs(str1.length - str2.length);
+  if (diffInLen > 1) {
+    return false;
+  }
+
+  let errorCount = 0;
   if (str1.length === str2.length) {
-    let errorCount = 0;
     for (let i = 0; i < str1.length; i++) {
       if (str1[i] !== str2[i]) {
         errorCount++;
-      }
-      if (errorCount > 1) {
-        return false;
+        if (errorCount > 1) {
+          return false;
+        }
       }
     }
-  } else {
-    let errorCount = 0;
-    const longestStr = findLongestStr(str1, str2);
-    let x = 0;
-    for(let i = 0; i < longestStr; i++) {
-      if (str1[i] !== str2[x]) {
-        errorCount++;
-        x++;
-      }
-      if (errorCount > 1) {
-        return false;
-      }
-      x++;
+    return true;
+  }
+  const longStr = str1.length > str2.length ? str1 : str2;
+  const shortStr = str1.length <= str2.length ? str1 : str2;
+  for (let i = 0; i + errorCount < longStr.length; i++) {
+    if (longStr[i + errorCount] === shortStr[i]) {
+      continue;
     }
-    // ***** Helper functions ********
-    function findLongestStr(str1, str2) {
-      str1 > str2 ? str1 : str2;
+    errorCount++;
+    if (errorCount > 1) {
+      return false;
     }
   }
   return true;
+};
+
+// ****** TESTS ******
+function runTests(cases, expected) {
+  for (const [str1, str2] of cases) {
+    console.log(
+      isOneAway(str1, str2) === expected && isOneAway(str2, str1) === expected
+    );
+  }
 }
 
-// TESTS
-console.log(isOneAway('pale', 'ple') === true);
-console.log(isOneAway('pales', 'pale') === true);
-console.log(isOneAway('pale', 'bale') === true);
-console.log(isOneAway('pale', 'bake') === false);
+runTests(
+  [
+    ['pale', 'ple'], // deletion
+    ['pale', 'opale'], // insertion in beginning
+    ['pale', 'palse'], // insertion in middle
+    ['pale', 'pales'], // insertion at end
+    ['pale', 'bale'], // replacement
+    ['p', 'b'],
+    ['p', 'p'],
+    ['p', ''],
+    ['', '']
+  ],
+  true
+);
+
+runTests(
+  [
+    ['pale', 'ae'], // greater than 1 deletions
+    ['pale', 'ppalpe'], // greater than 1 insertions
+    ['pale', 'bake'], // greater than 1 replacements
+    ['pale', 'balpe'], // 1 insertion, 1 replacement
+    ['pale', 'plo'], // 1 deletion, 1 replacement
+    ['pale', 'ales'] // 1 deletion, 1 insertion
+  ],
+  false
+);

JavaScript/chapter01/1.6 - String Compression/rroque98_sol.js

@@ -1,33 +1,38 @@
-/* Implement a method to perform basic string 
-compression using the counts of repeated characters
+/* Implement a method to perform basic string
+compression using the counts of repeated characters.
+If the compressed string length is more than original
+string length, return original string.
 Ex: 'aabcccccaaa' would become a2b1c5a3
 */
 
 const stringCompression = (str) => {
   if (!str.length) {
     return '';
   }
-  var compStr = '';
-  var count = 1;
-  var currentChar = str[0];
-  for (let i = 1; i < str.length; i++) {
+  let compStr = '';
+  let count = 0;
+  let currentChar = str[0];
+  for (let i = 0; i < str.length; i++) {
     let char = str[i];
     if (char === currentChar) {
       count++;
-      if (i === str.length - 1) {
-        compStr += `${currentChar}${count}`;
-      }
     } else {
       compStr += `${currentChar}${count}`;
       currentChar = char;
       count = 1;
     }
   }
+  compStr += `${currentChar}${count}`;
+  if (compStr.length > str.length) {
+    return str;
+  }
   return compStr;
 }
 
 // TESTS
 console.log(stringCompression('aabcccccaaa') === 'a2b1c5a3');
 console.log(stringCompression('cccccccc') === 'c8');
 console.log(stringCompression('') === '');
-console.log(stringCompression('AabccCccaaa') === 'A1a1b1c2C1c2a3');
+console.log(stringCompression('AabccCccaaa') === 'AabccCccaaa');
+// Explanation: 'A1a1b1c2C1c2a3' length is longer than original string so returns original string
+console.log(stringCompression('x') === 'x');

JavaScript/chapter01/1.7 - Rotate Matrix/rroque98_sol.js

@@ -0,0 +1,29 @@
+/*Given an image represented by an N*N matrix where
+each pixel in the image is 4 bytes, write a method
+to rotate the image by 90 degrees. Can you do this
+in place?*/
+
+const rotateImage = nestedArr => {
+  const n = nestedArr.length;
+  if (n === 0 || n === 1) {
+    return nestedArr;
+  }
+  var rotatedArr = [];
+  for (let col = 0; col < n; col++) {
+    let newRow = [];
+    for (let row = n - 1; row >= 0; row--) {
+      newRow.push(nestedArr[row][col]);
+    }
+    rotatedArr.push(newRow);
+  }
+  return rotatedArr;
+};
+
+// TESTS:
+console.log(
+  JSON.stringify(rotateImage([[1, 2, 3], [4, 5, 6], [7, 8, 9]])) ===
+    JSON.stringify([[7, 4, 1], [8, 5, 2], [9, 6, 3]])
+);
+console.log(JSON.stringify(rotateImage([[1]])) === JSON.stringify([[1]]));
+console.log(JSON.stringify(rotateImage([[]])) === JSON.stringify([[]]));
+console.log(JSON.stringify(rotateImage([])) === JSON.stringify([]));

JavaScript/chapter01/1.8 - Zero Matrix/rroque98_sol.js

@@ -0,0 +1,76 @@
+/*Write an algorithm such that if an element
+ in an M*N matrix is 0,it's entire row and column
+  are set to 0*/
+
+const zeroMatrix = nestedArr => {
+  const rowsAndColsWithZeros = checkForZeroIndex(nestedArr);
+  const rowLength = nestedArr[0].length;
+  const columnLength = nestedArr.length;
+  for (const row in rowsAndColsWithZeros['rows']) {
+    for (let col = 0; col < rowLength; col++) {
+      nestedArr[row][col] = 0;
+    }
+  }
+  for (const col in rowsAndColsWithZeros['columns']) {
+    for (let row = 0; row < columnLength; row++) {
+      nestedArr[row][col] = 0;
+    }
+  }
+  return nestedArr;
+};
+
+// **** Helper function ****
+function checkForZeroIndex(nestArr) {
+  let zeroIndices = { rows: {}, columns: {} };
+  for (let row = 0; row < nestArr.length; row++) {
+    for (let col = 0; col < nestArr[row].length; col++) {
+      if (nestArr[row][col] === 0) {
+        zeroIndices['rows'][row] = true;
+        zeroIndices['columns'][col] = true;
+      }
+    }
+  }
+  return zeroIndices;
+}
+
+// **** TESTS ****:
+let actual = zeroMatrix([[]]);
+let expected = [[]];
+isEqual(actual, expected);
+
+actual = zeroMatrix([[3, 5, 6], [1, 0, 2], [4, 4, 5], [2, 2, 2]]);
+expected = [[3, 0, 6], [0, 0, 0], [4, 0, 5], [2, 0, 2]];
+isEqual(actual, expected);
+
+actual = zeroMatrix([[3, 5, 6], [1, 0, 2], [4, 4, 0], [2, 0, 2]]);
+expected = [[3, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]];
+isEqual(actual, expected);
+
+actual = zeroMatrix([[3, 5, 6], [0, 0, 2], [4, 4, 0], [2, 0, 2]]);
+expected = [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]];
+isEqual(actual, expected);
+
+function isEqual(actual, expected) {
+  console.log(JSON.stringify(actual) === JSON.stringify(expected));
+}
+
+// ****HELPER FUNCTION TESTS ****:
+actual = checkForZeroIndex([[1, 2, 0]]);
+expected = { rows: { 0: true }, columns: { 2: true } };
+testCheckForZeroIndex(actual, expected);
+
+actual = checkForZeroIndex([[0]]);
+expected = { rows: { 0: true }, columns: { 0: true } };
+testCheckForZeroIndex(actual, expected);
+
+actual = checkForZeroIndex([[1, 2, 3], [4, 0, 5], [6, 0, 8]]);
+expected = { rows: { 1: true, 2: true }, columns: { 1: true } };
+testCheckForZeroIndex(actual, expected);
+
+function testCheckForZeroIndex(actual, expected) {
+  let rows = JSON.stringify(actual.rows);
+  let cols = JSON.stringify(actual.columns);
+  let expRows = JSON.stringify(expected.rows);
+  let expCols = JSON.stringify(expected.columns);
+  console.log(rows === expRows && cols === expCols);
+}

Python/chapter01/1.3 - URLify/camilo_solution_1.3.py

@@ -5,7 +5,21 @@
  (Note: If implementing in Java,please use a character array so that you can
  perform this operation in place.)
 EXAMPLE
-Input: "Mr John Smith ", 13 Output: "Mr%20John%20Smith"
+Input: "Mr John Smith   ", 13 Output: "Mr%20John%20Smith"
 """
 
 def urlify(str):
+    len_ = len(str) #gets the lenght of str
+    new_str = ""#build a new string
+    for i in range(len_-1):
+        if str[i] == " " and str[i+1]==" ":#if two space aheah are space then break
+            break
+        if str[i] == " ": #if we find a space just add %20
+            new_str+= "%20"
+
+        else: #just add the chars
+            new_str+= str[i]
+
+    return new_str
+
+print(urlify("MY house is on fire "))