meetforever/GRPO_CL huggingface dataset:
user: # Task
Get the digits sum of `n`th number from the [Look-and-Say sequence](http://en.wikipedia.org/wiki/Look-and-say_sequence)(1-based).

`1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211, ...`

# Input/Output

`[input]` integer `n`

`n`th number in the sequence to get where `1 <= n <= 55`  and `n=1 is "1"`.

[output] an integer

The sum of digits in `n`th number from the `Look-and-Say` sequence.

# Example

For `n = 2`, the output shoule be 2.

`"11" --> 1 + 1 --> 2`

For `n = 3`, the output shoule be 3.

`"21" --> 2 + 1 --> 3`

For `n = 4`, the output shoule be 5.

`"1211" --> 1 + 2 + 1 + 1 --> 5`

Answer: {"fn_name": "look_and_say_and_sum", "inputs": [[1], [2], [3], [4], [5]], "outputs": [[1], [2], [3], [5], [8]]}
user: You will be given a string (x) featuring a cat 'C', a dog 'D' and a mouse 'm'. The rest of the string will be made up of '.'. 

You need to find out if the cat can catch the mouse from it's current position. The cat can jump (j) characters. 

Also, the cat cannot jump over the dog.

So:

if j = 5:

```..C.....m.``` returns 'Caught!'  <-- not more than j characters between

```.....C............m......``` returns 'Escaped!'  <-- as there are more than j characters between the two, the cat can't jump far enough

if j = 10:

```...m.........C...D``` returns 'Caught!' <--Cat can jump far enough and jump is not over dog

```...m....D....C.......``` returns 'Protected!' <-- Cat can jump far enough, but dog is in the way, protecting the mouse

Finally, if all three animals are not present, return 'boring without all three'

Answer: {"fn_name": "cat_mouse", "inputs": [["..D.....C.m", 2], ["............C.............D..m...", 8], ["m.C...", 5], [".CD......m.", 10], [".CD......m.", 1]], "outputs": [["Caught!"], ["Escaped!"], ["boring without all three"], ["Protected!"], ["Escaped!"]]}
user: You're playing a game with a friend involving a bag of marbles. In the bag are ten marbles:

* 1 smooth red marble
* 4 bumpy red marbles
* 2 bumpy yellow marbles
* 1 smooth yellow marble
* 1 bumpy green marble
* 1 smooth green marble

You can see that the probability of picking a smooth red marble from the bag is `1 / 10` or `0.10` and the probability of picking a bumpy yellow marble is `2 / 10` or `0.20`.

The game works like this: your friend puts her hand in the bag, chooses a marble (without looking at it) and tells you whether it's bumpy or smooth. Then you have to guess which color it is before she pulls it out and reveals whether you're correct or not.

You know that the information about whether the marble is bumpy or smooth changes the probability of what color it is, and you want some help with your guesses.

Write a function `color_probability()` that takes two arguments: a color (`'red'`, `'yellow'`, or `'green'`) and a texture (`'bumpy'` or `'smooth'`) and returns the probability as a decimal fraction accurate to two places.

The probability should be a string and should discard any digits after the 100ths place. For example, `2 / 3` or `0.6666666666666666` would become the string `'0.66'`. Note this is different from rounding.

As a complete example, `color_probability('red', 'bumpy')` should return the string `'0.57'`.

Answer: {"fn_name": "color_probability", "inputs": [["red", "bumpy"], ["green", "bumpy"], ["yellow", "smooth"], ["red", "smooth"], ["green", "smooth"], ["yellow", "bumpy"]], "outputs": [["0.57"], ["0.14"], ["0.33"], ["0.33"], ["0.33"], ["0.28"]]}
user: Passer ratings are the generally accepted standard for evaluating NFL quarterbacks.
I knew a rating of 100 is pretty good, but never knew what makes up the rating.
So out of curiosity I took a look at the wikipedia page and had an idea or my first kata: https://en.wikipedia.org/wiki/Passer_rating

## Formula

There are four parts to the NFL formula:
```python
A = ((Completions / Attempts) - .3) * 5
B = ((Yards / Attempts) - 3) * .25
C = (Touchdowns / Attempt) * 20
D = 2.375 - ((Interceptions / Attempts) * 25)
```
However, if the result of any calculation is greater than `2.375`, it is set to `2.375`. If the result is a negative number, it is set to zero.

Finally the passer rating is: `((A + B + C + D) / 6) * 100`

Return the rating rounded to the nearest tenth.

## Example

Last year Tom Brady had 432 attempts, 3554 yards, 291 completions, 28 touchdowns, and 2 interceptions.
His passer rating was 112.2

Happy coding!

Answer: {"fn_name": "passer_rating", "inputs": [[432, 3554, 291, 28, 2], [5, 76, 4, 1, 0], [48, 192, 19, 2, 3], [1, 2, 1, 1, 0], [34, 172, 20, 1, 1], [10, 17, 2, 0, 1]], "outputs": [[112.2], [158.3], [39.6], [118.8], [69.7], [0.0]]}
user: You will be given a vector of strings. You must sort it alphabetically (case-sensitive, and based on the ASCII values of the chars) and then return the first value.

The returned value must be a string, and have `"***"` between each of its letters.

You should not remove or add elements from/to the array.

Answer: {"fn_name": "two_sort", "inputs": [[["bitcoin", "take", "over", "the", "world", "maybe", "who", "knows", "perhaps"]], [["turns", "out", "random", "test", "cases", "are", "easier", "than", "writing", "out", "basic", "ones"]], [["lets", "talk", "about", "javascript", "the", "best", "language"]], [["i", "want", "to", "travel", "the", "world", "writing", "code", "one", "day"]], [["Lets", "all", "go", "on", "holiday", "somewhere", "very", "cold"]]], "outputs": [["b***i***t***c***o***i***n"], ["a***r***e"], ["a***b***o***u***t"], ["c***o***d***e"], ["L***e***t***s"]]}
user: # Background


My TV remote control has arrow buttons and an `OK` button.

I can use these to move a "cursor" on a logical screen keyboard to type words...

# Keyboard

The screen "keyboard" layout looks like this


  #tvkb {
    width : 400px;
    border: 5px solid gray; border-collapse: collapse;
  }
  #tvkb td {
    color : orange;
    background-color : black;
    text-align : center;
    border: 3px solid gray; border-collapse: collapse;
  }


