meetforever/GRPO_CL huggingface dataset:
user: # Definition

**_Jumping number_** is the number that *All adjacent digits in it differ by 1*.

____

# Task

**_Given_** a number, **_Find if it is Jumping or not_** . 
____

# Warm-up (Highly recommended)

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

# Notes 

* **_Number_** *passed is always*  **_Positive_** .

* **_Return_** *the result as* **_String_** . 

* **_The difference between_** *‘9’ and ‘0’* is **_not considered as 1_** . 

* **_All single digit numbers_** are considered as **_Jumping numbers_**. 
___

# Input >> Output Examples

```
jumpingNumber(9) ==> return "Jumping!!"
```
## **_Explanation_**:

* It's  **_single-digit number_** 
___

```
jumpingNumber(79) ==> return "Not!!"
```

## **_Explanation_**:

* *Adjacent digits* **_don't differ by 1_**
___

```
jumpingNumber(23) ==> return "Jumping!!"
```

## **_Explanation_**:

* *Adjacent digits* **_differ by 1_**
___

```
jumpingNumber(556847) ==> return "Not!!"
```

## **_Explanation_**:

* *Adjacent digits* **_don't differ by 1_**
___

```
jumpingNumber(4343456) ==> return "Jumping!!"
```

## **_Explanation_**:

* *Adjacent digits* **_differ by 1_**
___

```
jumpingNumber(89098) ==> return "Not!!"
```

## **_Explanation_**:

* *Adjacent digits* **_don't differ by 1_**
___

```
jumpingNumber(32) ==> return "Jumping!!"
```

## **_Explanation_**:

* *Adjacent digits* **_differ by 1_**
___
___
___

# [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": "jumping_number", "inputs": [[1], [7], [9], [23], [32], [79], [98], [987654322]], "outputs": [["Jumping!!"], ["Jumping!!"], ["Jumping!!"], ["Jumping!!"], ["Jumping!!"], ["Not!!"], ["Jumping!!"], ["Not!!"]]}
user: Create a function that takes a list of one or more non-negative integers, and arranges them such that they form the largest possible number.

Examples:

`largestArrangement([4, 50, 8, 145])` returns 8504145 (8-50-4-145)

`largestArrangement([4, 40, 7])` returns 7440 (7-4-40)

`largestArrangement([4, 46, 7])` returns 7464 (7-46-4)

`largestArrangement([5, 60, 299, 56])` returns 60565299 (60-56-5-299)

`largestArrangement([5, 2, 1, 9, 50, 56])` returns 95655021 (9-56-5-50-21)

Answer: {"fn_name": "largest_arrangement", "inputs": [[[50, 2, 1, 9]], [[3655, 89]], [[8]], [[12, 13, 89, 155, 8, 26, 0]], [[76, 4, 3, 81, 514, 6, 716]], [[817, 6879, 163, 348, 8, 22, 47]], [[411, 742, 89, 691, 284]], [[587, 625, 638, 898, 122]], [[797, 535, 210, 87]], [[5, 2, 1, 9, 50, 56]], [[197, 853, 819]], [[23044, 2, 7626, 914, 7800]], [[451, 850, 85, 283, 4, 734, 605, 499, 249]], [[304, 12, 206, 584, 78, 69, 864, 860]], [[8346, 991, 25, 4, 67]], [[298, 268, 58, 598, 702, 603, 597]], [[422, 995, 500, 202, 772, 230, 258, 144, 752]], [[618, 514, 863, 195, 965, 262]], [[141, 63, 51, 966, 520, 48, 82, 14, 397]], [[756, 688, 8, 657, 912]], [[70, 7, 81, 28, 336, 246, 817, 77, 4, 550]], [[150, 398, 919, 890, 447, 285]], [[783, 19, 88, 5, 7]], [[10, 327, 6, 70, 13, 83, 482, 77]], [[8, 6, 590, 70]], [[6, 73, 79, 356, 7]], [[64, 29, 5, 9, 982, 3]], [[3487, 103559, 243]], [[7, 78, 79, 72, 709, 7, 94]]], "outputs": [[95021], [893655], [8], [8982615513120], [8176716651443], [881768794734822163], [89742691411284], [898638625587122], [87797535210], [95655021], [853819197], [91478007626230442], [858507346054994514283249], [864860786958430420612], [991834667425], [70260359859758298268], [995772752500422258230202144], [965863618514262195], [9668263520514839714141], [9128756688657], [8181777770550433628246], [919890447398285150], [887837519], [83777064823271310], [8706590], [797736356], [9982645329], [3487243103559], [9479787772709]]}
user: You are given an array that of arbitrary depth that needs to be nearly flattened into a 2 dimensional array. The given array's depth is also non-uniform, so some parts may be deeper than others.

