meetforever/GRPO_CL huggingface dataset:
user: # A History Lesson

The Pony Express was a mail service operating in the US in 1859-60.




It reduced the time for messages to travel between the Atlantic and Pacific coasts to about 10 days, before it was made obsolete by the [transcontinental telegraph](https://en.wikipedia.org/wiki/First_transcontinental_telegraph).

# How it worked

There were a number of *stations*, where:

* The rider switched to a fresh horse and carried on, or
* The mail bag was handed over to the next rider


# Kata Task

`stations` is a list/array of distances (miles) from one station to the next along the Pony Express route.

Implement the `riders` method/function, to return how many riders are necessary to get the mail from one end to the other.

**NOTE:** Each rider travels as far as he can, but never more than 100 miles.

---
*Good Luck.
DM.*

---

See also

* The Pony Express
* The Pony Express (missing rider)

Answer: {"fn_name": "riders", "inputs": [[[18, 15]], [[43, 23, 40, 13]], [[33, 8, 16, 47, 30, 30, 46]], [[6, 24, 6, 8, 28, 8, 23, 47, 17, 29, 37, 18, 40, 49]], [[50, 50]], [[50, 50, 25, 50, 24]], [[50, 50, 25, 50, 25]], [[50, 50, 25, 50, 26]], [[90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90]]], "outputs": [[1], [2], [3], [4], [1], [2], [2], [3], [100]]}
user: Some integral numbers are odd. All are more odd, or less odd, than others.

Even numbers satisfy `n = 2m` ( with `m` also integral ) and we will ( completely arbitrarily ) think of odd numbers as `n = 2m + 1`.  
Now, some odd numbers can be more odd than others: when for some `n`, `m` is more odd than for another's. Recursively. :]  
Even numbers are always less odd than odd numbers, but they also can be more, or less, odd than other even numbers, by the same mechanism.

# Task

Given a _non-empty_ finite list of _unique_ integral ( not necessarily non-negative ) numbers, determine the number that is _odder than the rest_.  
Given the constraints, there will always be exactly one such number.

# Examples

```python
oddest([1,2]) => 1
oddest([1,3]) => 3
oddest([1,5]) => 5
```

# Hint

Do you _really_ want one? Point or tap here.

Answer: {"fn_name": "oddest", "inputs": [[[1, 2]], [[1, 3]], [[1, 5]], [[0]], [[1, 3, 5, 7]], [[2, 4]], [[-1]], [[-1, 0, 1]], [[-3, 3]], [[-5, 3]], [[-42, -41, -40, -39, -38, -37, -36, -35, -34, -33, -32, -31, -30, -29, -28, -27, -26, -25, -24, -23, -22, -21, -20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42]]], "outputs": [[1], [3], [5], [0], [7], [2], [-1], [-1], [3], [-5], [-1]]}
user: Write a function `getDrinkByProfession`/`get_drink_by_profession()` that receives as input parameter a string, and produces outputs according to the following table:




Input
Output


"Jabroni"
"Patron Tequila"


"School Counselor"
"Anything with Alcohol"


 "Programmer"
 "Hipster Craft Beer"


 "Bike Gang Member"
"Moonshine" 


 "Politician"
"Your tax dollars" 


 "Rapper"
"Cristal" 


 *anything else* 
"Beer" 





Note: *anything else* is the default case: if the input to the function is not any of the values in the table, then the return value should be "Beer."

Make sure you cover the cases where certain words do not show up with correct capitalization. For example, getDrinkByProfession("pOLitiCIaN") should still return "Your tax dollars".

Answer: {"fn_name": "get_drink_by_profession", "inputs": [["jabrOni"], ["scHOOl counselor"], ["prOgramMer"], ["bike ganG member"], ["poLiTiCian"], ["rapper"], ["pundit"], ["Pug"], ["jabrOnI"], ["scHOOl COUnselor"], ["prOgramMeR"], ["bike GanG member"], ["poLiTiCiAN"], ["RAPPer"], ["punDIT"], ["pUg"]], "outputs": [["Patron Tequila"], ["Anything with Alcohol"], ["Hipster Craft Beer"], ["Moonshine"], ["Your tax dollars"], ["Cristal"], ["Beer"], ["Beer"], ["Patron Tequila"], ["Anything with Alcohol"], ["Hipster Craft Beer"], ["Moonshine"], ["Your tax dollars"], ["Cristal"], ["Beer"], ["Beer"]]}
user: # Your Task
You have a cuboid with dimensions x,y,z ∈ ℕ. A subcuboid of this cuboid has dimensions length, width, height ∈ ℕ where 1≤length≤x, 1≤width≤y, 1≤height≤z. If two subcuboids have the same length, width, and height, but they are at different positions within the cuboid, they are distinct. Find the total number of subcuboids for the given cuboid.
# Examples
See sample tests and the image below
### 27 subcuboids for a 2×2×2 cuboid
![subcuboids(2,2,2)](https://i.imgur.com/3CnboOW.jpg)

Answer: {"fn_name": "subcuboids", "inputs": [[1, 1, 1], [2, 2, 2], [2, 3, 3], [4, 5, 6], [3, 7, 11]], "outputs": [[1], [27], [108], [3150], [11088]]}
user: Coffee Vending Machine Problems [Part 1]

You have a vending machine, but it can not give the change back. You decide to implement this functionality. First of all, you need to know the minimum number of coins for this operation (i'm sure you don't want to return 100 pennys instead of 1$ coin).
So, find an optimal number of coins required, if you have unlimited set of coins with given denominations.

Assume all inputs are valid positive integers, and every set of coin denominations has len 4 for simplicity;

Examples:

optimal_number_of_coins(1, [1, 2, 5, 10]) 
(1 penny) so returns 1  
optimal_number_of_coins(5, [1, 2, 5, 10])
(5) so returns 1
optimal_number_of_coins(6, [1, 3, 5, 10])
(3+3 or 5+1) = 6 so returns 2
optimal_number_of_coins(10, [1, 2, 5, 10]) 
(10) so returns 1
optimal_number_of_coins(12, [1, 3, 5, 10])
(10+1+1) = 12 so returns 3
optimal_number_of_coins(53, [1, 2, 5, 25])
(25+25+2+1) = 53 so returns 4
optimal_number_of_coins(7, [1, 1, 1, 25])
(1+1+1+1+1+1+1) = 7 so returns 7
etc..

Have fun =)

Answer: {"fn_name": "optimal_number_of_coins", "inputs": [[1, [1, 2, 5, 10]], [5, [1, 2, 5, 10]], [6, [1, 3, 5, 10]], [10, [1, 2, 5, 10]], [12, [1, 3, 5, 10]], [53, [1, 2, 5, 25]], [7, [1, 1, 1, 25]], [76, [1, 3, 4, 10]], [33, [1, 6, 9, 10]], [63, [1, 2, 9, 10]], [239, [1, 2, 3, 10]], [333, [1, 1, 5, 25]], [543, [1, 3, 5, 25]], [777, [1, 2, 3, 10]], [18, [1, 3, 9, 10]], [16, [1, 8, 9, 10]], [14, [1, 3, 7, 9]]], "outputs": [[1], [1], [2], [1], [3], [4], [7], [9], [4], [7], [26], [17], [25], [80], [2], [2], [2]]}
user: In this kata you need to create a function that takes a 2D array/list of non-negative integer pairs and returns the sum of all the "saving" that you can have getting the [LCM](https://en.wikipedia.org/wiki/Least_common_multiple) of each couple of number compared to their simple product.

For example, if you are given:
```
[[15,18], [4,5], [12,60]]
```
Their product would be:
```
[270, 20, 720]
```
While their respective LCM would be:
```
[90, 20, 60]
```
Thus the result should be:
```
(270-90)+(20-20)+(720-60)==840
```
This is a kata that I made, among other things, to let some of my trainees familiarize with the [euclidean algorithm](https://en.wikipedia.org/wiki/Euclidean_algorithm), a really neat tool to have on your belt ;)

Answer: {"fn_name": "sum_differences_between_products_and_LCMs", "inputs": [[[[15, 18], [4, 5], [12, 60]]], [[[1, 1], [0, 0], [13, 91]]], [[[15, 7], [4, 5], [19, 60]]], [[[20, 50], [10, 10], [50, 20]]], [[]]], "outputs": [[840], [1092], [0], [1890], [0]]}
user: You are given an array of non-negative integers, your task is to complete the series from 0 to the highest number in the array.

If the numbers in the sequence provided are not in order you should order them, but if a value repeats, then you must return a sequence with only one item, and the value of that item must be 0. like this:
```
inputs        outputs
[2,1]     ->  [0,1,2]
[1,4,4,6] ->  [0]
```
Notes: all numbers are positive integers.

This is set of example outputs based on the input sequence.
```
inputs        outputs
[0,1]   ->    [0,1]
[1,4,6] ->    [0,1,2,3,4,5,6]
[3,4,5] ->    [0,1,2,3,4,5]
[0,1,0] ->    [0]
```

Answer: {"fn_name": "complete_series", "inputs": [[[0, 1]], [[1, 4, 6]], [[3, 4, 5]], [[2, 1]], [[1, 4, 4, 6]]], "outputs": [[[0, 1]], [[0, 1, 2, 3, 4, 5, 6]], [[0, 1, 2, 3, 4, 5]], [[0, 1, 2]], [[0]]]}
user: Complete the function which takes two arguments and returns all numbers which are divisible by the given divisor. First argument is an array of `numbers` and the second is the `divisor`.

## Example

```python
divisible_by([1, 2, 3, 4, 5, 6], 2) == [2, 4, 6]
```

Answer: {"fn_name": "divisible_by", "inputs": [[[1, 2, 3, 4, 5, 6], 2], [[1, 2, 3, 4, 5, 6], 3], [[0, 1, 2, 3, 4, 5, 6], 4], [[0], 4], [[1, 3, 5], 2], [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 1]], "outputs": [[[2, 4, 6]], [[3, 6]], [[0, 4]], [[0]], [[]], [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]]}
user: Given a string, swap the case for each of the letters.

e.g. CodEwArs --> cODeWaRS

### Examples

```
""           ->   ""
"CodeWars"   ->   "cODEwARS"
"abc"        ->   "ABC"
"ABC"        ->   "abc"
"123235"     ->   "123235"
```

Answer: {"fn_name": "swap", "inputs": [["HelloWorld"], ["CodeWars"], ["ThIs iS A l0NG sENTence witH nUMbERs in IT 123 456"], [""], [" "], ["  "], [" 1a1 "], ["H_E_l-l_0 WO|||Rld"], ["TeSt"], ["EeEEeeEEEeee"]], "outputs": [["hELLOwORLD"], ["cODEwARS"], ["tHiS Is a L0ng SentENCE WITh NumBerS IN it 123 456"], [""], [" "], ["  "], [" 1A1 "], ["h_e_L-L_0 wo|||rLD"], ["tEsT"], ["eEeeEEeeeEEE"]]}
user: Create a function that returns the sum of the two lowest positive numbers given an array of minimum 4 positive integers. No floats or non-positive integers will be passed.

For example, when an array is passed like `[19, 5, 42, 2, 77]`, the output should be `7`.

`[10, 343445353, 3453445, 3453545353453]` should return `3453455`.

Answer: {"fn_name": "sum_two_smallest_numbers", "inputs": [[[5, 8, 12, 18, 22]], [[7, 15, 12, 18, 22]], [[25, 42, 12, 18, 22]], [[1, 8, 12, 18, 5]], [[13, 12, 5, 61, 22]]], "outputs": [[13], [19], [30], [6], [17]]}
user: We have 3 equations with 3 unknowns x, y, and z and we are to solve for these unknowns.
Equations 4x -3y +z = -10, 2x +y +3z = 0, and -x +2y -5z = 17 will be passed in as an array of [[4, -3, 1, -10], [2, 1, 3, 0], [-1, 2, -5, 17]] and the result should be returned as an array like [1, 4, -2] (i.e. [x, y, z]).

Note: In C++ do not use new or malloc to allocate memory for the returned variable as allocated memory will not be freed in the Test Cases. Setting the variable as static will do.

Answer: {"fn_name": "solve_eq", "inputs": [[[[4, -3, 1, -10], [2, 1, 3, 0], [-1, 2, -5, 17]]], [[[2, 1, 3, 10], [-3, -2, 7, 5], [3, 3, -4, 7]]], [[[3, 2, 0, 7], [-4, 0, 3, -6], [0, -2, -6, -10]]], [[[4, 2, -5, -21], [2, -2, 1, 7], [4, 3, -1, -1]]]], "outputs": [[[1, 4, -2]], [[-1, 6, 2]], [[3, -1, 2]], [[1, 0, 5]]]}
user: Given a string of words and numbers. Extract the expression including: 
1. the operator: either addition or subtraction
2. the two numbers that we are operating on

Return the result of the calculation.

Example:

"Panda has 48 apples and loses 4" returns 44

"Jerry has 34 apples and gains 6" returns 40

"loses" and "gains" are the only two words describing operators.

Should be a nice little kata for you :)

Note:
No fruit debts nor bitten apples = The numbers are integers and no negatives

Answer: {"fn_name": "calculate", "inputs": [["Panda has 48 apples and loses 4"], ["Jerry has 34 apples and gains 6"], ["Tom has 20 apples and gains 15"], ["Fred has 110 bananas and loses 50"], ["Pippi has 20 tunas and gains 0"]], "outputs": [[44], [40], [35], [60], [20]]}
user: Define two functions: `hex_to_bin` and `bin_to_hex` (or `hexToBin` and `binToHex`)


# hex_to_bin

Takes a hexadecimal string as an argument .

**Note:** This string can contain upper or lower case characters and start with any amount of zeros.

Returns the binary representation (without leading zeros) of the numerical value of the hexadecimal string.

Examples:

```
"00F"    -->  "1111"
"5"      -->  "101"
"00000"  -->  "0"
"04D2"   -->  "10011010010"
```

# bin_to_hex

Takes a binary string (with or without leading zeros) as an argument .

Returns the hexadecimal representation of the numerical value of the binary string.

**Note:** Any non-numerical characters should be lower case


Examples:

```
"1111"         -->  "f"
"000101"       -->  "5"
"10011010010"  -->  "4d2"
```

**Note:** You can assume all arguments are valid so there is no need for error checking.

Oh, and I've disabled a few things.


Any feedback would be much appreciated

Answer: {"fn_name": "bin_to_hex", "inputs": [["000101"], ["001111"], ["000"], ["10011010010"]], "outputs": [["5"], ["f"], ["0"], ["4d2"]]}
user: You are going to be given a word. Your job is to return the middle character of the word. If the word's length is odd, return the middle character. If the word's length is even, return the middle 2 characters.

#Examples:
~~~if-not:bf
```
Kata.getMiddle("test") should return "es"

Kata.getMiddle("testing") should return "t"

Kata.getMiddle("middle") should return "dd"

Kata.getMiddle("A") should return "A"

```
~~~
~~~if:bf
```
runBF("test\0") should return "es"

runBF("testing\0") should return "t"

runBF("middle\0") should return "dd"

runBF("A\0") should return "A"

```
~~~

#Input

A word (string) of length `0 < str < 1000` (In javascript you may get slightly more than 1000 in some test cases due to an error in the test cases). You do not need to test for this. This is only here to tell you that you do not need to worry about your solution timing out.


#Output

The middle character(s) of the word represented as a string.

Answer: {"fn_name": "get_middle", "inputs": [["test"], ["testing"], ["middle"], ["A"], ["of"]], "outputs": [["es"], ["t"], ["dd"], ["A"], ["of"]]}
user: Laura Bassi was the first female professor at a European university.  
Despite her immense intellect, she was not always allowed to lecture publicly.

One day a professor with very strong beliefs against women in academia sent some `agents` to find Bassi and end her career.

Help her escape by telling her the safest places in town!

Task

```if:python,javascript
Implement the function `advice(agents, n)` where
```
```if:haskell
Implement the function `advice agents n :: [(Int,Int)] -> Int -> [(Int,Int)]` where
```
```if:swift
Implement the function `advice(agents: [[Int]], n: Int) -> [[Int]]` where
```

- `agents` is an array of agent coordinates.
- `n` defines the size of the city that Bassi needs to hide in, in other words the side length of the square grid. 

The function should return a list of coordinates that are the furthest away (by Manhattan distance) from all agents.

As an example, say you have a 6x6 map, and agents at locations

```python
[(0, 0), (1, 5), (5, 1)]
```

The distances to the nearest agent look like this.



The safest spaces are the ones with distance `4`, marked in bright red. So the function should return

```python
[(2, 2), (3, 3), (4, 4), (5, 5)]
```

in any order.

Edge cases:
- If there is an agent on every grid cell, there is no safe space, so return an empty list.
- If there are no agents, then every cell is a safe spaces, so return all coordinates.
- if `n` is `0`, return an empty list.
- If agent coordinates are outside of the map, they are simply not considered.
- There are no duplicate agents on the same square.

Performance

All reference solutions run in around 6 seconds.
You might not pass the tests if you use a brute-force solution.

```if-not:swift,javascript
There are `200` random tests with `n <= 50`. Inefficient solutions might time out.
```
```if:javascript
There are `300` random tests with `n <= 70`. Inefficient solutions might time out.
```
```if:swift
There are `200` random tests with `n <= 70`. Inefficient solutions might time out.
```

This kata is inspired by ThoughtWorks' coding challenge

Answer: {"fn_name": "advice", "inputs": [[[[1, 1]], 2], [[[1, 1]], 0], [[[9, 9]], 1], [[[0, 0]], 10]], "outputs": [[[[0, 0]]], [[]], [[[0, 0]]], [[[9, 9]]]]}
user: Given a natural number n, we want to know in how many ways we may express these numbers as product of other numbers.

For example the number
```python
 18 = 2 x 9 = 3 x 6 = 2 x 3 x 3 # (we do not consider the product 18 x 1), (3 ways) 
```

See this example a bit more complicated,
```python
60 = 2 x 30 = 3 x 20 =  4 x 15 = 5 x 12 = 6 x 10 = 2 x 2 x 15 = 2 x 3 x 10 = 2 x 5 x 6 =  3 x 4 x 5 = 2 x 2 x 3 x 5 (10 ways)
```
We need the function ```prod_int_part()```, that receives a number n, and ouputs the amount of total different products with all the products of max length sorted in this way:

1) each product will be expressed in a list of its factors in incresing order from left to right

2) if there is more than one list-product, these lists should be ordered by the value of the first term, if two lists have the same term equal thay should be ordered by the value of the second term.

