簡體   English   中英

JS:重復​​字符串(Hackerrank 挑戰)

[英]JS: Repeated string (Hackerrank Challenge)

我正在 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;
}

如果有人可以看看這個並提出更好的解決方案,那就太好了。

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

任何想在 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 lengthn測試用例,因此我們需要采用更高級別的方法。

我們知道字符串s有多少個 a,它們將被重復——如果我們重復m次,我們將得到m * s.countCharacter('a') a's,其中m > (n/l)並且ls.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

HackerRank 問題描述。

第一個錯誤是您對Math.round的調用應該是Math.floor 您可以驗證代碼是否正常工作,因為您的代碼表明repeatedString('cat', 2)是 2,它應該是 1。

在再次提交之前,您應該手動運行幾次完整性檢查。

這個問題似乎是一個字符串問題,但實際上它只是一個數學問題。 簡單的計算。 首先計算子串中有多少個“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;
}

}

我嘗試了迭代,但出現運行時錯誤。 所以要走的方法是使用很少的數學。 這是我的 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;

看看我的回答,你可以用兩個小函數來實現,以獲得更好的性能。 所有測試均正確通過。 我將基准與使用 .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)
    );
}

所以這是我對此的回答。 通過了所有測試,但沒有明顯優化。

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

下面確實通過了 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;

    }

這是蠻力和非蠻力方法

 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 }

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

我最近通過首先過濾掉給定字符串中出現的模式並將其乘以字符串的出現來解決這個挑戰。 第 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;
}
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 進行驗證。

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

以下代碼適用於 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;
    }
}
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))
    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;
// 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;
}

暫無
暫無

聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.

 
粵ICP備18138465號  © 2020-2024 STACKOOM.COM