All of lowest level arrays (most deeply nested) will contain only integers and none of the higher level arrays will contain anything but other arrays. All arrays given will be at least 2 dimensional. All lowest level arrays will contain at least one element.

Your solution should be an array containing all of the lowest level arrays and only these. The sub-arrays should be ordered by the smallest element within each, so `[1,2]` should preceed `[3,4,5]`. Note: integers will not be repeated.

For example:

If you receive `[[[1,2,3],[4,5]],[6,7]]`, your answer should be `[[1,2,3],[4,5],[6,7]]`.

Answer: {"fn_name": "near_flatten", "inputs": [[[[1]]], [[[1, 2, 3], [4, 5, 6]]], [[[1, 2, 3], [[4, 5], [[6], [7, 8]]]]], [[[[1, 2, 3], [9, 10]], [[4, 5], [6, 7, 8]]]]], "outputs": [[[[1]]], [[[1, 2, 3], [4, 5, 6]]], [[[1, 2, 3], [4, 5], [6], [7, 8]]], [[[1, 2, 3], [4, 5], [6, 7, 8], [9, 10]]]]}
user: An Ironman Triathlon is one of a series of long-distance triathlon races organized by the World Triathlon Corporaion (WTC).
It consists of a 2.4-mile swim, a 112-mile bicycle ride and a marathon (26.2-mile) (run, raced in that order and without a break. It hurts... trust me.

Your task is to take a distance that an athlete is through the race, and return one of the following:

If the distance is zero, return `'Starting Line... Good Luck!'`.

If the athlete will be swimming, return an object with `'Swim'` as the key, and the remaining race distance as the value.

If the athlete will be riding their bike, return an object with `'Bike'` as the key, and the remaining race distance as the value.

If the athlete will be running, and has more than 10 miles to go, return an object with `'Run'` as the key, and the remaining race distance as the value.

If the athlete has 10 miles or less to go, return return an object with `'Run'` as the key, and `'Nearly there!'` as the value.

Finally, if the athlete has completed te distance, return `"You're done! Stop running!"`.

All distance should be calculated to two decimal places.

Answer: {"fn_name": "i_tri", "inputs": [[36], [103], [0], [2], [151]], "outputs": [[{"Bike": "104.60 to go!"}], [{"Bike": "37.60 to go!"}], ["Starting Line... Good Luck!"], [{"Swim": "138.60 to go!"}], ["You're done! Stop running!"]]}
user: Find the sum of the odd numbers within an array, after cubing the initial integers. The function should return `undefined`/`None`/`nil`/`NULL` if any of the values aren't numbers. 

~~~if:java,csharp
Note: There are ONLY integers in the JAVA and C# versions of this Kata.
~~~

~~~if:python
Note: Booleans should not be considered as numbers.
~~~

Answer: {"fn_name": "cube_odd", "inputs": [[[1, 2, 3, 4]], [[-3, -2, 2, 3]], [["a", 12, 9, "z", 42]], [[true, false, 2, 4, 1]]], "outputs": [[28], [0], [null], [null]]}
user: The "Russian Peasant Method" is an old algorithm used by Russian peasants (and before them ancient Egyptians) to perform multiplication.  Consider that X and Y are two numbers.  X can be any number but Y must be a positive integer. To multiply X and Y:

1. Let the product = 0
2. If Y is odd, then the product = product + X
3. X = X + X
4. Y = integer part of Y / 2 
5. if Y is nonzero, repeat from step 2; otherwise the algorithm terminates and returns the product.

For example:

Let X = 10

Let Y = 5

X: 10 20 40 80

Y: 5  2  1  0

product = 10 + 40 = 50

Note: usage of multiplication is of course forbidden...

Answer: {"fn_name": "russian_peasant_multiplication", "inputs": [[10, 5], [1.001, 2], [175, 18], [-2, 2], [2500, 123]], "outputs": [[50], [2.002], [3150], [-4], [307500]]}
user: Given a string and an array of index numbers, return the characters of the string rearranged to be in the order specified by the accompanying array.

Ex:

scramble('abcd', [0,3,1,2]) -> 'acdb' 

The string that you will be returning back will have: 'a' at index 0, 'b' at index 3, 'c' at index 1, 'd' at index 2, because the order of those characters maps to their corisponding numbers in the index array. 


In other words, put the first character in the string at the index described by the first element of the array



You can assume that you will be given a string and array of equal length and both containing valid characters (A-Z, a-z, or 0-9).

Answer: {"fn_name": "scramble", "inputs": [["abcd", [0, 3, 1, 2]], ["sc301s", [4, 0, 3, 1, 5, 2]], ["bskl5", [2, 1, 4, 3, 0]]], "outputs": [["acdb"], ["c0s3s1"], ["5sblk"]]}
user: Program a function `sumAverage(arr)` where `arr` is an array containing arrays full of numbers, for example:

```python
sum_average([[1, 2, 2, 1], [2, 2, 2, 1]])
```

First, determine the average of each array. Then, return the sum of all the averages.

- All numbers will be less than 100 and greater than -100.
- `arr` will contain a maximum of 50 arrays.
- After calculating all the averages, add them **all** together, **then** round down, as shown in the example below:

The example given: `sumAverage([[3, 4, 1, 3, 5, 1, 4], [21, 54, 33, 21, 77]])`, the answer being 44.
1. Calculate the average of each individual array:
```
[3, 4, 1, 3, 5, 1, 4] = (3 + 4 + 1 + 3 + 5 + 1 + 4) / 7 = 3
[21, 54, 33, 21, 77] = (21 + 54 + 33 + 21 + 77) / 5 = 41.2
```
2. Add the average of each array together:
```
3 + 41.2 = 44.2
```
3. Round the final average down:

~~~if:julia
In Julia, the `Statistics` package is preloaded.
~~~
```python
import math
math.floor(44.2) = 44
```

Answer: {"fn_name": "sum_average", "inputs": [[[[1, 2, 2, 1], [2, 2, 2, 1]]], [[[52, 64, 84, 21, 54], [44, 87, 46, 90, 43]]], [[[44, 76, 12], [96, 12, 34, 53, 76, 34, 56, 86, 21], [34, 65, 34, 76, 34, 87, 34]]], [[[41, 16, 99, 93, 59, 18, 35, 23, 55, 45, 38, 39, 74, 60, 95, 44, 59, 70, 44, 89, 90, 19, 23, 67, 65, 66, 41, 89, 49, 22, 23, 47, 60, 12, 59, 58, 25, 69, 66, 82, 53, 41, 51, 69, 78, 18, 17, 44, 74, 96, 46, 73, 22, 37, 95, 32, 62, 49, 8, 88, 59, 66, 23, 10, 61, 28, 11, 99, 27, 98, 8, 18, 73, 18, 61, 25, 60, 38, 81, 13, 36, 63, 12, 83, 57, 11, 19, 51, 41, 20, 37, 63, 79, 94, 25, 45, 24, 73, 67, 42]]], [[[3, 4, 1, 3, 5, 1, 4], [21, 54, 33, 21, 76]]], [[[-4, 3, -8, -2], [2, 9, 1, -5], [-7, -2, -6, -4]]]], "outputs": [[3], [117], [148], [50], [44], [-6]]}
user: The Tower of Hanoi problem involves 3 towers.  A number of rings decreasing in size are placed on one tower.  All rings must then be moved to another tower, but at no point can a larger ring be placed on a smaller ring.

Your task:  Given a number of rings, return the MINIMUM number of moves needed to move all the rings from one tower to another.

Reference: Tower of Hanoi, Courtesy of Coolmath Games

NB:  This problem may seem very complex, but in reality there is an amazingly simple formula to calculate the minimum number.  Just Learn how to solve the problem via the above link (if you are not familiar with it), and then think hard.  Your solution should be in no way extraordinarily long and complex.  The Kata ranking is for figuring out the solution, but the coding skills required are minimal.

Answer: {"fn_name": "tower_of_hanoi", "inputs": [[4], [5], [10], [50]], "outputs": [[15], [31], [1023], [1125899906842623]]}
user: Check if it is a vowel(a, e, i, o, u,) on the ```n``` position in a string (the first argument). Don't forget about uppercase.

A few cases:

```
{
checkVowel('cat', 1)  ->   true // 'a' is a vowel
checkVowel('cat', 0)  ->   false // 'c' is not a vowel
checkVowel('cat', 4)  ->   false // this position doesn't exist
}
```
P.S. If n < 0, return false

Answer: {"fn_name": "check_vowel", "inputs": [["cat", 1], ["cat", 0], ["cat", 4], ["Amanda", -2], ["Amanda", 0], ["Amanda", 2]], "outputs": [[true], [false], [false], [false], [true], [true]]}
user: We are given a sequence of coplanar points and see all the possible triangles that may be generated which all combinations of three points.

We have the following list of points with the cartesian coordinates of each one:
```
Points [x, y]
   A   [1, 2]
   B   [3, 3]
   C   [4, 1]
   D   [1, 1]
   E   [4, -1]
```
With these points we may have the following triangles: ```ABC, ABD, ABE, ACD, ACE, ADE, BCD, BCE, BDE, CDE.``` There are three special ones: ```ABC, ACD and CDE```, that have an angle of 90°. All is shown in the picture below:



We need to count all the rectangle triangles that may be formed by a given list of points.

The case decribed above will be:
```python
count_rect_triang([[1, 2],[3, 3],[4, 1],[1, 1],[4, -1]]) == 3
```

Observe this case:
```python
count_rect_triang([[1, 2],[4, -1],[3, 3],[4, -1],[4, 1],[1, 1],[4, -1], [4, -1], [3, 3], [1, 2]]) == 3
```
If no rectangle triangles may be generated the function will output ```0```.

Enjoy it!

Answer: {"fn_name": "count_rect_triang", "inputs": [[[[1, 2], [3, 3], [4, 1], [1, 1], [4, -1]]], [[[1, 2], [4, -1], [3, 3], [4, -1], [4, 1], [1, 1], [4, -1], [4, -1], [3, 3], [1, 2]]]], "outputs": [[3], [3]]}
user: Given: an array containing hashes of names

Return: a string formatted as a list of names separated by commas except for the last two names, which should be separated by an ampersand.

Example:

``` ruby
list([ {name: 'Bart'}, {name: 'Lisa'}, {name: 'Maggie'} ])
# returns 'Bart, Lisa & Maggie'

list([ {name: 'Bart'}, {name: 'Lisa'} ])
# returns 'Bart & Lisa'

list([ {name: 'Bart'} ])
# returns 'Bart'

list([])
# returns ''
```
``` elixir
list([ %{name: "Bart"}, %{name: "Lisa"}, %{name: "Maggie"} ])
# returns 'Bart, Lisa & Maggie'

list([ %{name: "Bart"}, %{name: "Lisa"} ])
# returns 'Bart & Lisa'

list([ %{name: "Bart"} ])
# returns 'Bart'

list([])
# returns ''
```
``` javascript
list([ {name: 'Bart'}, {name: 'Lisa'}, {name: 'Maggie'} ])
// returns 'Bart, Lisa & Maggie'

list([ {name: 'Bart'}, {name: 'Lisa'} ])
// returns 'Bart & Lisa'

list([ {name: 'Bart'} ])
// returns 'Bart'

list([])
// returns ''
```
```python
namelist([ {'name': 'Bart'}, {'name': 'Lisa'}, {'name': 'Maggie'} ])
# returns 'Bart, Lisa & Maggie'

namelist([ {'name': 'Bart'}, {'name': 'Lisa'} ])
# returns 'Bart & Lisa'

namelist([ {'name': 'Bart'} ])
# returns 'Bart'

namelist([])
# returns ''
```

Note: all the hashes are pre-validated and will only contain A-Z, a-z, '-' and '.'.

Answer: {"fn_name": "namelist", "inputs": [[[{"name": "Bart"}, {"name": "Lisa"}, {"name": "Maggie"}, {"name": "Homer"}, {"name": "Marge"}]], [[{"name": "Bart"}, {"name": "Lisa"}, {"name": "Maggie"}]], [[{"name": "Bart"}, {"name": "Lisa"}]], [[{"name": "Bart"}]], [[]]], "outputs": [["Bart, Lisa, Maggie, Homer & Marge"], ["Bart, Lisa & Maggie"], ["Bart & Lisa"], ["Bart"], [""]]}
user: In this Kata, you will be given an array and your task will be to determine if an array is in ascending or descending order and if it is rotated or not. 

Consider the array `[1,2,3,4,5,7,12]`. This array is sorted in `Ascending` order. If we rotate this array once to the left, we get `[12,1,2,3,4,5,7]` and twice-rotated we get `[7,12,1,2,3,4,5]`. These two rotated arrays are in `Rotated Ascending` order.

Similarly, the array `[9,6,5,3,1]` is in `Descending` order, but we can rotate it to get an array in `Rotated Descending` order: `[1,9,6,5,3]` or `[3,1,9,6,5]` etc.

Arrays will never be unsorted, except for those that are rotated as shown above. Arrays will always have an answer, as shown in the examples below.

More examples:
```Haskell
solve([1,2,3,4,5,7]) = "A" -- Ascending
solve([7,1,2,3,4,5]) = "RA" -- Rotated ascending
solve([4,5,6,1,2,3]) = "RA" -- Rotated ascending
solve([9,8,7,6]) = "D" -- Descending
solve([5,9,8,7,6]) = "RD" -- Rotated Descending
```
More examples in the test cases. 

Good luck!

Answer: {"fn_name": "solve", "inputs": [[[1, 2, 3, 4, 5, 7]], [[7, 1, 2, 3, 4, 5]], [[2, 3, 4, 5, 7, 12]], [[7, 12, 1, 2, 3, 4, 5]], [[4, 5, 6, 1, 2, 3]], [[9, 8, 7, 6, 5]], [[5, 9, 8, 7, 6]], [[6, 5, 9, 8, 7]], [[9, 6, 7]], [[10, 12, 11]], [[13, 10, 11]]], "outputs": [["A"], ["RA"], ["A"], ["RA"], ["RA"], ["D"], ["RD"], ["RD"], ["RA"], ["RD"], ["RA"]]}
user: # Task

You are given a positive integer `n`. We intend to make some ascending sequences according to the following rules:

 1. Make a sequence of length 1: [ n ]

 2. Or, insert a number to the left side of the sequence. But this number can not exceed half of the first number of the sequence. 

 3. Follow rule 2, continue insert number to the left side of the sequence.

Your task is to count the number of all possible sequences, and return it.

If you do not understand the task, please read the rewritten version below:

You are given a positive integer `n`. Your task is to count the number of such sequences: 

- It should be an ascending sequence;

- It should end with number `n`.

- Each number in the sequence should smaller or equals to the half of its right, except for the last number `n`.

- We define that a sequence containing only a number `n` is a valid ascending sequence.

# Examples

For `n = 6`, the output should be `6`.

All sequences we made are:

```
[6]

insert a number to the left:

[1,6]
[2,6]
[3,6]

continue insert number:

[1,2,6]
[1,3,6]
```
There are 6 sequences in total.


For `n = 10`, the output should be `14`.

All sequences we made are:

```
[10]

insert a number to the left:

[1,10]
[2,10]
[3,10]
[4,10]
[5,10]

continue insert number:

[1,2,10]
[1,3,10]
[1,4,10]
[2,4,10]
[1,5,10]
[2,5,10]

continue insert number:

[1,2,4,10]
[1,2,5,10]

```
There are 14 sequences in total.

# Note

- `1 <= n <= 1000`

- `3` fixed testcases

- `100` random testcases, testing for correctness of solution

- All inputs are valid.

- If my reference solution gives the wrong result in the random tests, please let me know(post an issue).

Answer: {"fn_name": "make_sequences", "inputs": [[6], [10], [1000]], "outputs": [[6], [14], [1981471878]]}
user: Write a method that will search an array of strings for all strings that contain another string, ignoring capitalization. Then return an array of the found strings. 

The method takes two parameters, the query string and the array of strings to search, and returns an array. 

If the string isn't contained in any of the strings in the array, the method returns an array containing a single string: "Empty" (or `Nothing` in Haskell, or "None" in Python and C)

### Examples
If the string to search for is "me", and the array to search is ["home", "milk", "Mercury", "fish"], the method should return ["home", "Mercury"].

Answer: {"fn_name": "word_search", "inputs": [["ab", ["za", "ab", "abc", "zab", "zbc"]], ["aB", ["za", "ab", "abc", "zab", "zbc"]], ["ab", ["za", "aB", "Abc", "zAB", "zbc"]], ["abcd", ["za", "aB", "Abc", "zAB", "zbc"]]], "outputs": [[["ab", "abc", "zab"]], [["ab", "abc", "zab"]], [["aB", "Abc", "zAB"]], [["None"]]]}
user: Given a sorted array of numbers, return the summary of its ranges.

## Examples
```python
summary_ranges([1, 2, 3, 4]) == ["1->4"]
summary_ranges([1, 1, 1, 1, 1]) == ["1"]
summary_ranges([0, 1, 2, 5, 6, 9]) == ["0->2", "5->6", "9"]
summary_ranges([0, 1, 2, 3, 3, 3, 4, 5, 6, 7]) == ["0->7"]
summary_ranges([0, 1, 2, 3, 3, 3, 4, 4, 5, 6, 7, 7, 9, 9, 10]) == ["0->7", "9->10"]
summary_ranges([-2, 0, 1, 2, 3, 3, 3, 4, 4, 5, 6, 7, 7, 9, 9, 10, 12]) == ["-2", "0->7", "9->10", "12"]
```

Answer: {"fn_name": "summary_ranges", "inputs": [[[]], [[1, 1, 1, 1]], [[1, 2, 3, 4]], [[0, 1, 2, 5, 6, 9]], [[0, 1, 2, 3, 4, 5, 6, 7]], [[0, 1, 2, 3, 5, 6, 7]], [[0, 1, 2, 3, 4, 5, 6, 7, 9, 10]], [[-2, 0, 1, 2, 3, 4, 5, 6, 7, 9, 10, 12]], [[-3, -2, -1, 0, 2, 3]], [[-2]]], "outputs": [[[]], [["1"]], [["1->4"]], [["0->2", "5->6", "9"]], [["0->7"]], [["0->3", "5->7"]], [["0->7", "9->10"]], [["-2", "0->7", "9->10", "12"]], [["-3->0", "2->3"]], [["-2"]]]}
user: KISS stands for Keep It Simple Stupid.
It is a design principle for keeping things simple rather than complex.

You are the boss of Joe.

Joe is submitting words to you to publish to a blog. He likes to complicate things.

Define a function that determines if Joe's work is simple or complex.

Input will be non emtpy strings with no punctuation.

It is simple if:
``` the length of each word does not exceed the amount of words in the string ```
(See example test cases)

Otherwise it is complex.

If complex:
```python
return "Keep It Simple Stupid"
```
or if it was kept simple:
```python
return "Good work Joe!"
```

Note: Random test are random and nonsensical. Here is a silly example of a random test:
```python
"jump always mostly is touchy dancing choice is pineapples mostly"
```

Answer: {"fn_name": "is_kiss", "inputs": [["Joe had a bad day"], ["Joe had some bad days"], ["Joe is having no fun"], ["Sometimes joe cries for hours"], ["Joe is having lots of fun"], ["Joe is working hard a lot"], ["Joe listened to the noise and it was an onamonapia"], ["Joe listened to the noises and there were some onamonapias"]], "outputs": [["Good work Joe!"], ["Good work Joe!"], ["Keep It Simple Stupid"], ["Keep It Simple Stupid"], ["Good work Joe!"], ["Keep It Simple Stupid"], ["Good work Joe!"], ["Keep It Simple Stupid"]]}
user: Oh no!  You have stumbled upon a mysterious signal consisting of beeps of various lengths, and it is of utmost importance that you find out the secret message hidden in the beeps.  There are long and short beeps, the longer ones roughly three times as long as the shorter ones.  Hmm... that sounds familiar.

That's right: your job is to implement a decoder for the Morse alphabet.  Rather than dealing with actual beeps, we will use a common string encoding of Morse.  A long beep is represened by a dash (`-`) and a short beep by a dot (`.`).  A series of long and short beeps make up a letter, and letters are separated by spaces (` `).  Words are separated by double spaces.

You should implement the International Morse Alphabet.  You need to support letters a-z and digits 0-9 as follows:

    a .-      h ....    o ---     u ..-      1 .----     6 -....
    b -...    i ..      p .--.    v ...-     2 ..---     7 --...
    c -.-.    j .---    q --.-    w .--      3 ...--     8 ---..
    d -..     k -.-     r .-.     x -..-     4 ....-     9 ----.
    e .       l .-..    s ...     y -.--     5 .....     0 -----
    f ..-.    m --      t -       z --..
    g --.     n -.


## Examples

    .... . .-.. .-.. ---  .-- --- .-. .-.. -..   → "hello world"
    .---- ... -  .- -. -..  ..--- -. -..         → "1st and 2nd"

```if:python
A dictionnary `TOME` is preloaded for you, with the information above to convert morse code to letters.
```
```if:javascrip
An object `TOME` is preloaded for you, with the information above to convert morse code to letters.
```
```if:ruby
A Hashmap `$dict` is preloaded for you, with the information above to convert morse code to letters.
```

Answer: {"fn_name": "decode", "inputs": [[".... . .-.. .-.. ---  .-- --- .-. .-.. -.."], [".---- ... -  .- -. -..  ..--- -. -.."], ["..  .- --  .-  - . ... -"], [".- -... -.-. -.. . ..-. --. .... .. .--- -.- .-.. -- -. --- .--. --.- .-. ... - ..- ...- .-- -..- -.-- --.. ----- .---- ..--- ...-- ....- ..... -.... --... ---.. ----."], [""]], "outputs": [["hello world"], ["1st and 2nd"], ["i am a test"], ["abcdefghijklmnopqrstuvwxyz0123456789"], [""]]}
user: Return a new array consisting of elements which are multiple of their own index in input array (length > 1).

Some cases: 

```
[22, -6, 32, 82, 9, 25] =>  [-6, 32, 25]

[68, -1, 1, -7, 10, 10] => [-1, 10]

[-56,-85,72,-26,-14,76,-27,72,35,-21,-67,87,0,21,59,27,-92,68] => [-85, 72, 0, 68]
```

Answer: {"fn_name": "multiple_of_index", "inputs": [[[22, -6, 32, 82, 9, 25]], [[68, -1, 1, -7, 10, 10]], [[11, -11]], [[-56, -85, 72, -26, -14, 76, -27, 72, 35, -21, -67, 87, 0, 21, 59, 27, -92, 68]], [[28, 38, -44, -99, -13, -54, 77, -51]], [[-1, -49, -1, 67, 8, -60, 39, 35]]], "outputs": [[[-6, 32, 25]], [[-1, 10]], [[-11]], [[-85, 72, 0, 68]], [[38, -44, -99]], [[-49, 8, -60, 35]]]}