abcde123
fghij456
klmno789
pqrst.@0
uvwxyz_/
aASP



* `aA` is the SHIFT key. Pressing this key toggles alpha characters between UPPERCASE and lowercase
* `SP` is the space character
* The other blank keys in the bottom row have no function

# Kata task

How many button presses on my remote are required to type the given `words`?

## Hint

This Kata is an extension of the earlier ones in this series. You should complete those first.

## Notes

* The cursor always starts on the letter `a` (top left)
* The alpha characters are initially lowercase (as shown above)
* Remember to also press `OK` to "accept" each letter
* Take the shortest route from one letter to the next
* The cursor wraps, so as it moves off one edge it will reappear on the opposite edge
* Although the blank keys have no function, you may navigate through them if you want to
* Spaces may occur anywhere in the `words` string
* Do not press the SHIFT key until you need to. For example, with the word `e.Z`, the SHIFT change happens **after** the `.` is pressed (not before)
 
# Example

words = `Code Wars`

* C => `a`-`aA`-OK-`A`-`B`-`C`-OK = 6
* o => `C`-`B`-`A`-`aA`-OK-`u`-`v`-`w`-`x`-`y`-`t`-`o`-OK = 12
* d => `o`-`j`-`e`-`d`-OK = 4
* e => `d`-`e`-OK = 2
* space => `e`-`d`-`c`-`b`-`SP`-OK = 5
* W => `SP`-`aA`-OK-`SP`-`V`-`W`-OK = 6
* a => `W`-`V`-`U`-`aA`-OK-`a`-OK = 6
* r => `a`-`f`-`k`-`p`-`q`-`r`-OK = 6
* s => `r`-`s`-OK = 2

Answer = 6 + 12 + 4 + 2 + 5 + 6 + 6 + 6 + 2 = 49



*Good Luck!
DM.*



Series
* TV Remote
* TV Remote (shift and space)
* TV Remote (wrap)
* TV Remote (symbols)

