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和2作为参数使用，并与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

这是一个有点奇怪的解决方案，因为它仅对index参数使用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 3

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

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 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以便将其与rotateString进行比较，因此您可以将字符串构建反转。它应该是：

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

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

if (rotationCheck === rotatedString){

Answer 6

不是试图以随机碎片打破它并进行不同的检查，而是可以对字母进行计数。这会简单得多：

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)));

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

6 个答案: