LeetCode Greatest Common Divisor of Strings solutions All In One

LeetCode 1071

errors


function gcdOfStrings(str1: string, str2: string): string {
  let result = ``;
  let temp = [];
  if(str1.length > str2.length) {
    let reg = new RegExp(str2, 'g');
    if(str1.replaceAll(reg, ``) === ``) {
      return str2;
    } else {
      for(let s of str2) {
        // console.log(`s =`, s);
        if(str1.startsWith(temp.join(``) + s)) {
          temp.push(s);
          // console.log(`temp =`, temp.join(``));
          let reg = new RegExp(temp.join(``), 'g');
          // console.log(`str1 left =`, str1.replaceAll(reg, ``));
          // console.log(`str2 left =`, str2.replaceAll(reg, ``));
          if(str1.replaceAll(reg, ``) === `` && str2.replaceAll(reg, ``) === ``) {
            // 最大公约数 ✅
            // break;
            // return temp.join(``);
            // 替换，收集
            result = temp.join(``);
          }
        } else {
          // break;
          return ``;
        }
      }
    }
  } else {
    let reg = new RegExp(str1, 'g');
    if(str2.replaceAll(reg, ``) === ``) {
      return str1;
    } else {
      for(let s of str1) {
        if(str2.startsWith(temp.join(``) + s)) {
          temp.push(s);
          let reg = new RegExp(temp.join(``), 'g');
          if(str1.replaceAll(reg, ``) === `` && str2.replaceAll(reg, ``) === ``) {
            // 最大公约数 ✅
            // return temp.join(``);
            // 替换，收集
            result = temp.join(``);
          }
        } else {
          return ``;
        }
      }
    }
  }
  // return ``;
  return result;
};

// function gcdOfStrings(str1: string, str2: string): string {
//   let temp = [];
//   if(str1.length > str2.length) {
//     for(let s of str2) {
//       console.log(`s =`, s);
//       if(str1.startsWith(temp.join(``) + s)) {
//         temp.push(s);
//         console.log(`temp =`, temp.join(``));
//         let reg = new RegExp(temp.join(``), 'g');
//         console.log(`str1 left =`, str1.replaceAll(reg, ``));
//         console.log(`str2 left =`, str2.replaceAll(reg, ``));
//         if(str1.replaceAll(reg, ``) === `` && str2.replaceAll(reg, ``) === ``) {
//           // 最大公约数 ✅
//           // break;
//           return temp.join(``);
//         }
//       } else {
//         // break;
//         return ``;
//       }
//     }
//   } else {
//     for(let s of str1) {
//       if(str2.startsWith(temp.join(``) + s)) {
//         temp.push(s);
//         let reg = new RegExp(temp.join(``), 'g');
//         if(str1.replaceAll(reg, ``) === `` && str2.replaceAll(reg, ``) === ``) {
//           // 最大公约数 ✅
//           return temp.join(``);
//         }
//       } else {
//         return ``;
//       }
//     }
//   }
//   return ``;
// };

/* 

Wrong Answer
94 / 124 testcases passed

Input
str1 =
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
str2 =
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"


Output
"A"
Expected
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"

 */


/* 

Wrong Answer
63 / 124 testcases passed

Input
str1 =
"ABCDEF"
str2 =
"ABC"

Output
"ABC"
Expected
""

 */

/* 

Wrong Answer
78 / 124 testcases passed

Input
str1 =
"ABABABAB"
str2 =
"ABAB"

Output
"AB"
Expected
"ABAB"
 */

solutions