Answer: {"fn_name": "tv_remote", "inputs": [["Code Wars"], ["does"], ["your"], ["solution"], ["work"], ["for"], ["these"], ["words"], ["DOES"], ["YOUR"], ["SOLUTION"], ["WORK"], ["FOR"], ["THESE"], ["WORDS"], ["Does"], ["Your"], ["Solution"], ["Work"], ["For"], ["These"], ["Words"], ["A"], ["AADVARKS"], ["A/A/A/A/"], ["1234567890"], ["MISSISSIPPI"], ["a"], ["aadvarks"], ["a/a/a/a/"], ["mississippi"], ["Xoo ooo ooo"], ["oXo ooo ooo"], ["ooX ooo ooo"], ["ooo Xoo ooo"], ["ooo oXo ooo"], ["ooo ooX ooo"], ["ooo ooo Xoo"], ["ooo ooo oXo"], ["ooo ooo ooX"], ["The Quick Brown Fox Jumps Over A Lazy Dog."], ["Pack My Box With Five Dozen Liquor Jugs."], [""], [" "], ["   "], ["    x   X    "]], "outputs": [[49], [16], [21], [33], [18], [12], [27], [23], [19], [22], [34], [19], [15], [28], [24], [28], [33], [45], [26], [20], [35], [31], [4], [33], [32], [26], [38], [1], [30], [29], [35], [53], [65], [53], [53], [65], [53], [53], [65], [53], [254], [242], [0], [3], [5], [30]]}
user: Imagine if there were no order of operations. Instead, you would do the problem from left to right. For example, the equation `$a +b  *c /d$` would become `$(((a+b)*c)//d)$` (`Math.floor(((a+b)*c)/d)` in JS). Return `None`/`null` (depending on your language) if the equation is `""`.

### Task:

Given an equation with a random amount of spaces greater than or equal to zero between each number and operation, return the result without order of operations. Note that if two numbers are spaces apart, act as if they were one number: `1   3` = `13`. However, if given something `% 0` or something `/ 0`, return `None/null`.

