✅ [1071] factors method!! MY 100TH QN!!!!

Author: enkr1

1071/my_solution.js

@@ -7,60 +7,59 @@ var gcdOfStrings = function (str1, str2) {
   // must be the same after merging before/after, if they have common divider.
   if ((str1 + str2) !== (str2 + str1)) return "";
 
-  const findGCD = (str) => {
-    console.log(`________________________________`)
-    let gcd = null, tmpGcd = str[0], l = 0, r = 1
 
-    while (r < str.length) {
-      console.log(gcd)
+  const calculateFactors = (n) => {
+    let factors = []
 
-      let curr = str[r]
-
-      console.log(`l:${l},r:${r},gcd:${gcd},tmpGcd:${tmpGcd}`)
+    for (let i = n; i > 0; i--) { // <= to include itself or start from the back to get the reversed version
+      if ((n % i) === 0) factors.push(i)
+    }
 
-      if (curr === str[l]) {
-        console.log(`curr:${curr} === str[l]:${str[l]}`)
-        console.log(`gcd:${gcd},tmpGcd:${tmpGcd}`)
+    return factors;
+  }
 
-        if (gcd !== null && tmpGcd.length !== gcd.length) {
-          console.log(`EDGE:`)
-          console.log(gcd)
-          console.log(tmpGcd)
-          return ""; // edge case when tmp gcd is not the same
-        }
+  let f1 = calculateFactors(str1.length), f2 = calculateFactors(str2.length), greatestCommonFactor = 0
 
-        gcd = tmpGcd;
-        tmpGcd = curr;
-        // l = r;
-      } else {
-        tmpGcd += curr;
-      }
+  let listToFindGCF = (f1.length > f2.length) ? f2 : f1; // use the shortest
+  let largerFactorList = (f1.length > f2.length) ? f1 : f2;
+  let gcf = null; // greatest common factor
 
-      console.log(`-> end tmpGcd:${tmpGcd}`)
-      r++;
-    }
+  console.log(`-> f1: ${f1}, f2: ${f2}, gcf: ${gcf}`)
+  while (gcf === null) {
+    let curr = listToFindGCF.shift();
+    if (largerFactorList.includes(curr)) gcf = curr;
+  }
 
-    console.log(`-> final gcd:${gcd}, tmpGcd:${tmpGcd}`)
-    console.log(gcd === null ? tmpGcd : gcd)
+  let multiplier = ((str2.length > str1.length) ? str2.length : str1.length) / gcf;
+  console.log(`--> f1: ${f1}, f2: ${f2}, gcf: ${gcf}`)
 
-    return gcd === null ? tmpGcd : gcd;
+  // get the part
+  // validate by their multiplier
+  const validateByGCF = (str) => {
+    let multiplier = str.length / gcf;
+    console.log(`---> multiplier: ${multiplier}`)
+    // NOTE: slice is inclusive
+    let slicedStr = str.slice(0, gcf), multipliedStr = "";
+    while (multiplier > 0) {
+      multipliedStr += slicedStr;
+      multiplier--;
+    }
+    console.log(`str: ${str}, slicedStr: ${slicedStr}, mstr: ${multipliedStr}`)
+    return (multipliedStr === str) ? slicedStr : "";
   }
 
-  let
-    gcd1 = findGCD(str1),
-    gcd2 = findGCD(str2);
-  console.log("gcd1")
-  console.log(gcd1)
-  console.log("gcd2")
-  console.log(gcd2)
-  return gcd1 == gcd2 ? gcd1 : "";
+  return validateByGCF(str1); // either one will do as long as we get the gcf
+  let gcd1 = validateByGCF(str1), gcd2 = validateByGCF(str2);
+  // return (gcd1===gcd2)?
+
 
 };
 
 let x =
-  // gcdOfStrings("ABCABC", "ABC")
-  // gcdOfStrings("ABABAB", "ABAB")
-  gcdOfStrings("ABABABAB", "ABAB")
+  gcdOfStrings("ABCABC", "ABC")
+// gcdOfStrings("ABABAB", "ABAB")
+// gcdOfStrings("ABCDABCDABCDABCD", "ABCDABCD")
+// gcdOfStrings("ABABABAB", "ABAB")
 
 console.log("Result")
 console.log(x)

1071/solution.js

@@ -4,33 +4,38 @@
  * @return {string}
  */
 var gcdOfStrings = function (str1, str2) {
+  // must be the same after merging before/after, if they have common divider.
+  if ((str1 + str2) !== (str2 + str1)) return "";
 
-  const findGCD = (str) => {
-    let gcd = null, tmpGcd = str[0], l = 0, r = 1
+  const calculateFactors = (n) => {
+    let factors = []
 
-    while (r < str.length) {
-      let curr = str[r]
-
-      if (curr === str[l]) {
-        if (gcd !== null && tmpGcd.length !== gcd.length) return ""; // edge case when tmp gcd is not the same
-
-        gcd = tmpGcd;
-        tmpGcd = curr;
-        // l = r;
-      } else {
-        tmpGcd += curr;
-      }
-
-      r++;
+    for (let i = n; i > 0; i--) { // <= to include itself or start from the back to get the reversed version
+      if ((n % i) === 0) factors.push(i)
     }
 
-    return gcd === null ? tmpGcd : gcd;
+    return factors;
   }
 
   let
-    gcd1 = findGCD(str1),
-    gcd2 = findGCD(str2);
+    f1 = calculateFactors(str1.length), f2 = calculateFactors(str2.length),
+    listToFindGCF = (f1.length > f2.length) ? f2 : f1, // use the shortest
+    largerFactorList = (f1.length > f2.length) ? f1 : f2,
+    gcf = null; // greatest common factor
+
+  while (gcf === null) {
+    let curr = listToFindGCF.shift();
+    if (largerFactorList.includes(curr)) gcf = curr;
+  }
 
-  return gcd1 == gcd2 ? gcd1 : "";
+  const validateByGCF = (str) => {
+    let multiplier = str.length / gcf, slicedStr = str.slice(0, gcf), multipliedStr = "";
+    while (multiplier > 0) {
+      multipliedStr += slicedStr;
+      multiplier--;
+    }
+    return (multipliedStr === str) ? slicedStr : "";
+  }
 
+  return validateByGCF(str1); // either one will do as long as we get the gcf
 };