meetforever/GRPO_CL huggingface dataset:
user: Everybody know that you passed to much time awake during night time...

Your task here is to define how much coffee you need to stay awake after your night. 
You will have to complete a function that take an array of events in arguments, according to this list you will return the number of coffee you need to stay awake during day time. **Note**: If the count exceed 3 please return 'You need extra sleep'.

The list of events can contain the following:

- You come here, to solve some kata ('cw').

- You have a dog or a cat that just decide to wake up too early ('dog' | 'cat').

- You just watch a movie ('movie').

- Other events can be present and it will be represent by arbitrary string, just ignore this one.

Each event can be downcase/lowercase, or uppercase. If it is downcase/lowercase you need 1 coffee by events and if it is uppercase you need 2 coffees.

Answer: {"fn_name": "how_much_coffee", "inputs": [[[]], [["cw"]], [["CW"]], [["cw", "CAT"]], [["cw", "CAT", "DOG"]], [["cw", "CAT", "cw=others"]]], "outputs": [[0], [1], [2], [3], ["You need extra sleep"], [3]]}
user: The rgb function is incomplete. Complete it so that passing in RGB decimal values will result in a hexadecimal representation being returned. Valid decimal values for RGB are 0 - 255. Any values that fall out of that range must be rounded to the closest valid value.

Note: Your answer should always be 6 characters long, the shorthand with 3 will not work here.

The following are examples of  expected output values:
```python
rgb(255, 255, 255) # returns FFFFFF
rgb(255, 255, 300) # returns FFFFFF
rgb(0,0,0) # returns 000000
rgb(148, 0, 211) # returns 9400D3
```
```if:nasm

char \*rgb(int r, int g, int b, char \*outp)

```

Answer: {"fn_name": "rgb", "inputs": [[0, 0, 0], [1, 2, 3], [255, 255, 255], [254, 253, 252], [-20, 275, 125]], "outputs": [["000000"], ["010203"], ["FFFFFF"], ["FEFDFC"], ["00FF7D"]]}
user: You are a *khm*mad*khm* scientist and you decided to play with electron distribution among atom's shells.
You know that basic idea of electron distribution is that electrons should fill a shell untill it's holding the maximum number of electrons.


  ---
Rules:  
  - Maximum number of electrons in a shell is distributed with a rule of 2n^2 (n being position of a shell). 
  - For example, maximum number of electrons in 3rd shield is 2*3^2 = 18.
  - Electrons should fill the lowest level shell first.
  - If the electrons have completely filled the lowest level shell, the other unoccupied electrons will fill the higher level shell and so on.  
  ---
        
```
Ex.:    atomicNumber(1); should return [1]
        atomicNumber(10); should return [2, 8]
        atomicNumber(11); should return [2, 8, 1]
        atomicNumber(47); should return [2, 8, 18, 19]
```

Answer: {"fn_name": "atomic_number", "inputs": [[1], [10], [11], [22], [23], [47], [50], [52], [60], [61]], "outputs": [[[1]], [[2, 8]], [[2, 8, 1]], [[2, 8, 12]], [[2, 8, 13]], [[2, 8, 18, 19]], [[2, 8, 18, 22]], [[2, 8, 18, 24]], [[2, 8, 18, 32]], [[2, 8, 18, 32, 1]]]}
user: ### Description
As hex values can include letters `A` through to `F`, certain English words can be spelled out, such as `CAFE`, `BEEF`, or `FACADE`.
This vocabulary can be extended by using numbers to represent other letters, such as `5EAF00D`, or `DEC0DE5`.

Given a string, your task is to return the decimal sum of all words in the string that can be interpreted as such hex values.


### Example

Working with the string `BAG OF BEES`:  
* `BAG` ==> `0` as it is not a valid hex value  
* `OF` ==> `0F` ==> `15`  
* `BEES` ==> `BEE5` ==> `48869`

So `hex_word_sum('BAG OF BEES')` returns the sum of these, `48884`.


### Notes
* Inputs are all uppercase and contain no punctuation
* `0` can be substituted for `O`
* `5` can be substituted for `S`

Answer: {"fn_name": "hex_word_sum", "inputs": [["DEFACE"], ["SAFE"], ["CODE"], ["BUGS"], [""], ["DO YOU SEE THAT BEE DRINKING DECAF COFFEE"], ["ASSESS ANY BAD CODE AND TRY AGAIN"]], "outputs": [[14613198], [23294], [49374], [0], [0], [13565769], [10889952]]}
user: ## Task

