cc22 quickSort √

.babelrc

@@ -0,0 +1,5 @@
+{
+    "presets":[
+        "es2015", "react"
+    ]
+}

.eslintrc.js

@@ -0,0 +1,33 @@
+module.exports = {
+    "env": {
+        "browser": true,
+        "commonjs": true,
+        "es6": true
+    },
+    "extends": "eslint:recommended",
+    "parserOptions": {
+        "ecmaFeatures": {
+            "experimentalObjectRestSpread": true,
+            "jsx": true
+        },
+        "sourceType": "module"
+    },
+    "rules": {
+        "indent": [
+            "error",
+            2
+        ],
+        "linebreak-style": [
+            "error",
+            "unix"
+        ],
+        "quotes": [
+            "error",
+            "single"
+        ],
+        "semi": [
+            "error",
+            "always"
+        ]
+    }
+};

.gcc-flags.json

@@ -0,0 +1,8 @@
+{
+  "execPath": "/usr/bin/g++",
+  "gccDefaultCFlags": "-Wall",
+  "gccDefaultCppFlags": "-Wall -std=c++11",
+  "gccErrorLimit": 15,
+  "gccIncludePaths": ".,./include,./path",
+  "gccSuppressWarnings": true
+}

.gitignore

@@ -1 +1,22 @@
+# npm installs
+/node_modules
+*/node_modules
+
+# MongoDB
+*/data
+
+# all logfiles and tempfiles.
+/log/*
+!/log/.keep
+/tmp
+
+# Ignore vim
+*~
+*.swp
+*.swo
+
+# Ignore macOS
 .DS_Store
+
+# gcc
+a.out

cc01longestString/longestString.js

@@ -0,0 +1,35 @@
+/*
+ * Write a function that accepts an array of strings.
+ * Return the longest string in the array.
+ */
+
+/* Take the first array item and put it in a "holding" array.
+ * Compare it to the next anArray, put the bigger of the two in the holding array.
+ */
+const bigString = function (anArr) {
+  const holdBig = [anArr[0]];
+  const tie = ['There\'s a tie: '];
+
+  for (let i = 1; i < anArr.length; i++) {
+    if (holdBig[0].length < anArr[i].length) {
+      holdBig.pop();
+      // console.log(anArr[i]);
+      holdBig.push(anArr[i]);
+    };
+    // tie if length match but different string - NOPE
+    // if (holdBig[0].length === anArr[i].length) {
+    //   tie.push(anArr[i]);
+    //   return `${tie[0]} ${tie[1]}`;
+    // }
+  };
+  return holdBig[0];
+};
+
+testAnArray = ['fred', 'ted', 'bob', 'alice', 'joe', 'arnold', 'mary', 'jebedaiah', 'ed', 'zachahurres', 'mae', 'antidisestablishmentarianism']
+console.log(bigString(testAnArray)); // ---> antidisestablishmentarianism
+
+// Refactor to return an array of the equal length strings if there's a tie? √
+// testAnArrayTie = ['fred', 'ted', 'bob', 'antidisestablishmentarianism', 'alice', 'joe', 'arnold', 'mary', 'jebedaiah', 'ed', 'zachahurres', 'mae', 'antidisestablishmentarianism', 'manny']
+// console.log(bigString(testAnArrayTie));
+
+// Refactor to handle non-Array arguments?

cc01longestString/solution.js

@@ -0,0 +1,35 @@
+const longestString = (strArr) => {
+  let tempStr = '';
+  strArr.forEach(str => {
+    if(str.length > tempStr.length) tempStr = str;
+  });
+  return tempStr;
+};
+
+longestString(['abc', 'def', 'gasdfasf', 'asdf', 'e', 'agwoaiengpoing']);
+
+// Ryan's lecture video comments:
+// https://youtu.be/juZvUpn4j5Y
+const longestString = (strArr) => {
+  // tempStr variable to hold the string
+  let tempStr = '';
+  // loop over strArr
+  strArr.forEach(str => {
+    // if current string in arry is bigger than tempStr,
+    // then update the variable tempStr
+    if(str.length > tempStr.length) tempStr = str;
+  })
+  return tempStr;
+};
+
+console.log(`Ryan: ${longestString(['abc', 'def', 'gasdfasf', 'asdf', 'e', 'agwoaiengpoing', 'pp'])}`);
+
+// Jesh's solution using sort()
+const longStr = (arr) => {
+  arr.sort((a, b) => {
+    return b.length - a.length;
+  });
+  return arr[0];
+}
+
+console.log(`Jesh: ${longStr(['abc', 'def', 'gasdfasf', 'asdf', 'e', 'agwoaiengpoing', 'pp'])}`);

cc02isUnique/isUnique.js

