meetforever/GRPO_CL huggingface dataset:
user: # Let's watch a parade!
## Brief
You're going to watch a parade, but you only care about one of the groups marching. The parade passes through the street where your house is. Your house is at number `location` of the street. Write a function `parade_time` that will tell you the times when you need to appear to see all appearences of that group.

## Specifications
You'll be given:

* A `list` of `string`s containing `groups` in the parade, in order of appearance. A group may appear multiple times. You want to see all the parts of your favorite group.
* An positive `integer` with the `location` on the parade route where you'll be watching.
* An positive `integer` with the `speed` of the parade
* A `string` with the `pref`ferred group you'd like to see

You need to return the time(s) you need to be at the parade to see your favorite group as a `list` of `integer`s.

It's possible the group won't be at your `location` at an exact `time`. In that case, just be sure to get there right before it passes (i.e. the largest integer `time` before the float passes the `position`).

## Example
```python
groups = ['A','B','C','D','E','F']
location = 3
speed = 2
pref = 'C'
                  v
Locations: |0|1|2|3|4|5|6|7|8|9|...
F E D C B A      | |               time = 0
> > F E D C B A  | |               time = 1
    > > F E D C B|A|               time = 2
        > > F E D|C|B A            time = 3
                  ^
parade_time(['A','B','C','D','E','F'], 3, 2,'C']) == [3]
```

