meetforever/GRPO_CL huggingface dataset:
user: # Summary:
Given a number, `num`, return the shortest amount of `steps` it would take from 1, to land exactly on that number.

# Description:
A `step` is defined as either:
- Adding 1 to the number: `num += 1`
- Doubling the number: `num *= 2`

You will always start from the number `1` and you will have to return the shortest count of steps it would take to land exactly on that number.

`1 <= num <= 10000`

Examples:

`num == 3` would return `2` steps:

```
1 -- +1 --> 2:        1 step
2 -- +1 --> 3:        2 steps

2 steps
```

`num == 12` would return `4` steps:

```
1 -- +1 --> 2:        1 step
2 -- +1 --> 3:        2 steps
3 -- x2 --> 6:        3 steps
6 -- x2 --> 12:       4 steps

4 steps
```

`num == 16` would return `4` steps:

```
1 -- +1 --> 2:        1 step
2 -- x2 --> 4:        2 steps
4 -- x2 --> 8:        3 steps
8 -- x2 --> 16:       4 steps

4 steps
```

Answer: {"fn_name": "shortest_steps_to_num", "inputs": [[2], [3], [4], [5], [6], [7], [8], [9], [10], [20], [30], [40], [50], [11], [24], [37], [19], [48], [59], [65], [73], [83], [64], [99], [100], [10000], [1500], [1534], [1978], [2763], [9999], [2673], [4578], [9876], [2659], [7777], [9364], [7280], [4998], [9283], [8234], [7622], [800], [782], [674], [4467], [1233], [3678], [7892], [5672]], "outputs": [[1], [2], [2], [3], [3], [4], [3], [4], [4], [5], [7], [6], [7], [5], [5], [7], [6], [6], [9], [7], [8], [9], [6], [9], [8], [17], [16], [18], [17], [17], [20], [16], [17], [18], [16], [18], [17], [17], [17], [17], [16], [19], [11], [13], [12], [18], [14], [18], [19], [16]]}
user: Prior to having fancy iPhones, teenagers would wear out their thumbs sending SMS
messages on candybar-shaped feature phones with 3x4 numeric keypads.

    ------- ------- -------
    |     | | ABC | | DEF |
    |  1  | |  2  | |  3  |
    ------- ------- -------
    ------- ------- -------
    | GHI | | JKL | | MNO |
    |  4  | |  5  | |  6  |
    ------- ------- -------
    ------- ------- -------
    |PQRS | | TUV | | WXYZ|
    |  7  | |  8  | |  9  |
    ------- ------- -------
    ------- ------- -------
    |     | |space| |     |
    |  *  | |  0  | |  #  |
    ------- ------- -------

Prior to the development of T9 (predictive text entry) systems, the method to
type words was called "multi-tap" and involved pressing a button repeatedly to
cycle through the possible values.

For example, to type a letter `"R"` you would press the `7` key three times (as
the screen display for the current character cycles through `P->Q->R->S->7`).  A
character is "locked in" once the user presses a different key or pauses for a
short period of time (thus, no extra button presses are required beyond what is
needed for each letter individually). The zero key handles spaces, with one press of the key producing a space and two presses producing a zero.

In order to send the message `"WHERE DO U WANT 2 MEET L8R"` a teen would have to
actually do 47 button presses.  No wonder they abbreviated.

For this assignment, write a module that can calculate the amount of button
presses required for any phrase. Punctuation can be ignored for this exercise. Likewise, you can assume the phone doesn't distinguish between upper/lowercase characters (but you should allow your module to accept input in either for convenience).

Hint: While it wouldn't take too long to hard code the amount of keypresses for
all 26 letters by hand, try to avoid doing so! (Imagine you work at a phone
manufacturer who might be testing out different keyboard layouts, and you want
to be able to test new ones rapidly.)

Answer: {"fn_name": "presses", "inputs": [["LOL"], ["HOW R U"], ["WHERE DO U WANT 2 MEET L8R"], ["lol"], ["0"], ["ZER0"], ["1"], ["IS NE1 OUT THERE"], ["#"], ["#codewars #rocks"]], "outputs": [[9], [13], [47], [9], [2], [11], [1], [31], [1], [36]]}
user: Consider integer coordinates x, y in the Cartesian plan and three functions f, g, h
defined by:
```
f: 1 <= x <= n, 1 <= y <= n --> f(x, y) = min(x, y)
g: 1 <= x <= n, 1 <= y <= n --> g(x, y) = max(x, y)
h: 1 <= x <= n, 1 <= y <= n --> h(x, y) = x + y
``` 
where n is a given integer (n >= 1, guaranteed) and x, y are integers.