@@ -0,0 +1,21 @@
+/*
+* Implement an algorithm to determine if a string has all unique characters.
+* Extra Credit - Answer this question - What if you cannot use additional data structures?
+*/
+const isUnique = (str) => {
+  for (let i = 0; i < str.length; i++) {
+    for (let j = i + 1; j < str.length; j++) {
+      // console.log(`Q: does ${str[i]} === ${str[j]}? A: ${str[i] === str[j]}`)
+      if (str[i] === str[j]) {
+        return false;
+      }
+    }
+  }  return true;
+};
+
+console.log(isUnique('abcdhijklmnopqrstuv')); // true
+console.log(isUnique('abcdefghijklmnopqrstuvwyz')); // true
+console.log(isUnique('abcdefga')); // false
+console.log(isUnique('bcdgefga')); // false
+console.log(isUnique([1, 2, 3, 4, 5, 6, 3])); // false
+console.log(isUnique([0, 1, 2, 3, 4, 6, 7, 8, 9, 9])); // false

cc03reverseCase/pdk_reverseCase.js

@@ -0,0 +1,53 @@
+// I don't know why this got merge/erased, but this is my work:
+
+/*
+ * Write a function that reverses the case of each letter in the strings that it receives.
+ * Example: 'Hello World' -> 'hELLO wORLD'
+ * Assume that each string will contain only spaces and letters.
+ */
+
+const reverseCase = function (str) {
+  // declare an array to house individual string letters or spaces in word/sentence order
+  const letters = [];
+  // declare a variable which will be used to reconstructed string
+  let caseConvertedString;
+
+  // examine each letter in the string
+  for (let i = 0; i < str.length; i++) {
+    // uppercase or lowercase or a space?
+    // if a space, push space into temp holding array (if not a space, it's a letter)
+    if (str[i] === ' ') {
+      letters.push(str[i]);
+      // if already Upper Case, push lower Case version of letter into holding array
+    } else if (str[i] === str[i].toUpperCase()) {
+      letters.push(str[i].toLowerCase())
+      // if not space and not already Upper Case, push Upper Case version of letter to holding array
+    } else letters.push(str[i].toUpperCase())
+  }
+  // zip up the array of letters and spaces into a string
+  caseConvertedString = letters.join('');
+  return caseConvertedString;
+}
+
+const testCase1 = 'Hello World'
+console.log(reverseCase(testCase1)); // ---> hELLO wORLD
+const testCase2 = 'Fsdfsdf ESDFSDFdfsdfsdfsdfdsf';
+console.log(reverseCase(testCase2)); // ---> fSDFSDF esdfsdfDFSDFSDFSDFDSF
+// will it handle periods?
+const testCase3 = 'The quick brown Mr. Fox jumped over the lazy Mr. Dog.';
+console.log(reverseCase(testCase3)); // ---> tHE QUICK BROWN mR. fOX JUMPED OVER THE LAZY mR. dOG.
+
+// // Latoyya's solution
+// const reverseString = (str) => {
+//   let newString = '';
+//   for (let i = 0; i < str.length; i++) {
+//     if (str.charCodeAt(i) >= 65 && str.charCodeAt(i) <= 90) {
+//       newString += str.charAt(i).toLowerCase();
+//     } else {
+//       newString += str.charAt(i).toUpperCase();
+//     }
+//   }
+//   return newString;
+// };
+// console.log(reverseString('Hello World'));
+// console.log(reverseString('Hello World My NamE is LAtoyYa SmitH'));

cc04largestPrimePalindrome/findPrimePalindromes.js

