JS：重复字符串（Hackerrank Challenge）答案

【问题标题】：JS: Repeated string (Hackerrank Challenge)JS：重复字符串（Hackerrank Challenge）
【发布时间】：2018-11-27 23:07:21
【问题描述】：

我在 Hackerrank 中做如下挑战之一：

Lilah 有一个字符串 s，由她重复的小写英文字母组成无限多次。

给定一个整数 n，找出并打印出字母 a 的个数 Lilah 无限字符串的前 n 个字母。第一行包含一个字符串 s。第二行包含一个整数 n。

我需要打印一个整数，表示无限重复 S 多次创建的无限字符串的前 N 个字母中字母 a 的数量。

例如：

s 是 'aba', n = 10.. 无限字符串的前 n = 10 个字母是 'abaabaabaa...' 因为有 7 个 a，所以我们会得到 7 作为最终答案

这是我的答案。它通过了前两个案例，但其余的都失败了。

function repeatedString(s, n) {
    var repeat = Math.round(n / s.length);
    var remainder = n % s.length;
    var answer = 0;
    for (var i = 0; i < s.length; i++) {
        if (s.charAt(i) == 'a') {
            answer += repeat;
            if (i < remainder)
                answer++;
        }
    }
    return answer;
}

如果有人可以看看这个并提出更好的解决方案，那就太好了。

【问题讨论】：

编程的美妙之处在于通过反复试验找到解决方案。并用你的头。我什至不明白这里的问题描述。
我会先计算remainder。然后从n 中减去remainder 并除以s.length。这样您就可以得到准确的整数商，而无需 Math.round 或 Math.floor。

标签： javascript algorithm

【解决方案1】：

//From a website i found it.

 const as = s.split("").filter(c => c === "a").length;
        const times = parseInt(n / s.length);
        const rest = n % s.length;

        const totalAs = times * as
            + s.slice(0, rest).split("").filter(c => c === "a").length

        return totalAs;

【讨论】：

我认为我们可以使用 Math.floor() 而不是 parseInt() 因为 Math.floor() 是有意义的

【解决方案2】：

任何想在 HackerRank 上查看原始问题的人都可以这样做here（也包括在下面）。问题陈述是：

打印一个整数，表示无限次重复`s` 创建的无限字符串的前`n` 字母中字母a 的数量。

这有两个部分。

s 被“无限”重复，但我们只需要检查到长度 n。
我们需要计算该字符串中 a 的数量。

让我们先从一个简单的问题开始：编写一个函数来计算一个字符包含在字符串中的次数。

String.prototype.countCharacter = function(char) {
    return [...this].filter(c => c === char).length;
}

console.log('aaaa'.countCharacter('a')); // 4
console.log('aabb'.countCharacter('b')); // 2

现在是棘手的部分。我们可以天真地使用String.repeat() 重复字符串，直到它的长度大于n，但是对于任意大的n，这变得不切实际。事实上，HackerRank 为我们提供了一个比max string length 更大的n 测试用例，因此我们需要采用更高级别的方法。

我们知道字符串s 中有多少个a，这将被重复 - 如果我们重复它m 次，我们将有m * s.countCharacter('a') a's，其中m > (n/l) 和l 是s.length .这并不像看起来那么复杂：我们将需要重复字符串，直到我们得到一个长度大于n 的字符串，并且我们可以存储我们需要重复字符串以达到（或 go结束）n 在一个名为 repeatsRequired 的变量中，它只是 n / l 向上取整。

从那里，很容易判断该字符串有多少个字符，并且我们可以用charactersRequired % l 来判断有多少额外个字符。如果我们知道最后会有多少多余的字符，我们可以切掉s的多余部分并计算a的数量，a的总数为：