Let's see some cases:
```python
prod_int_part(18) == [3, [2, 3, 3]]

prod_int_part(60) == [10, [2, 2, 3, 5]
```

If we have only one list-product with the maximum length, there is no use to have it with two nested braces, so the result will be like this case:
```python
prod_int_part(54) == [6, [2, 3, 3, 3]]
```

Now, let's see examples when ```n``` cannot be partitioned:
```python
prod_int_part(37) == [0, []]

prod_int_part(61) == [0, []]
```
Enjoy it!!

Answer: {"fn_name": "prod_int_part", "inputs": [[18], [60], [54], [37], [61]], "outputs": [[[3, [2, 3, 3]]], [[10, [2, 2, 3, 5]]], [[6, [2, 3, 3, 3]]], [[0, []]], [[0, []]]]}
user: You have to build a pyramid.

This pyramid should be built from characters from a given string.

You have to create the code for these four methods:
```python
watch_pyramid_from_the_side(characters):

watch_pyramid_from_above(characters):

count_visible_characters_of_the_pyramid(characters):

count_all_characters_of_the_pyramid(characters):
```

The first method ("FromTheSide") shows the pyramid as you would see from the side.
The second method ("FromAbove") shows the pyramid as you would see from above.
The third method ("CountVisibleCharacters") should return the count of all characters, that are visible from outside the pyramid.
The forth method ("CountAllCharacters") should count all characters of the pyramid. Consider that the pyramid is completely solid and has no holes or rooms in it.

