meetforever/GRPO_CL huggingface dataset:
user: Polycarpus works as a DJ in the best Berland nightclub, and he often uses dubstep music in his performance. Recently, he has decided to take a couple of old songs and make dubstep remixes from them.

Let's assume that a song consists of some number of words (that don't contain WUB). To make the dubstep remix of this song, Polycarpus inserts a certain number of words "WUB" before the first word of the song (the number may be zero), after the last word (the number may be zero), and between words (at least one between any pair of neighbouring words), and then the boy glues together all the words, including "WUB", in one string and plays the song at the club.

For example, a song with words "I AM X" can transform into a dubstep remix as "WUBWUBIWUBAMWUBWUBX" and cannot transform into "WUBWUBIAMWUBX".

Recently, Jonny has heard Polycarpus's new dubstep track, but since he isn't into modern music, he decided to find out what was the initial song that Polycarpus remixed. Help Jonny restore the original song.

## Input
The input consists of a single non-empty string, consisting only of uppercase English letters, the string's length doesn't exceed 200 characters

## Output
Return the words of the initial song that Polycarpus used to make a dubsteb remix. Separate the words with a space.

## Examples

```python
song_decoder("WUBWEWUBAREWUBWUBTHEWUBCHAMPIONSWUBMYWUBFRIENDWUB")
  # =>  WE ARE THE CHAMPIONS MY FRIEND
```

Answer: {"fn_name": "song_decoder", "inputs": [["AWUBBWUBC"], ["AWUBWUBWUBBWUBWUBWUBC"], ["WUBAWUBBWUBCWUB"], ["RWUBWUBWUBLWUB"], ["WUBJKDWUBWUBWBIRAQKFWUBWUBYEWUBWUBWUBWVWUBWUB"], ["WUBKSDHEMIXUJWUBWUBRWUBWUBWUBSWUBWUBWUBHWUBWUBWUB"], ["QWUBQQWUBWUBWUBIWUBWUBWWWUBWUBWUBJOPJPBRH"], ["WUBWUBOWUBWUBWUBIPVCQAFWYWUBWUBWUBQWUBWUBWUBXHDKCPYKCTWWYWUBWUBWUBVWUBWUBWUBFZWUBWUB"], ["WUBYYRTSMNWUWUBWUBWUBCWUBWUBWUBCWUBWUBWUBFSYUINDWOBVWUBWUBWUBFWUBWUBWUBAUWUBWUBWUBVWUBWUBWUBJB"], ["AWUBWUBWUB"], ["AWUBBWUBCWUBD"], ["WUBWWUBWUBWUBUWUBWUBBWUB"], ["WUWUBBWWUBUB"], ["WUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUABWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUBWUB"], ["U"], ["WUWUB"], ["UBWUB"], ["WUWUBUBWUBUWUB"], ["WUBWWUBAWUB"], ["WUUUUU"], ["WUBWUBA"]], "outputs": [["A B C"], ["A B C"], ["A B C"], ["R L"], ["JKD WBIRAQKF YE WV"], ["KSDHEMIXUJ R S H"], ["Q QQ I WW JOPJPBRH"], ["O IPVCQAFWY Q XHDKCPYKCTWWY V FZ"], ["YYRTSMNWU C C FSYUINDWOBV F AU V JB"], ["A"], ["A B C D"], ["W U B"], ["WU BW UB"], ["WUAB"], ["U"], ["WU"], ["UB"], ["WU UB U"], ["W A"], ["WUUUUU"], ["A"]]}
user: This time no story, no theory. The examples below show you how to write function `accum`:

**Examples:**
```
accum("abcd") -> "A-Bb-Ccc-Dddd"
accum("RqaEzty") -> "R-Qq-Aaa-Eeee-Zzzzz-Tttttt-Yyyyyyy"
accum("cwAt") -> "C-Ww-Aaa-Tttt"
```

The parameter of accum is a string which includes only letters from `a..z` and `A..Z`.

