The details for the problem detailed in this post can be found at
<a className="text-base font-semibold text-indigo-600 hover:text-indigo-500" href="https://www.hackerrank.com/challenges/jumping-on-the-clouds/problem">https://www.hackerrank.com/challenges/jumping-on-the-clouds/problem</a>

**The following solution is written in Javascript.**

## Problem

There is a new mobile game that starts with consecutively numbered clouds. Some of the clouds are thunderheads and others
are cumulus. The player can jump on any cumulus cloud having a number that is equal to the number of the current cloud
plus 1 or 2. The player must avoid the thunderheads. Determine the minimum number of jumps it will take to jump from the
starting position to the last cloud. It is always possible to win the game.

Breaking down the challenge into blocks of requirements, we get:

- **int 0** = Safe Cloud
- **int 1** = Unsafe Cloud
- **int c[n]** = Clouds - an array of binary integers
- **Jump** = To any cumulus that is c[i+1] or c[i+2]

### Example

<SyntaxHighlighter language="javascript" style={style}>
    {`
    c = [0, 1, 0, 0, 0, 1, 0]
  `}
</SyntaxHighlighter>

Index the array from 0...6. The number on each cloud is its index in the list so the player must avoid the clouds at indices
1 and 5. They could follow these two paths: 0 > 2 > 4 > 6 or 0 > 2 > 3 > 4 > 6 . The first path takes 3 jumps while the second takes 4.
Return 3.

### Function Description

jumpingOnClouds has the following parameter(s):
- **int c[n]**: an array of binary integers

### Returns

- **int**: the minimum number of jumps required

### Input Format

The first line contains an integer **n**, the total number of clouds. The second line contains **n** space-separated
binary integers describing clouds **c[i]**.

### Sample Input 0

<SyntaxHighlighter language="javascript" style={style}>
    {`
    7
    0 0 1 0 0 1 0
  `}
</SyntaxHighlighter>

### Sample Output 0

<SyntaxHighlighter language="javascript" style={style}>
    {`
    4
  `}
</SyntaxHighlighter>

### Explanation

The player must avoid c[2] and c[5]. The game can be won with a minimum of 4 jumps:

![Hacker Rank jumping on cloud](https://s3.amazonaws.com/hr-challenge-images/20832/1461134731-c258160d15-jump2.png "Hacker Rank Jumping on Clouds")

### Sample Input 1

<SyntaxHighlighter language="javascript" style={style}>
    {`
    6
    0 0 0 0 1 0
  `}
</SyntaxHighlighter>

### Sample Output 0

<SyntaxHighlighter language="javascript" style={style}>
    {`
    3
  `}
</SyntaxHighlighter>

### Explanation

The player must avoid c[4]. The game can be won with a minimum of 3 jumps:

![Hacker Rank jumping on cloud](https://s3.amazonaws.com/hr-challenge-images/20832/1461136358-764298d363-jump5.png "Hacker Rank Jumping on Clouds")

### Goal

For each game, you will get an array of clouds numbered 1 if they are safe or 2 if they must be avoided. Write a function
that returns the minimum number of jumps required.

### Constraints & Validation

- The number of socks clouds will be more than 2 but less than 100
- Each cloud will be 1 or 0

<SyntaxHighlighter language="javascript" style={style}>
    {`
    2 <= n <= 100
    c[i] will consist of {0,1}
  `}
</SyntaxHighlighter>

### First Attempt Solution

The first solution I came up with created an array with the path indexes and returned the path length.

<SyntaxHighlighter language="javascript" style={style}>
    {`
    function jumpingOnClouds(c) {

        let path = [];

        for(let i = 0; i < c.length; i++){
            if(c[i+2] == 0) {
                if(i != 0) path.push(i);
                i ++;
            } else if (c[i+1] == 0) {
                if(i != 0) path.push(i);
            }
            if(i == c.length - 1) path.push(i)
        }
        return path.length;
    }
`}
</SyntaxHighlighter>

### Refactored Solution 1

While looking to refactor the code I realised that each index of **c** could be used as a boolean (true or false).

Using this we can replace the if statement with a ternary statement and just compute the number of jumps.

<SyntaxHighlighter language="javascript" style={style}>
    {`
    function jumpingOnClouds(c) {

            let jumps = 0;

            for(let i = 0; i < c.length - 1;){
                i += (c[i+2] ? 1 : 2);
                jumps++;
            }
            return jumps;
        }
`}
</SyntaxHighlighter>

### Refactored Solution 2

The refactored solution above made me think that you could achieve the same simplicity with a while loop.

<SyntaxHighlighter language="javascript" style={style}>
    {`
    function jumpingOnClouds(c) {

        let jumps = 0,
            currentCloud = 0;

        while (currentCloud < c.length-1) {
            currentCloud += (c[currentCloud+2] ? 1 : 2);
            jumps++;
        }
        return jumps;
    }
`}
</SyntaxHighlighter>

### Conclusion

I'm not sure which of the two refactored solutions above is more optimal, with a simple enough function like the one above
I doubt there is any difference in speed, however the second solution using the while loop is definitely easier to read.



Given the sequence of up and down steps, find the number of valleys walked through

hrcc-jumping-on-clouds.png

HackerRank Jumping on the Clouds Challenge


The details for the problem detailed in this post can be found at
<a className="text-base font-semibold text-indigo-600 hover:text-indigo-500" href="https://www.hackerrank.com/challenges/ctci-array-left-rotation/problem">https://www.hackerrank.com/challenges/ctci-array-left-rotation/problem</a>

**The following solution is written in Javascript.**

## Problem

A left rotation operation on an array shifts each of the array's elements **1** unit to the left. For example, if **2** left
rotations are performed on array **[1,2,3,4,5]**, then the array would become . Note that the lowest index item moves to the highest
index in a rotation. This is called a circular array.

Given an array **a** of **n** integers and a number, **d**, perform **d** left rotations on the array. Return the updated array to
be printed as a single line of space-separated integers.

### Function Description

Complete the function rotLeft in the editor below.

rotLeft has the following parameter(s):

- **int a[n]**: the array to rotate
- **int d**: the number of rotations

### Returns

- **int a'[n]**: the rotated array

### Input Format

The first line contains two space-separated integers **n** and **d**, the size of **a** and the number of left rotations.
The second line contains **n** space-separated integers, each an a[i].

### Constraints

<SyntaxHighlighter language="javascript" style={style}>
    {`
    1 <= n <= 10^5
    1 <= d <= 1n
    1 <= a[i] <= 10^6
  `}
</SyntaxHighlighter>

### Sample Input

<SyntaxHighlighter language="javascript" style={style}>
    {`
    5 4
    1 2 3 4 5
  `}
</SyntaxHighlighter>

### Sample Output

<SyntaxHighlighter language="javascript" style={style}>
    {`
    5 1 2 3 4
  `}
</SyntaxHighlighter>

### Explanation

When we perform **d = 4** left rotations, the array undergoes the following sequence of changes:

<SyntaxHighlighter language="javascript" style={style}>
    {`
        [1,2,3,4,5,] -> [2,3,4,5,1] -> [3,4,5,1,2,] -> [4,5,1,2,3] -> [5,1,2,3,4]
    `}
</SyntaxHighlighter>

### Solution

<SyntaxHighlighter language="javascript" style={style}>
    {`
    function rotLeft(a, d) {
        const dif = a.length - d;

        if (d < a.length) {
            return a.slice(-dif).concat(a.slice(0, d))
        } else {
            return a.slice(-(d % a.length)).concat(a.slice(0, dif))
        }
    }
`}
</SyntaxHighlighter>

### Refactored Solution

Although the solution above works with all test cases there is some code repetition, both return statements are essentially
the same with slightly different parameters for each slice method. In my first attempt I was getting the last x amount of indexes
and then concatenating the first range of indexes. By using a range in both instances I  was able to replace the if statment
with a ternary statement.

<SyntaxHighlighter language="javascript" style={style}>
    {`
    function rotLeft(a, d) {
        const len = d < a.length ? d : d % a.length;
        return a.slice(len, a.length).concat(a.slice(0, len))
    }
`}
</SyntaxHighlighter>

Return the updated array to be printed as a single line of space-separated integers.

hrcc-arrays-left-rotation.png

HackerRank Left Rotation Arrays Challenge

The details for the problem detailed in this post can be found at
<a className="text-base font-semibold text-indigo-600 hover:text-indigo-500" href="https://www.hackerrank.com/challenges/new-year-chaos/problem">https://www.hackerrank.com/challenges/new-year-chaos/problem</a>

**The following solution is written in Javascript.**

## Problem

It is New Year's Day and people are in line for the Wonderland rollercoaster ride. Each person wears a sticker indicating their initial position in the queue from 1 to n. Any person can bribe the person directly in front of them to swap positions, but they still wear their original sticker. One person can bribe at most two others.

Determine the minimum number of bribes that took place to get to a given queue order. Print the number of bribes, or, if anyone has bribed more than two people, print Too chaotic.

### Example

<SyntaxHighlighter language="javascript" style={style}>
    {`
    q = [1,2,3,5,4,6,7,8]
  `}
</SyntaxHighlighter>

If person 5 bribes person 4 the queue will look like this: 1,2,3,5,4,6,7,8. Only 1 bribe is required. Print 1.

<SyntaxHighlighter language="javascript" style={style}>
    {`
    q = [4,1,2,3]
  `}
</SyntaxHighlighter>

### Function Description

Complete the function minimumBribes in the editor below.

minimumBribes has the following parameter(s):
- int q[n]: the positions of the people after all bribes

### Returns

- No value is returned. Print the minimum number of bribes necessary or Too chaotic if someone has bribed more than 2 people.

### Input Format

The first line contains an integer , the number of test cases.

Each of the next  pairs of lines are as follows:
- The first line contains an integer , the number of people in the queue
- The second line has  space-separated integers describing the final state of the queue.

### Constraints & Validation

<SyntaxHighlighter language="javascript" style={style}>
    {`
    1 <= t <= 10
    1 <= n <= 10^5
  `}
</SyntaxHighlighter>

### Sample Input 0

<SyntaxHighlighter language="javascript" style={style}>
    {`
   STDIN       Function
   -----       --------
   2           t = 2
   5           n = 5
   2 1 5 3 4   q = [2, 1, 5, 3, 4]
   5           n = 5
   2 5 1 3 4   q = [2, 5, 1, 3, 4]
  `}
</SyntaxHighlighter>

### Sample Output 0

<SyntaxHighlighter language="javascript" style={style}>
    {`
    3
    Too chaotic
  `}
</SyntaxHighlighter>

### Explanation

The first **n = 10** letters of the infinite string are abaabaabaa. Because there are 7 a's, we return 7.

### Test Case 1

![Hacker RankNew Year Chaos](https://s3.amazonaws.com/hr-challenge-images/494/1451665589-31d436ba19-pic11.png "Hacker Rank New Year Chaos test case 1")

After person 5 moves one position ahead by bribing person 4:

![Hacker RankNew Year Chaos](https://s3.amazonaws.com/hr-challenge-images/494/1451665679-6504422ed9-pic2.png "Hacker Rank New Year Chaos test case 1")

Now person 5 moves another position ahead by bribing person 3:

![Hacker RankNew Year Chaos](https://s3.amazonaws.com/hr-challenge-images/494/1451665818-27bd62bb0d-pic3.png "Hacker Rank New Year Chaos test case 1")

And person 2 moves one position ahead by bribing person 1:

![Hacker RankNew Year Chaos](https://s3.amazonaws.com/hr-challenge-images/494/1451666025-02a2395a00-pic5.png "Hacker Rank New Year Chaos test case 1")

So the final state is 2,1,5,3,4 after three bribing operations.

### Test Case 2

No person can bribe more than two people, yet it appears person 5 has done so. It is not possible to achieve the input state.

### First Attempt

We will first add a statement that will simply return **n** id the string is 'a'.

<SyntaxHighlighter language="javascript" style={style}>
    {`
    if(s == 'a') return n;
    `}
</SyntaxHighlighter>

We then create the substring by creating an array from the string to loop through.

<SyntaxHighlighter language="javascript" style={style}>
    {`
    let array = s.split(''),
        count = 0,
        aCount = 0,
        substring = '';

        while (count < n) {
            if(newString.length == n) break;
            if(count == array.length) count = 0;
            newString += array[count]
            count++;
        }
`}
</SyntaxHighlighter>

Finaly we return the frequency of a in the substring

<SyntaxHighlighter language="javascript" style={style}>
 {`
    return newString.split('a').length-1;;

`}
</SyntaxHighlighter>

The full function is as below:

<SyntaxHighlighter language="javascript" style={style}>
    {`
    function repeatedString(s, n) {

        if(s == 'a') return n;

        let array = s.split(''),
            count = 0,
            aCount = 0,
            newString = '';

        while (count < n) {
            if(newString.length == n) break;
            if(count == array.length) count = 0;
            newString += array[count]
            count++;
        }

        return newString.split('a').length-1;;
    }
`}
</SyntaxHighlighter>

Although this function worked it failed on a number of test cases due to the Time limit exceeding. The method above is
far from optimized and is more of a brute force attempt.

### Second Attempt

For my second attempt I decided that instead of using loops I could calculate the frequency of 'a' in **s** and then
calculate how many times the string can be repeated in n.

<SyntaxHighlighter language="javascript" style={style}>
    {`
    let aInString = (s.split('a').length - 1),
        frequency = Math.floor(n/(s.length)) * aInString;
    `}
</SyntaxHighlighter>

One thing to consider here though is the fact that there could be a number of characters remaining after we divide **n**
by the length of **s**. We can work out how many characters, if any, are left with the modular operator:

<SyntaxHighlighter language="javascript" style={style}>
    {`
    remStringLength = n % s.length;
    `}
</SyntaxHighlighter>

We can now use the slice method to get the actual string remaining and use the split method we've already used to return
the frequency of 'a' if there are any in the remaining string and add it to the frequency:

<SyntaxHighlighter language="javascript" style={style}>
    {`
    frequency += (s.slice(0, remStringLength).split('a').length - 1);
    `}
</SyntaxHighlighter>

### Final Full Function

<SyntaxHighlighter language="javascript" style={style}>
    {`
    function repeatedString(s, n) {

            if(s == 'a') return n;

            let aInString = (s.split('a').length - 1),
                frequency = Math.floor(n/(s.length)) * aInString,
                remStringLength = n % s.length;

            frequency += (s.slice(0, remStringLength).split('a').length - 1);

            return frequency;
        }
    `}
</SyntaxHighlighter>

Print the number of bribes, or, if anyone has bribed more than two people, print Too chaotic.

hrcc-new-year-chaos.png

HackerRank New Year Chaos Challenge

The details for the problem detailed in this post can be found at
<a className="text-base font-semibold text-indigo-600 hover:text-indigo-500" href="https://www.hackerrank.com/challenges/2d-array/problem">https://www.hackerrank.com/challenges/2d-array/problem</a>

**The following solution is written in Javascript.**

## Problem

Breaking down the challenge into blocks of requirements, we get:

- **arr[i][j]** = multi-dimensional array that is 6 x 6
- **i** = height of the array, with a number range of 0 to 5
- **j** = width of the array, with a number range of 0 to 5
- **hourglass** = the same of shape as a ⏳
- **hourglass** = 3 index values at the top, one in the middles, and 3 at the bottom

So we are given a two dimensional array consists of n rows and m columns and has a integers in a range -9 to 9 on each indexes. The task is to find maximum sum of values in a abstract hourglass shape.

The problem begins with a 6x6 2D Array, like this one:

<SyntaxHighlighter language="javascript" style={style}>
  {`
    1  1  1  0  0  0
    0  1  0  0  0  0
    1  1  1  0  0  0
    0  0  2  4  4  0
    0  0  0  2  0  0
    0  0  1  2  4  0
  `}
</SyntaxHighlighter>

An hourglass in A is a subset of values with indices falling in the pattern below:

<SyntaxHighlighter language="javascript" style={style}>
  {`
    a  b  c
       d
    e  f  g
  `}
</SyntaxHighlighter>

This hourglass pattern occurs 16 times within the array. Given the example above all the hour glass combinations would be:
<SyntaxHighlighter language="javascript" style={style}>
    {`
    1 1 1     1 1 0     1 0 0     0 0 0
      1         0         0         0
    1 1 1     1 1 0     1 0 0     0 0 0

    0 1 0     1 0 0     0 0 0     0 0 0
      1         1         0         0
    0 0 2     0 2 4     2 4 4     4 4 0

    1 1 1     1 1 0     1 0 0     0 0 0
      0         2         4         4
    0 0 0     0 0 2     0 2 0     2 0 0

    0 0 2     0 2 4     2 4 4     4 4 0
      0         0         2         0
    0 0 1     0 1 2     1 2 4     2 4 0

`}
</SyntaxHighlighter>

Again using the sample data above the sum of each hourglass would be:

<SyntaxHighlighter language="javascript" style={style}>
    {`
    7     4     2     0
    4     8     10    8
    3     6     7     6
    3     9     19    14
  `}
</SyntaxHighlighter>

The largest value of all the hourglasses is:

<SyntaxHighlighter language="javascript" style={style}>
    {`
    19
  `}
</SyntaxHighlighter>

### Goal

The goal is to write a function that calculates the sum of the numbers in each of the hourglass patterns and return the maximum sum.

### Constraints & Validation

Since the minimum value of any position is -9, the minimum value of the sum is -63.

<SyntaxHighlighter language="javascript" style={style}>
  {`
    function hourglassSum(arr) {
        let max = -63;
    }
  `}
</SyntaxHighlighter>

#### Validating the arr

So we need to validate the following:
- The argument is an array
- Each of the 6 lines of inputs arr[i] contains 6 space-seperated integers arr[i][j]

<SyntaxHighlighter language="javascript" style={style} wrapLongLines={true} >
    {`
    function hourglassSum(arr) {
        let max = -63;

            if (Array.isArray(arr)
              && arr.length === 6
              && arr.map(i => i.length).reduce((p, n) => p + n) === 36)
              {
                // Loop through arr
            }
            return max;
        }
`}
</SyntaxHighlighter>

### Solution

We’ll use a nested loop to evaluate the sums of all the hourglass patterns (4 on each row) for all the possible rows (4 rows).

After each sum is computed, it will be compared to the current maximum sum and will replace that sum if it is greater.

Finally, after all iterations are complete, the maximum sum will be returned.

Here’s the completed function:

<SyntaxHighlighter language="javascript" style={style} wrapLongLines={true} >
    {`
    function hourglassSum(arr) {
        let max = -63

                if (Array.isArray(arr)
                  && arr.length === 6
                  && arr.map(i => i.length).reduce((p, n) => p + n) === 36) {

                    for (let row = 0; row < 4; row++) {
                        for (let col = 0; col < 4; col++) {
                            let sum = 0;

                            sum += arr[row][col];
                            sum += arr[row][col + 1];
                            sum += arr[row][col + 2];
                            sum += arr[row + 1][col + 1];
                            sum += arr[row + 2][col];
                            sum += arr[row + 2][col + 1];
                            sum += arr[row + 2][col + 2];

                            max = max < sum ? sum : max;
                        }
                    }
                }
                return max;
            }
`}
</SyntaxHighlighter>

### Refactored Solution

<SyntaxHighlighter language="javascript" style={style} wrapLongLines={true} >
  {`
    function hourglassSum(arr) {
        let max = -63;

        if (Array.isArray(arr)
          && arr.length === 6
          && arr.map(i => i.length).reduce((p, n) => p + n) === 36) {
            for (let i = 0; i < 4; i++) {
                for (let j = 0; j < 4; j++) {
                    let sum = 0;
                    sum = (arr[i][j] + arr[i][j + 1] + arr[i][j + 2] + arr[i + 1][j + 1] + arr[i + 2][j] + arr[i + 2][j + 1] + arr[i + 2][j + 2]);
                    max = max < sum ? sum : max;
                }
            }
        }
        return max;
    }
  `}
</SyntaxHighlighter>

HackerRank’s 2D Array Hourglass Code Challenge With JavaScript

HackerRankCodingChallenge.png

HackerRank 2D Array - DS


**The following solution is written in Javascript.**


## Problem

An avid hiker keeps meticulous records of their hikes. During the last hike that took exactly  steps, for every step it
was noted if it was an uphill, U, or a downhill, D step. Hikes always start and end at sea level, and each step up or
down represents a  unit change in altitude.

Breaking down the challenge into blocks of requirements, we get:

- **U** = A uphill step
- **D** = A downhill step
- Each step represents 1 unit
- A mountain is a sequence of consecutive steps above sea level, starting with a step up from sea level and
ending with a step down to sea level.
- A valley is a sequence of consecutive steps below sea level, starting with a step down
from sea level and ending with a step up to sea level.

### Example

<SyntaxHighlighter language="javascript" style={style}>
    {`
    Steps = 8 path = [D D U U U U D D]
  `}
</SyntaxHighlighter>

### Function Description

The countingValleys function has two parameters:

- **int steps**: the number of steps on the hike
- **string path**: a string describing the path

### Returns

- **int**: the umber of valleys traversed

### Sample Input

<SyntaxHighlighter language="javascript" style={style}>
  {`
    8
    UDDDUDUU
  `}
</SyntaxHighlighter>

### Sample Output

<SyntaxHighlighter language="javascript" style={style}>
    {`
    1
  `}
</SyntaxHighlighter>

### Explanation

If we represent _ as sea level, a step up as /, and a step down as \, the hike can be drawn as:

<SyntaxHighlighter language="javascript" style={style}>
    {`
    _/\\      _
       \\    /
        \\/\\/
  `}
</SyntaxHighlighter>

The hiker enters and leaves one valley.


### Goal

Given the sequence of up and down steps during a hike, find and print the number of valleys walked through.

### Constraints & Validation

- The number of socks **n** will not be more than 100
- The number of a colour **ar[i]** will not be more than 100

<SyntaxHighlighter language="javascript" style={style}>
    {`
    2 <= steps <= 10^6 (1,000,000)
    path[i] will consist of {UD}
  `}
</SyntaxHighlighter>

The sockMerchant function expects two arguments, an integer and a sting.

<SyntaxHighlighter language="javascript" style={style}>
    {`
    function countingValleys(steps, path) {

        if (Number.isInteger(steps)
            && steps >= 2 && steps <= Math.pow(10, 6))
        {
            // Loop through path

            // Return number of valleys traversed
        }
    }
    `}
</SyntaxHighlighter>


### Solution

We need to loop through the path string and calculate the number of mountains and valleys traversed. To do this we can
increase or decrease the walkers current altitude based on the character being U or D. Each time a walker takes a
downhill step when their altitude is at Sea level they enter a valley.

<SyntaxHighlighter language="javascript" style={style}>
    {`
    let alt = 0,
        valleys = 0;

    for (var i = 0; i < path.length; i++) {
      if(str.charAt(i) == 'D')
        if(alt == 0) valleys =+ 1;
        alt -= 1;
      } else {
        alt += 1;
      }
    }
    `}
</SyntaxHighlighter>

We can now return the number of valleys traversed.

### First Attempt Solution

<SyntaxHighlighter language="javascript" style={style}>
    {`
    function countingValleys(steps, path) {
        if (Number.isInteger(steps)
            && steps >= 2 && steps <= Math.pow(10, 6)) {

            let alt = 0,
                valleys = 0;

            for (var i = 0; i < path.length; i++) {
                if(path.charAt(i) == 'D') {
                    if(alt == 0) valleys ++;
                    alt --;
                } else {
                    alt ++;
                }
            }

            return valleys;
        }
    }
`}
</SyntaxHighlighter>

### Refactored Solution

Although the solution above does work it terminated due to timeout on some of the test cases. This may be caused by the
function using the .charAt() method on each loop. I noticed also that I was using path.length in the for loop instead
of the steps value.

I refactored the code to test this using a simple array index instead of .charAt()

<SyntaxHighlighter language="javascript" style={style}>
    {`
    function countingValleys(steps, path) {
        if (Number.isInteger(steps)
            && steps >= 2 && steps <= Math.pow(10, 6)) {

            let array = path.split(''),
                alt = 0,
                valleys = 0;

                for (var i = 0; i < steps; i++) {
                    if(array[i] == 'D') {
                        if(alt == 0) valleys ++;
                        alt --;
                    } else {
                        alt ++;
                    }
                }
                return valleys;
            }
        }
`}
</SyntaxHighlighter>

The solution above successfully passed each of the test cases demonstrating the importance of using methods only where necessary.



One of HackerRank’s Warm-up Challenges in Javascript

hrcc-count-valleys.png

HackerRank - Counting Valleys Challenge

The details for the problem detailed in this post can be found at
<a className="text-base font-semibold text-indigo-600 hover:text-indigo-500" href="https://www.hackerrank.com/challenges/repeated-string/problem">https://www.hackerrank.com/challenges/repeated-string/problem</a>

**The following solution is written in Javascript.**

## Problem

Write a function that given an integer, **n**, and a string, **s**, will find and print the number of letter a's in the
first **n** of the infinite string.

- **string s** = a string of lowercase English letters that is repeated infinitely many times.
- **int n** = the first n letters of the infinite string.

### Example

The substring we consider is **abcacabcac**, the first **10** characters of the infinite string. There are **4**
occurrences of a in the substring.

### Function Description

repeatedString has the following parameter(s):
- **s**: a string to repeat
- **n**: the number of characters to consider

### Returns

- **int**: the frequency of a in the substring

### Input Format

- The first line contains a single string, **s**.
- The second line contains an integer, **n**.

### Constraints & Validation

- s will be between 1 and 100 characters in length
- n will be between 1 and 10^12
- For 25% of test cases, n will be less than or equal to 10^6

<SyntaxHighlighter language="javascript" style={style}>
    {`
    1 <= |s| <= 100
    1 <= n <= 10^12
  `}
</SyntaxHighlighter>

### Sample Input 0

<SyntaxHighlighter language="javascript" style={style}>
    {`
    aba
    10
  `}
</SyntaxHighlighter>

### Sample Output 0

<SyntaxHighlighter language="javascript" style={style}>
    {`
    7
  `}
</SyntaxHighlighter>

### Explanation

The first **n = 10** letters of the infinite string are abaabaabaa. Because there are 7 a's, we return 7.

### Sample Input 1

<SyntaxHighlighter language="javascript" style={style}>
    {`
    a
    1000000000000
  `}
</SyntaxHighlighter>

### Sample Output 0

<SyntaxHighlighter language="javascript" style={style}>
    {`
    1000000000000
  `}
</SyntaxHighlighter>

### Explanation

Because all of the first **n = 1000000000000** letters of the infinite string are a, we return **1000000000000**.

### First Attempt

We will first add a statement that will simply return **n** id the string is 'a'.

<SyntaxHighlighter language="javascript" style={style}>
    {`
    if(s == 'a') return n;
    `}
</SyntaxHighlighter>

We then create the substring by creating an array from the string to loop through.

<SyntaxHighlighter language="javascript" style={style}>
    {`
    let array = s.split(''),
        count = 0,
        aCount = 0,
        substring = '';

        while (count < n) {
            if(newString.length == n) break;
            if(count == array.length) count = 0;
            newString += array[count]
            count++;
        }
`}
</SyntaxHighlighter>

Finaly we return the frequency of a in the substring

<SyntaxHighlighter language="javascript" style={style}>
 {`
    return newString.split('a').length-1;;

`}
</SyntaxHighlighter>

The full function is as below:

<SyntaxHighlighter language="javascript" style={style}>
    {`
    function repeatedString(s, n) {

        if(s == 'a') return n;

        let array = s.split(''),
            count = 0,
            aCount = 0,
            newString = '';

        while (count < n) {
            if(newString.length == n) break;
            if(count == array.length) count = 0;
            newString += array[count]
            count++;
        }

        return newString.split('a').length-1;;
    }
`}
</SyntaxHighlighter>

Although this function worked it failed on a number of test cases due to the Time limit exceeding. The method above is
far from optimized and is more of a brute force attempt.

### Second Attempt

For my second attempt I decided that instead of using loops I could calculate the frequency of 'a' in **s** and then
calculate how many times the string can be repeated in n.

<SyntaxHighlighter language="javascript" style={style}>
    {`
    let aInString = (s.split('a').length - 1),
        frequency = Math.floor(n/(s.length)) * aInString;
    `}
</SyntaxHighlighter>

One thing to consider here though is the fact that there could be a number of characters remaining after we divide **n**
by the length of **s**. We can work out how many characters, if any, are left with the modular operator:

<SyntaxHighlighter language="javascript" style={style}>
    {`
    remStringLength = n % s.length;
    `}
</SyntaxHighlighter>

We can now use the slice method to get the actual string remaining and use the split method we've already used to return
the frequency of 'a' if there are any in the remaining string and add it to the frequency:

<SyntaxHighlighter language="javascript" style={style}>
    {`
    frequency += (s.slice(0, remStringLength).split('a').length - 1);
    `}
</SyntaxHighlighter>

### Final Full Function

<SyntaxHighlighter language="javascript" style={style}>
    {`
    function repeatedString(s, n) {

            if(s == 'a') return n;

            let aInString = (s.split('a').length - 1),
                frequency = Math.floor(n/(s.length)) * aInString,
                remStringLength = n % s.length;

            frequency += (s.slice(0, remStringLength).split('a').length - 1);

            return frequency;
        }
    `}
</SyntaxHighlighter>

Given an integer, n, print the number of letter a in the first n letters of the infinite string