More about order of operations: [here](https://en.wikipedia.org/wiki/Order_of_operations#:~:text=In%20the%20United%20States%2C%20the,Excuse%20My%20Dear%20Aunt%20Sally%22.)

### Key:

- `^` represents `**`

```if:python
- `/` represents `//` or `math.floor` because the result will always be an integer
```

```if:javascript
- `/` should always be rounded down(`Math.floor`) because the result will always be an integer
```

### Operations allowed: 
 `+, -, * , /, ^, %`

### Example:

`no_order(2 + 3 - 4 * 1 ^ 3) returns 1`

because:
```
  2 + 3 - 4 * 1 ^ 3
= 2 + 3 - 4 * 1 ^ 3
= 5 - 4 * 1 ^ 3
= 1 * 1 ^ 3
= 1 ^ 3
= 1
```

Answer: {"fn_name": "no_order", "inputs": [["2 + 3- 4*1   ^  3"], ["7 *  3 - 3/  10  0"], ["1 20% 0 + 9"], ["6 9* 2+6 /  0"]], "outputs": [[1], [0], [null], [null]]}
user: # Introduction 

Hamsters are rodents belonging to the subfamily Cricetinae. The subfamily contains about 25 species, classified in six or seven genera. They have become established as popular small house pets, and, partly because they are easy to breed in captivity, hamsters are often used as laboratory animals.


# Task 

Write a function that accepts two inputs: `code` and `message` and returns an encrypted string from `message` using the `code`.   
The `code` is a string that generates the key in the way shown below:

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

```

All letters from `code` get number `1`. All letters which directly follow letters from `code` get number `2` (unless they already have a smaller number assigned), etc. It's difficult to describe but it should be easy to understand from the example below:

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

```

How does the encoding work using the `hamster` code?    

```
a => a1
b => a2
c => a3
d => a4
e => e1
f => e2
...
```

And applying it to strings :

```
hamsterMe('hamster', 'hamster')   => h1a1m1s1t1e1r1
hamsterMe('hamster', 'helpme')    => h1e1h5m4m1e1

```

And you probably started wondering what will happen if there is no `a` in the `code`.  
Just add these letters after the last available letter (in alphabetic order) in the `code`.

The key for code `hmster` is:
```
 1  | e h m r s t
 2  | f i n     u
 3  | g j o     v
 4  |   k p     w
 5  |   l q     x
 6  |           y
 7  |           z
 8  |           a
 9  |           b
10  |           c
11  |           d
```

# Additional notes

The `code` will have at least 1 letter.   
Duplication of letters in `code` is possible and should be handled.    
The `code` and `message` consist of only lowercase letters.

Answer: {"fn_name": "hamster_me", "inputs": [["hamster", "hamster"], ["hamster", "helpme"], ["hmster", "hamster"], ["hhhhammmstteree", "hamster"], ["f", "abcdefghijklmnopqrstuvwxyz"]], "outputs": [["h1a1m1s1t1e1r1"], ["h1e1h5m4m1e1"], ["h1t8m1s1t1e1r1"], ["h1a1m1s1t1e1r1"], ["f22f23f24f25f26f1f2f3f4f5f6f7f8f9f10f11f12f13f14f15f16f17f18f19f20f21"]]}
user: Two tortoises named ***A*** and ***B*** must run a race. ***A*** starts with an average speed of ```720 feet per hour```.
Young ***B*** knows she runs faster than ***A***, and furthermore has not finished her cabbage.

When she starts, at last, she can see that ***A*** has a `70 feet lead` but ***B***'s speed is `850 feet per hour`.
How long will it take ***B*** to catch ***A***?

More generally:
given two speeds `v1` (***A***'s speed, integer > 0) and `v2` (***B***'s speed, integer > 0) and a lead `g` (integer > 0)
how long will it take ***B*** to catch ***A***? 

The result will be an array ```[hour, min, sec]``` which is the time needed in hours, minutes and seconds (round down to the nearest second)
or a string in some languages.

If `v1 >= v2` then return `nil`, `nothing`, `null`, `None` or `{-1, -1, -1}` for C++, C, Go, Nim, `[]` for Kotlin or "-1 -1 -1".

## Examples:
(form of the result depends on the language)
```
race(720, 850, 70) => [0, 32, 18] or "0 32 18"
race(80, 91, 37)   => [3, 21, 49] or "3 21 49"
```

** Note: 

- See other examples in "Your test cases".

- In Fortran - as in any other language - the returned string is not permitted to contain any redundant trailing whitespace: you can use dynamically allocated character strings.

** Hints for people who don't know how to convert to hours, minutes, seconds:

- Tortoises don't care about fractions of seconds

- Think of calculation by hand using only integers (in your code use or simulate integer division)

- or Google: "convert decimal time to hours minutes seconds"

Answer: {"fn_name": "race", "inputs": [[720, 850, 70], [80, 91, 37], [80, 100, 40], [720, 850, 37], [720, 850, 370], [120, 850, 37], [820, 850, 550], [820, 81, 550]], "outputs": [[[0, 32, 18]], [[3, 21, 49]], [[2, 0, 0]], [[0, 17, 4]], [[2, 50, 46]], [[0, 3, 2]], [[18, 20, 0]], [null]]}
user: You drop a ball from a given height. After each bounce, the ball returns to some fixed proportion of its previous height. If the ball bounces to height 1 or less, we consider it to have stopped bouncing. Return the number of bounces it takes for the ball to stop moving.

```
bouncingBall(initialHeight, bouncingProportion)

boucingBall(4, 0.5)
After first bounce, ball bounces to height 2
After second bounce, ball bounces to height 1
Therefore answer is 2 bounces

boucingBall(30, 0.3)
After first bounce, ball bounces to height 9
After second bounce, ball bounces to height 2.7
After third bounce, ball bounces to height 0.81
Therefore answer is 3 bounces


```

Initial height is an integer in range [2,1000]

Bouncing Proportion is a decimal in range [0, 1)

Answer: {"fn_name": "bouncing_ball", "inputs": [[2, 0.5], [4, 0.5], [10, 0.1], [100, 0.1], [9, 0.3], [30, 0.3]], "outputs": [[1], [2], [1], [2], [2], [3]]}
user: Given a set of elements (integers or string characters) that may occur more than once, we need to know the amount of subsets that none of their values have repetitions.
Let's see with an example:
``` 
set numbers = {1, 2, 3, 4}
``` 
The subsets are:
``` 
{{1}, {2}, {3}, {4}, {1,2}, {1,3}, {1,4}, {2,3}, {2,4},{3,4}, {1,2,3}, {1,2,4}, {1,3,4}, {2,3,4}, {1,2,3,4}} (15 subsets, as you can see the empty set, {}, is not counted)
``` 
Let's see an example with repetitions of an element:
```
set letters= {a, b, c, d, d}
```
The subsets for this case will be:
```
{{a}, {b}, {c}, {d}, {a,b}, {a,c}, {a,d}, {b,c}, {b,d},{c,d}, {a,b,c}, {a,b,d}, {a,c,d}, {b,c,d}, {a,b,c,d}} (15 subsets, only the ones that have no repeated elements inside)
```

The function ```est_subsets()``` (javascript: ``estSubsets()```) will calculate the number of these subsets.
It will receive the array as an argument and according to its features will output the amount of different subsets without repetitions of its elements.
```python
est_subsets([1, 2, 3, 4]) == 15
est_subsets(['a', 'b', 'c', 'd', 'd']) == 15
```
Features of the random tests:
```
Low Performance Tests: 40
Length of the arrays between 6 and 15

High Performance Tests: 80
Length of the arrays between 15 and 100 (Python an Ruby) and between 15 and 50 javascript)
```
Just do it!