In the table below you can see the value of the function f with n = 6.

  ---|*0* |*1*|*2*|*3*|*4*|*5*|*6*|
  -- |--|--|--|--|--|--|--|
  *6*|- |1 |2 |3 |4 |5 |6 |
  *5*|- |1 |2 |3 |4 |5 |5 |
  *4*|- |1 |2 |3 |4 |4 |4 |
  *3*|- |1 |2 |3 |3 |3 |3 |
  *2*|- |1 |2 |2 |2 |2 |2 |
  *1*|- |1 |1 |1 |1 |1 |1 |
  *0*|- |- |- |- |- |- |- |

The task is to calculate the sum of f(x, y), g(x, y) and h(x, y) for all integers x and y such that (1 <= x <= n, 1 <= y <= n).

The function sumin (sum of f) will take n as a parameter and return the sum of min(x, y) in the domain 1 <= x <= n, 1 <= y <= n.
The function sumax (sum of g) will take n as a parameter and return the sum of max(x, y) in the same domain.
The function sumsum (sum of h) will take n as a parameter and return the sum of x + y in the same domain.


#Examples:
```
sumin(6) --> 91
sumin(45) --> 31395
sumin(999) --> 332833500
sumin(5000) --> 41679167500

sumax(6) --> 161
sumax(45) --> 61755
sumax(999) --> 665167500
sumax(5000) --> 83345832500

sumsum(6) --> 252
sumsum(45) --> 93150
sumsum(999) --> 998001000
sumsum(5000) --> 125025000000
```

#Hint:
1. Try to avoid nested loops
2. Note that h = f + g

Answer: {"fn_name": "sumin", "inputs": [[5], [6], [8], [15], [100], [365], [730], [4000]], "outputs": [[55], [91], [204], [1240], [338350], [16275715], [129938905], [21341334000]]}
user: In this kata, your task is to create a function that takes a single list as an argument and returns a flattened list. The input list will have a maximum of one level of nesting (list(s) inside of a list).

```python
# no nesting
[1, 2, 3]

# one level of nesting
[1, [2, 3]]
```
---

# Examples

```python
>>> flatten_me(['!', '?'])
['!', '?']

>>> flatten_me([1, [2, 3], 4])
[1, 2, 3, 4]

>>> flatten_me([['a', 'b'], 'c', ['d']])
['a', 'b', 'c', 'd']

>>> flatten_me([[True, False], ['!'], ['?'], [71, '@']]) 
[True, False, '!', '?', 71, '@']
```

Good luck!

Answer: {"fn_name": "flatten_me", "inputs": [[[1, [2, 3], 4]], [[["a", "b"], "c", ["d"]]], [["!", "?"]]], "outputs": [[[1, 2, 3, 4]], [["a", "b", "c", "d"]], [["!", "?"]]]}
user: Have you heard about Megamind? Megamind and Metro Man are two aliens who came to earth. Megamind wanted to destroy the earth, while Metro Man wanted to stop him and protect mankind. After a lot of fighting, Megamind finally threw Metro Man up into the sky. Metro Man was defeated and was never seen again. Megamind wanted to be a super villain. He believed that the difference between a villain and a super villain is nothing but presentation. Megamind became bored, as he had nobody or nothing to fight against since Metro Man was gone. So, he wanted to create another hero against whom he would fight for recreation. But accidentally, another villain named Hal Stewart was created in the process, who also wanted to destroy the earth. Also, at some point Megamind had fallen in love with a pretty girl named Roxanne Ritchi. This changed him into a new man. Now he wants to stop Hal Stewart for the sake of his love. So, the ultimate fight starts now.

* Megamind has unlimited supply of guns named Magic-48. Each of these guns has `shots` rounds of magic spells.
* Megamind has perfect aim. If he shoots a magic spell it will definitely hit Hal Stewart. Once hit, it decreases the energy level of Hal Stewart by `dps` units.
* However, since there are exactly `shots` rounds of magic spells in each of these guns, he may need to swap an old gun with a fully loaded one. This takes some time. Let’s call it swapping period. 
* Since Hal Stewart is a mutant, he has regeneration power. His energy level increases by `regen` unit during a swapping period. 
* Hal Stewart will be defeated immediately once his energy level becomes zero or negative. 
* Hal Stewart initially has the energy level of `hp` and Megamind has a fully loaded gun in his hand.
* Given the values of `hp`, `dps`, `shots` and `regen`, find the minimum number of times Megamind needs to shoot to defeat Hal Stewart. If it is not possible to defeat him,  return `-1` instead.