function gcdOfStrings(str1: string, str2: string): string {
  let result = ``;
  let temp = [];
  if(str1.length > str2.length) {
    let reg = new RegExp(str2, 'g');
    if(str1.replaceAll(reg, ``) === ``) {
      return str2;
    } else {
      for(let s of str2) {
        if(str1.startsWith(temp.join(``) + s)) {
          temp.push(s);
          let reg = new RegExp(temp.join(``), 'g');
          if(str1.replaceAll(reg, ``) === `` && str2.replaceAll(reg, ``) === ``) {
            // 替换，收集 ✅
            result = temp.join(``);
          }
        } else {
          return ``;
        }
      }
    }
  } else {
    let reg = new RegExp(str1, 'g');
    if(str2.replaceAll(reg, ``) === ``) {
      return str1;
    } else {
      for(let s of str1) {
        if(str2.startsWith(temp.join(``) + s)) {
          temp.push(s);
          let reg = new RegExp(temp.join(``), 'g');
          if(str1.replaceAll(reg, ``) === `` && str2.replaceAll(reg, ``) === ``) {
            // 替换，收集 ✅
            result = temp.join(``);
          }
        } else {
          return ``;
        }
      }
    }
  }
  return result;
};

function gcdOfStrings(str1: string, str2: string): string {
    if (str1 + str2 !== str2 + str1) return '';
    const gcd = (a, b) => (b === 0 ? a : gcd(b, a % b));
    const len = gcd(str1.length, str2.length);
    return str1.substring(0, len);
};

比较 string 大小 (github 上 javascript 数据结构与算法第三版，我曾经提过 issues ✅)

~~https://github.com/trekhleb/javascript-algorithms~~

https://github.com/loiane/javascript-datastructures-algorithms/issues/29
https://github.com/loiane/javascript-datastructures-algorithms

function gcdOfStrings(str1: string, str2: string): string {
    let largerWord: string, smallerWord: string;
    if(str1.length >= str2.length){
        largerWord = str1;
        smallerWord = str2;
    } else {
        largerWord = str2;
        smallerWord = str1
    }
    if(smallerWord === largerWord) {
        return smallerWord;
    }
    let largestCommonDenominator = '';
    for(let i = smallerWord.length; i > 0; i--){
        const possibleDenominator = smallerWord.slice(0, i);
        const possibleDenominatorLength = possibleDenominator.length;
        if(smallerWord.length % possibleDenominatorLength === 0 && largerWord.length % possibleDenominatorLength === 0) {
            const numSmaller = smallerWord.length / possibleDenominatorLength;
            const numLarger = largerWord.length / possibleDenominatorLength;
            if(possibleDenominator.repeat(numSmaller) === smallerWord && possibleDenominator.repeat(numLarger) === largerWord) {
               return possibleDenominator
            }
        }
    }
    return '';
}

demos

function gcdOfStrings(str1: string, str2: string): string {
  let result = ``;
  let temp = [];
  if(str1.length > str2.length) {
    let reg = new RegExp(str2, 'g');
    if(str1.replaceAll(reg, ``) === ``) {
      return str2;
    } else {
      for(let s of str2) {
        // console.log(`s =`, s);
        if(str1.startsWith(temp.join(``) + s)) {
          temp.push(s);
          // console.log(`temp =`, temp.join(``));
          let reg = new RegExp(temp.join(``), 'g');
          // console.log(`str1 left =`, str1.replaceAll(reg, ``));
          // console.log(`str2 left =`, str2.replaceAll(reg, ``));
          if(str1.replaceAll(reg, ``) === `` && str2.replaceAll(reg, ``) === ``) {
            // 最大公约数 ✅
            // break;
            // return temp.join(``);
            // 替换，收集
            result = temp.join(``);
          }
        } else {
          // break;
          return ``;
        }
      }
    }
  } else {
    let reg = new RegExp(str1, 'g');
    if(str2.replaceAll(reg, ``) === ``) {
      return str1;
    } else {
      for(let s of str1) {
        if(str2.startsWith(temp.join(``) + s)) {
          temp.push(s);
          let reg = new RegExp(temp.join(``), 'g');
          if(str1.replaceAll(reg, ``) === `` && str2.replaceAll(reg, ``) === ``) {
            // 最大公约数 
            // return temp.join(``);
            // 替换，收集 ✅
            result = temp.join(``);
          }
        } else {
          return ``;
        }
      }
    }
  }
  // return ``;
  return result;
};