Answer: {"fn_name": "est_subsets", "inputs": [[[1, 2, 3, 4]], [["a", "b", "c", "d", "d"]]], "outputs": [[15], [15]]}
user: It's tricky keeping track of who is owed what when spending money in a group. Write a function to balance the books.

* The function should take one parameter: an object/dict with two or more name-value pairs which represent the members of the group and the amount spent by each.
* The function should return an object/dict with the same names, showing how much money the members should pay or receive.

**Further points:**

* The values should be positive numbers if the person should receive money from the group, negative numbers if they owe money to the group.
* If value is a decimal, round to two decimal places.
 
Translations and comments (and upvotes!) welcome.

### Example

3 friends go out together: A spends £20, B spends £15, and C spends £10. The function should return an object/dict showing that A should receive £5, B should receive £0, and C should pay £5.

Answer: {"fn_name": "split_the_bill", "inputs": [[{"A": 20, "B": 15, "C": 10}], [{"A": 40, "B": 25, "X": 10}], [{"A": 40, "B": 25, "C": 10, "D": 153, "E": 58}], [{"A": 475, "B": 384, "C": 223, "D": 111, "E": 19}], [{"A": 20348, "B": 493045, "C": 2948, "D": 139847, "E": 48937534, "F": 1938724, "G": 4, "H": 2084}]], "outputs": [[{"A": 5.0, "B": 0.0, "C": -5.0}], [{"A": 15.0, "B": 0.0, "X": -15.0}], [{"A": -17.2, "B": -32.2, "C": -47.2, "D": 95.8, "E": 0.8}], [{"A": 232.6, "B": 141.6, "C": -19.4, "D": -131.4, "E": -223.4}], [{"A": -6421468.75, "B": -5948771.75, "C": -6438868.75, "D": -6301969.75, "E": 42495717.25, "F": -4503092.75, "G": -6441812.75, "H": -6439732.75}]]}
user: ## Witamy!

You are in Poland and want to order a drink. You need to ask "One beer please": "Jedno piwo poprosze"

``` java
Translator.orderingBeers(1) = "Jedno piwo poprosze"
```

But let's say you are really thirsty and want several beers. Then you need to count in Polish. And more difficult, you need to understand the Polish grammar and cases (nominative, genitive, accustative and more).

## The grammar

In English, the plural of "beer" is simply "beers", with an "s". 

In Polish, the plural of "piwo" (nominative singular) is "piw" (genitive plural) or "piwa" (nominative plural). It depends!


The rules:

* usually the plural is genitive: "piw"
* but after the numerals 2, 3, 4, and compound numbers ending with them (e.g. 22, 23, 24), the noun is plural and takes the same case as the numeral, so nominative: "piwa"
* and exception to the exception: for 12, 13 and 14, it's the genitive plural again: "piw" (yes, I know, it's crazy!)


## The numbers

From 0 to 9:
    
    "zero", "jeden", "dwa", "trzy", "cztery", "piec", "szesc" , "siedem", "osiem", "dziewiec"

From 10 to 19 it's nearly the same, with "-ascie" at the end:

    "dziesiec", "jedenascie", "dwanascie", "trzynascie", "czternascie", "pietnascie", "szesnascie", "siedemnascie", "osiemnascie", "dziewietnascie"

Tens from 10 to 90 are nearly the same, with "-ziesci" or "ziesiat" at the end:

    "dziesiec", "dwadziescia", "trzydziesci", "czterdziesci", "piecdziesiat", "szescdziesiat", "siedemdziesiat", "osiemdziesiat", "dziewiecdziesiat"

Compound numbers are constructed similarly to English: tens + units. For example, 22 is "dwadziescia dwa".

"One" could be male ("Jeden"), female ("Jedna") or neuter ("Jedno"), which is the case for "beer" (piwo). But all other numbers are invariant, even if ending with "jeden".

Ah, and by the way, if you don't want to drink alcohol (so no beers are ordered), ask for mineral water instead: "Woda mineralna".

Note: if the number of beers is outside your (limited) Polish knowledge (0-99), raise an error!

---
More about the crazy polish grammar: https://en.wikipedia.org/wiki/Polish_grammar