# Example
Suppose, `hp` = 13, `dps` = 4, `shots` = 3 and `regen` = 1. There are 3 rounds of spells in the gun. Megamind shoots all of them. Hal Stewart’s energy level decreases by 12 units, and thus his energy level becomes 1. Since Megamind’s gun is now empty, he will get a new gun and thus it’s a swapping period. At this time, Hal Stewart’s energy level will increase by 1 unit and will become 2. However, when Megamind shoots the next spell, Hal’s energy level will drop by 4 units and will become −2, thus defeating him. So it takes 4 shoots in total to defeat Hal Stewart. However, in this same example if Hal’s regeneration power was 50 instead of 1, it would have been impossible to defeat Hal.

Answer: {"fn_name": "mega_mind", "inputs": [[12, 4, 3, 2], [9, 4, 2, 7], [13, 4, 3, 1], [13, 4, 3, 50], [36, 4, 3, 2], [15, 4, 3, 12], [100000, 99999, 100000, 100000], [100000, 100000, 100000, 100000], [100000, 1, 50000, 49999], [100000, 1, 1000, 999], [17, 4, 4, 16], [23, 4, 4, 13], [1, 4, 4, 15], [22, 4, 4, 13], [16, 4, 4, 16], [20, 4, 4, 15]], "outputs": [[3], [4], [4], [-1], [11], [-1], [2], [1], [2500050000], [99001000], [-1], [16], [1], [12], [4], [20]]}
user: A new task for you!

You have to create a method, that corrects a given time string.
There was a problem in addition, so many of the time strings are broken.
Time-Format is european. So from "00:00:00" to "23:59:59".


Some examples:

"09:10:01" -> "09:10:01"
"11:70:10" -> "12:10:10"
"19:99:99" -> "20:40:39"
"24:01:01" -> "00:01:01"

If the input-string is null or empty return exactly this value! (empty string for C++)
If the time-string-format is invalid, return null. (empty string for C++)

Have fun coding it and please don't forget to vote and rank this kata! :-) 

I have created other katas. Have a look if you like coding and challenges.

Answer: {"fn_name": "time_correct", "inputs": [[null], [""], ["001122"], ["00;11;22"], ["0a:1c:22"], ["09:10:01"], ["11:70:10"], ["19:99:99"], ["24:01:01"], ["52:01:01"], ["14:59:94"]], "outputs": [[null], [""], [null], [null], [null], ["09:10:01"], ["12:10:10"], ["20:40:39"], ["00:01:01"], ["04:01:01"], ["15:00:34"]]}
user: Return the Nth Even Number

The input will not be 0.

Answer: {"fn_name": "nth_even", "inputs": [[1], [2], [3], [100], [1298734]], "outputs": [[0], [2], [4], [198], [2597466]]}
user: Complete the function which returns the weekday according to the input number:

* `1` returns `"Sunday"`
* `2` returns `"Monday"`
* `3` returns `"Tuesday"`
* `4` returns `"Wednesday"`
* `5` returns `"Thursday"`
* `6` returns `"Friday"`
* `7` returns `"Saturday"`
* Otherwise returns `"Wrong, please enter a number between 1 and 7"`

Answer: {"fn_name": "whatday", "inputs": [[1], [2], [3], [4], [5], [6], [7], [0], [8], [20]], "outputs": [["Sunday"], ["Monday"], ["Tuesday"], ["Wednesday"], ["Thursday"], ["Friday"], ["Saturday"], ["Wrong, please enter a number between 1 and 7"], ["Wrong, please enter a number between 1 and 7"], ["Wrong, please enter a number between 1 and 7"]]}
user: # Task
 You are given n rectangular boxes, the ith box has the length lengthi, the width widthi and the height heighti. 
 
 Your task is to check if it is possible to pack all boxes into one so that inside each box there is no more than one another box (which, in turn, can contain at most one another box, and so on). 
 
 More formally, your task is to check whether there is such sequence of n different numbers pi (1 ≤ pi ≤ n) that for each 1 ≤ i < n the box number pi can be put into the box number pi+1.

 A box can be put into another box if all sides of the first one are less than the respective ones of the second one. You can rotate each box as you wish, i.e. you can `swap` its length, width and height if necessary.

