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

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

javascript algorithm

Javascript JS：重复字符串（Hackerrank挑战）,javascript,algorithm,Javascript,Algorithm,我正在Hackerrank中进行以下挑战之一： Lilah有一串小写英文字母s，她重复了一遍无数次给定一个整数n，查找并打印莉拉无限长字符串的前n个字母。第一行包含一个字符串s。第二行包含一个整数n 我需要打印一个整数，表示无限字符串的前N个字母中字母a的数量，该字符串是通过无限多次重复s创建的例如： s为‘aba’，n=10。。无限字符串的前n=10个字母是‘abaaba…’因为有7个a，我们会得到7作为最终答案这是我的答案。它通过了前两个案例，但其余的都失败了 functio

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

Lilah有一串小写英文字母s，她重复了一遍无数次

给定一个整数n，查找并打印莉拉无限长字符串的前n个字母。第一行包含一个字符串s。第二行包含一个整数n

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

例如：

s为‘aba’，n=10。。无限字符串的前n=10个字母是‘abaaba…’因为有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;
}

函数repeatedString（s，n）{
var repeat=数学四舍五入（n/s.长度）；
var余数=n%s.长度；
var-answer=0；
对于（变量i=0；i


如果有人能看看这一点，并提出一个更好的解决方案，这将是伟大的
 第一个错误是，您对Math.round
的调用应该是Math.floor
。您可以验证代码是否工作正常，因为您的代码说明repeatedString（'cat'，2）
是2，应该是1
在再次提交之前，您应该手动运行多个健全性检查。
long repeatedcount=0；
   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;

int length=s.length（）；
长余数=n%长度；
int repeatedCountForRequires=0；
用于（int i=0；i长度）{
余数=长度；
}
for（int i=0；i<余数；i++）{
如果（s.charAt（i）='a'）{
RepeatedCountforRequires++；
}
}
RepeatedCount=（（n-余数）*RepeatedCount/length）+RepeatedCountFor余数；
intl=s.length（）；
字符串ne=“”；
长值=0；
如果（l==1&&s.charAt（0）==a）
{
值=n；
}
其他的
{
数值=0；
对于（int i=0；i#包括
#包括
使用名称空间std；
int main（）
{
chars[101]；
cin>>s；
长n；
cin>>n；
整数计数=0；
对于（inti=0；i，以下代码用于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;
    }
}

任何想要查看HackerRank原始问题的人都可以这样做（也包括在下面）。问题陈述是：
打印一个整数，表示通过无限次重复s
创建的无限字符串的第一个n字母中字母a的数量。
这有两个部分
s
被“无限”重复，但我们只需要检查长度n
我们需要计算该字符串中a的数量
让我们首先从一个简单的问题开始：编写一个函数来计算字符串中包含字符的次数

String.prototype.countCharacter=函数（char）{
返回[…this].filter（c=>c==char）.length；
}
console.log（'aaaa'.countCharacter（'a'））；//4
console.log（'aabb'.countCharacter（'b'）；/2这个问题看起来是一个字符串问题，但实际上只是一个数学问题。简单的计算。首先计算子字符串中有多少个“a”。然后确定子字符串的长度是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;
}

长透镜；
龙我；
长计数=0，c=0；
长事实=0；
len=s.长度（）；
字符串s1=s；
对于（i=0；i我尝试了迭代，但出现了运行时错误。因此，采用的方法是使用少量数学。以下是我的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;

看看我的答案，为了获得更好的性能，你可以用两个小函数来实现。所有测试都能正确通过。

函数计数（str，ln）{
让计数=0；
for（设i=0；i
这是我的答案。通过了所有测试，但没有明显优化
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;
}

静态长重复字符串（字符串s，长n）{
长计数=0；
for（char c:s.toCharArray（））
如果（c=='a'）
计数++；
长系数=（n/s.长度（））；
长rem=（n%s.length（））；
计数=系数*计数；
对于（inti=0；i以下内容确实通过了Java8中的每个测试用例
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;

    }

静态长重复字符串（字符串s，长n）{
int size=s.length（）；
长总计=0；
整数计数=0；
对于（inti=0；i，这里有一个蛮力和非蛮力方法

console.log（repeatedString（'abab'，1000））
console.log（repeatedStringBruteForce（'abab'，1000））
函数repeatedStringBruteForce（s，n）{
var stringLength=s.length；
var charIndex=0；
对于（var i=stringLength；ilet 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;

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

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

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

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

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

    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;

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

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

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

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;

    }

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

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