Answer: {"fn_name": "ordering_beers", "inputs": [[0], [1], [2], [3], [4], [5], [8], [10], [11], [12], [13], [14], [15], [16], [20], [21], [22], [28], [33], [44], [55], [98], [99]], "outputs": [["Woda mineralna poprosze"], ["Jedno piwo poprosze"], ["Dwa piwa poprosze"], ["Trzy piwa poprosze"], ["Cztery piwa poprosze"], ["Piec piw poprosze"], ["Osiem piw poprosze"], ["Dziesiec piw poprosze"], ["Jedenascie piw poprosze"], ["Dwanascie piw poprosze"], ["Trzynascie piw poprosze"], ["Czternascie piw poprosze"], ["Pietnascie piw poprosze"], ["Szesnascie piw poprosze"], ["Dwadziescia piw poprosze"], ["Dwadziescia jeden piw poprosze"], ["Dwadziescia dwa piwa poprosze"], ["Dwadziescia osiem piw poprosze"], ["Trzydziesci trzy piwa poprosze"], ["Czterdziesci cztery piwa poprosze"], ["Piecdziesiat piec piw poprosze"], ["Dziewiecdziesiat osiem piw poprosze"], ["Dziewiecdziesiat dziewiec piw poprosze"]]}
user: Third day at your new cryptoanalyst job and you come across your toughest assignment yet. Your job is to implement a simple keyword cipher. A keyword cipher is a type of monoalphabetic substitution where two parameters are provided as such (string, keyword). The string is encrypted by taking the keyword, dropping any letters that appear more than once. The rest of the letters of the alphabet that aren't used are then appended to the end of the keyword.

For example, if your string was "hello" and your keyword was "wednesday", your encryption key would be 'wednsaybcfghijklmopqrtuvxz'.

To encrypt 'hello' you'd substitute as follows,
```
              abcdefghijklmnopqrstuvwxyz
  hello ==>   |||||||||||||||||||||||||| ==> bshhk
              wednsaybcfghijklmopqrtuvxz

```             

hello encrypts into bshhk with the keyword wednesday. This cipher also uses lower case letters only.

Good Luck.

Answer: {"fn_name": "keyword_cipher", "inputs": [["Welcome home", "secret"], ["hello", "wednesday"], ["HELLO", "wednesday"], ["HeLlO", "wednesday"], ["WELCOME HOME", "gridlocked"], ["alpha bravo charlie", "delta"], ["Home Base", "seven"], ["basecamp", "covert"], ["one two three", "rails"], ["Test", "unbuntu"]], "outputs": [["wticljt dljt"], ["bshhk"], ["bshhk"], ["bshhk"], ["wlfimhl kmhl"], ["djofd eqdvn lfdqjga"], ["dlja esqa"], ["ocprvcil"], ["mks twm tdpss"], ["raqr"]]}
user: Create a function that takes a string as a parameter and does the following, in this order:

1. replaces every letter with the letter following it in the alphabet (see note below)
2. makes any vowels capital
3. makes any consonants lower case

**Note:** the alphabet should wrap around, so `Z` becomes `A`

So, for example the string `"Cat30"` would return `"dbU30"` (`Cat30 --> Dbu30 --> dbU30`)

Answer: {"fn_name": "changer", "inputs": [["Cat30"], ["Alice"], ["sponge1"], ["Hello World"], ["dogs"], ["z"]], "outputs": [["dbU30"], ["bmjdf"], ["tqpOhf1"], ["Ifmmp xpsmE"], ["Epht"], ["A"]]}
user: Complete the method so that it formats the words into a single comma separated value. The last word should be separated by the word 'and' instead of a comma. The method takes in an array of strings and returns a single formatted string. Empty string values should be ignored. Empty arrays or null/nil values being passed into the method should result in an empty string being returned. 

```Python
format_words(['ninja', 'samurai', 'ronin']) # should return "ninja, samurai and ronin"
format_words(['ninja', '', 'ronin']) # should return "ninja and ronin"
format_words([]) # should return ""
```
```Haskell
formatWords ["ninja", "samurai", "ronin"] -- should return "ninja, samurai and ronin"
formatWords ["ninja", "", "ronin"] -- should return "ninja and ronin"
formatWords [] -- should return ""
```

Answer: {"fn_name": "format_words", "inputs": [[["one", "two", "three", "four"]], [["one"]], [["one", "", "three"]], [["", "", "three"]], [["one", "two", ""]], [[]], [null], [[""]]], "outputs": [["one, two, three and four"], ["one"], ["one and three"], ["three"], ["one and two"], [""], [""], [""]]}