JS：重复​​字符串（Hackerrank 挑战）

Question

我正在 Hackerrank 中进行以下挑战之一：

Lilah 有一串小写英文字母 s，她无限次重复了这个字符串。

给定一个整数 n，找出并打印 Lilah 无限字符串的前 n 个字母中字母 a 的数量。 第一行包含一个字符串，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;
}

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

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

Answer 2

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

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

这有两个部分。

1. s被“无限地”重复，但我们只需要检查长度为n 。
2. 我们需要计算该字符串中 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 . s.length . 这并不像看起来那么复杂：我们需要重复该字符串直到我们得到一个长度大于n的字符串，并且我们可以存储我们需要重复该字符串以达到（或超过）的次数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

Answer 3

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

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

Answer 4

这个问题似乎是一个字符串问题，但实际上它只是一个数学问题。 简单的计算。 首先计算子串中有多少个“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;
}

}

Answer 5

我尝试了迭代，但出现运行时错误。 所以要走的方法是使用很少的数学。 这是我的 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;

Answer 6

看看我的回答，你可以用两个小函数来实现，以获得更好的性能。 所有测试均正确通过。 我将基准与使用 .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)
    );
}

Answer 7

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

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

Answer 8

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

Answer 9

下面确实通过了 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;

    }

Answer 10

这是蛮力和非蛮力方法

 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 }

Answer 11

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

Answer 12

我最近通过首先过滤掉给定字符串中出现的模式并将其乘以字符串的出现来解决这个挑战。 第 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;
}

Answer 13

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 进行验证。

Answer 14

``javascript`：

函数repeatString(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# : public static long重复字符串(string s, long 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;
}

Answer 15

   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;

Answer 16

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

Answer 17

#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

Answer 18

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;

Answer 19

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

Answer 20

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

Answer 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;
    }
}

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

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

Answer 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;
}