LeetCode Greatest Common Divisor of Strings 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) {
        // 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 {
    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);
};

demos

https://leetcode.com/problems/greatest-common-divisor-of-strings/?envType=study-plan-v2&envId=leetcode-75

(

标签：join,Divisor,temp,str2,str1,reg,Common,return,LeetCode
From： https://www.cnblogs.com/xgqfrms/p/18207872