@@ -0,0 +1,104 @@
+// I: a sorted array of prime numbers, smallest to largest
+// O: array of prime palindromes
+const findPrimePals = function(primeArr) {
+  // console.log(primeArr);
+  const primePalsArr = []
+  for (i = 0; i < primeArr.length; i++) {
+    if (isPalindrome(numToStr(primeArr[i]))) primePalsArr.push(numToStr(primeArr[i]))
+  }
+  return primePalsArr;
+}
+
+// evaluates a range of natural numbers
+// I: largest number in range (inclusive)
+// O: an array of ALL prime #'s from range 0 thru INPUT integer
+const findPrimes = function(bigNum) {
+  const primes = [];
+  // for number in range 0 thru *num
+  for (i = 0; i <=bigNum; i++) {
+    if (isPrime(i)) primes.push(i);
+  }
+  return primes;
+  }
+
+// I: any integer
+// O: "true" if INPUT is a prime number
+const isPrime = function(num) {
+  // return true if num is prime.
+  // otherwise return false
+  if (num < 2) {return false;}
+  else if (num === 2) {return true;}
+  else if (num % 2 === 0) {return false;}
+  else if (num >= 3) {
+    for (var i = 2; i < Math.sqrt(num + 1); i++) { // Maybe a ceiling would work better (but slower?)?
+      if (num % i === 0) {
+        return false;
+      }
+    }
+  } return true;
+}
+
+// I: any string NOTE: does NOT handle integers
+// O: "true" if INPUT is a palindrome
+function isPalindrome(str) {
+  // return true if string is a palindrome.
+  // otherwise return false
+  for (let i = 0; i < str.length / 2; i++) { // <--- make sure divided by 2 handles odd and even length (floor vs. ceiling)
+    if (str[i] === str[str.length - 1 - i]) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+}
+
+// I: a NUMBER
+// O: a STRING
+const numToStr = function(num) {
+  return `${num}`;
+}
+
+// // isPalindrome() TEST SUITE
+// console.log(`Q: Is 'palindrome' a palindrome?            A: ${isPalindrome('palindrome')}`) // <-- false
+// console.log(`Q: Is ' ' a palindrome?                     A: ${isPalindrome(' ')}`) // <-- true
+// console.log(`Q: Is 'a' a palindrome?                     A: ${isPalindrome('a')}`) // <-- true
+// console.log(`Q: Is 'bb' a palindrome?                    A: ${isPalindrome('bb')}`) // <-- true
+// console.log(`Q: Is 'cdc' a palindrome?                   A: ${isPalindrome('cdc')}`) // <-- true
+// console.log(`Q: Is 'amanaplanacanalpanama' a palindrome? A: ${isPalindrome('amanaplanacanalpanama')}`) // <-- true
+// console.log(`Q: Is an integer a palindrome?              A: ${isPalindrome(5)}`) // <-- undefined
+
+// // numToStr() test
+// console.log(numToStr(5)); // <--- '5'
+// console.log(typeof numToStr(5)); // <--- string
+// console.log(`Q: Is the integer converted to a string?    A: ${isPalindrome(numToStr(5))}`) // <-- true
+
+// // isPrime TEST SUITE
+// // 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199,
+// console.log(`Q: Is   0    prime? A: ${isPrime(0)}`)     // <--- false
+// console.log(`Q: Is   1    prime? A: ${isPrime(1)}`)     // <--- false
+// console.log(`Q: Is   2    prime? A: ${isPrime(2)}`)     // <--- true
+// console.log(`Q: Is   3    prime? A: ${isPrime(3)}`)     // <--- true
+// console.log(`Q: Is   4    prime? A: ${isPrime(4)}`)     // <--- false
+// console.log(`Q: Is   5    prime? A: ${isPrime(5)}`)     // <--- true
+// console.log(`Q: Is   6    prime? A: ${isPrime(6)}`)     // <--- false
+// console.log(`Q: Is   7    prime? A: ${isPrime(7)}`)     // <--- true
+// console.log(`Q: Is   8    prime? A: ${isPrime(8)}`)     // <--- false
+// console.log(`Q: Is   9    prime? A: ${isPrime(9)}`)     // <--- false
+// console.log(`Q: Is   10   prime? A: ${isPrime(10)}`)    // <--- false
+// console.log(`Q: Is   11   prime? A: ${isPrime(11)}`)    // <--- true
+// console.log(`Q: Is   12   prime? A: ${isPrime(12)}`)    // <--- false
+// console.log(`Q: Is   13   prime? A: ${isPrime(13)}`)    // <--- true
+// console.log(`Q: Is  121   prime? A: ${isPrime(121)}`)   // <--- false (11 * 11 = 121)
+// console.log(`Q: Is 104729 prime? A: ${isPrime(104729)}`)// <--- true (104,729 is the 10,000th prime number!)
+
+// // findPrimes TEST SUITE
+// [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127]
+console.log(`Q: what are the primes from 0 to 127?\nA: ${findPrimes(127)}`);
+// console.log(`Q: what are the primes from 0 to 121?\nA: ${findPrimes(104729)}`); // <--- 10,000 prime numbers!!!!
+console.log(findPrimes(104729).length);
+
+// findPrimePals TEST SUITE
+// [11, 101, ...]
+console.log(`Q: Is findPrimePals(findPrimes(127)) an instance of an array?\nA: ${findPrimePals(findPrimes(127)) instanceof Array}`); // <--- true
+console.log(`Q: what are the prime palindromes from 0 to 127?\nA: ${findPrimePals(findPrimes(127))}`); // <--- 2,3,5,7,11,101
+console.log(`Q: what are the prime palindromes from 0 to 1000?\nA: ${findPrimePals(findPrimes(1000))}`); // <--- 2,3,5,7,11,101,131,151,181,191,313,353,373,383,727,757,787,797,919,929