Every character will be used for building one layer of the pyramid. So the length of the given string will be the height of the pyramid. Every layer will be built with stones from the given character. There is no limit of stones.
The pyramid should have perfect angles of 45 degrees.

Example: Given string: "abc"

Pyramid from the side:
```
  c
 bbb
aaaaa
```
Pyramid from above:
```
aaaaa
abbba
abcba
abbba
aaaaa
```
Count of visible stones/characters: 
```
25
```
Count of all used stones/characters:
```
35
```

There is no meaning in the order or the choice of the characters. It should work the same for example "aaaaa" or "54321".

Hint: Your output for the side must always be a rectangle! So spaces at the end of a line must not be deleted or trimmed!

If the string is null or empty, you should exactly return this value for the watch-methods and -1 for the count-methods.

Have fun coding it and please don't forget to vote and rank this kata! :-) 

I have created other katas. Have a look if you like coding and challenges.

Answer: {"fn_name": "watch_pyramid_from_the_side", "inputs": [[null], [""]], "outputs": [[null], [""]]}
user: Your task is to write function which takes string and list of delimiters as an input and returns list of strings/characters after splitting given string.

Example:
```python
multiple_split('Hi, how are you?', [' ']) => ['Hi,', 'how', 'are', 'you?']
multiple_split('1+2-3', ['+', '-']) => ['1', '2', '3']
```