Answer: {"fn_name": "accum", "inputs": [["ZpglnRxqenU"], ["NyffsGeyylB"], ["MjtkuBovqrU"], ["EvidjUnokmM"], ["HbideVbxncC"], ["VwhvtHtrxfE"], ["KurgiKmkphY"], ["NctlfBlnmfH"], ["WegunHvbdmV"], ["VoywwSpqidE"], ["VbaixFpxdcO"], ["OlyqvYwkuzF"], ["JrhfdMtchiH"], ["JiwpcSwslvW"], ["EagpiEvmabJ"], ["RznlcEmuxxP"], ["OrggaExarzP"], ["DriraMtedfB"], ["BjxseRxgtjT"], ["EquhxOswchE"]], "outputs": [["Z-Pp-Ggg-Llll-Nnnnn-Rrrrrr-Xxxxxxx-Qqqqqqqq-Eeeeeeeee-Nnnnnnnnnn-Uuuuuuuuuuu"], ["N-Yy-Fff-Ffff-Sssss-Gggggg-Eeeeeee-Yyyyyyyy-Yyyyyyyyy-Llllllllll-Bbbbbbbbbbb"], ["M-Jj-Ttt-Kkkk-Uuuuu-Bbbbbb-Ooooooo-Vvvvvvvv-Qqqqqqqqq-Rrrrrrrrrr-Uuuuuuuuuuu"], ["E-Vv-Iii-Dddd-Jjjjj-Uuuuuu-Nnnnnnn-Oooooooo-Kkkkkkkkk-Mmmmmmmmmm-Mmmmmmmmmmm"], ["H-Bb-Iii-Dddd-Eeeee-Vvvvvv-Bbbbbbb-Xxxxxxxx-Nnnnnnnnn-Cccccccccc-Ccccccccccc"], ["V-Ww-Hhh-Vvvv-Ttttt-Hhhhhh-Ttttttt-Rrrrrrrr-Xxxxxxxxx-Ffffffffff-Eeeeeeeeeee"], ["K-Uu-Rrr-Gggg-Iiiii-Kkkkkk-Mmmmmmm-Kkkkkkkk-Ppppppppp-Hhhhhhhhhh-Yyyyyyyyyyy"], ["N-Cc-Ttt-Llll-Fffff-Bbbbbb-Lllllll-Nnnnnnnn-Mmmmmmmmm-Ffffffffff-Hhhhhhhhhhh"], ["W-Ee-Ggg-Uuuu-Nnnnn-Hhhhhh-Vvvvvvv-Bbbbbbbb-Ddddddddd-Mmmmmmmmmm-Vvvvvvvvvvv"], ["V-Oo-Yyy-Wwww-Wwwww-Ssssss-Ppppppp-Qqqqqqqq-Iiiiiiiii-Dddddddddd-Eeeeeeeeeee"], ["V-Bb-Aaa-Iiii-Xxxxx-Ffffff-Ppppppp-Xxxxxxxx-Ddddddddd-Cccccccccc-Ooooooooooo"], ["O-Ll-Yyy-Qqqq-Vvvvv-Yyyyyy-Wwwwwww-Kkkkkkkk-Uuuuuuuuu-Zzzzzzzzzz-Fffffffffff"], ["J-Rr-Hhh-Ffff-Ddddd-Mmmmmm-Ttttttt-Cccccccc-Hhhhhhhhh-Iiiiiiiiii-Hhhhhhhhhhh"], ["J-Ii-Www-Pppp-Ccccc-Ssssss-Wwwwwww-Ssssssss-Lllllllll-Vvvvvvvvvv-Wwwwwwwwwww"], ["E-Aa-Ggg-Pppp-Iiiii-Eeeeee-Vvvvvvv-Mmmmmmmm-Aaaaaaaaa-Bbbbbbbbbb-Jjjjjjjjjjj"], ["R-Zz-Nnn-Llll-Ccccc-Eeeeee-Mmmmmmm-Uuuuuuuu-Xxxxxxxxx-Xxxxxxxxxx-Ppppppppppp"], ["O-Rr-Ggg-Gggg-Aaaaa-Eeeeee-Xxxxxxx-Aaaaaaaa-Rrrrrrrrr-Zzzzzzzzzz-Ppppppppppp"], ["D-Rr-Iii-Rrrr-Aaaaa-Mmmmmm-Ttttttt-Eeeeeeee-Ddddddddd-Ffffffffff-Bbbbbbbbbbb"], ["B-Jj-Xxx-Ssss-Eeeee-Rrrrrr-Xxxxxxx-Gggggggg-Ttttttttt-Jjjjjjjjjj-Ttttttttttt"], ["E-Qq-Uuu-Hhhh-Xxxxx-Oooooo-Sssssss-Wwwwwwww-Ccccccccc-Hhhhhhhhhh-Eeeeeeeeeee"]]}
user: The numbers 12, 63 and 119 have something in common related with their divisors and their prime factors, let's see it.
```
Numbers PrimeFactorsSum(pfs)        DivisorsSum(ds)              Is ds divisible by pfs
12         2 + 2 + 3 = 7         1 + 2 + 3 + 4 + 6 + 12 = 28            28 / 7 = 4,  Yes
63         3 + 3 + 7 = 13        1 + 3 + 7 + 9 + 21 + 63 = 104         104 / 13 = 8, Yes
119        7 + 17 = 24           1 + 7 + 17 + 119 = 144                144 / 24 = 6, Yes
```
There is an obvius property you can see: the sum of the divisors of a number is divisible by the sum of its prime factors.