(number of a's in s) * (repeats required - 1)
+ (number of a's in final partial repeat)

String.prototype.countCharacter = function(char) {
  return [...this].filter(c => c === char).length;
}

// Complete the repeatedString function below.
function repeatedString(s, n) {

  const l = s.length,
        repeatsRequired = Math.ceil(n / l),
        charsRequired = repeatsRequired * l,
        numCharsInLastRepeat = l - (charsRequired % n);

  const a_s = s.countCharacter('a'),
        a_r = s.slice(0, numCharsInLastRepeat).countCharacter('a');

  return a_s * (repeatsRequired - 1) + a_r;
}

console.log(repeatedString('aba', 10)); // 7
console.log(repeatedString('a', 1000000000000)); // 1000000000000

【讨论】：

为什么是(repeatsRequired - 1)？

【解决方案3】：

第一个错误是您对Math.round 的调用应该是Math.floor。您可以验证代码是否无法正常工作，因为您的代码说 repeatedString('cat', 2) 是 2，应该是 1。

在再次提交之前，您应该再手动运行几次健全性检查。

【讨论】：

【解决方案4】：

查看我的答案，您可以使用两个小功能来获得更好的性能。所有测试都正确通过。 I am attaching the benchmark comparing with other methods that use .split, .replace, .filter, .match

function countAs(str, ln) {
  let count = 0;
  for (let i = 0; i < ln; i++) {
    if (str[i] === 'a') {
      count++;
    }
  }
  return count;
}

function repeatedString(s, n) {
    return (
        countAs(s, s.length) * parseInt(n / s.length, 10) +
        countAs(s, n % s.length)
    );
}

【讨论】：

【解决方案5】：

function repeatedString(s,n) {

    if(s.includes('a')) {
  
      const sTotal = Math.floor(n / s.length); // repeated string total 
      const aCount = s.match(/a/g).length; // 'a' character count in s
      let aTotalCount = sTotal * aCount; // total 'a' count of repeated string pattern within number limit
      const remainingChar = n % s.length;  // remaining characters after repeating string within number limit
      
     // if there are remaining characters, add them to the total 'a' count. 
      if(remainingChar !== 0 && s.substr(0,remainingChar).includes('a')) {
          aTotalCount += s.substr(0,remainingChar).match(/a/g).length;
      }
        
      aTotalCount = Math.floor(aTotalCount);
      return aTotalCount;
      
    } else {
      return 0;
    }

}

这就是我想出的。通过所有 22 个测试用例的 Hacker Rank 验证。

【讨论】：

请在帖子中添加问题陈述

【解决方案6】：

function repeatedString(s, n) {
    return (s.match(/a/g) || []).length * Math.floor(n/s.length) + (s.substring(0, n % s.length).match(/a/g) || []).length;
}

【讨论】：

这是一款非常酷的单线。谢谢

【解决方案7】：

这个问题看起来是一个字符串问题，但实际上它只是一个数学问题。简单的计算。首先计算子字符串中有多少个“a”。然后 id 子串的长度是 n 的完美因子，那么 length*(n/substrlength) 就是 ans。否则，如果它不是一个完美的因素，那么在剩余（n%substrlength）字符串中找到多少个“a”，只需将其添加到初始结果中即可。 //C++代码

long len;
long i;
long count=0,c=0;
long fact=0;
len=s.length();
string s1=s;
for(i=0;i<s.length();i++)
{
    if(s[i]=='a')
    {
        count++;
    }
}
fact=n/len;
long sum=count*fact;
if(n%len==0)
{
    return sum;
}
else
{
    for(i=0;i<n%len;i++)
    {
        if(s[i]=='a')
        c++;
    }
    return sum+c;
}

}

【讨论】：

【解决方案8】：

我尝试了迭代，但出现了运行时错误。所以要走的方法是使用很少的数学。这是我的 Java 代码。

    long left = n % s.length();
    long most = s.chars().filter(c -> (char) c == 'a').count();
    long last = s.substring(0, (int) left).chars().filter(c -> (char) c == 'a').count();
    long repeated = n / s.length();

    return most * repeated + last;

【讨论】：

【解决方案9】：

这就是我对此的回答。通过了所有测试，但没有明显优化。

function repeatedString(s, n) {
    if (!s) {
        return 0;
    }

    if (!n) {
      return 0;
    }
    n = Number(n);
    const numOfA = s.split("").filter((e) => e === "a").length;
    const numOfLetters = s.length;
    const subStringOccurences =
      numOfLetters > 0 ? Math.floor(n / numOfLetters) : 0;
    const remaingOfLetters = n - (subStringOccurences * numOfLetters);
    const remaingA =
      remaingOfLetters > 0
        ? s
            .slice(0, remaingOfLetters)
            .split("")
            .filter((e) => e === "a").length
        : 0;
    return subStringOccurences * numOfA + remaingA;
}

【讨论】：

【解决方案10】：

static long repeatedString(String s, long n) {        
        long count =0;
        for(char c : s.toCharArray())
            if(c == 'a')
            count++;

         long factor = (n/s.length());
         long rem = (n%s.length());
         count =  factor*count  ;
        for(int i=0;i<rem;i++)
            if(s.charAt(i)=='a')
                    count++;  
            return count;
        
        }

【讨论】：

虽然此代码可能会为问题提供解决方案，但最好添加有关其工作原理/方式的上下文。这可以帮助未来的用户学习并将这些知识应用到他们自己的代码中。在解释代码时，您也可能会以赞成票的形式从用户那里获得积极的反馈。

【解决方案11】：

以下确实通过了 java 8 中的每个测试用例！！

static long repeatedString(String s, long n) {
        int size = s.length();
        long total = 0;
        int count = 0;
        for(int i =0;i<size;i++){
            if(s.charAt(i)=='a'){
                total++;
                if(i<(n % size))
                count++;
            }
        }
        long repeat = (long)n/size; 
        total = total*repeat;
        return total+count;

    }

【讨论】：

【解决方案12】：

这里有一个蛮力和非蛮力的方法

console.log(repeatedString('abab',1000))
console.log(repeatedStringBruteForce('abab',1000))

function repeatedStringBruteForce(s, n) {
    var stringLength = s.length;
    var charIndex = 0;
    for (var i = stringLength; i < n; i++) {
        s += s[charIndex];
        charIndex++;
    }

    return s.split('a').length - 1
}

function repeatedString(s, n) {
    // Get number of A's in original given string
    var aNum = s.split('a').length - 1;
    // Calculate number of given strings that fit into n
    var numOfStrings = Math.floor(n / s.length);
    // Get Total Number A's by multiplying the number of strings that fit by the number of A's in original string
    var totalAs = aNum * numOfStrings;
    // Now get the remainder string that couldnt fit
    var remainder = (n % s.length)/s.length;
    var leftOverStringLength = Math.floor(remainder * s.length);
    // Get the left over substring 
    var leftOverString = s.substring(0, leftOverStringLength);
    // Add any left over A's to our total A's
    totalAs += leftOverString.split('a').length - 1;

    return totalAs
}

【讨论】：

【解决方案13】：

const repeatedString = (s, n) => {
   const lengthOfS = s.length;
   const numberOfAInS = s.split('').filter(item => item === 'a').length;
   let aInRest = 0;
   if (n % lengthOfS !== 0) {
   aInRest = s
     .slice(0, n % lengthOfS)
     .split('')
     .filter(item => item === 'a').length;
   }
   return parseInt(n / lengthOfS) * numberOfAInS + aInRest;
};

【讨论】：

【解决方案14】：

我最近接受了这个挑战，通过首先过滤掉给定字符串中出现的模式并将其乘以字符串的出现来解决它。第 2 步是检查字符串出现是否正在完成，如果没有完成，则在子字符串中查找模式：

function repeatedString(s, n) {
let count = s.split('').filter(el => el === 'a').length;
count *= Math.floor(n/s.length);

if ((n % s.length) !== 0) {
    const subStr = s.slice(0, n % s.length );
    const patterStr = subStr.split('').filter(el => el === 'a');
    count += patterStr.length;
}

return count;
}

【讨论】：

【解决方案15】：

``javascript`：

函数重复字符串（s，n） {

        if (s.includes("a") && n > 0)
        {
            var m = (n / s.Length);
          
             let matchCnt = 0;


            matchCnt =  (s.match(/a/g) || []).length;
                

            
            if (s.Length == matchCnt)
            {
                return n;
            }
            else
            {
                if (n == s.Length)
                {
                    return matchCnt;
                }
                else if (n < s.length)
                {
                    var newStr = s.Remove(Convert.ToInt32(n));
                    var newStr = s.substring(n)
                    newStr = s.replace(newStr, "");
                    matchCnt =  (newStr.match(/a/g) || []).length;
                
                    return matchCnt;
                }
                else
                {
                    if (n % s.length == 0)
                    {
                        return matchCnt * n;
                    }
                    else if (n % s.length != 0)
                    {
                        var extra = n % s.length;

                          if (extra > 1)
                        {
                            return  (n / s.length) * matchCnt;
                        }
                        else
                        {
                            return extra + (n / s.length) * matchCnt;
                        }
                    }
                }
            }
        }
        return 0;
}

c # : 公共静态长重复字符串（字符串 s，长 n） { char str = 'a';

        if (s.Contains("a") && n > 0)
        {
            var m = (Convert.ToDouble(n) / s.Length);
            var matchCnt = s.Count(x => x == str);
            if (s.Length == matchCnt)
            {
                return n;
            }
            else
            {
                if (n == s.Length)
                {
                    return matchCnt;
                }
                else if (n < s.Length)
                {
                    var newStr = s.Remove(Convert.ToInt32(n));
                    matchCnt = newStr.Count(x => x == str);
                    return matchCnt;
                }
                else
                {
                    if (n % s.Length == 0)
                    {
                        return matchCnt * n;
                    }
                    else if (n % s.Length != 0)
                    {
                        var extra = n % s.Length;

                          if (extra > 1)
                        {
                            return  (n / s.Length) * matchCnt;
                        }
                        else
                        {
                            return extra + (n / s.Length) * matchCnt;
                        }
                    }
                }
            }
        }
        return 0;
}

【讨论】：

【解决方案16】：

   long repeateCount=0;
int length =s.length();
long remainder=n%length;
int repeateCountForRemainder=0;

for(int i =0;i<length;i++){
    if(s.charAt(i)=='a'){
        repeateCount++;
    }
}

if(remainder !=0 && remainder>length){
    remainder=length;
}
for(int i =0;i< remainder;i++){

    if(s.charAt(i)=='a'){
        repeateCountForRemainder++;
    }
}

repeateCount = ((n-remainder)*repeateCount/length)+ repeateCountForRemainder;

【讨论】：

【解决方案17】：

function repeatedString(s, n) {
  var noOfa = s.length - s.replace(/a/g, "").length;
  var r = n % (s.length);
  var remaining = (s.substring(0, r)).length - (s.substring(0, r)).replace(/a/g, "").length;

  return noOfa * (Math.floor(n / (s.length))) + remaining;
}

【讨论】：

虽然此代码可能会回答问题，但提供有关它如何和/或为什么解决问题的额外上下文将提高答案的长期价值。

【解决方案18】：

#include<iostream>
#include<string.h>
using namespace std;
int main()
{
char s[101];
cin>>s;
long long n;
cin>>n;
int count=0;
for(int i=0;i<strlen(s);i++)
{
    if(s[i]=='a')
    count++;
}
long long d = (n/strlen(s))*count;
long long m = n%strlen(s);
for(int i=0;i<m;i++)
{
    if(s[i]=='a')
    d++;
}
cout<<d;
}
//Correctly working solution

【讨论】：

欢迎来到stackoverflow。请添加一些文本来描述为什么您的代码 sn-p 解决了 OP 的问题。欲了解更多信息，请点击此处：How to Answer

【解决方案19】：

let finalCounter;

if (s.length === 1 && s==='a') {
  return n;
} else if (s.length === 1 && s !=='a') {
  return 0;
}

const aCounter = (s.match(/a/g)||[]).length;
if (aCounter === 0) {
  return 0;
}
const times = Math.floor(n/s.length);
const counterExact = aCounter * times;
const remainCount = n%s.length;
const substr = s.substring(0, remainCount);
const extraCounter = (substr.match(/a/g)||[]).length;
finalCounter = counterExact+extraCounter;
return finalCounter;

【讨论】：

【解决方案20】：

const computeNumOfReapitedA = (s) => {

    return s.split('').filter(character => {
        return character === 'a';
    });
};

const computeNumOfOccurrences = (s, numOfChars) => {

    let quotient = Math.floor(numOfChars/s.length);
    let remainder = numOfChars % s.length;

    return computeNumOfReapitedA(s).length * quotient + computeNumOfReapitedA(s.substr(0, 
           remainder)).length;  
};

【讨论】：

【解决方案21】：

以下代码适用于 5 个测试用例。

对于其余部分，它未能引发运行时错误。

static long repeatedString(string s, long n)
{
    int count = 0, k = 0;
    do {
        n--;
        if (s[k] == 'a') {
            count++;
        }
        if (k==s.Length-1) {
            k = -1;   
        }
        k++;
    } while (n>=0);
        return count;
    }
}

【讨论】：

【解决方案22】：

def repeatedString(s, n):

  aois = s.count('a')
  soq = math.floor(n/len(s))
  sol = n-(soq*len(s))
  sl= s[0:int(sol)]
  aoisl = sl.count('a')
  return int(((aois*soq)+aoisl))

【讨论】：

虽然这可能是一个更好的算法，但不幸的是它不是 OP 要求的 JavaScript

【解决方案23】：

    int l=s.length();
    String ne="";
    long value=0;
    if(l==1&&s.charAt(0)=='a')
    {
        value=n;
    }

    else
    {
        value=0;
        for(int i=0;i<=(n/l)+1;i++)
        {
            ne=ne+s;
        }
        for(int i=0;i<n;i++)
        {
            if(ne.charAt(i)=='a')
            {
                value++;
            }
        }
    }
    return value;

【讨论】：

请补充说明

【解决方案24】：

// Complete the repeatedString function below.
static long repeatedString(String s, long n) {
    long stringLength = s.length();
    char[] charArray = s.toCharArray();
    int count=0;
    if(s.equals("a")){
        return n;
    }
    for(char character : charArray){
        if(character == 'a'){
            count++;
        }
    }
    int rem = (int)(n % stringLength);
    count *= (n/stringLength);
    if(rem != 0){
        char[] subString = s.substring(0,rem).toCharArray();
        for(char character : subString){
            if(character == 'a'){
                count++;
            }
        }
    }
    return count;
}

【讨论】：

您能否补充说明这是如何解决问题的？
问题是需要在重复的无限字符串中显示 a 的计数，这意味着你可以在一个字符串中计算 a 并且你可以乘以重复次数在这有两种可能，其中 n 是数字字符数需要重复 1) n 可能等于 0 表示 n % stringLength = 0 2) n 可能不等于 0 那么您的解决方案应该是字符串中包含的字符数 * n/stringLength + 余数中包含的字符字符串长度

打印一个整数，表示无限次重复s 创建的无限字符串的前n 字母中字母a 的数量。

打印一个整数，表示无限次重复`s` 创建的无限字符串的前`n` 字母中字母a 的数量。