# Kangaroo – HackerRank Solution ## Problem :

You are choreographing a circus show with various animals. For one act, you are given two kangaroos on a number line ready to jump in the positive direction (i.e, toward positive infinity).

• The first kangaroo starts at location `x1` and moves at a rate of `v1` meters per jump.
• The second kangaroo starts at location `x2` and moves at a rate of `v2 `meters per jump.

You have to figure out a way to get both kangaroos at the same location at the same time as part of the show. If it is possible, return `YES`, otherwise return `NO`.

For example, kangaroo 1 starts at `x1 = 2` with a jump distance `v1 = 1` and kangaroo 2 starts at `x``2 = 1` with a jump distance of `v2 = 2`. After one jump, they are both at `x = 3`, (`x1 + v1 = 2 + 1, x2 + v2 = 1 + 2`), so our answer is `YES`.

### Function Description :

Complete the function kangaroo in the editor below. It should return `YES` if they reach the same position at the same time, or `NO` if they don’t.

kangaroo has the following parameter(s):

• x1, v1: integers, starting position and jump distance for kangaroo 1
• x2, v2: integers, starting position and jump distance for kangaroo 2

### Input Format :

A single line of four space-separated integers denoting the respective values of `x1``v1``x2`, and `v2`.

### Constraints :

• `0 <= x1 < x2 <= 10000`
• `1 <= v1 <= 10000`
• `1 <= v2 <= 10000`

### Output Format :

Print `YES` if they can land on the same location at the same time; otherwise, print `NO`.

Note: The two kangaroos must land at the same location after making the same number of jumps.

### Sample Input 0 :

``0 3 4 2``

### Sample Output 0 :

``YES``

### Explanation 0 :

The two kangaroos jump through the following sequence of locations:

From the image, it is clear that the kangaroos meet at the same location (number 12 on the number line) after same number of jumps (4 jumps), and we print `YES`.

### Sample Input 1 :

``````0 2 5 3
``````

### Sample Output 1 :

``NO``

### Explanation 1 :

The second kangaroo has a starting location that is ahead (further to the right) of the first kangaroo’s starting location (i.e., `x2 > x1`). Because the second kangaroo moves at a faster rate (meaning `v2 > v1`and is already ahead of the first kangaroo, the first kangaroo will never be able to catch up. Thus, we print NO.

## Solution :

``````#include <bits/stdc++.h>

using namespace std;

vector<string> split_string(string);

// Complete the kangaroo function below.
string kangaroo(int x1, int v1, int x2, int v2) {
while(true){
if(x2 > x1 && v2 > v1 || x1 > x2 && v1 > v2 || v1 == v2){
return "NO";
}
if((x1 += v1) == (x2 +=v2)){
return "YES";
}
}
}

int main()
{
ofstream fout(getenv("OUTPUT_PATH"));

string x1V1X2V2_temp;
getline(cin, x1V1X2V2_temp);

vector<string> x1V1X2V2 = split_string(x1V1X2V2_temp);

int x1 = stoi(x1V1X2V2);

int v1 = stoi(x1V1X2V2);

int x2 = stoi(x1V1X2V2);

int v2 = stoi(x1V1X2V2);

string result = kangaroo(x1, v1, x2, v2);

fout << result << "\n";

fout.close();

return 0;
}

vector<string> split_string(string input_string) {
string::iterator new_end = unique(input_string.begin(), input_string.end(), [] (const char &x, const char &y) {
return x == y and x == ' ';
});

input_string.erase(new_end, input_string.end());

while (input_string[input_string.length() - 1] == ' ') {
input_string.pop_back();
}

vector<string> splits;
char delimiter = ' ';

size_t i = 0;
size_t pos = input_string.find(delimiter);

while (pos != string::npos) {
splits.push_back(input_string.substr(i, pos - i));

i = pos + 1;
pos = input_string.find(delimiter, i);
}

splits.push_back(input_string.substr(i, min(pos, input_string.length()) - i + 1));

return splits;
}
``````

904 total views,  2 views today