We need the function ```ds_multof_pfs()``` that receives two arguments: ```nMin``` and  ```nMax```, as a lower and upper limit (inclusives), respectively, and outputs a sorted list with the numbers that fulfill the property described above.

We represent the features of the described function:
```python
ds_multof_pfs(nMin, nMax) -----> [n1, n2, ....., nl] # nMin ≤ n1 < n2 < ..< nl ≤ nMax
```
Let's see some cases:
```python
ds_multof_pfs(10, 100) == [12, 15, 35, 42, 60, 63, 66, 68, 84, 90, 95]

ds_multof_pfs(20, 120) == [35, 42, 60, 63, 66, 68, 84, 90, 95, 110, 114, 119]
```
Enjoy it!!

Answer: {"fn_name": "ds_multof_pfs", "inputs": [[10, 100], [20, 120], [50, 140]], "outputs": [[[12, 15, 35, 42, 60, 63, 66, 68, 84, 90, 95]], [[35, 42, 60, 63, 66, 68, 84, 90, 95, 110, 114, 119]], [[60, 63, 66, 68, 84, 90, 95, 110, 114, 119, 140]]]}
user: We need a function ```count_sel()``` that receives an array or list of integers (positive and negative) and may give us the following information in the order and  structure presented bellow:

```[(1), (2), (3), [[(4)], 5]]```

(1) - Total amount of received integers.

(2) - Total amount of different values the array has.

(3) - Total amount of values that occur only once.

(4) and (5) both in a list

(4) - It is (or they are) the element(s) that has (or have) the maximum occurrence. If there are more than one, the elements should be sorted (by their value obviously)

(5) - Maximum occurrence of the integer(s)

Let's see some cases
```python
____ count_sel([-3, -2, -1, 3, 4, -5, -5, 5, -1, -5]) ----> [10, 7, 5, [[-5], 3]]

(1) - The list has ten elements (10 numbers)

(2) - We have seven different values: -5, -3, -2, -1, 3, 4, 5 (7 values)

(3) - The numbers that occur only once: -3, -2, 3, 4, 5 (5 values)

(4) and (5) - The number -5 occurs three times (3 occurrences)

____ count_sel([4, 4, 2, -3, 1, 4, 3, 2, 0, -5, 2, -2, -2, -5]) ----> [14, 8, 4, [[2, 4], 3]]
```
Enjoy it and happy coding!!

Answer: {"fn_name": "count_sel", "inputs": [[[-3, -2, -1, 3, 4, -5, -5, 5, -1, -5]], [[5, -1, 1, -1, -2, 5, 0, -2, -5, 3]], [[-2, 4, 4, -2, -2, -1, 3, 5, -5, 5]], [[4, -5, 1, -5, 2, 4, -1, 4, -1, 1]], [[4, 4, 2, -3, 1, 4, 3, 2, 0, -5, 2, -2, -2, -5]]], "outputs": [[[10, 7, 5, [[-5], 3]]], [[10, 7, 4, [[-2, -1, 5], 2]]], [[10, 6, 3, [[-2], 3]]], [[10, 5, 1, [[4], 3]]], [[14, 8, 4, [[2, 4], 3]]]]}
user: Ask a small girl - "How old are you?". She always says strange things... Lets help her!