# Example

 For `length = [1, 3, 2], width = [1, 3, 2] and height = [1, 3, 2]`, the output should be `true`;
 
 For `length = [1, 1], width = [1, 1] and height = [1, 1],` the output should be `false`;
 
 For `length = [3, 1, 2], width = [3, 1, 2] and height = [3, 2, 1]`, the output should be `false`.
 
# Input/Output


 - `[input]` integer array `length`

    Array of positive integers.

    Constraints:

    `1 ≤ length.length ≤ 100,`

    `1 ≤ length[i] ≤ 2000.`


 - `[input]` integer array `width`

    Array of positive integers.

    Constraints:

    `width.length = length.length,`

    `1 ≤ width[i] ≤ 2000.`


 - `[input]` integer array `height`

    Array of positive integers.

    Constraints:

    `height.length = length.length,`

    `1 ≤ height[i] ≤ 2000.`


 - `[output]` a boolean value

    `true` if it is possible to put all boxes into one, `false` otherwise.

Answer: {"fn_name": "boxes_packing", "inputs": [[[1, 3, 2], [1, 3, 2], [1, 3, 2]], [[1, 1], [1, 1], [1, 1]], [[3, 1, 2], [3, 1, 2], [3, 2, 1]], [[2], [3], [4]], [[5, 7, 4, 1, 2], [4, 10, 3, 1, 4], [6, 5, 5, 1, 2]], [[6, 4], [5, 3], [4, 5]], [[6, 3], [5, 4], [4, 5]], [[6, 3], [5, 5], [4, 4]], [[883, 807], [772, 887], [950, 957]], [[6, 5], [5, 3], [4, 4]], [[4, 10, 3, 1, 4], [5, 7, 4, 1, 2], [6, 5, 5, 1, 2]], [[10, 8, 6, 4, 1], [7, 7, 6, 3, 2], [9, 6, 3, 2, 1]]], "outputs": [[true], [false], [false], [true], [true], [true], [true], [true], [true], [true], [true], [true]]}
user: ## Task

**_Given_** *an array of integers* , **_Find_** **_the maximum product_** *obtained from multiplying 2 adjacent numbers in the array*.
____

# Notes

* **_Array/list_** size is *at least 2*.

* **_Array/list_** numbers could be a *mixture of positives, negatives also zeroes* .
___

# Input >> Output Examples
```
adjacentElementsProduct([1, 2, 3]); ==> return 6
```

## **_Explanation_**:

* **_The maximum product_** *obtained from multiplying* ` 2 * 3 = 6 `, and **_they're adjacent numbers in the array_**.
___
```
adjacentElementsProduct([9, 5, 10, 2, 24, -1, -48]); ==> return 50
```
## **_Explanation_**:
**_Max product_** obtained *from multiplying*   ``` 5 * 10  =  50  ```.
___
```
adjacentElementsProduct([-23, 4, -5, 99, -27, 329, -2, 7, -921])  ==>  return -14
```

## **_Explanation_**:

* **_The maximum product_** *obtained from multiplying* ` -2 * 7 = -14 `, and **_they're adjacent numbers in the array_**.
___
___
___

# [Playing with Numbers Series](https://www.codewars.com/collections/playing-with-numbers)

# [Playing With Lists/Arrays Series](https://www.codewars.com/collections/playing-with-lists-slash-arrays)

# [For More Enjoyable Katas](http://www.codewars.com/users/MrZizoScream/authored)
___

## ALL translations are welcomed

## Enjoy Learning !!
# Zizou

Answer: {"fn_name": "adjacent_element_product", "inputs": [[[5, 8]], [[5, 1, 1, 8]], [[1, 2, 3]], [[1, 5, 10, 9]], [[4, 12, 3, 1, 5]], [[5, 1, 2, 3, 1, 4]], [[3, 6, -2, -5, 7, 3]], [[9, 5, 10, 2, 24, -1, -48]], [[5, 6, -4, 2, 3, 2, -23]], [[-23, 4, -5, 99, -27, 329, -2, 7, -921]], [[1, 0, 1, 0, 1000]], [[1, 2, 3, 0]]], "outputs": [[40], [8], [6], [90], [48], [6], [21], [50], [30], [-14], [0], [6]]}
user: Welcome.

In this kata you are required to, given a string, replace every letter with its position in the alphabet.

If anything in the text isn't a letter, ignore it and don't return it.

`"a" = 1`, `"b" = 2`, etc.

## Example

```python
alphabet_position("The sunset sets at twelve o' clock.")
```
Should return `"20 8 5 19 21 14 19 5 20 19 5 20 19 1 20 20 23 5 12 22 5 15 3 12 15 3 11"` (as a string)

