Question

尝试解决此HackerRank challenge：

Lilah有一个字符串， s ，由小写英文字母组成，她反复重复了无数次。

给出一个整数 n ，查找并打印Lilah无限字符串的前几个字母中的字母a的数量。

例如，如果字符串 s = abcac 和 n = 10 ，则我们认为的子字符串为 abcacabcac ，第一个她的无限字符串的10 个字符。子字符串中出现 4 个“ a”。

我写道：

function repeatedString(s, n) {

    s = s.repeat(n);
    s = s.slice(0, n);
    
    let array = Array.from(s);
    let count = 0;
    for (let i = 0; i < array.length; i++) {
        let char = array[i];
        if (char.match(/[a]/gi)) {
            count++;
        }
    }
    return count;
}
console.log(repeatedString("abcac", 10));

但是HackerRank显然不喜欢s = s.repeat(n);：

我不确定如何另外生成适当长度的字符串以进行切片。 s = s.repeat(Infinity)不起作用，并且s作为参数传递时已经不是重复了无数次。

即console.logging，最初是日志

abcac

在这种情况下。

我也尝试过：

function repeatedString(s, n) {

  let j = n;
  let newString = "";
  while (n > 0) {
      newString += s;
      n--;
  }
  
  newString = newString.slice(0, j);
  let count = 0;
  let array = Array.from(newString);
 
  for (let i = 0; i < array.length; i++) {
      let char = array[i];
      if (char.match(/[a]/gi)) {
          count++;
      }
  }
  return count;
}
console.log(repeatedString("abcac", 10));

但这导致超时错误。

还有其他关于如何创建有效长度的字符串以供切片的想法吗？

编辑：

约束：

1 <= | s | <= 100

1 <= n <= 10 ^ 12

对于 25％的测试用例， n <= 10 ^ 6

Answer 1

实际上重复字符串 n 次会极大地浪费内存和运行时间。

只需计算整个字符串重复的频率乘以该字符串包含的htonl的数量加上a部分中a的数量

您的运行时间从s.slice(0, n%s.length)降到s.length

Answer 2

我对此进行了测试，并且知道它可以工作。本质上，我不是在创建新的字符串，我只是发现我必须乘以原始字符串多少次才能截断它。然后我将该数字乘以原始字符串中有多少个a。

function repeatedString(s, n) {

    var charLength = s.length;
    var repeat = Math.floor(n/charLength);
    var remainder = n%(charLength);
    var strCut = s.slice(0, remainder);
    
    let count = 0;
    let arrayX = Array.from(s);
    for (let i = 0; i < arrayX.length; i++) {
        let char = arrayX[i];
        if (char.match(/[a]/gi)) {
            count++;
        }
    }
    
    count = count * repeat;
    
    let arrayY = Array.from(strCut);
    for (let i = 0; i < arrayY.length; i++) {
        let char = arrayY[i];
        if (char.match(/[a]/gi)) {
            count++;
        }
    }

    return count;
}

console.log(repeatedString("abcac", 10));

Answer 3

我使用.repeat尝试了一个小型解决方案，但正如Thomas所说的那样，它很昂贵，并且花了很多时间来运行测试。

function repeatedString(s, n) {
    const allAs = s.match(/a/g);
    if (!allAs) {
        return 0;
    }
    if (s === 'a') {
        return n;
    }
    const reps = s.repeat(Math.ceil(n/s.length)).slice(0, n).match(/a/g)
    if (!reps) return 0;
    return reps.length;
};

console.log(repeatedString('abc', 10));
console.log(repeatedString('abcde', 10));

但是我遵循了Thomas的想法，并提出了一个更简单的解决方案

function repeatedString(s, n) {
    const allAs = s.match(/a/g);
    if (!allAs) {
        return 0;
    }
    if (s === 'a') {
        return n;
    }
    const rem = n % s.length;
    const reps = (n-rem)/s.length;
    let count = reps * allAs.length;
    if (rem) {
        const rest = s.slice(0, rem).match(/a/g);
        if (rest) count = count + rest.length
    }
    return count;
}

console.log(repeatedString('a', 100000));
console.log(repeatedString('abcde', 10000000000));

Answer 4

您可以使用while循环重复原始字符串，直到长度匹配为止，然后使用match来计数a的数量。

function repeatedString(s, n) {
  let i = 0, l = s.length;
  while (s.length < n) s += s[i++ % l]
  return s.match(/a/g).length;
}
console.log(repeatedString("abcac", 10));

Answer 5

我做了这段代码，效果很好。

function repeatedString(s, n) {
    let modulus = n % s.length;
    let repetition = (n - modulus) / s.length;
    let remainCounts = s.slice(0, modulus).split("").filter((item) => item == "a").length
    
    return (s.split("").filter((item) => item == "a").length * repetition) + remainCounts
}

enter image description here

无限重复字符串-在N个无限字符串长度内返回特定字符的计数-JavaScript

5 个答案: