检查第二个字符串是否是另一个字符串的旋转

Question

我正在尝试编写一个接收两个字符串参数的函数，并检查第二个参数是否是第一个字符串的旋转版本。

所以结果如下：

checkRotationStrings('waterbottle', 'lewaterbott'); // true checkRotationStrings('waterbottle', 'bottlewater'); // true checkRotationStrings('waterbottle', 'erbottlewat'); // true checkRotationStrings('waterbottle', 'lewaterbottx'); // false

我编写了以下代码，但有些边缘情况我似乎无法弄清楚：

function checkRotationStrings(string, rotatedString) {
  let result;
  let rotationCheck
  let stringArr = string.split('');
  let rotatedStringArr = rotatedString.split('')

  for (let i = 0; i < string.length - 1; i++) {
    if (rotatedString[0] === stringArr[i]) {
       result = stringArr.slice(i);
       rotationCheck = stringArr.slice(0, i).concat(result).join('');
    }
  }
  console.log(rotationCheck)
  if (rotationCheck === string){
    return true;
  } else {
    return false;
  }
}

任何帮助将不胜感激。

Answer 1

您可以使用String#repeat 和rotated 和两个作为参数并使用String#includes 进行检查。

function checkRotationStrings(string, rotated) {
    return string.length === rotated.length && rotated.repeat(2).includes(string);
}

console.log(checkRotationStrings('waterbottle', 'lewaterbott'));  //  true
console.log(checkRotationStrings('waterbottle', 'bottlewater'));  //  true
console.log(checkRotationStrings('waterbottle', 'erbottllewat')); // false
console.log(checkRotationStrings('waterbottle', 'lewaterbottx')); // false
console.log(checkRotationStrings('waterbottle', 'ttlewaterb'));   // false

Answer 2

您可以使用子字符串并旋转直到找到匹配项。像这样：

function checkRotationStrings(string, rotatedString) {

  let match = false;
  for (let i = 0;
    (i < string.length - 1) & !match; i++) {

    match = rotatedString.substring(i, rotatedString.length) + rotatedString.substring(0, i) === string;

  }
  return match

}


console.log(checkRotationStrings('waterbottle', 'lewaterbott')); // true
console.log(checkRotationStrings('waterbottle', 'bottlewater')); // true 
console.log(checkRotationStrings('waterbottle', 'erbottlewat')); // true 
console.log(checkRotationStrings('waterbottle', 'lewaterbottx')); // false

Answer 3

这是一个有点奇怪的解决方案，因为它仅将some 用于索引参数。但是some 中的每次迭代只是比较两个字符串，一个是第一个的旋转，另一个是第二个。

const checkRotationStrings = (str, rot) => 
    str.split('').some((s, i) => str.slice(i) + str.slice(0, i) == rot);

[
  ['waterbottle', 'lewaterbott'],   // true 
  ['waterbottle', 'bottlewater'],   // true 
  ['waterbottle', 'erbottllewat'],  // false  -- ORIGINAL
  ['waterbottle', 'erbottlewat'],   // true   -- CORRECTED
  ['waterbottle', 'lewaterbottx']   // false
].forEach(([s, r]) => console.log(`'${s}', '${r}': ${checkRotationStrings(s, r)}`))

Answer 4

您可以执行以下操作：

    checkRotationStrings(str1: string, str2: string) {

    if (str1.length !== str2.length) {

      return false;
    } else {

      for (var i = 0; i < str2.length; i++) {

        if (str2[i] === str1[0]) {

          var substring1 = str2.substring(0,i);
          var substring2 = str2.substring(i,str2.length);
          var concatWord = substring2.concat(substring1);

          if(str1 === concatWord){

            console.log(str1 + " matches " + concatWord)
            return true;

          }else{
            console.log(str1 + " not matches " + concatWord)

          }


        }

      }

      return false;

    }


  }

Answer 5

Stack Overflow 问题通常会以全新代码（和/或想法）的形式获得关于如何达到预期结果的答案。通常，至少会尝试帮助提问者解决他们的实际问题，在这种情况下，这似乎是在寻求对您的代码的一些帮助（一个问题至少与“切片”有关，因为你评论了）。

如果我特别喜欢它，我也喜欢提供新的代码或想法，所以我在这里只是部分批评，但迄今为止的答案完全缺乏与问题的相关性。

您所设想的检查字符串旋转的方式并没有错。你只有几个错误：

首先，因为rotationCheck 是为了旋转string 以便与rotatedString 进行比较，所以你将字符串构建颠倒了。应该是：

rotationCheck = result.concat(stringArr.slice(0, i)).join('');

其次，一旦您构建了旋转检查，您需要将其与rotatedString 进行比较，而不是string。所以：

if (rotationCheck === rotatedString){

Answer 6

我可能会迟到，但这是我的解决方案，它包括所有边缘情况。

function checkRotation(str1,str2){
  const char0 = str1[0];
  let ind = str2.indexOf(char0);
  while(ind>-1){
    const start = str2.substring(0,ind);
    const end = str2.substring(ind,str2.length);
    if(end+start === str1){
      return true;
    }
    ind = str2.indexOf(char0,ind+1)
  }
  return false
}
console.log(checkRotation("assads","adsass"))

Answer 7

与其尝试将其分解成随机的部分并进行不同的检查，不如对字母进行计数。这会简单得多：

const countLetters = a => Array.prototype.reduce.call(a, (r, l) => Object.assign(r, { [l]: (r[l] || 0) + 1 }), {});

function checkRotatedString(a, b) {
  const countA = countLetters(a);
  const countB = countLetters(b);
  
  return Object.keys(countA).length === Object.keys(countB).length 
    && Object.entries(countA).every(([key, value]) => value === countB[key]);
}

// Tests
[['waterbottle', 'lewaterbott'], ['waterbottle', 'bottlewater'], ['waterbottle', 'erbottlewat'], ['waterbottle', 'lewaterbottx']]
  .forEach(a => console.log(a, checkRotatedString.apply(null, a)));