For correct answer program should return int from 0 to 9.

Assume test input string always valid and may look like 
"1 year old" or "5 years old", etc.. The first char is number only.

Answer: {"fn_name": "get_age", "inputs": [["1 year old"], ["2 years old"], ["3 years old"], ["4 years old"], ["5 years old"], ["6 years old"], ["7 years old"], ["8 years old"], ["9 years old"]], "outputs": [[1], [2], [3], [4], [5], [6], [7], [8], [9]]}
user: The number ```12``` is the first number in having six divisors, they are: ```1, 2, 3, 4, 6 and 12.```
Your challenge for this kata is to find the minimum number that has a certain number of divisors.
For this purpose we have to create the function 

```find_min_num() or findMinNum() or similar in the other languages```

that receives the wanted number of divisors ```num_div```, and outputs the smallest number having an amount of divisors equals to ```num_div```.

Let's see some cases:
```
find_min_num(10) = 48 # divisors are: 1, 2, 3, 4, 6, 8, 12, 16, 24 and  48
find_min_num(12) = 60
```
In this kata all the tests will be with ```numDiv < 80```

(There will be a next kata with numDiv < 10000, Find the First Number Having a Certain Number of Divisors II, should have the help of number theory)

Enjoy it and happy coding!
(Memoization is advisable)

Answer: {"fn_name": "find_min_num", "inputs": [[6], [10], [12], [13]], "outputs": [[12], [48], [60], [4096]]}
user: Your job is to write function last_digits(n,d) which return the last `d` digits of an integer `n` as a list.
`n` will be from 0 to 10^10

Examples:

`last_digits(1,1)     --> [1]`

`last_digits(1234,2)   --> [3,4]`

`last_digits(637547,6) --> [6,3,7,5,4,7]`

Special cases:

If `d` > the number of digits, just return the number's digits as a list.

If `d` <= 0, then return an empty list.

This is the first kata I have made, so please report any issues.

