meetforever/GRPO_CL huggingface dataset:
user: Mr. Khalkhoul, an amazing teacher, likes to answer questions sent by his students via e-mail, but he often doesn't have the time to answer all of them. In this kata you will help him by making a program that finds
some of the answers.

You are given a `question` which is a string containing the question and some `information` which is a list of strings representing potential answers.

Your task is to find among `information` the UNIQUE string that has the highest number of words in common with `question`. We shall consider words to be separated by a single space.

You can assume that:

* all strings given contain at least one word and have no leading or trailing spaces,
* words are composed with alphanumeric characters only

You must also consider the case in which you get no matching words (again, ignoring the case): in such a case return `None/nil/null`.

Mr. Khalkhoul is countin' on you :)

Answer: {"fn_name": "answer", "inputs": [["is khalkhoul dumb", ["no he is NOT", "i guess so"]]], "outputs": [["no he is NOT"]]}
user: Consider the string `"adfa"` and the following rules: 
```Pearl
a) each character MUST be changed either to the one before or the one after in alphabet. 
b) "a" can only be changed to "b" and "z" to "y". 
```
From our string, we get:
```Pearl
"adfa" -> ["begb","beeb","bcgb","bceb"]
Another example: "bd" -> ["ae","ac","ce","cc"]
--We see that in each example, one of the possibilities is a palindrome.
```
I was working on the code for this but I couldn't quite figure it out. So far I have:

```python
def solve(st):
    return [all(ord(x) - ord(y) in ["FIX"] for x, y in zip(st, st[::-1]))][0]
```
I'm not sure what three numbers go into the array labelled `["FIX"]`. This is the only thing missing. 

You will be given a lowercase string and your task is to return `True` if at least one of the possiblities is a palindrome or `False` otherwise. You can use your own code or fix mine. 

More examples in test cases. Good luck!

Answer: {"fn_name": "solve", "inputs": [["abba"], ["abaazaba"], ["abccba"], ["adfa"], ["ae"], ["abzy"], ["ababbaba"], ["sq"], ["kxbkwgyydkcbtjcosgikfdyhuuprubpwthgflucpyylbofvqxkkvqthmdnywpaunfihvupbwpruwfybdmgeuocltdaidyyewmbzm"]], "outputs": [[true], [false], [true], [true], [false], [false], [true], [true], [true]]}
user: Having two standards for a keypad layout is inconvenient!  
Computer keypad's layout:  


 
Cell phone keypad's layout:  


Solve the horror of unstandartized keypads by providing a function that converts computer input to a number as if it was typed by a phone.

Example:  
"789" -> "123"

Notes:  
You get a string with numbers only

Answer: {"fn_name": "computer_to_phone", "inputs": [["0789456123"], ["000"], ["94561"], [""], ["919"]], "outputs": [["0123456789"], ["000"], ["34567"], [""], ["373"]]}
user: Write a function that accepts an array of 10 integers (between 0 and 9), that returns a string of those numbers in the form of a phone number.

Example:

```python
create_phone_number([1, 2, 3, 4, 5, 6, 7, 8, 9, 0]) # => returns "(123) 456-7890"
```
```f#
createPhoneNumber [1; 2; 3; 4; 5; 6; 7; 8; 9; 0] // => returns "(123) 456-7890"
```

The returned format must be correct in order to complete this challenge. 
Don't forget the space after the closing parentheses!

Answer: {"fn_name": "create_phone_number", "inputs": [[[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]], [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], [[0, 2, 3, 0, 5, 6, 0, 8, 9, 0]], [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]], "outputs": [["(123) 456-7890"], ["(111) 111-1111"], ["(023) 056-0890"], ["(000) 000-0000"]]}
user: The code provided is supposed replace all the dots `.` in the specified String `str` with dashes `-`

But it's not working properly.

# Task

Fix the bug so we can all go home early.

# Notes

String `str` will never be null.

Answer: {"fn_name": "replace_dots", "inputs": [[""], ["no dots"], ["one.two.three"], ["........"]], "outputs": [[""], ["no dots"], ["one-two-three"], ["--------"]]}
user: You need count how many valleys you will pass.

