It counts the number of "a" in a full string, and in the last, potentially partial string, and calculates the total amount of "a" based on that.

"a" count of full string * number of string repeats + "a" count of last string.

I think it's important to note the difference between '/' and '//' in python 3. '/' will return a decimal number, whereas '//' uses truncate division (floor division) returning a whole number.

I used the same logic but a simpler code. It's the same thing so you can understand. at first s.count("s") will give the number of a's in one substring. Multiplying that with (n//len(s)), which is the number of complete substrings present in that repeated string, gives the number of a's till that part. Now what's left is a smaller (incomplete) part of the substring which is s[0:n%len(s)] ( length of the remaining = the remainder). We just find the number of a's in that part and add it to the previous value of count

Do you think the Python interpreter would do the optimization for you?

And why count the same thing twice? :)

s = input()
n = int(input())
d, r = divmod(n, len(s))
print(s.count('a', 0, r) * (d + 1) + s.count('a', r) * d)

I'll explain here with an example, suppose the input is:

aba
10

n = 10, means the string s = "aba" is repeated over the course of 10 letters, i.e. abaabaabaa. Now, we break this string further down. First part, the exactly divisible part, s1 = "abaabaaba" and the second part, the remainder part, s2 = "a". To represent the count of a in s1 and s2, we have, int(n/len(s)) or n//len(s) and s[:n%len(s)], multiplied by count of a in s, respectively.

string slicing s[ : : ]

The ":" allows Python select (Slice) all the elements before the nth element.

s = (abacde)

s[:3] = (aba)

So if n is 3, this allows Python to select all elements up to, but not including the 3rd item.

If you are calling it more readable you should have managed to format it properly at the least.

Thank you :)

This is a great one, thank you.

Forces me to think about the input string as a single unit as opposed to just concatenating the string onto itself until it reached the length of n and checking for the amount of a's in the resulting string like i originally did.

Really good solution

perhaps you don't need to use filter if you split str by 'a'

const repeatedString = (s, n) => {
    const countA = s => s.split('a').length - 1;

    let len = s.length;
    let reps = Math.floor(n / len);
    let remainder = s.slice(0, n % len);

    return reps * countA(s) + countA(remainder);
};

nice solution, very similar to mine!

countAs looks a bit uglier, but I tried to avoid transforming to array.

Also, I think it is almost the same, but you could use % for calculating the rest

function repeatedString(s, n) {

  countAs = (s, index) => {
    let count = 0;
    while (index >= 0) {
        if (s[index] == 'a') count++;
        index--;
    }
    return count;
  };
  if (n <= s.length) {
    return countAs(s, n - 1);
  } else { 
    const parts = Math.floor(n / s.length);
    const rest = n % s.length;
    return countAs(s, s.length - 1) * parts + countAs(s, rest - 1);
  }
}

I did the same but with regex:

 function repeatedString(s, n) {
     const count = (s) => s.replace(/[^a]/g, '').length;
     return count(s) * (parseInt(n / s.length)) +
		 count(s.substr(0, n % s.length));
 }

Based on your code i reached the solution below:

            double r = 0;

    foreach (char c in s)
    {
        if (c == 'a')
        {
            r++;
        }
    }
    r = ( r * (n/ s.Length));
    for (int i = 0; i < n % s.Length; i++)
    {
        if (s[i] == 'a')
        {
            r++;
        }
    }
    return Convert.ToInt64(r);

PS.: Not tested against "n < len(s)".

here is my code in C#: I am also getting 10/23 cases wrong.

              int len = s.Length;
        long cnt = 0;
        string remStr;
        long repeats = 1, finalCnt,remCnt;

        if (len > 1)
        {
            int rem = (int)n % len;
            repeats = (n-rem)/len;           

            cnt = s.Split('a').Length - 1;
            finalCnt = cnt * repeats;

            remStr = s.Substring(0, rem);
            remCnt = remStr.Split('a').Length - 1;

            finalCnt = finalCnt + remCnt;
            return finalCnt;
        }
        else
        {
            if ((s == "a")&&(len==1))
            {
                return n;
            }
            else
                return 0;
        }

You can write the same as

return sum(s[i % len(s)] == 'a' for i in range(n))

But how efficient is it for ?

int main(){
    string s;
    cin >> s;
    long n;
    cin >> n;
    long count=0;
    int i,k=s.size();
    long p=n/k;
    
      for(i=0;i<s.size();i++){
        if(s[i]=='a')
            count++;
      }
    
    count = count * p;
    
    for(i=0;i<(n%s.size());i++){
        if(s[i]=='a')
            count++;
    } 
    cout << count << endl;
        return 0;
}

More simplified cpp solution,i hope this will be heplful

Great..!

Thanks for the suggestion

numOfS calculates how many times string s has appeared as a complete string, up to nth character in the infinite string . rest represents the number of characters left after finding out number of s.

For example, let's say we have a string s "abcd" and n is equal to 10. The infinite string will be something like "abcdabcdabcd...". Then, we can break this infinite string into substrings like this up to 10th character, abcd/abcd/ab. In this case, we have 2 complete sets of s and a partial s which contains only 2 characters.

numOfS gives us 2.5, but long is a type of integer so the result becomes 2 and 0.5 is gone. The value 2.5 means we have 2 complete sets of s and 0.5, half of s. Since ab is not a complete s, we need to figure out how to pick up that 0.5 we dropped above.

Now, rest counts what's left, remainders. 10 % 4 is 2. Finally, these results will be passed onto aCounter, which literally counts the number of As in the string, depending on the algorithm.

The rest is pretty easy to understand :)

String manipulation can be deceptive! I was going through with the mindset during my planning phase of splitting the string with a substring() at long index but quickly realized that is not allowed.

Tried a few different tricks and came upon this solution. I was 1/2 of the way there. Thank you for this.

Of course, 'ca' is the remaining 'a' characters, while 'c' is the total amount of characters in the given string without the remaining. 'r' is the remaining that doesn't fit into the 'n', so ((n - r) / s.length * c) is the amount of characters whitout the remainings of 'a' characters. The remaining must be counted only if is not greater than the index (i < r). So the total amount without the remaining + the remaining 'ca' is the result.

Hello @fmuiin14 , I have explained in the response for the @hmndz question

((10 - 1) / 3 * 2) + 1 is (9)/3 * 2 + 1 not (9/6) +1

in which part of this code you can't understand

@DKODD

Woah did you just try to flirt lol

count = count*(n/l)+ count1 breakdown:

count*(n/l) is needed because count only recorded the amount of times that 'a' occuranced in the oringial string (i.e not the repeated string). So we need to multiply the count by the amount of times the string was repeated.

A better way of seeing is it is count*repeats + leftover occurances

"+ count1" is needed since there could be strings with leftover 'a's, and we've already kept track of that with the second for loop

I hope this helps