Answer: {"fn_name": "solution", "inputs": [[1, 1], [123767, 4], [0, 1], [34625647867585, 10], [1234, 0], [24134, -4], [1343, 5]], "outputs": [[[1]], [[3, 7, 6, 7]], [[0]], [[5, 6, 4, 7, 8, 6, 7, 5, 8, 5]], [[]], [[]], [[1, 3, 4, 3]]]}
user: Here you will create the classic [Pascal's triangle](https://en.wikipedia.org/wiki/Pascal%27s_triangle).
Your function will be passed the depth of the triangle and you code has to return the corresponding pascal triangle up to that depth.

The triangle should be returned as a nested array.

for example:
```python
pascal(5) # should return [[1], [1,1], [1,2,1], [1,3,3,1], [1,4,6,4,1]]
```

To build the triangle, start with a single 1 at the top, for each number in the next row you just take the two numbers above it and add them together (except for the edges, which are all `1`), e.g.:
```
              [1]
            [1   1]
          [1   2   1]
        [1   3   3   1]
```

Answer: {"fn_name": "pascal", "inputs": [[1], [5], [10]], "outputs": [[[[1]]], [[[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1]]], [[[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1]]]]}
user: A `bouncy number` is a positive integer whose digits neither increase nor decrease. For example, 1235 is an increasing number, 5321 is a decreasing number, and 2351 is a bouncy number. By definition, all numbers under 100 are non-bouncy, and 101 is the first bouncy number.

Determining if a number is bouncy is easy, but counting all bouncy numbers with N digits can be challenging for large values of N. To complete this kata, you must write a function that takes a number N and return the count of bouncy numbers with N digits. For example, a "4 digit" number includes zero-padded, smaller numbers, such as 0001, 0002, up to 9999.

For clarification, the bouncy numbers between 100 and 125 are: 101, 102, 103, 104, 105, 106, 107, 108, 109, 120, and 121.

Answer: {"fn_name": "bouncy_count", "inputs": [[0], [1], [2], [3], [4], [5], [6], [10], [20], [50]], "outputs": [[0], [0], [0], [525], [8325], [95046], [987048], [9999722967], [99999999999959940181], [99999999999999999999999999999999999999912040301674]]}
user: In this kata, the number 0 is infected. You are given a list. Every turn, any item in the list that is adjacent to a 0 becomes infected and transforms into a 0. How many turns will it take for the whole list to become infected?

```
[0,1,1,0] ==> [0,0,0,0] 
All infected in 1 turn.

[1,1,0,1,1] --> [1,0,0,0,1] --> [0,0,0,0,0]
All infected in 2 turns

[0,1,1,1] --> [0,0,1,1] --> [0,0,0,1] --> [0,0,0,0]
All infected in 3 turns.
```

All lists will contain at least one item, and at least one zero, and the only items will be 0s and 1s. Lists may be very very long, so pure brute force approach will not work.

Answer: {"fn_name": "infected_zeroes", "inputs": [[[0]], [[0, 1, 1, 0]], [[0, 1, 1, 1, 0]], [[1, 1, 0, 1, 1]], [[0, 1, 1, 1]], [[1, 1, 1, 0]]], "outputs": [[0], [1], [2], [2], [3], [3]]}
user: ## **Task**

Four mirrors are placed in a way that they form a rectangle with corners at coordinates `(0, 0)`, `(max_x, 0)`, `(0, max_y)`, and `(max_x, max_y)`. A light ray enters this rectangle through a hole at the position `(0, 0)` and moves at an angle of 45 degrees relative to the axes. Each time it hits one of the mirrors, it gets reflected. In the end, the light ray hits one of the rectangle's corners, and flies out. Your function must determine whether the exit point is either `(0, 0)` or `(max_x, max_y)`. If it is either `(0, 0)` or `(max_x, max_y)`, return `True` and `False` otherwise.

**Example**

For `max_x = 10` and `max_y = 20`, the ray goes through the following lattice points: `(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9), (10, 10), (9, 11), (8, 12), (7, 13), (6, 14), (5, 15), (4, 16), (3, 17), (2, 18), (1, 19), (0, 20)`.

The ray left the rectangle at position `(0, 20)`, so the result is `False`.

Here is an image of the light being reflected.
![d](https://upload.wikimedia.org/wikipedia/commons/thumb/7/73/Arithmetic-billiard-40-10.jpg/450px-Arithmetic-billiard-40-10.jpg)


Also, once completing this kata, please do not rate it based off of the difficulty level(kyu) and instead on whether you think it is a good kata.

Answer: {"fn_name": "reflections", "inputs": [[10, 10], [10, 20], [12, 23], [5, 25]], "outputs": [[true], [false], [false], [true]]}
user: You are given a set of `n` segments on the axis `Ox`, each segment has integer endpoints between `0` and `m` inclusive.
 Segments may intersect, overlap or even coincide with each other. Each segment is characterized by two integers li and ri — coordinates of the left and of the right endpoints.

 Consider all integer points between `0` and `m` inclusive. Your task is to print all such points that don't belong to any segment. The point x belongs to the segment `[l;r]` if and only if `l ≤ x ≤ r`.

**Input:**
 `m` — the upper bound for coordinates;
 array of coordinates li and ri `0 ≤ li ≤ ri ≤ m` — the endpoints of the `i`-th segment. Segments may intersect, overlap or even coincide with each other.

**Output:**
 All points from `0` to `m` that don't belong to any segment.

**Examples:**
```python
segments(5, [(2,2),(1,2),(5,5)]) => [0,3,4]
segments(7, [(0,7)]) => []
```

Answer: {"fn_name": "segments", "inputs": [[7, [[0, 7]]], [2, []], [0, []], [0, [[0, 0]]]], "outputs": [[[]], [[0, 1, 2]], [[0]], [[]]]}
user: Your task is to create function```isDivideBy``` (or ```is_divide_by```) to check if an integer number is divisible by each out of two arguments.

A few cases:

```

(-12, 2, -6)  ->  true
(-12, 2, -5)  ->  false

(45, 1, 6)    ->  false
(45, 5, 15)   ->  true

(4, 1, 4)     ->  true
(15, -5, 3)   ->  true

```

Answer: {"fn_name": "is_divide_by", "inputs": [[8, 2, 4], [12, -3, 4], [8, 3, 4], [48, 2, -5], [-100, -25, 10], [10000, 5, -3], [4, 4, 2], [5, 2, 3], [-96, 25, 17], [33, 1, 33]], "outputs": [[true], [true], [false], [false], [true], [false], [true], [false], [false], [true]]}
user: Your task is to ___Reverse and Combine Words___. It's not too difficult, but there are some things you have to consider...

### So what to do?


Input: String containing different "words" separated by spaces

```
1. More than one word? Reverse each word and combine first with second, third with fourth and so on...
   (odd number of words => last one stays alone, but has to be reversed too)
2. Start it again until there's only one word without spaces
3. Return your result...
```

### Some easy examples:
```
Input:  "abc def"
Output: "cbafed"

Input:  "abc def ghi 123"
Output: "defabc123ghi"

Input:  "abc def gh34 434ff 55_eri 123 343"
Output: "43hgff434cbafed343ire_55321"
```

I think it's clear?! First there are some static tests, later on random tests too...

### Hope you have fun! :-)

Answer: {"fn_name": "reverse_and_combine_text", "inputs": [["abc def"], ["abc def ghi jkl"], ["dfghrtcbafed"], ["234hh54 53455 sdfqwzrt rtteetrt hjhjh lllll12  44"], ["sdfsdf wee sdffg 342234 ftt"]], "outputs": [["cbafed"], ["defabcjklghi"], ["dfghrtcbafed"], ["trzwqfdstrteettr45hh4325543544hjhjh21lllll"], ["gffds432243fdsfdseewttf"]]}
user: The odd and even numbers are fighting against each other!

You are given a list of positive integers. The odd numbers from the list will fight using their `1` bits from their binary representation, while the even numbers will fight using their `0` bits. If present in the list, number `0` will be neutral, hence not fight for either side.

You should return:

* `odds win` if number of `1`s from odd numbers is larger than `0`s from even numbers
* `evens win` if number of `1`s from odd numbers is smaller than `0`s from even numbers
* `tie` if equal, including if list is empty

Please note that any prefix that might appear in the binary representation, e.g. `0b`, should not be counted towards the battle.

### Example:
For an input list of `[5, 3, 14]`:

* odds: `5` and `3` => `101` and `11` => four `1`s
* evens: `14` => `1110` => one `0`

Result: `odds win` the battle with 4-1

If you enjoyed this kata, you can find a nice variation of it [here](https://www.codewars.com/kata/world-bits-war).

Answer: {"fn_name": "bits_battle", "inputs": [[[5, 3, 14]], [[3, 8, 22, 15, 78]], [[]], [[1, 13, 16]]], "outputs": [["odds win"], ["evens win"], ["tie"], ["tie"]]}
user: The Monty Hall problem is a probability puzzle base on the American TV show "Let's Make A Deal".

In this show, you would be presented with 3 doors: One with a prize behind it, and two without (represented with goats).

After choosing a door, the host would open one of the other two doors which didn't include a prize, and ask the participant if he or she wanted to switch to the third door. Most wouldn't. One would think you have a fifty-fifty chance of winning after having been shown a false door, however the math proves that you significantly increase your chances, from 1/3 to 2/3 by switching.

Further information about this puzzle can be found on https://en.wikipedia.org/wiki/Monty_Hall_problem.

In this program you are given an array of people who have all guessed on a door from 1-3, as well as given the door which includes the price. You need to make every person switch to the other door, and increase their chances of winning. Return the win percentage (as a rounded int) of all participants.

Answer: {"fn_name": "monty_hall", "inputs": [[1, [1, 2, 2, 2, 3, 2, 1, 3, 1, 3]], [2, [2, 1, 2, 1, 2, 3, 1, 1, 2, 2, 3]], [3, [1, 1, 1, 2, 2, 3, 2, 2, 1, 3, 3, 2, 3, 1, 1, 2]]], "outputs": [[70], [55], [75]]}
user: # Task
 You are a magician. You're going to perform a trick.

 You have `b` black marbles and `w` white marbles in your magic hat, and an infinite supply of black and white marbles that you can pull out of nowhere. 
 
 You ask your audience to repeatedly remove a pair of marbles from your hat and, for each pair removed, you add one marble to the hat according to the following rule until there is only 1 marble left. 

 If the marbles of the pair that is removed are of the same color, you add a white marble to the hat. Otherwise, if one is black and one is white, you add a black marble.
 
 Given the initial number of black and white marbles in your hat, your trick is to predict the color of the last marble.
 
 Note: A magician may confuse your eyes, but not your mind ;-)

# Input/Output


 - `[input]` integer `b`

  Initial number of black marbles in the hat. 
  
  `1 <= b <= 10^9`


 - `[input]` integer `w`

  Initial number of white marbles in the hat. 
  
  `1 <= w <= 10^9`


 - `[output]` a string

  `"Black"` or `"White"` if you can safely predict the color of the last marble. If not, return `"Unsure"`.

Answer: {"fn_name": "not_so_random", "inputs": [[1, 1], [2, 1], [1, 2], [2, 2], [6, 9], [10000, 10000], [11111, 22222]], "outputs": [["Black"], ["White"], ["Black"], ["White"], ["White"], ["White"], ["Black"]]}
user: Given a string made up of letters a, b, and/or c, switch the position of letters a and b (change a to b and vice versa). Leave any incidence of c untouched.

Example:

'acb' --> 'bca'
'aabacbaa' --> 'bbabcabb'

Answer: {"fn_name": "switcheroo", "inputs": [["abc"], ["aaabcccbaaa"], ["ccccc"], ["abababababababab"], ["aaaaa"]], "outputs": [["bac"], ["bbbacccabbb"], ["ccccc"], ["babababababababa"], ["bbbbb"]]}
user: ## Nova polynomial add

This kata is from a series on polynomial handling. ( [#1](http://www.codewars.com/kata/nova-polynomial-1-add-1) [#2](http://www.codewars.com/kata/570eb07e127ad107270005fe) [#3](http://www.codewars.com/kata/5714041e8807940ff3001140 ) [#4](http://www.codewars.com/kata/571a2e2df24bdfd4e20001f5) )

Consider a polynomial in a list where each element in the list element corresponds to a factor. The factor order is the position in the list. The first element is the zero order factor (the constant).

`p = [a0, a1, a2, a3]` signifies the polynomial `a0 + a1x + a2x^2 + a3*x^3`

In this kata add two polynomials:

```python
poly_add ( [1, 2], [1] ) = [2, 2]
```

Answer: {"fn_name": "poly_add", "inputs": [[[1], [1]], [[1, 2], [1]], [[1, 2, 3, 4], [4, 3, 2, 1]], [[], []], [[1, 2, 3, 4, 5, 6], []], [[], [1, 2, 3, 4, 5, 6]]], "outputs": [[[2]], [[2, 2]], [[5, 5, 5, 5]], [[]], [[1, 2, 3, 4, 5, 6]], [[1, 2, 3, 4, 5, 6]]]}
user: Complete the function that takes two numbers as input, ```num``` and ```nth``` and return the `nth` digit of `num` (counting from right to left).

## Note
- If ```num``` is negative, ignore its sign and treat it as a positive value
- If ```nth``` is not positive, return `-1`
- Keep in mind that `42 = 00042`. This means that ```findDigit(42, 5)``` would return `0`

## Examples

```
findDigit(5673, 4)     returns 5
findDigit(129, 2)      returns 2
findDigit(-2825, 3)    returns 8
findDigit(-456, 4)     returns 0
findDigit(0, 20)       returns 0
findDigit(65, 0)       returns -1
findDigit(24, -8)      returns -1
```

Answer: {"fn_name": "find_digit", "inputs": [[5673, 4], [129, 2], [-2825, 3], [0, 20], [65, 0], [24, -8], [-456, 5], [-1234, 2], [-5540, 1], [678998, 0], [-67854, -57], [0, -3]], "outputs": [[5], [2], [8], [0], [-1], [-1], [0], [3], [0], [-1], [-1], [-1]]}
user: ## Your Job

  Find the sum of all multiples of `n` below `m` 
  
  
## Keep in Mind

  * `n` and `m` are natural numbers (positive integers)
  * `m` is **excluded** from the multiples
  
  
## Examples

Answer: {"fn_name": "sum_mul", "inputs": [[4, 123], [123, 4567], [2, 10], [2, 2], [7, 7], [7, 2], [21, 3], [0, 2], [2, 0], [4, -7], [-7, 4]], "outputs": [[1860], [86469], [20], [0], [0], [0], [0], ["INVALID"], ["INVALID"], ["INVALID"], ["INVALID"]]}