Start is always from zero level.

Every time you go down below 0 level counts as an entry of a valley, and as you go up to 0 level from valley counts as an exit of a valley.

One passed valley is equal one entry and one exit of a valley.
```
s='FUFFDDFDUDFUFUF'
U=UP
F=FORWARD
D=DOWN
```

To represent string above
```
(level 1)  __
(level 0)_/  \         _(exit we are again on level 0)
(entry-1)     \_     _/
(level-2)       \/\_/
```
So here we passed one valley

Answer: {"fn_name": "counting_valleys", "inputs": [["UFFFD"], ["DFFFD"], ["UFFFU"], ["DFFFU"], ["UFFDDFDUDFUFU"], ["UFFDDFDUDFUFUUFFDDFDUDFUFU"], ["UFFDDFDUDFUFUUFFDDUFFDDUFFDDUDUDUDUDUDUUUUUUUUU"], ["UFFDDFDUDFUFUUFFDDFDUDFUFUUFFDDFDUDFUFUUFFDDFDUDFUFU"], ["UFFDDFDUDFUFUUFFDDFDUDFUFUUFFDDFDUDFUFUUFFDDFDUDFUFUUFFDDFDUDFUFUUFFDDFDUDFUFU"]], "outputs": [[0], [0], [0], [1], [1], [2], [3], [4], [6]]}
user: Apparently "Put A Pillow On Your Fridge Day is celebrated on the 29th of May each year, in Europe and the U.S. The day is all about prosperity, good fortune, and having bit of fun along the way."

All seems very weird to me.