Answer: {"fn_name": "alphabet_position", "inputs": [["-.-'"]], "outputs": [[""]]}
user: All of the animals are having a feast! Each animal is bringing one dish. There is just one rule: the dish must start and end with the same letters as the animal's name. For example, the great blue heron is bringing garlic naan and the chickadee is bringing chocolate cake.

Write a function `feast` that takes the animal's name and dish as arguments and returns true or false to indicate whether the beast is allowed to bring the dish to the feast.

Assume that `beast` and `dish` are always lowercase strings, and that each has at least two letters. `beast` and `dish` may contain hyphens and spaces, but these will not appear at the beginning or end of the string. They will not contain numerals.

Answer: {"fn_name": "feast", "inputs": [["great blue heron", "garlic naan"], ["chickadee", "chocolate cake"], ["brown bear", "bear claw"], ["marmot", "mulberry tart"], ["porcupine", "pie"], ["cat", "yogurt"], ["electric eel", "lasagna"], ["slow loris", "salsas"], ["ox", "orange lox"], ["blue-footed booby", "blueberry"], ["fruit-fly", "blueberry"]], "outputs": [[true], [true], [false], [true], [true], [false], [false], [true], [true], [true], [false]]}
user: Write a function that rearranges an integer into its largest possible value. 

```python
super_size(123456) # 654321
super_size(105)    # 510
super_size(12)     # 21
```
``` haskell
superSize 123456 `shouldBe` 654321
superSize    105 `shouldBe`    510
superSize     12 `shouldBe`     21
```

If the argument passed through is single digit or is already the maximum possible integer, your function should simply return it.

Answer: {"fn_name": "super_size", "inputs": [[69], [513], [2017], [414], [608719], [123456789], [700000000001], [666666], [2], [0]], "outputs": [[96], [531], [7210], [441], [987610], [987654321], [710000000000], [666666], [2], [0]]}
user: Write a function that takes a string and returns an array of the repeated characters (letters, numbers, whitespace) in the string.

If a charater is repeated more than once, only show it once in the result array.

Characters should be shown **by the order of their first repetition**. Note that this may be different from the order of first appearance of the character.

Characters are case sensitive.

For F# return a "char list"

## Examples:

```python
remember("apple") => returns ["p"]
remember("apPle") => returns []          # no repeats, "p" != "P"
remember("pippi") => returns ["p","i"]   # show "p" only once
remember('Pippi') => returns ["p","i"]   # "p" is repeated first
```

Answer: {"fn_name": "remember", "inputs": [["apple"], ["limbojackassin the garden"], ["11pinguin"], ["Claustrophobic"], ["apPle"], ["11 pinguin"], ["pippi"], ["Pippi"], ["kamehameha"], [""]], "outputs": [[["p"]], [["a", "s", "i", " ", "e", "n"]], [["1", "i", "n"]], [["o"]], [[]], [["1", "i", "n"]], [["p", "i"]], [["p", "i"]], [["a", "m", "e", "h"]], [[]]]}
user: ## Task

Given a positive integer as input, return the output as a string in the following format: 

Each element, corresponding to a digit of the number, multiplied by a power of 10 in such a way that with the sum of these elements you can obtain the original number.

## Examples

Input | Output
---   | ---
0     | ""
56    | "5\*10+6"
60    | "6\*10"
999   | "9\*100+9\*10+9"
10004 | "1\*10000+4"

Note: `input >= 0`

Answer: {"fn_name": "simplify", "inputs": [[8964631], [56], [999], [11], [991], [47], [234], [196587], [660], [600], [9090], [10104], [80008], [90000], [0]], "outputs": [["8*1000000+9*100000+6*10000+4*1000+6*100+3*10+1"], ["5*10+6"], ["9*100+9*10+9"], ["1*10+1"], ["9*100+9*10+1"], ["4*10+7"], ["2*100+3*10+4"], ["1*100000+9*10000+6*1000+5*100+8*10+7"], ["6*100+6*10"], ["6*100"], ["9*1000+9*10"], ["1*10000+1*100+4"], ["8*10000+8"], ["9*10000"], [""]]}
user: A Narcissistic Number is a number of length n in which the sum of its digits to the power of n is equal to the original number. If this seems confusing, refer to the example below.

Ex: 153, where n = 3 (number of digits in 153)
1^(3) + 5^(3) + 3^(3) = 153