List of delimiters is optional and can be empty, so take that into account.

Important note: Result cannot contain empty string.

Answer: {"fn_name": "multiple_split", "inputs": [["Hi everybody!", [" ", "!"]], ["(1+2)*6-3^9", ["+", "-", "(", ")", "^", "*"]], ["Solve_this|kata-very\\quickly!", ["!", "|", "\\", "_", "-"]], ["", []], [""], ["some strange string"], ["1_2_3_huhuh_hahaha", ["_"]], ["((1+2))*(6-3)^9", ["+", "-", "(", ")", "^", "*"]], ["(((1+2)-(3)))", ["(", ")"]]], "outputs": [[["Hi", "everybody"]], [["1", "2", "6", "3", "9"]], [["Solve", "this", "kata", "very", "quickly"]], [[]], [[]], [["some strange string"]], [["1", "2", "3", "huhuh", "hahaha"]], [["1", "2", "6", "3", "9"]], [["1+2", "-", "3"]]]}
user: # Task
 Given an array of 2^(k) integers (for some integer `k`), perform the following operations until the array contains only one element:
```
On the 1st, 3rd, 5th, etc. 
iterations (1-based) replace each pair of consecutive elements with their sum;
On the 2nd, 4th, 6th, etc. 
iterations replace each pair of consecutive elements with their product.
```
After the algorithm has finished, there will be a single element left in the array. Return that element.