Nevertheless, you will be given an array of two strings (s). First find out if the first string contains a fridge... (i've deemed this as being 'n', as it looks like it could hold something).

Then check that the second string has a pillow - deemed 'B' (struggled to get the obvious pillow-esque character).

If the pillow is on top of the fridge - it must be May 29th! Or a weird house... Return true; For clarity, on top means right on top, ie in the same index position.

If the pillow is anywhere else in the 'house', return false;

There may be multiple fridges, and multiple pillows. But you need at least 1 pillow ON TOP of a fridge to return true. Multiple pillows on fridges should return true also.

100 random tests

Answer: {"fn_name": "pillow", "inputs": [[["EvH/KNikBiyxfeyK/miCMj", "I/HwjnHlFLlahMOKNadps"]], [["\\DjQ\\[zv]SpG]Z/[Qm\\eLL", "amwZArsaGRmibriXBgTRZp"]], [["n", "B"]], [["yF[CeAAiNihWEmKxJc/NRMVn", "rMeIa\\KAfbjuLiTnAQxNw[XB"]], [["inECnBMAA/u", "ABAaIUOUx/M"]]], "outputs": [[false], [false], [true], [true], [true]]}
user: *This is the advanced version of the 
[Minimum and Maximum Product of k Elements](https://www.codewars.com/kata/minimum-and-maximum-product-of-k-elements/) kata.*

---

Given a list of **integers** and a positive integer `k` (> 0), find the minimum and maximum possible product of `k` elements taken from the list.

If you cannot take enough elements from the list, return `None`/`nil`.

## Examples

```python
numbers = [1, -2, -3, 4, 6, 7]

k = 1  ==>  -3, 7
k = 2  ==>  -21, 42    # -3*7, 6*7
k = 3  ==>  -126, 168  # -3*6*7, 4*6*7
k = 7  ==>  None       # there are only 6 elements in the list
```

Note: the test lists can contain up to 500 elements, so a naive approach will not work.

---

## My other katas

If you enjoyed this kata then please try [my other katas](https://www.codewars.com/collections/katas-created-by-anter69)! :-)

#### *Translations are welcome!*

Answer: {"fn_name": "find_min_max_product", "inputs": [[[0, 1, 2, 3, 4], 2], [[0, -1, -2, -3, -4], 2], [[0, -1, -2, -3, -4], 3], [[-1, -2, -3, -4], 2], [[-1, -2, -3, -4], 3], [[], 2], [[-4, -10, -1], 2], [[0, 6, 3, 5, 4], 4], [[5, 4, 3, 3, 6], 2]], "outputs": [[[0, 12]], [[0, 12]], [[-24, 0]], [[2, 12]], [[-24, -6]], [null], [[4, 40]], [[0, 360]], [[9, 30]]]}
user: Given a sequence of items and a specific item in that sequence, return the item immediately following the item specified. If the item occurs more than once in a sequence, return the item after the first occurence. This should work for a sequence of any type.

When the item isn't present or nothing follows it, the function should return nil in Clojure and Elixir, Nothing in Haskell, undefined in JavaScript, None in Python.

```python
next_item([1, 2, 3, 4, 5, 6, 7], 3) # => 4
next_item(['Joe', 'Bob', 'Sally'], 'Bob') # => "Sally"
```

Answer: {"fn_name": "next_item", "inputs": [[[1, 2, 3, 4, 5, 6, 7, 8], 3], [["a", "b", "c"], "d"], [["a", "b", "c"], "c"], ["testing", "t"], ["Hello!", "o"], ["Hello!", "!"], ["Hello!", "x"]], "outputs": [[4], [null], [null], ["e"], ["!"], [null], [null]]}
user: Assume `"#"` is like a backspace in string. This means that string `"a#bc#d"` actually is `"bd"`

Your task is to process a string with `"#"` symbols.


## Examples

```
"abc#d##c"      ==>  "ac"
"abc##d######"  ==>  ""
"#######"       ==>  ""
""              ==>  ""
```

Answer: {"fn_name": "clean_string", "inputs": [["abjd####jfk#"], ["gfh#jds###d#dsd####dasdaskhj###dhkjs####df##s##d##"], ["831####jns###s#cas/*####-5##s##6+yqw87e##hfklsd-=-28##fds##"], ["######831###dhkj####jd#dsfsdnjkf###d####dasns"], [""], ["#######"], ["####gfdsgf##hhs#dg####fjhsd###dbs########afns#######sdanfl##db#####s#a"], ["#hskjdf#gd"], ["hsk48hjjdfgd"]], "outputs": [["jf"], ["gdasda"], ["6+yqw8hfklsd-=-f"], ["jdsfdasns"], [""], [""], ["sa"], ["hskjdgd"], ["hsk48hjjdfgd"]]}
user: Decompose a number `num` into an array (tuple in Haskell, array of arrays `long[][]` in C# or Java) of the form `[[k1,k2,k3...], r]`,  `([k1,k2,k3...], r)` in Haskell, `[[k1,k2,k3...], [r]]` in C# or Java) such that:

1. each kn is more than one
2. eack kn is maximized (first maximizing for 2 then 3 then 4 and so on)
3. and 2^(k1) + 3^(k2) + 4^(k3) + ... + n^(kn-1) + r = num


##Examples
```
# when there are no `k` more than 1:

3 

[[], 3] = 

3

# when the remainder is zero:

8330475

[[22, 13, 10, 8, 7, 6, 6, 5, 5, 5, 4, 4, 4, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2], 0] = 

2 ^ 22 + 3 ^ 13 + 4 ^ 10 + 5 ^ 8 + 6 ^ 7 + 7 ^ 6 + 8 ^ 6 + 9 ^ 5 + 10 ^ 5 + 11 ^ 5 + 12 ^ 4 + 13 ^ 4 + 14 ^ 4 + 15 ^ 3 + 16 ^ 3 + 17 ^ 3 + 18 ^ 3 + 19 ^ 3 + 20 ^ 3 + 21 ^ 2 + 22 ^ 2 + 23 ^ 2 + 24 ^ 2 + 0 = 8330475

# when there is both `k` and a remainder:

26 

[[4, 2], 1] = 

2 ^ 4 + 3 ^ 2 + 1 = 26

# when there is neither `k` nor a remainder:

0

[[], 0] = 

0
```

As allways any feedback would be much appreciated

Answer: {"fn_name": "decompose", "inputs": [[0], [4], [9], [25], [8330475], [9819938], [8331299], [8328441]], "outputs": [[[[], 0]], [[[2], 0]], [[[3], 1]], [[[4, 2], 0]], [[[22, 13, 10, 8, 7, 6, 6, 5, 5, 5, 4, 4, 4, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2], 0]], [[[23, 12, 9, 8, 6, 6, 5, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], 0]], [[[22, 13, 10, 8, 7, 6, 6, 5, 5, 5, 4, 4, 4, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2], 199]], [[[22, 13, 10, 8, 7, 6, 6, 5, 5, 5, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], 50]]]}
user: Given a string (`str`) containing a base-10 integer between `0` and `10000`, convert the integer to its binary representation. At that point, obtain a count of the maximum amount of consecutive 0s. From there, return the count in written form with a capital letter.

In the very first example, we have an argument of `"9"` which is being passed to the method. The binary representation of `9` is `1001` which can be read as: one, zero, zero, one. There are, at most, two consecutive 0s, resulting in the integer `2` as the value of the count. The output in the block of code above reflects the final step of taking `2` from standard form to the written form `"Two"` as prompted.

In the very last example, we have an argument of `"550"` which is being passed to the method. The binary representation of `550` is `1000100110` which can be read as: one, zero, zero, zero, one, zero, zero, one, one, zero. There are, at most, three consecutive 0s, resulting in the integer `3` as the value of the count. The output in the block of code above reflects the final step of taking `3` from standard form to the written form of `"Three"` as prompted.

One way, among many, to visualize the end of each step might look like:
```
max_consec_zeros("777")
1: "777"
2: 777
3: 1100001001
4: 4
5: "Four"
max_consec_zeros("777") => "Four"
```
Happy coding!

Answer: {"fn_name": "max_consec_zeros", "inputs": [["7"], ["33"], ["77"], ["100"], ["105"], ["113"], ["160"], ["180"], ["223"], ["256"], ["777"], ["992"], ["1024"], ["1037"], ["1088"], ["2017"], ["2048"], ["3050"], ["4096"], ["6144"], ["6656"], ["7188"], ["8192"], ["9999"], ["10000"]], "outputs": [["Zero"], ["Four"], ["Two"], ["Two"], ["Two"], ["Three"], ["Five"], ["Two"], ["One"], ["Eight"], ["Four"], ["Five"], ["Ten"], ["Six"], ["Six"], ["Four"], ["Eleven"], ["One"], ["Twelve"], ["Eleven"], ["Nine"], ["Five"], ["Thirteen"], ["Four"], ["Four"]]}
user: ### Task
You've just moved into a perfectly straight street with exactly ```n``` identical houses on either side of the road. Naturally, you would like to find out the house number of the people on the other side of the street. The street looks something like this:

--------------------
### Street
```
1|   |6
3|   |4
5|   |2
```

Evens increase on the right; odds decrease on the left. House numbers start at ```1``` and increase without gaps.
When ```n = 3```, ```1``` is opposite ```6```, ```3``` opposite ```4```, and ```5``` opposite ```2```. 

-----------------
### Example
Given your house number ```address``` and length of street ```n```, give the house number on the opposite side of the street.

```CoffeeScript
overTheRoad(address, n)
overTheRoad(1, 3) = 6
overTheRoad(3, 3) = 4
overTheRoad(2, 3) = 5
overTheRoad(3, 5) = 8
```

```python
over_the_road(address, n)
over_the_road(1, 3) = 6
over_the_road(3, 3) = 4
over_the_road(2, 3) = 5
over_the_road(3, 5) = 8
```


Both n and address could get upto 500 billion with over 200 random tests.

Answer: {"fn_name": "over_the_road", "inputs": [[1, 3], [3, 3], [2, 3], [3, 5], [7, 11], [10, 22], [20, 3400], [9, 26], [20, 10]], "outputs": [[6], [4], [5], [8], [16], [35], [6781], [44], [1]]}
user: # Task
 You're given a two-dimensional array of integers `matrix`. Your task is to determine the smallest non-negative integer that is not present in this array.

# Input/Output


 - `[input]` 2D integer array `matrix`

  A non-empty rectangular matrix. 

 `1 ≤ matrix.length ≤ 10`

 `1 ≤ matrix[0].length ≤ 10`


 - `[output]` an integer

  The smallest non-negative integer that is not present in matrix.


# Example

 For 
 
 ```
 matrix = [
 [0, 2],
 [5, 1]]```
 the result should be `3`
 
 0,1,2,`(3)`...5

Answer: {"fn_name": "smallest_integer", "inputs": [[[[0, 2], [5, 1]]], [[[4, 5, 3, 21, 3, 8], [2, 2, 6, 5, 10, 9], [7, 5, 6, 8, 2, 6], [1, 4, 7, 8, 9, 0], [1, 3, 6, 5, 5, 1], [2, 7, 3, 4, 4, 3]]], [[[4, 5, 3, -4, 3, 8], [2, 0, 6, 5, 4, 9], [7, 5, 6, 8, 2, 6], [1, 4, 7, 8, 9, 11], [1, 3, 10, 5, 5, 1], [12, 7, 3, 4, 4, 3]]], [[[1, 2], [3, 4]]], [[[0, 1], [2, 3]]], [[[4, 5, 13, 0, 3], [2, 6, 5, 10, 9], [7, 5, -6, 8, 6], [1, 4, 7, 8, 9], [2, 3, 4, 44, 3]]], [[[-1, 100, -1, 100], [100, -1, 100, -1], [-1, 100, -1, 100], [100, -1, 100, -1]]], [[[-1, -1], [-1, -1]]]], "outputs": [[3], [11], [13], [0], [4], [11], [0], [0]]}
user: You are given two positive integer lists with a random number of elements (1 <= n <= 100). Create a [GCD](https://en.wikipedia.org/wiki/Greatest_common_divisor) matrix and calculate the average of all values. 

Return a float value rounded to 3 decimal places. 


## Example

```
a = [1, 2, 3]
b = [4, 5, 6]

#       a =    1  2  3     b =
gcd(a, b) = [ [1, 2, 1],   # 4
              [1, 1, 1],   # 5
              [1, 2, 3] ]  # 6

average(gcd(a, b)) = 1.444
```

Answer: {"fn_name": "gcd_matrix", "inputs": [[[1, 2, 3], [4, 5, 6]], [[5, 5, 5], [10, 10, 10]], [[4, 7, 2, 10, 99, 4], [55, 32, 1, 344, 35234, 3]]], "outputs": [[1.444], [5.0], [2.0]]}
user: Take debugging to a whole new level:

Given a string, remove every *single* bug.

This means you must remove all instances of the word 'bug' from within a given string, *unless* the word is plural ('bugs').

For example, given 'obugobugobuoobugsoo', you should return 'ooobuoobugsoo'.

Another example: given 'obbugugo', you should return 'obugo'.

Note that all characters will be lowercase.

Happy squishing!

Answer: {"fn_name": "debug", "inputs": [["obugobugobuoobugsoo"], ["obbugugo"], ["bugs bunny"], ["bugs buggy"], ["oaiwjefbugoijoijapsbugsdoibugbugjfoijasdfbugsbug"], ["bugbugbugiahweoifuhiaasnoidfhnbugbugs"], ["bugsbugswaoeifhiauwehfoiwubugshefjnviouah"], ["bugbugbugbug"], ["bugsbugsbugsbugs"], ["buggybugs"], ["oaisjdfowjefpoibugsjsofijeo oi bugs o bug f bug poaj sfd s"]], "outputs": [["ooobuoobugsoo"], ["obugo"], ["bugs bunny"], ["bugs gy"], ["oaiwjefoijoijapsbugsdoijfoijasdfbugs"], ["iahweoifuhiaasnoidfhnbugs"], ["bugsbugswaoeifhiauwehfoiwubugshefjnviouah"], [""], ["bugsbugsbugsbugs"], ["gybugs"], ["oaisjdfowjefpoibugsjsofijeo oi bugs o  f  poaj sfd s"]]}
user: ## Task:

You have to write a function `pattern` which returns the following Pattern(See Examples) upto n number of rows. 

* Note:```Returning``` the pattern is not the same as ```Printing``` the pattern.

### Rules/Note:

* The pattern should be created using only unit digits.
* If `n < 1` then it should return "" i.e. empty string.
* `The length of each line is same`, and is equal to the number of characters in a line i.e `n`.
* Range of Parameters (for the sake of CW Compiler) :
  + `n ∈ (-50,150]`
   
### Examples:

 + pattern(8):

       88888888
       87777777
       87666666
       87655555
       87654444
       87654333
       87654322
       87654321
       
 + pattern(17):
   
       77777777777777777
       76666666666666666
       76555555555555555
       76544444444444444
       76543333333333333
       76543222222222222
       76543211111111111
       76543210000000000
       76543210999999999
       76543210988888888
       76543210987777777
       76543210987666666
       76543210987655555
       76543210987654444
       76543210987654333
       76543210987654322
       76543210987654321


[List of all my katas]("http://www.codewars.com/users/curious_db97/authored")

Answer: {"fn_name": "pattern", "inputs": [[1], [2], [3], [7], [17], [27], [0], [-89]], "outputs": [["1"], ["22\n21"], ["333\n322\n321"], ["7777777\n7666666\n7655555\n7654444\n7654333\n7654322\n7654321"], ["77777777777777777\n76666666666666666\n76555555555555555\n76544444444444444\n76543333333333333\n76543222222222222\n76543211111111111\n76543210000000000\n76543210999999999\n76543210988888888\n76543210987777777\n76543210987666666\n76543210987655555\n76543210987654444\n76543210987654333\n76543210987654322\n76543210987654321"], ["777777777777777777777777777\n766666666666666666666666666\n765555555555555555555555555\n765444444444444444444444444\n765433333333333333333333333\n765432222222222222222222222\n765432111111111111111111111\n765432100000000000000000000\n765432109999999999999999999\n765432109888888888888888888\n765432109877777777777777777\n765432109876666666666666666\n765432109876555555555555555\n765432109876544444444444444\n765432109876543333333333333\n765432109876543222222222222\n765432109876543211111111111\n765432109876543210000000000\n765432109876543210999999999\n765432109876543210988888888\n765432109876543210987777777\n765432109876543210987666666\n765432109876543210987655555\n765432109876543210987654444\n765432109876543210987654333\n765432109876543210987654322\n765432109876543210987654321"], [""], [""]]}
user: # Task
Some children are playing rope skipping game. Children skip the rope at roughly the same speed: `once per second`. If the child fails during the jump, he needs to tidy up the rope and continue. This will take `3 seconds`.

You are given an array `failedCount`, where each element is the jump count at the failed. ie. `[12,23,45]` means the child failed 3 times in the game process. The 1st mistake occurred when he jumped 12 times; The 2nd mistake occurred when he jumped 23 times; The 3rd mistake occurred when he jumped 45 times.

Your task is to calculate how many times the child jumped in 60 seconds.

Note: Each child persisted at least 60 jumps, which meant it could have been over 60 seconds, but the child continued to skip rope.

# Input/Output

`[input]` integer array `failedCount`

`0 ≤ failedCount.length ≤ 60`

`1 ≤ failedCount[i] ≤ 60`

`[output]` an integer

how many times the child jumped in 60 seconds.


# Example

For `failedCount = []`, the output should be `60`.

There is no mistake in the game process. So the child jumped 60 times in 60 seconds.

For `failedCount = [12, 23, 45]`, the output should be `51`.
```
The 1st mistake occurred when he jumped 12 times. --> 12 seconds past.
Tidy up the rope and continue.                    --> 15 seconds past.
The 2nd mistake occurred when he jumped 23 times. --> 26 seconds past.
Tidy up the rope and continue.                    --> 29 seconds past.
The 3rd mistake occurred when he jumped 45 times. --> 51 seconds past.
Tidy up the rope and continue.                    --> 54 seconds past.
When he jumped 51 times                           --> 60 seconds past.
```

Answer: {"fn_name": "tiaosheng", "inputs": [[[]], [[12, 23, 45]], [[17]], [[10, 20, 30, 40]], [[10, 20, 30, 40, 58]], [[10, 20, 30, 40, 47, 60]], [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]], "outputs": [[60], [51], [57], [48], [48], [47], [30]]}
user: # Task
Two arrays are called similar if one can be obtained from another by swapping at most one pair of elements.

Given two arrays, check whether they are similar.

# Example

For `A = [1, 2, 3]` and `B = [1, 2, 3]`, the output should be `true;`

For `A = [1, 2, 3]` and `B = [2, 1, 3]`, the output should be `true;`

For `A = [1, 2, 2]` and `B = [2, 1, 1]`, the output should be `false.`

# Input/Output

- `[input]` integer array `A`

Array of integers.

Constraints: `3 ≤ A.length ≤ 10000, 1 ≤ A[i] ≤ 1000.`

- `[input]` integer array `B`

Array of integers of the same length as `A`.

Constraints: `B.length = A.length, 1 ≤ B[i] ≤ 1000.`

- `[output]` a boolean value

`true` if `A` and `B` are similar, `false` otherwise.

Answer: {"fn_name": "are_similar", "inputs": [[[1, 2, 3], [1, 2, 3]], [[1, 2, 3], [2, 1, 3]], [[1, 2, 2], [2, 1, 1]], [[1, 2, 3], [1, 10, 2]], [[2, 3, 1], [1, 3, 2]], [[1, 1, 2], [1, 2, 2]]], "outputs": [[true], [true], [false], [false], [true], [false]]}
user: Sam is an avid collector of numbers. Every time he finds a new number he throws it on the top of his number-pile. Help Sam organise his collection so he can take it to the International Number Collectors Conference in Cologne. 

Given an array of numbers, your function should return an array of arrays, where each subarray contains all the duplicates of a particular number. Subarrays should be in the same order as the first occurence of the number they contain:
Assume the input is always going to be an array of numbers. If the input is an empty array, an empty array should be returned.

Answer: {"fn_name": "group", "inputs": [[[3, 2, 6, 2, 1, 3]], [[3, 2, 6, 2]], [[]], [[1, 100, 4, 2, 4]], [[-1, 1, -1]]], "outputs": [[[[3, 3], [2, 2], [6], [1]]], [[[3], [2, 2], [6]]], [[]], [[[1], [100], [4, 4], [2]]], [[[-1, -1], [1]]]]}
user: There is no single treatment that works for every phobia, but some people cure it by being gradually exposed to the phobic situation or object. In this kata we will try curing arachnophobia by drawing primitive spiders.
 
Our spiders will have legs, body, eyes and a mouth. Here are some examples:
```
/\((OOwOO))/\

/╲(((0000w0000)))╱\

^(oWo)^
```
You will be given four values:  
1) `leg size` where each value stands for its own leg type: `1 for "^ ^", 2 for "/\ /\", 3 for "/╲ ╱\", 4 for "╱╲ ╱╲"`  
2) `body size` where each value stands for its own body type: `1 for "( )", 2 for "(( ))", 3 for "((( )))"`  
3) `mouth` representing the spider's mouth  
4) `eye` representing the spider's eye

**Note:** the eyes are symmetric, and their total amount is `2 to the power of body size`.
  
You will also be given only valid data. That's it for the instructions, you can start coding!

Answer: {"fn_name": "draw_spider", "inputs": [[1, 1, "W", "o"], [2, 2, "w", "O"], [3, 3, "w", "0"]], "outputs": [["^(oWo)^"], ["/\\((OOwOO))/\\"], ["/\u2572(((0000w0000)))\u2571\\"]]}