Write a method is_narcissistic(i) (in Haskell: isNarcissistic :: Integer -> Bool) which returns whether or not i is a Narcissistic Number.

Answer: {"fn_name": "is_narcissistic", "inputs": [[153], [370], [371], [407], [1634], [8208], [9474], [54748], [92727], [93084], [548834], [1741725], [4210818], [9800817], [9926315], [24678050], [88593477], [146511208], [472335975], [534494836], [912985153], [4679307774], [115132219018763992565095597973971522401]], "outputs": [[true], [true], [true], [true], [true], [true], [true], [true], [true], [true], [true], [true], [true], [true], [true], [true], [true], [true], [true], [true], [true], [true], [true]]}
user: In a small town the population is `p0 = 1000` at the beginning of a year. The population
regularly increases by `2 percent` per year and moreover `50` new inhabitants per year
come to live in the town. 
How many years does the town need to see its population
greater or equal to `p = 1200` inhabitants?

```
At the end of the first year there will be: 
1000 + 1000 * 0.02 + 50 => 1070 inhabitants

At the end of the 2nd year there will be: 
1070 + 1070 * 0.02 + 50 => 1141 inhabitants (number of inhabitants is an integer)

At the end of the 3rd year there will be:
1141 + 1141 * 0.02 + 50 => 1213

It will need 3 entire years.
```
More generally given parameters:

`p0, percent, aug (inhabitants coming or leaving each year), p (population to surpass)`

the function `nb_year` should return `n` number of entire years needed to
get a population greater or equal to `p`.

aug is an integer, percent a positive or null number, p0 and p are positive integers (> 0)
```
Examples:
nb_year(1500, 5, 100, 5000) -> 15
nb_year(1500000, 2.5, 10000, 2000000) -> 10
```

Note: Don't forget to convert the percent parameter as a percentage in the body of your function: if the parameter percent is 2 you have to convert it to 0.02.

Answer: {"fn_name": "nb_year", "inputs": [[1500, 5, 100, 5000], [1500000, 2.5, 10000, 2000000], [1500000, 0.25, 1000, 2000000], [1500000, 0.25, -1000, 2000000], [1500000, 0.25, 1, 2000000], [1500000, 0.0, 10000, 2000000]], "outputs": [[15], [10], [94], [151], [116], [50]]}
user: # Task
N lamps are placed in a line, some are switched on and some are off. What is the smallest number of lamps that need to be switched so that on and off lamps will alternate with each other? 

You are given an array `a` of zeros and ones - `1` mean switched-on lamp and `0` means switched-off.

Your task is to find the smallest number of lamps that need to be switched.

# Example

For `a = [1, 0, 0, 1, 1, 1, 0]`, the result should be `3`.
```
a     --> 1 0 0 1 1 1 0
swith --> 0 1     0
became--> 0 1 0 1 0 1 0 ```

# Input/Output


- `[input]` integer array `a`

array of zeros and ones - initial lamp setup, 1 mean switched-on lamp and 0 means switched-off.

`2 < a.length <= 1000`


- `[output]` an integer

minimum number of switches.

Answer: {"fn_name": "lamps", "inputs": [[[1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1]], [[1, 0, 1]], [[1, 0, 1, 0]], [[0, 1, 0, 1, 0]], [[1, 0, 1, 0, 0, 1, 0, 1]], [[1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0]]], "outputs": [[5], [0], [0], [0], [4], [5]]}
user: A population of bears consists of black bears, brown bears, and white bears.

The input is an array of two elements. 

Determine whether the offspring of the two bears will return `'black'`, `'brown'`, `'white'`, `'dark brown'`, `'grey'`, `'light brown'`, or `'unknown'`.

Elements in the the array will always be a string.



## Examples:

    bear_fur(['black', 'black'])  returns 'black'

    bear_fur(['brown', 'brown'])  returns 'brown'

    bear_fur(['white', 'white'])  returns 'white'

    bear_fur(['black', 'brown'])  returns 'dark brown'

    bear_fur(['black', 'white'])  returns 'grey'

    bear_fur(['brown', 'white'])  returns 'light brown'

    bear_fur(['yellow', 'magenta'])  returns 'unknown'

Answer: {"fn_name": "bear_fur", "inputs": [[["black", "black"]], [["white", "white"]], [["brown", "brown"]], [["black", "brown"]], [["black", "white"]], [["white", "brown"]], [["pink", "black"]]], "outputs": [["black"], ["white"], ["brown"], ["dark brown"], ["grey"], ["light brown"], ["unknown"]]}