Answer: {"fn_name": "parade_time", "inputs": [[["a", "b", "c", "d", "e", "f"], 3, 2, "c"], [["c", "b", "c", "d", "e", "f"], 3, 2, "c"], [["a", "b", "c", "d", "e", "f"], 3, 2, "g"], [["a", "b", "c", "c", "e", "c"], 7, 1, "c"], [["a", "b", "c", "d", "e", "f"], 1, 2, "b"], [["a", "b", "c", "d", "e", "b"], 1, 2, "b"]], "outputs": [[[3]], [[2, 3]], [[]], [[10, 11, 13]], [[1]], [[1, 3]]]}
user: On Unix system type files can be identified with the ls -l command which displays the type of the file in the first alphabetic letter of the file system permissions field. You can find more information about file type on Unix system on the [wikipedia page](https://en.wikipedia.org/wiki/Unix_file_types).

- '-' A regular file ==> `file`.
- 'd' A directory ==> `directory`.
- 'l' A symbolic link ==> `symlink`.
- 'c' A character special file. It refers to a device that handles data as a stream of bytes (e.g: a terminal/modem) ==> `character_file`.
- 'b' A block special file. It refers to a device that handles data in blocks (e.g: such as a hard drive or CD-ROM drive) ==> `block_file`.
- 'p' a named pipe ==> `pipe`.
- 's' a socket ==> `socket`.
- 'D' a door ==> `door`.

In this kata you should complete a function that return the `filetype` as a string regarding the `file_attribute` given by the `ls -l` command. 

For example if the function receive `-rwxr-xr-x` it should return `file`.

Answer: {"fn_name": "linux_type", "inputs": [["-rwxrwxrwx"], ["Drwxr-xr-x"], ["lrwxrw-rw-"], ["srwxrwxrwx"]], "outputs": [["file"], ["door"], ["symlink"], ["socket"]]}
user: Given two arrays of integers `m` and `n`, test if they contain *at least* one identical element. Return `true` if they do; `false` if not.

Your code must handle any value within the range of a 32-bit integer, and must be capable of handling either array being empty (which is a `false` result, as there are no duplicated elements).

Answer: {"fn_name": "duplicate_elements", "inputs": [[[1, 2, 3, 4, 5], [1, 6, 7, 8, 9]], [[9, 8, 7], [8, 1, 3]], [[2398632, 9172846, 4728162], [2398632, 9235623, 8235492]], [[-2, -4, -6, -8], [-2, -3, -5, -7]], [[-9, -8, -7], [-8, -1, -3]], [[-2398632, -9172846, -4728162], [-2398632, -9235623, -8235492]], [[1, 3, 5, 7, 9], [2, 4, 6, 8]], [[9, 8, 7], [6, 5, 4]], [[], [9, 8, 7, 6, 5]], [[9, 8, 7, 6, 5], []], [[], []]], "outputs": [[true], [true], [true], [true], [true], [true], [false], [false], [false], [false], [false]]}
user: The prime numbers are not regularly spaced. For example from `2` to `3` the step is `1`.
From `3` to `5` the step is `2`. From `7` to `11` it is `4`.
Between 2 and 50 we have the following pairs of 2-steps primes:

`3, 5 - 5, 7, - 11, 13, - 17, 19, - 29, 31, - 41, 43`

We will write a function `step` with parameters:

- `g` (integer >= 2) which indicates the step we are looking for,

- `m` (integer >= 2) which gives the start of the search (m inclusive),

- `n` (integer >= m) which gives the end of the search (n inclusive)

In the example above `step(2, 2, 50)` will return `[3, 5]` which is the first pair between 2 and 50 with a 2-steps.

So this function should return the **first** pair of the two prime numbers spaced with a step of `g`
between the limits `m`, `n` if these g-steps prime numbers exist otherwise `nil` or `null` or `None` or `Nothing` or `[]` or `"0, 0"` or `{0, 0}` or `0 0`(depending on the language). 


#Examples:

- 


`step(2, 5, 7) --> [5, 7] or (5, 7) or {5, 7} or "5 7"`

`step(2, 5, 5) --> nil or ... or [] in Ocaml or {0, 0} in C++`

`step(4, 130, 200) --> [163, 167] or (163, 167) or {163, 167}`

- **See more examples for your language in "RUN"**


- Remarks:

([193, 197] is also such a 4-steps primes between 130 and 200 but it's not the first pair).

`step(6, 100, 110) --> [101, 107]` though there is a prime between 101 and 107 which is 103; the pair 101-103 is a 2-step.


#Notes: 
The idea of "step" is close to that of "gap" but it is not exactly the same. For those interested they can have a look
at . 

A "gap" is more restrictive: there must be no primes in between 
(101-107 is a "step" but not a "gap". Next kata will be about "gaps":-).

For Go: nil slice is expected when there are no `step` between m and n.
Example: step(2,4900,4919) --> nil

Answer: {"fn_name": "step", "inputs": [[2, 100, 110], [4, 100, 110], [6, 100, 110], [8, 300, 400], [10, 300, 400], [4, 30000, 100000], [6, 30000, 100000], [8, 30000, 100000], [11, 30000, 100000], [16, 5, 20], [2, 10000000, 11000000], [52, 1300, 15000], [10, 4900, 5000], [30, 4900, 5000], [2, 4900, 5000], [2, 104000, 105000], [2, 4900, 4919], [7, 4900, 4919], [4, 30115, 100000], [4, 30140, 100000], [4, 30000, 30325]], "outputs": [[[101, 103]], [[103, 107]], [[101, 107]], [[359, 367]], [[307, 317]], [[30109, 30113]], [[30091, 30097]], [[30089, 30097]], [null], [null], [[10000139, 10000141]], [[1321, 1373]], [[4909, 4919]], [[4903, 4933]], [[4931, 4933]], [[104087, 104089]], [null], [null], [[30133, 30137]], [[30319, 30323]], [[30109, 30113]]]}
user: Given some points (cartesian coordinates), return true if all of them lie on a line.  Treat both an empty set and a single point as a line.

```python
on_line(((1,2), (7,4), (22,9)) == True
on_line(((1,2), (-3,-14), (22,9))) == False
```

Answer: {"fn_name": "on_line", "inputs": [[[]], [[1, 1]]], "outputs": [[true], [true]]}
user: # Introduction and Warm-up (Highly recommended)

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

# Task

**_Given_** an *array/list [] of integers* , **_Find_** **_The maximum difference_** *between the successive elements in its sorted form*. 
___

# Notes 

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

* **_Array/list's numbers_**  Will be **mixture of positives and negatives also zeros_**  

* **_Repetition_** of numbers in *the array/list could occur*.

* **_The Maximum Gap_** is *computed Regardless the sign*.

___

# Input >> Output Examples 

```
maxGap ({13,10,5,2,9}) ==> return (4)
```

## **_Explanation_**: 

* **_The Maximum Gap_** *after sorting the array is* `4` , *The difference between*   ``` 9 - 5 = 4 ``` .
___

```
maxGap ({-3,-27,-4,-2}) ==> return (23)
```
## **_Explanation_**: 

* **_The Maximum Gap_** *after sorting the array is* `23` , *The difference between*   ` |-4- (-27) | = 23` .

*  **_Note_** : *Regardless the sign of negativity* .
___

```
maxGap ({-7,-42,-809,-14,-12}) ==> return (767)  
```
## **_Explanation_**: 

* **_The Maximum Gap_** *after sorting the array is* `767` , *The difference between*   ` | -809- (-42) | = 767` .

*  **_Note_** : *Regardless the sign of negativity* .
___

```
maxGap ({-54,37,0,64,640,0,-15}) //return (576)
```
## **_Explanation_**: 

* **_The Maximum Gap_** *after sorting the array is* `576` , *The difference between*   ` | 64 - 640 | = 576` .

*  **_Note_** : *Regardless the sign of negativity* .
___
___
___

# [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": "max_gap", "inputs": [[[13, 10, 2, 9, 5]], [[13, 3, 5]], [[24, 299, 131, 14, 26, 25]], [[-3, -27, -4, -2]], [[-7, -42, -809, -14, -12]], [[12, -5, -7, 0, 290]], [[-54, 37, 0, 64, -15, 640, 0]], [[130, 30, 50]], [[1, 1, 1]], [[-1, -1, -1]]], "outputs": [[4], [8], [168], [23], [767], [278], [576], [80], [0], [0]]}
user: ## Description
Your job is to create a simple password validation function, as seen on many websites. 

The rules for a valid password are as follows:
- There needs to be at least 1 uppercase letter.
- There needs to be at least 1 lowercase letter.
- There needs to be at least 1 number.
- The password needs to be at least 8 characters long.

You are permitted to use any methods to validate the password.

## Examples:

### Extra info
- You will only be passed strings.
- The string can contain any standard keyboard character.
- Accepted strings can be any length, as long as they are 8 characters or more.

Answer: {"fn_name": "password", "inputs": [["Abcd1234"], ["Abcd123"], ["abcd1234"], ["AbcdefGhijKlmnopQRsTuvwxyZ1234567890"], ["ABCD1234"], ["Ab1!@#$%^&*()-_+={}[]|\\:;?/>.<,"], ["!@#$%^&*()-_+={}[]|\\:;?/>.<,"], [""], [" aA1----"], ["4aA1----"]], "outputs": [[true], [false], [false], [true], [false], [true], [false], [false], [true], [true]]}
user: Deoxyribonucleic acid, DNA is the primary information storage molecule in biological systems. It is composed of four nucleic acid bases Guanine ('G'), Cytosine ('C'), Adenine ('A'), and Thymine ('T'). 

Ribonucleic acid, RNA, is the primary messenger molecule in cells. RNA differs slightly from DNA its chemical structure and contains no Thymine. In RNA Thymine is replaced by another nucleic acid Uracil ('U').

Create a function which translates a given DNA string into RNA.

For example:

```
"GCAT"  =>  "GCAU"
```

The input string can be of arbitrary length - in particular, it may be empty.  All input is guaranteed to be valid, i.e. each input string will only ever consist of `'G'`, `'C'`, `'A'` and/or `'T'`.

Answer: {"fn_name": "dna_to_rna", "inputs": [["TTTT"], ["GCAT"], ["GACCGCCGCC"], ["GATTCCACCGACTTCCCAAGTACCGGAAGCGCGACCAACTCGCACAGC"], ["CACGACATACGGAGCAGCGCACGGTTAGTACAGCTGTCGGTGAACTCCATGACA"], ["AACCCTGTCCACCAGTAACGTAGGCCGACGGGAAAAATAAACGATCTGTCAATG"], ["GAAGCTTATCCGTTCCTGAAGGCTGTGGCATCCTCTAAATCAGACTTGGCTACGCCGTTAGCCGAGGGCTTAGCGTTGAGTGTCATTATATACGCGGCCTGCGACCTGGCCACACAATGCCCTCGAAAATTTTTCTTTCGGTTATACGAGTTGCGAAACCTTTCGCGCGTAGACGAAGAATTTGAAGTGGCCTACACCGTTTGGAAAGCCGTTCTCATTAGAATGGTACCGACTACTCGGCTCGGAGTCATTGTATAGGGAGAGTGTCGTATCAACATCACACACTTTTAGCATTTAAGGTCCATGGCCGTTGACAGGTACCGA"]], "outputs": [["UUUU"], ["GCAU"], ["GACCGCCGCC"], ["GAUUCCACCGACUUCCCAAGUACCGGAAGCGCGACCAACUCGCACAGC"], ["CACGACAUACGGAGCAGCGCACGGUUAGUACAGCUGUCGGUGAACUCCAUGACA"], ["AACCCUGUCCACCAGUAACGUAGGCCGACGGGAAAAAUAAACGAUCUGUCAAUG"], ["GAAGCUUAUCCGUUCCUGAAGGCUGUGGCAUCCUCUAAAUCAGACUUGGCUACGCCGUUAGCCGAGGGCUUAGCGUUGAGUGUCAUUAUAUACGCGGCCUGCGACCUGGCCACACAAUGCCCUCGAAAAUUUUUCUUUCGGUUAUACGAGUUGCGAAACCUUUCGCGCGUAGACGAAGAAUUUGAAGUGGCCUACACCGUUUGGAAAGCCGUUCUCAUUAGAAUGGUACCGACUACUCGGCUCGGAGUCAUUGUAUAGGGAGAGUGUCGUAUCAACAUCACACACUUUUAGCAUUUAAGGUCCAUGGCCGUUGACAGGUACCGA"]]}
user: Iahub got bored, so he invented a game to be played on paper.
 He writes n integers a1, a2, ..., an. Each of those integers can be either 0 or 1. He's allowed to do exactly one move: he chooses two indices i and j (1 ≤ i ≤ j ≤ n) and flips all values ak for which their positions are in range [i, j] (that is i ≤ k ≤ j). Flip the value of x means to apply operation x = 1 - x.
 The goal of the game is that after exactly one move to obtain the maximum number of ones. Write a program to solve the little game of Iahub.
```
@param {Array} line of the input there are n integers: a1, a2, ..., an. 1 ≤ n ≤ 100. It is guaranteed that each of those n values is either 0 or 1
@return {Integer} the maximal number of 1s that can be obtained after exactly one move
```
Examples :
```
[1, 0, 0, 1, 0, 0]  =>  5
[1, 0, 0, 1]  =>  4

```
Note:
 In the first case, flip the segment from 2 to 6 (i = 2, j = 6). That flip changes the sequence, it becomes: [1 1 1 0 1 1]. So, it contains four ones. There is no way to make the whole sequence equal to [1 1 1 1 1 1].
 In the second case, flipping only the second and the third element (i = 2, j = 3) will turn all numbers into 1.

(c)ll931110 & fchirica

Answer: {"fn_name": "flipping_game", "inputs": [[[1, 0, 0, 1, 0, 0]], [[1, 0, 0, 1]], [[1]], [[0]], [[1, 0, 0, 0, 1, 0, 0, 0]], [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], [[0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1]]], "outputs": [[5], [4], [0], [1], [7], [18], [22], [18]]}
user: Check your arrows
You have a quiver of arrows, but some have been damaged. The quiver contains arrows with an optional range information (different types of targets are positioned at different ranges), so each item is an arrow.

You need to verify that you have some good ones left, in order to prepare for battle:
```python
anyArrows([{'range': 5}, {'range': 10, 'damaged': True}, {'damaged': True}])
```

If an arrow in the quiver does not have a damaged status, it means it's new.

The expected result is a boolean, indicating whether you have any good arrows left.

Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions

Answer: {"fn_name": "any_arrows", "inputs": [[[]], [[{"range": 5, "damaged": false}]], [[{"range": 5, "damaged": false}, {"range": 15, "damaged": true}]], [[{"range": 5}, {"range": 10, "damaged": true}, {"damaged": true}]], [[{"range": 10, "damaged": true}, {"damaged": true}]]], "outputs": [[false], [true], [true], [true], [false]]}
user: This function should take two string parameters: a person's name (`name`) and a quote of theirs (`quote`), and return a string attributing the quote to the person in the following format:

```python
'[name] said: "[quote]"'
```

For example, if `name` is `'Grae'` and `'quote'` is `'Practice makes perfect'` then your function should return the string
```python
'Grae said: "Practice makes perfect"'
```
Unfortunately, something is wrong with the instructions in the function body. Your job is to fix it so the function returns correctly formatted quotes.

Click the "Train" button to get started, and be careful with your quotation marks.

Answer: {"fn_name": "quotable", "inputs": [["Grae", "Practice makes perfect"], ["Dan", "Get back to work, Grae"], ["Alex", "Python is great fun"], ["Bethany", "Yes, way more fun than R"], ["Darrell", "What the heck is this thing?"]], "outputs": [["Grae said: \"Practice makes perfect\""], ["Dan said: \"Get back to work, Grae\""], ["Alex said: \"Python is great fun\""], ["Bethany said: \"Yes, way more fun than R\""], ["Darrell said: \"What the heck is this thing?\""]]}
user: You have to create a method "compoundArray" which should take as input two int arrays of different length and return one int array with numbers of both arrays shuffled one by one. 
```Example: 
Input - {1,2,3,4,5,6} and {9,8,7,6} 
Output - {1,9,2,8,3,7,4,6,5,6}
```

Answer: {"fn_name": "compound_array", "inputs": [[[1, 2, 3, 4, 5, 6], [9, 8, 7, 6]], [[0, 1, 2], [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]], [[11, 12], [21, 22, 23, 24]], [[2147483647, 2147483646, 2147483645, 2147483644, 2147483643], [9]], [[214, 215, 216, 217, 218], []], [[], [214, 215, 219, 217, 218]], [[], []]], "outputs": [[[1, 9, 2, 8, 3, 7, 4, 6, 5, 6]], [[0, 9, 1, 8, 2, 7, 6, 5, 4, 3, 2, 1, 0]], [[11, 21, 12, 22, 23, 24]], [[2147483647, 9, 2147483646, 2147483645, 2147483644, 2147483643]], [[214, 215, 216, 217, 218]], [[214, 215, 219, 217, 218]], [[]]]}
user: ## The Problem

James is a DJ at a local radio station. As it's getting to the top of the hour, he needs to find a song to play that will be short enough to fit in before the news block. He's got a database of songs that he'd like you to help him filter in order to do that.

## What To Do

Create `longestPossible`(`longest_possible` in python and ruby) helper function that takes 1 integer argument which is a maximum length of a song in seconds.

`songs` is an array of objects which are formatted as follows:

```python
{'artist': 'Artist', 'title': 'Title String', 'playback': '04:30'}
```

You can expect playback value to be formatted exactly like above.

Output should be a title of the longest song from the database that matches the criteria of not being longer than specified time. If there's no songs matching criteria in the database, return `false`.

Answer: {"fn_name": "longest_possible", "inputs": [[215], [270], [13], [300]], "outputs": [["For Reasons Unknown"], ["YYZ"], [false], ["Surfing With The Alien"]]}
user: # Task

You are given a function that should insert an asterisk (`*`) between every pair of **even digits** in the given input, and return it as a string. If the input is a sequence, concat the elements first as a string. 


## Input

The input can be an integer, a string of digits or a sequence containing integers only. 


## Output

Return a string. 


## Examples
```
5312708     -->  "531270*8"
"0000"      -->  "0*0*0*0"
[1, 4, 64]  -->  "14*6*4"
```

Have fun!

Answer: {"fn_name": "asterisc_it", "inputs": [[5312708], [9682135], [2222], [1111], [9999], ["0000"], [8], [2], [0], [[1, 4, 64, 68, 67, 23, 1]]], "outputs": [["531270*8"], ["96*8*2135"], ["2*2*2*2"], ["1111"], ["9999"], ["0*0*0*0"], ["8"], ["2"], ["0"], ["14*6*4*6*8*67231"]]}
user: A [Mersenne prime](https://en.wikipedia.org/wiki/Mersenne_prime) is a prime number that can be represented as:
Mn = 2^(n) - 1. Therefore, every Mersenne prime is one less than a power of two. 

Write a function that will return whether the given integer `n` will produce a Mersenne prime or not.

The tests will check random integers up to 2000.

Answer: {"fn_name": "valid_mersenne", "inputs": [[2], [3], [5], [7], [11], [13], [17], [19], [21], [23], [31], [49], [61], [89], [107], [127], [221], [521], [607], [1279]], "outputs": [[true], [true], [true], [true], [false], [true], [true], [true], [false], [false], [true], [false], [true], [true], [true], [true], [false], [true], [true], [true]]}
user: As a treat, I'll let you read part of the script from a classic 'I'm Alan Partridge episode:
```
Lynn: Alan, there’s that teacher chap.
Alan: Michael, if he hits me, will you hit him first?
Michael: No, he’s a customer. I cannot hit customers. I’ve been told. I’ll go and get some stock.
Alan: Yeah, chicken stock.
Phil: Hello Alan.
Alan: Lynn, hand me an apple pie. And remove yourself from the theatre of conflict.
Lynn: What do you mean?
Alan: Go and stand by the yakults. The temperature inside this apple turnover is 1,000 degrees. If I squeeze it, a jet of molten Bramley apple is going to squirt out. Could go your way, could go mine. Either way, one of us is going down.
```

Alan is known for referring to the temperature of the apple turnover as 'Hotter than the sun!'. According to  space.com the temperature of the sun's corona is 2,000,000 degrees C, but we will ignore the science for now. 

Your job is simple, if (x) squared is more than 1000, return  'It's hotter than the sun!!', else, return 'Help yourself to a honeycomb Yorkie for the glovebox.'.

X will be either a number or a string. Both are valid. 

Other katas in this series:
Alan Partridge I - Partridge Watch
Alan Partridge III - London

Answer: {"fn_name": "apple", "inputs": [["50"], [4], ["12"], [60]], "outputs": [["It's hotter than the sun!!"], ["Help yourself to a honeycomb Yorkie for the glovebox."], ["Help yourself to a honeycomb Yorkie for the glovebox."], ["It's hotter than the sun!!"]]}
user: # Task

Write a function `deNico`/`de_nico()` that accepts two parameters:
- `key`/`$key` - string consists of unique letters and digits
- `message`/`$message` - string with encoded message 

and decodes the `message` using the `key`.  

First create a numeric key basing on the provided `key` by assigning each letter position in which it is located after setting the letters from `key` in an alphabetical order.

For example, for the key `crazy` we will get `23154` because of `acryz` (sorted letters from the key).  
Let's decode  `cseerntiofarmit on  ` using our `crazy` key.

```
1 2 3 4 5
---------
c s e e r
n t i o f
a r m i t
  o n   
```

After using the key:
```
2 3 1 5 4
---------
s e c r e
t i n f o
r m a t i
o n
```

# Notes 

- The `message` is never shorter than the `key`.
- Don't forget to remove trailing whitespace after decoding the message

# Examples

Check the test cases for more examples.

# Related Kata

[Basic Nico - encode](https://www.codewars.com/kata/5968bb83c307f0bb86000015)

Answer: {"fn_name": "de_nico", "inputs": [["crazy", "cseerntiofarmit on  "], ["crazy", "cseerntiofarmit on"], ["abc", "abcd"], ["ba", "2143658709"], ["a", "message"], ["key", "eky"]], "outputs": [["secretinformation"], ["secretinformation"], ["abcd"], ["1234567890"], ["message"], ["key"]]}
user: Some new cashiers started to work at your restaurant. 

They are good at taking orders, but they don't know how to capitalize words, or use a space bar! 

All the orders they create look something like this:

`"milkshakepizzachickenfriescokeburgerpizzasandwichmilkshakepizza"`

The kitchen staff are threatening to quit, because of how difficult it is to read the orders. 

Their preference is to get the orders as a nice clean string with spaces and capitals like so:

`"Burger Fries Chicken Pizza Pizza Pizza Sandwich Milkshake Milkshake Coke"`

The kitchen staff expect the items to be in the same order as they appear in the menu. 

The menu items are fairly simple, there is no overlap in the names of the items:
```
1. Burger
2. Fries
3. Chicken
4. Pizza
5. Sandwich
6. Onionrings
7. Milkshake
8. Coke
```

Answer: {"fn_name": "get_order", "inputs": [["burgerfriesfriesfriesfriesfriespizzasandwichcokefriesburger"]], "outputs": [["Burger Burger Fries Fries Fries Fries Fries Fries Pizza Sandwich Coke"]]}
user: # Kata Task

You are given a list of cogs in a gear train

Each element represents the number of teeth of that cog

e.g. `[100, 50, 25]` means 
* 1st cog has 100 teeth 
* 2nd cog has 50 teeth
* 3rd cog has 25 teeth

If the ``nth`` cog rotates clockwise at 1 RPM what is the RPM of the cogs at each end of the gear train? 

**Notes**
* no two cogs share the same shaft
* return an array whose two elements are RPM of the first and last cogs respectively
* use negative numbers for anti-clockwise rotation
* for convenience `n` is zero-based
* For C and NASM coders, the returned array will be `free`'d.

---

Series:
* Cogs
* Cogs 2

Answer: {"fn_name": "cog_RPM", "inputs": [[[100], 0], [[100, 100, 100, 100], 0], [[100, 100, 100, 100], 1], [[100, 100, 100, 100], 2], [[100, 100, 100, 100], 3]], "outputs": [[[1, 1]], [[1, -1]], [[-1, 1]], [[1, -1]], [[-1, 1]]]}
user: In this Kata we are passing a number (n) into a function. 

Your code will determine if the number passed is even (or not). 

The function needs to return either a true or false. 

Numbers may be positive or negative, integers or floats.

Floats are considered UNeven for this kata.

Answer: {"fn_name": "is_even", "inputs": [[0], [0.5], [1], [2], [-4], [15], [20], [220], [222222221], [500000000]], "outputs": [[true], [false], [false], [true], [true], [false], [true], [true], [false], [true]]}