Let's say we have a positive integer, `$n$`. You have to find the smallest possible positive integer that when multiplied by `$n$`, becomes a perfect power of integer `$k$`. A perfect power of `$k$` is any positive integer that can be represented as `$a^k$`. For example if `$k = 2$`, then `$36$` is a perfect power of `$k$`, but `$27$` isn't.

## Examples

```python
n, k = 100, 3  return  10, #because 10*100 becomes 1000, and 1000 = 10**3
n, k = 36, 2   return   1, #because 36 is already a perfect square 6**2
n, k = 72, 4   return  18, #because 18*72 = 1296 = 6**4
```

**Notes:** 
+ `$k, n \in \mathbb{N} $` and `$ 1 \lt n \lt 10^6,\text{ } 1 \lt k \lt 10 $`
+ However, the output may be way larger than `$10^6$`.

If you have trouble seeing the numbers, refresh your page ;-) Please rate this kata. All translations are welcome.

ABOVE: [If you see this:](https://imgur.com/TKY59S4), refresh your page.

Answer: {"fn_name": "mul_power", "inputs": [[100, 3], [36, 2], [72, 4], [5, 2], [1152, 3]], "outputs": [[10], [1], [18], [5], [12]]}
user: # Invalid Login - Bug Fixing #11

Oh NO! Timmy has moved divisions... but now he's in the field of security. Timmy, being the top coder he is, has allowed some bad code through. You must help Timmy and filter out any injected code!

## Task

Your task is simple, search the password string for any injected code (Injected code is any thing that would be used to exploit flaws in the current code, so basically anything that contains `||` or `//`) if you find any you must return `"Wrong username or password!"` because no one likes someone trying to cheat their way in!

## Preloaded

You will be given a preloaded class called `Database` with a method `login` this takes two parameters `username` and `password`. This is a generic login function which will check the database for the user it will return either `'Successfully Logged in!'` if it passes the test or `'Wrong username or password!'` if either the password is wrong or username does not exist.

## Usage

```python
database = Database()
database.login('Timmy', 'password')
```

Answer: {"fn_name": "validate", "inputs": [["Timmy", "password"], ["Timmy", "h4x0r"], ["Alice", "alice"], ["Timmy", "password\"||\"\"==\""], ["Admin", "gs5bw\"||1==1//"]], "outputs": [["Successfully Logged in!"], ["Wrong username or password!"], ["Successfully Logged in!"], ["Wrong username or password!"], ["Wrong username or password!"]]}
user: ## Task:
You have to create a function `isPronic` to check whether the argument passed is a Pronic Number and return true if it is & false otherwise.

### Description:

`Pronic Number` -A pronic number, oblong number, rectangular number or heteromecic number, is a number which is the product of two consecutive integers, that is, n(n + 1).

> The first few Pronic Numbers are - 0, 2, 6, 12, 20, 30, 42...

### Explanation:
    
      0 = 0 × 1   // ∴  0 is a Pronic Number
      2 = 1 × 2   // ∴  2 is a Pronic Number
      6 = 2 × 3   // ∴  6 is a Pronic Number
     12 = 3 × 4   // ∴ 12 is a Pronic Number
     20 = 4 × 5   // ∴ 20 is a Pronic Number
     30 = 5 × 6   // ∴ 30 is a Pronic Number
     42 = 6 × 7   // ∴ 42 is a Pronic Number

Answer: {"fn_name": "is_pronic", "inputs": [[2], [3], [4], [5], [6], [-3], [-27]], "outputs": [[true], [false], [false], [false], [true], [false], [false]]}
user: ```if:python
Create a function `args_count`, that returns the count of passed arguments
```
```if:kotlin
Create a function `argsCount`, that returns the count of passed arguments
```
```if:ruby
Create a method `args_count`, that returns the count of passed arguments
```
```if:julia
Create a method `argscount`, that returns the count of passed arguments
```
```python
args_count(1, 2, 3) -> 3
args_count(1, 2, 3, 10) -> 4
```

Answer: {"fn_name": "args_count", "inputs": [[100], [100, 2, 3]], "outputs": [[1], [3]]}
user: We have a set of consecutive numbers from ```1``` to ```n```.
We want to count all the subsets that do not contain consecutive numbers.
E.g.

If our set ```S1``` is equal to ```[1,2,3,4,5]```
The subsets that fulfill these property are:
```
[1],[2],[3],[4],[5],[1,3],[1,4],[1,5],[2,4],[2,5],[3,5],[1,3,5]
```
A total of      ```12   ``` subsets.

From the set ```S2``` equals to```[1,2,3]```, it is obvious that we have only ```4``` subsets and are:
```
[1],[2],[3],[1,3]
```
Make a code that may give the amount of all these subsets for any integer       ```n >= 2       ```.

Features of the random tests:
```
number of tests = 100 
10 <= n <= 120
```

Answer: {"fn_name": "f", "inputs": [[5], [3], [2], [20]], "outputs": [[12], [4], [2], [17710]]}
user: Reducing Problems - Bug Fixing #8

Oh no! Timmy's reduce is causing problems, Timmy's goal is to calculate the two teams scores and return the winner but timmy has gotten confused and sometimes teams don't enter their scores, total the scores out of 3! Help timmy fix his program!

Return true if team 1 wins or false if team 2 wins!

Answer: {"fn_name": "calculate_total", "inputs": [[[1, 2, 2], [1, 0, 0]], [[6, 45, 1], [1, 55, 0]], [[57, 2, 1], []], [[], [3, 4, 3]], [[], []]], "outputs": [[true], [false], [true], [false], [false]]}
user: Let's say we have a number, `num`. Find the number of values of `n` such that: there exists `n` consecutive **positive** values that sum up to `num`. A positive number is `> 0`. `n` can also be 1.

```python
#Examples
num = 1
#1
return 1

num = 15
#15, (7, 8), (4, 5, 6), (1, 2, 3, 4, 5)
return 4

num = 48
#48, (15, 16, 17)
return 2

num = 97
#97, (48, 49)
return 2
```
The upper limit is `$10^8$`

Answer: {"fn_name": "consecutive_sum", "inputs": [[1], [15], [48], [97]], "outputs": [[1], [4], [2], [2]]}
user: Failed Sort - Bug Fixing #4
Oh no, Timmy's Sort doesn't seem to be working? Your task is to fix the sortArray function to sort all numbers in ascending order

Answer: {"fn_name": "sort_array", "inputs": [["12345"], ["54321"], ["34251"], ["11111"], ["10101"]], "outputs": [["12345"], ["12345"], ["12345"], ["11111"], ["00111"]]}
user: In this Kata your task will be to return the count of pairs that have consecutive numbers as follows:
```Haskell
pairs([1,2,5,8,-4,-3,7,6,5]) = 3
The pairs are selected as follows [(1,2),(5,8),(-4,-3),(7,6),5]
--the first pair is (1,2) and the numbers in the pair are consecutive; Count = 1
--the second pair is (5,8) and are not consecutive
--the third pair is (-4,-3), consecutive. Count = 2
--the fourth pair is (7,6), also consecutive. Count = 3. 
--the last digit has no pair, so we ignore.
```

More examples in the test cases. 

Good luck!

Please also try [Simple time difference](https://www.codewars.com/kata/5b76a34ff71e5de9db0000f2)

Answer: {"fn_name": "pairs", "inputs": [[[1, 2, 5, 8, -4, -3, 7, 6, 5]], [[21, 20, 22, 40, 39, -56, 30, -55, 95, 94]], [[81, 44, 80, 26, 12, 27, -34, 37, -35]], [[-55, -56, -7, -6, 56, 55, 63, 62]], [[73, 72, 8, 9, 73, 72]]], "outputs": [[3], [2], [0], [4], [3]]}
user: Complete the solution so that it takes the object (JavaScript/CoffeeScript) or hash (ruby) passed in and generates a human readable string from its key/value pairs. 

The format should be "KEY = VALUE". Each key/value pair should be separated by a comma except for the last pair.

**Example:**
```python
solution({"a": 1, "b": '2'}) # should return "a = 1,b = 2"
```

Answer: {"fn_name": "solution", "inputs": [[{"a": 1, "b": 2}], [{"a": "b", "b": "a"}], [{"0": "a", "b": 2}], [{"b": 1, "c": 2, "e": 3}], [{}]], "outputs": [["a = 1,b = 2"], ["a = b,b = a"], ["0 = a,b = 2"], ["b = 1,c = 2,e = 3"], [""]]}
user: # Task
 You have some people who are betting money, and they all start with the same amount of money (this number>0). 

 Find out if the given end-state of amounts is possible after the betting is over and money is redistributed.

# Input/Output


 - `[input]` integer array arr

  the proposed end-state showing final amounts for each player


 - `[output]` a boolean value

  `true` if this is a possible end-state and `false` otherwise
  
# Examples


- For `arr = [0, 56, 100]`, the output should be `true`.

Three players start with the same amount of money 52.

At the end of game, player 1 lose `52`, player2 win `4`, and  player3 win `48`.


- For `arr = [0, 0, 0]`, the output should be `false`.

Players should start with a positive number of of money.

- For `arr = [11]`, the output should be `true`.

One player always keep his money at the end of game.


- For `arr = [100, 100, 100, 90, 1, 0, 0]`, the output should be `false`.

These players can not start with the same amount of money.

Answer: {"fn_name": "learn_charitable_game", "inputs": [[[100, 100, 100, 90, 1, 0, 0]], [[0, 0, 0, 0]], [[0, 56, 100]], [[33, 19, 38, 87, 93, 4]], [[11]]], "outputs": [[false], [false], [true], [false], [true]]}
user: In this Kata you need to write the method SharedBits that returns true if 2 integers share at least two '1' bits. For simplicity assume that all numbers are positive

For example
int seven = 7;    //0111
int ten = 10;     //1010
int fifteen = 15; //1111
SharedBits(seven, ten);     //false
SharedBits(seven, fifteen); //true
SharedBits(ten, fifteen);   //true

- seven and ten share only a single '1' (at index 3)
- seven and fifteen share 3 bits (at indexes 1, 2, and 3)
- ten and fifteen  share 2 bits (at indexes 0 and 2)

Hint: you can do this with just string manipulation, but binary operators will make your life much easier.

Answer: {"fn_name": "shared_bits", "inputs": [[1, 2], [16, 8], [1, 1], [2, 3], [7, 10], [43, 77], [7, 15], [23, 7]], "outputs": [[false], [false], [false], [false], [false], [true], [true], [true]]}
user: # Task
 Given an integer `n`, find the maximal number you can obtain by deleting exactly one digit of the given number.

# Example

 For `n = 152`, the output should be `52`;
 
 For `n = 1001`, the output should be `101`.
 
# Input/Output


 - `[input]` integer `n`

    Constraints: `10 ≤ n ≤ 1000000.`


 - `[output]` an integer

Answer: {"fn_name": "delete_digit", "inputs": [[152], [1001], [10]], "outputs": [[52], [101], [1]]}
user: Simple transposition is a basic and simple cryptography technique. We make 2 rows and put first a letter in the Row 1, the second in the Row 2, third in Row 1 and so on until the end. Then we put the text from Row 2 next to the Row 1 text and thats it.

Complete the function that receives a string and encrypt it with this simple transposition.

## Example
For example if the text to encrypt is: `"Simple text"`, the 2 rows will be:



Row 1
S
m
l
 
e
t


Row 2
i
p
e
t
x
 



So the result string will be: `"Sml etipetx"`

Answer: {"fn_name": "simple_transposition", "inputs": [["Sample text"], ["Simple transposition"], ["All that glitters is not gold"], ["The better part of valor is discretion"], ["Conscience does make cowards of us all"], ["Imagination is more important than knowledge"]], "outputs": [["Sml etapetx"], ["Sml rnpstoipetasoiin"], ["Alta ltesi o odl htgitr sntgl"], ["Tebte ato ao sdsrtoh etrpr fvlri icein"], ["Cncec osmk oad fu losinede aecwrso sal"], ["Iaiaini oeipratta nwegmgnto smr motn hnkolde"]]}
user: Given a credit card number we can determine who the issuer/vendor is with a few basic knowns.

```if:python
Complete the function `get_issuer()` that will use the values shown below to determine the card issuer for a given card number. If the number cannot be matched then the function should return the string `Unknown`.
```
```if-not:python
Complete the function `getIssuer()` that will use the values shown below to determine the card issuer for a given card number. If the number cannot be matched then the function should return the string `Unknown`.
```
```if:typescript
Where `Issuer` is defined with the following enum type.
~~~typescript
enum Issuer {
  VISA = 'VISA',
  AMEX = 'AMEX',
  Mastercard = 'Mastercard',
  Discover = 'Discover',
  Unknown = 'Unknown',
}
~~~
```

```markdown
| Card Type  | Begins With          | Number Length |
|------------|----------------------|---------------|
| AMEX       | 34 or 37             | 15            |
| Discover   | 6011                 | 16            |
| Mastercard | 51, 52, 53, 54 or 55 | 16            |
| VISA       | 4                    | 13 or 16      |
```

```if:c,cpp
**C/C++ note:** The return value in C is not freed.
```

## Examples

```if-not:python
~~~js
getIssuer(4111111111111111) == "VISA"
getIssuer(4111111111111) == "VISA"
getIssuer(4012888888881881) == "VISA"
getIssuer(378282246310005) == "AMEX"
getIssuer(6011111111111117) == "Discover"
getIssuer(5105105105105100) == "Mastercard"
getIssuer(5105105105105106) == "Mastercard"
getIssuer(9111111111111111) == "Unknown"
~~~
```
```if:python
~~~py
get_issuer(4111111111111111) == "VISA"
get_issuer(4111111111111) == "VISA"
get_issuer(4012888888881881) == "VISA"
get_issuer(378282246310005) == "AMEX"
get_issuer(6011111111111117) == "Discover"
get_issuer(5105105105105100) == "Mastercard"
get_issuer(5105105105105106) == "Mastercard"
get_issuer(9111111111111111) == "Unknown"
~~~
```

Answer: {"fn_name": "get_issuer", "inputs": [[4111111111111111], [4111111111111], [4012888888881881], [41111111111111], [411111111111111], [378282246310005], [348282246310005], [6011111111111117], [5105105105105100], [5105105105105106], [5205105105105106], [5305105105105106], [5405105105105106], [5505105105105106], [9111111111111111], [5605105105105106]], "outputs": [["VISA"], ["VISA"], ["VISA"], ["Unknown"], ["Unknown"], ["AMEX"], ["AMEX"], ["Discover"], ["Mastercard"], ["Mastercard"], ["Mastercard"], ["Mastercard"], ["Mastercard"], ["Mastercard"], ["Unknown"], ["Unknown"]]}
user: Check if given chord is minor or major.

_____________________________________________________________
Rules:

1. Basic minor/major chord have three elements.

2. Chord is minor when interval between first and second element equals 3 and between second and third -> 4.

3. Chord is major when interval between first and second element equals 4 and between second and third -> 3.

4. In minor/major chord interval between first and third element equals... 7.

_______________________________________________________________
There is a preloaded list of the 12 notes of a chromatic scale built on C. This means that there are (almost) all allowed note' s names in music.

notes = 
['C', ['C#', 'Db'], 'D', ['D#', 'Eb'], 'E', 'F', ['F#', 'Gb'], 'G', ['G#', 'Ab'], 'A', ['A#', 'Bb'], 'B']

Note that e. g. 'C#' - 'C' = 1, 'C' - 'C#' = 1, 'Db' - 'C' = 1 and 'B' - 'C' = 1. 

Input:
String of notes separated by whitespace, e. g. 'A C# E'

Output:
String message: 'Minor', 'Major' or 'Not a chord'.

Answer: {"fn_name": "minor_or_major", "inputs": [["C E G"], ["Db F Ab"], ["D F# A"], ["Eb G Bb"], ["E G# B"], ["F A C"], ["F# A# C#"], ["Gb Bb Db"], ["G B D"], ["Ab C Eb"], ["A C# E"], ["Bb D F"], ["B D# F#"], ["C Eb G"], ["C# E G#"], ["D F A"], ["D# F# A#"], ["Eb Gb Bb"], ["E G B"], ["F Ab C"], ["F# A C#"], ["G Bb D"], ["G# B D#"], ["A C E"], ["Bb Db F"], ["B D F#"], ["C D G"], ["A C D"], ["A C# D#"], ["D F A G"], ["D F"], ["D F A C#"], ["K L M"], ["C A G"], ["C H G"], ["G E C"], ["E C A"], ["G# E C#"], ["Bb Gb Eb"]], "outputs": [["Major"], ["Major"], ["Major"], ["Major"], ["Major"], ["Major"], ["Major"], ["Major"], ["Major"], ["Major"], ["Major"], ["Major"], ["Major"], ["Minor"], ["Minor"], ["Minor"], ["Minor"], ["Minor"], ["Minor"], ["Minor"], ["Minor"], ["Minor"], ["Minor"], ["Minor"], ["Minor"], ["Minor"], ["Not a chord"], ["Not a chord"], ["Not a chord"], ["Not a chord"], ["Not a chord"], ["Not a chord"], ["Not a chord"], ["Not a chord"], ["Not a chord"], ["Not a chord"], ["Not a chord"], ["Not a chord"], ["Not a chord"]]}
user: # Task
 Vanya gets bored one day and decides to enumerate a large pile of rocks. He first counts the rocks and finds out that he has `n` rocks in the pile, then he goes to the store to buy labels for enumeration. 
 
 Each of the labels is a digit from 0 to 9 and each of the `n` rocks should be assigned a unique number from `1` to `n`.

 If each label costs `$1`, how much money will Vanya spend on this project?

# Input/Output


 - `[input]` integer `n`

  The number of rocks in the pile.

  `1  ≤  n  ≤  10^9`


 - `[output]` an integer

  the cost of the enumeration.
  
# Example

 For `n = 13`, the result should be `17`.
 ```
 the numbers from 1 to n are:
 1 2 3 4 5 6 7 8 9 10 11 12 13
 we need 17 single digit labels:
 1 2 3 4 5 6 7 8 9 1 0 1 1 1 2 1 3
 each label cost $1, so the output should be 17.
 ```

Answer: {"fn_name": "rocks", "inputs": [[1], [10], [13], [100], [36123011]], "outputs": [[1], [11], [17], [192], [277872985]]}
user: Kate likes to count words in text blocks. By words she means continuous sequences of English alphabetic characters (from a to z ). Here are examples:

`Hello there, little user5453 374 ())$. I’d been using my sphere as a stool. Slow-moving target 839342 was hit by OMGd-63 or K4mp.` contains "words" `['Hello', 'there', 'little', 'user', 'I', 'd', 'been', 'using', 'my','sphere', 'as', 'a', 'stool', 'Slow', 'moving', 'target', 'was', 'hit', 'by', 'OMGd', 'or', 'K', 'mp']`

Kate doesn't like some of words and doesn't count them. Words to be excluded are "a", "the", "on", "at", "of", "upon", "in" and "as", case-insensitive.

Today Kate's too lazy and have decided to teach her computer to count "words" for her.


Example Input 1
-------------
Hello there, little user5453 374 ())$.

Example Output 1
-------------
4

Example Input 2
-------------

  I’d been using my sphere as a stool. I traced counterclockwise circles on it with my fingertips and it shrank until I could palm it. My bolt had shifted while I’d been sitting. I pulled it up and yanked the pleats straight as I careered around tables, chairs, globes, and slow-moving fraas. I passed under a stone arch into the Scriptorium. The place smelled richly of ink. Maybe it was because an ancient fraa and his two fids were copying out books there. But I wondered how long it would take to stop smelling that way if no one ever used it at all; a lot of ink had been spent there, and the wet smell of it must be deep into everything.

Example Output 2
--------------

112

Answer: {"fn_name": "word_count", "inputs": [["hello there"], ["hello there and a hi"], ["I'd like to say goodbye"], ["Slow-moving user6463 has been here"], ["%^&abc!@# wer45tre"], ["abc123abc123abc"], ["Really2374239847 long ^&#$&(*@# sequence"], ["Hello there, little user5453 374 ())$."]], "outputs": [[2], [4], [6], [6], [3], [3], [3], [4]]}
user: **This Kata is intended as a small challenge for my students**

All Star Code Challenge #18

Create a function called that accepts 2 string arguments and returns an integer of the count of occurrences the 2nd argument is found in the first one.

If no occurrences can be found, a count of 0 should be returned.

Notes:
* The first argument can be an empty string  
* The second string argument will always be of length 1

Answer: {"fn_name": "str_count", "inputs": [["hello", "l"], ["hello", "e"], ["codewars", "c"], ["ggggg", "g"], ["hello world", "o"]], "outputs": [[2], [1], [1], [5], [2]]}
user: Kontti language is a finnish word play game.

You add `-kontti` to the end of each word and then swap their characters until and including the first vowel ("aeiouy"); 

For example the word `tame` becomes `kome-tantti`; `fruity` becomes `koity-fruntti` and so on.

If no vowel is present, the word stays the same.

Write a string method that turns a sentence into kontti language!

Answer: {"fn_name": "kontti", "inputs": [["lamppu"], ["lamppu sofia"], ["silly game"], ["aeiou"], ["xyz lamppu"], [""], ["lAmppU"], ["silly grrr"]], "outputs": [["komppu-lantti"], ["komppu-lantti kofia-sontti"], ["kolly-sintti kome-gantti"], ["koeiou-antti"], ["koz-xyntti komppu-lantti"], [""], ["komppU-lAntti"], ["kolly-sintti grrr"]]}