# Example

 For inputArray = [1, 2, 3, 4, 5, 6, 7, 8], the output should be 186.

 We have `[1, 2, 3, 4, 5, 6, 7, 8] -> [3, 7, 11, 15] -> [21, 165] -> [186]`, so the answer is 186.

# Input/Output

 - `[input]` integer array `arr`

   Constraints: 2^(1) ≤ arr.length ≤ 2^(5), -9 ≤ arr[i] ≤ 99.

 - `[output]` an integer

Answer: {"fn_name": "array_conversion", "inputs": [[[1, 2, 3, 4, 5, 6, 7, 8]], [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], [[3, 3, 5, 5]]], "outputs": [[186], [64], [60]]}
user: Write a function that calculates the original product price, without VAT.

## Example
If a product price is `200.00` and VAT is `15%`, then the final product price (with VAT) is: `200.00 + 15% = 230.00`

Thus, if your function receives `230.00` as input, it should return `200.00`

**Notes:** 

* VAT is *always* `15%` for the purposes of this Kata.
* Round the result to 2 decimal places.
* If `null` value given then return `-1`

Answer: {"fn_name": "excluding_vat_price", "inputs": [[230.0], [123], [777], [460.0], [null]], "outputs": [[200.0], [106.96], [675.65], [400.0], [-1]]}