meetforever/GRPO_CL huggingface dataset:
user: An acrostic is a text in which the first letter of each line spells out a word. It is also a quick and cheap way of writing a poem for somebody, as exemplified below :



Write a program that reads an acrostic to identify the "hidden" word. Specifically, your program will receive a list of words (reprensenting an acrostic) and will need to return a string corresponding to the word that is spelled out by taking the first letter of each word in the acrostic.

Answer: {"fn_name": "read_out", "inputs": [[["Jolly", "Amazing", "Courteous", "Keen"]], [["Marvelous", "Excellent", "Gifted"]]], "outputs": [["JACK"], ["MEG"]]}
user: Your task is to define a function that understands basic mathematical expressions and solves them.
For example:

```python
calculate("1 + 1")        # => 2
calculate("18 + 4*6")     # => 42
calculate("245 - 826")    # => -581
calculate("09 + 000482")  # => 491
calculate("8 / 4 + 6")    # => 8
calculate("5 + 1 / 5")    # => 5.2
calculate("1+2+3")        # => 6
calculate("9 /3 + 12/ 6") # => 5
```
Notes:

- Input string will contain numbers (may be integers and floats) and arithmetic operations.
- Input string may contain spaces, and all space characters should be ignored.
- Operations that will be used: addition (+), subtraction (-), multiplication (*), and division (/)
- Operations must be done in the order of operations: First multiplication and division, then addition and subtraction.
- In this kata, input expression will not have negative numbers. (ex: "-4 + 5")
- If output is an integer, return as integer. Else return as float.
- If input string is empty, contains letters, has a wrong syntax, contains division by zero or is not a string, return False.

Answer: {"fn_name": "calculate", "inputs": [["1 + 1"], ["9 - 4"], ["1 - 4"], ["3 * 4"], ["9 / 3"], ["26 + 73"], ["524 + 277"], ["1 / 2"], ["2 / 5"], ["1 + 2 + 3 + 4 + 5 + 6"], ["123 - 3 - 20 - 100"], ["123 * 987 * 135 * 246"], ["200 / 2 / 10 / 5"], ["1+2-3+4-5+6-7+8-9+10"], ["5*2/3*9/10*123/8"], ["1*2*3/1/2/3+1+2+3-1-2-3"], ["1+2 * 4"], ["1+2 / 4"], ["1-2 * 4"], ["1-2 / 4"], ["1+2-3*4/6"], [""], ["7 - A"], ["3 + 2 *  "], ["  / 7 + 3"], [5], ["1 / 0"]], "outputs": [[2], [5], [-3], [12], [3], [99], [801], [0.5], [0.4], [21], [0], [4031727210], [2], [7], [46.125], [1], [9], [1.5], [-7], [0.5], [1], [false], [false], [false], [false], [false], [false]]}
user: # Task
 Your task is to find the smallest number which is evenly divided by all numbers between `m` and `n` (both inclusive).

# Example

 For `m = 1, n = 2`, the output should be `2`.
 
 For `m = 2, n = 3`, the output should be `6`.
 
 For `m = 3, n = 2`, the output should be `6` too.
 
 For `m = 1, n = 10`, the output should be `2520`.

# Input/Output


 - `[input]` integer `m`

  `1 ≤ m ≤ 25`


 - `[input]` integer `n`

  `1 ≤ n ≤ 25`


 - `[output]` an integer

Answer: {"fn_name": "mn_lcm", "inputs": [[1, 2], [1, 5], [5, 1], [1, 10], [2, 3], [3, 5], [10, 20], [1, 25], [24, 25]], "outputs": [[2], [60], [60], [2520], [6], [60], [232792560], [26771144400], [600]]}
user: # Task
 Alireza and Ali have a `3×3 table` and playing on that. they have 4 table(2×2) A,B,C and D in this table.
 
 At beginning all of 9 numbers in 3×3 table is zero.
 
 Alireza in each move choose a 2×2 table from A, B, C and D and increase all of 4 numbers in that by one.
 
 He asks Ali, how much he increase table A, B, C and D. (if he cheats you should return `[-1]`)
 
 Your task is to help Ali.

# Example

 For 
 ```
 table=
[[1,2,1],
[2,4,2],
[1,2,1]]```
The result should be `[1,1,1,1]`

 For:
 ```
Table=
[[3,7,4],
[5,16,11],
[2,9,7]]```
The result should be `[3,4,2,7]`

# Input/Output


 - `[input]` 2D integer array `table`

 `3×3` table.


 - `[output]` an integer array

Answer: {"fn_name": "table_game", "inputs": [[[[1, 2, 1], [2, 4, 2], [1, 2, 1]]], [[[3, 7, 4], [5, 16, 11], [2, 9, 7]]], [[[1, 4, 2], [5, 10, 5], [4, 7, 3]]], [[[2, 4, 2], [4, 6, 4], [2, 4, 2]]], [[[1, 2, 1], [1, 2, 1], [1, 2, 1]]], [[[2, 4, 2], [4, 8, 4], [2, 4, 2]]], [[[1, 3, 2], [5, 10, 5], [4, 7, 3]]]], "outputs": [[[1, 1, 1, 1]], [[3, 4, 2, 7]], [[-1]], [[-1]], [[-1]], [[2, 2, 2, 2]], [[1, 2, 4, 3]]]}
user: How much bigger is a 16-inch pizza compared to an 8-inch pizza? A more pragmatic question is: How many 8-inch pizzas "fit" in a 16-incher?

The answer, as it turns out, is exactly four 8-inch pizzas. For sizes that don't correspond to a round number of 8-inchers, you must round the number of slices (one 8-inch pizza = 8 slices), e.g.:

```python
how_many_pizzas(16) -> "pizzas: 4, slices: 0"
how_many_pizzas(12) -> "pizzas: 2, slices: 2"
how_many_pizzas(8) -> "pizzas: 1, slices: 0"
how_many_pizzas(6) -> "pizzas: 0, slices: 4"
how_many_pizzas(0) -> "pizzas: 0, slices: 0"
```
Get coding quick, so you can choose the ideal size for your next meal!

Answer: {"fn_name": "how_many_pizzas", "inputs": [[16], [12], [8], [6], [0]], "outputs": [["pizzas: 4, slices: 0"], ["pizzas: 2, slices: 2"], ["pizzas: 1, slices: 0"], ["pizzas: 0, slices: 4"], ["pizzas: 0, slices: 0"]]}
user: In this Kata, you will be given a string with brackets and an index of an opening bracket and your task will be to return the index of the matching closing bracket.  Both the input and returned index are 0-based **except in Fortran where it is 1-based**. An opening brace will always have a closing brace. Return `-1` if there is no answer (in Haskell, return `Nothing`; in Fortran, return `0`; in Go, return an error)

### Examples

```python
solve("((1)23(45))(aB)", 0) = 10 -- the opening brace at index 0 matches the closing brace at index 10
solve("((1)23(45))(aB)", 1) = 3 
solve("((1)23(45))(aB)", 2) = -1 -- there is no opening bracket at index 2, so return -1
solve("((1)23(45))(aB)", 6) = 9
solve("((1)23(45))(aB)", 11) = 14
solve("((>)|?(*'))(yZ)", 11) = 14
```

Input will consist of letters, numbers and special characters, but no spaces. The only brackets will be `(` and `)`. 

More examples in the test cases. 

Good luck!

~~~if:fortran
*NOTE: In Fortran, you may assume that the input string will not contain any leading/trailing whitespace.*
~~~

Answer: {"fn_name": "solve", "inputs": [["((1)23(45))(aB)", 0], ["((1)23(45))(aB)", 1], ["((1)23(45))(aB)", 2], ["((1)23(45))(aB)", 6], ["((1)23(45))(aB)", 11], ["(g(At)IO(f)(tM(qk)YF(n)Nr(E)))", 11], ["(g(At)IO(f)(tM(qk)YF(n)Nr(E)))", 0], ["(>_(va)`?(h)C(as)(x(hD)P|(fg)))", 19]], "outputs": [[10], [3], [-1], [9], [14], [28], [29], [22]]}
user: Given a number `n`, make a down arrow shaped pattern.

For example, when `n = 5`, the output would be:

    123454321
     1234321
      12321
       121
        1

and for `n = 11`, it would be:

    123456789010987654321
     1234567890987654321
      12345678987654321
       123456787654321
        1234567654321
         12345654321
          123454321
           1234321
            12321
             121
              1
              
An important thing to note in the above example is that the numbers greater than 9 still stay single digit, like after 9 it would be 0 - 9 again instead of 10 - 19.

Note: There are spaces for the indentation on the left of each line and no spaces on the right.
                
Have fun!

Answer: {"fn_name": "get_a_down_arrow_of", "inputs": [[5]], "outputs": [["123454321\n 1234321\n  12321\n   121\n    1"]]}
user: Description:

The mean (or average) is the most popular measure of central tendency; however it does not behave very well when the data is skewed (i.e. wages distribution). In such cases, it's better to use the median.

Your task for this kata is to find the median of an array consisting of n elements.

You can assume that all inputs are arrays of numbers in integer format. For the empty array your code should return `NaN` (false in JavaScript/`NULL` in PHP/`nil` in Ruby).

Examples:

Input `[1, 2, 3, 4]` --> Median `2.5`

Input `[3, 4, 1, 2, 5]` --> Median `3`

Answer: {"fn_name": "median", "inputs": [[[1, 2, 3, 4]], [[3, 4, 1, 2, 5]], [[10, 29, 23, 94, 76, 96, 5, 85, 4, 33, 47, 41, 87]], [[1]], [[1, -1]]], "outputs": [[2.5], [3], [41], [1], [0]]}
user: In this simple assignment you are given a number and have to make it negative. But maybe the number is already negative?

**Example:**
``` c
makeNegative(1); // return -1
makeNegative(-5); // return -5
makeNegative(0); // return 0
```
``` cfml
makeNegative(1); // return -1
makeNegative(-5); // return -5
makeNegative(0); // return 0
```
``` csharp
Kata.MakeNegative(1); // return -1
Kata.MakeNegative(-5); // return -5
Kata.MakeNegative(0); // return 0
```
``` java
Kata.makeNegative(1); // return -1
Kata.makeNegative(-5); // return -5
Kata.makeNegative(0); // return 0
```
``` python
make_negative(1);  # return -1
make_negative(-5); # return -5
make_negative(0);  # return 0
```
``` javascript
makeNegative(1); // return -1
makeNegative(-5); // return -5
makeNegative(0); // return 0
makeNegative(0.12); // return -0.12
```
``` typescript
makeNegative(1); // return -1
makeNegative(-5); // return -5
makeNegative(0); // return 0
```
``` cpp
makeNegative(1); // return -1
makeNegative(-5); // return -5
makeNegative(0); // return 0
```
``` haskell
makeNegative    1 -- return -1
makeNegative (-5) -- return -5
makeNegative    0 -- return 0
makeNegative 0.12 -- return -0.12
```
``` ruby
makeNegative(1); # return -1
makeNegative(-5); # return -5
makeNegative(0); # return 0
```
``` coffeescript
makeNegative 1    # return -1
makeNegative -5   # return -5
makeNegative 0    # return 0
```
``` elixir
make_negative 1    # return -1
make_negative -5   # return -5
make_negative 0    # return 0
```
``` go
MakeNegative(1)    # return -1
MakeNegative(-5)   # return -5
MakeNegative(0)    # return 0
```
``` julia
Kata.makeNegative(1)  # return -1
Kata.makeNegative(-5) # return -5
Kata.makeNegative(0)  # return 0
```
``` kotlin
Kata().makeNegative(1)  // return -1
Kata().makeNegative(-5) // return -5
Kata().makeNegative(0)  // return 0
```
``` asm
make_negative(1);    // return -1
make_negative(-5);   // return -5
make_negative(0);    // return 0
```
``` groovy
Kata.makeNegative(1)    // return -1
Kata.makeNegative(-5)   // return -5
Kata.makeNegative(0)    // return 0
```
``` php
makeNegative(1)    // return -1
makeNegative(-5)   // return -5
makeNegative(0)    // return 0
makeNegative(0.12) // return -0.12
```
```racket
(make-negative 1)    ; -1
(make-negative -5)   ; -5
(make-negative 0)    ; 0
(make-negative 0.12) ; -0.12
```

**Notes:**

- The number can be negative already, in which case no change is required.
- Zero (0) is not checked for any specific sign. Negative zeros make no mathematical sense.

Answer: {"fn_name": "make_negative", "inputs": [[42], [-9], [0], [1], [-1]], "outputs": [[-42], [-9], [0], [-1], [-1]]}
user: Much cooler than your run-of-the-mill Fibonacci numbers, the Triple Shiftian are so defined: `T[n] = 4 * T[n-1] - 5 * T[n-2] + 3 * T[n-3]`.

You are asked to create a function which accept a base with the first 3 numbers and then returns the nth element.
```python
triple_shiftian([1,1,1],25) == 1219856746
triple_shiftian([1,2,3],25) == 2052198929
triple_shiftian([6,7,2],25) == -2575238999
triple_shiftian([3,2,1],35) == 23471258855679
triple_shiftian([1,9,2],2) ==  2
```
*Note: this is meant to be an interview quiz, so the description is scarce in detail on purpose*

Special thanks to the [first person I met in person here in London just because of CW](http://www.codewars.com/users/webtechalex) and that assisted me during the creation of this kata ;)

Answer: {"fn_name": "triple_shiftian", "inputs": [[[1, 1, 1], 25], [[1, 2, 3], 25], [[3, 2, 1], 25], [[6, 7, 2], 25], [[1, 1, 1], 35], [[1, 2, 3], 35], [[3, 2, 1], 35], [[6, 7, 2], 35], [[3, 2, 1], 0], [[6, 7, 2], 2]], "outputs": [[1219856746], [2052198929], [2827228055], [-2575238999], [10127083068293], [17037073417493], [23471258855679], [-21379280887590], [3], [2]]}
user: # Task
 You are given a string `s`. Let's call its substring a group, if all letters in it are adjacent and the same(such as `"aa","bbb","cccc"`..). Let's call the substiring with 2 or more adjacent group a big group(such as `"aabb","bbccc"`...).
 
 Your task is to count the number of `big groups` in the given string.

# Example

 For `s = "ccccoodeffffiiighhhhhhhhhhttttttts"`, the result should be `3`.
 ```
The groups are "cccc", "oo", "ffff", "iii", "hhhhhhhhhh", "ttttttt"
The big groups are "ccccoo", "ffffiii", "hhhhhhhhhhttttttt", 
3 substrings altogether.```

 For `s = "gztxxxxxggggggggggggsssssssbbbbbeeeeeeehhhmmmmmmmitttttttlllllhkppppp"`, the result should be `2`.
 ```
The big groups are :
"xxxxxggggggggggggsssssssbbbbbeeeeeeehhhmmmmmmm"
and 
"tttttttlllll" ```

 For `s = "soooooldieeeeeer"`, the result should be `0`.
 
 There is no `big group` exist.
 
# Input/Output


 - `[input]` string `s`

  A string of lowercase Latin letters.


 - `[output]` an integer

  The number of big groups.

Answer: {"fn_name": "repeat_adjacent", "inputs": [["ccccoodeffffiiighhhhhhhhhhttttttts"], ["soooooldieeeeeer"], ["ccccoooooooooooooooooooooooddee"], ["wwwwaaaarrioooorrrrr"], ["gztxxxxxggggggggggggsssssssbbbbbeeeeeeehhhmmmmmmmitttttttlllllhkppppp"]], "outputs": [[3], [0], [1], [2], [2]]}
user: Make a function **"add"** that will be able to sum elements of **list** continuously and return a new list of sums.

For example: 

```
add [1,2,3,4,5] == [1, 3, 6, 10, 15], because it's calculated like 
this : [1, 1 + 2, 1 + 2 + 3, 1 + 2 + 3 + 4, 1 + 2 + 3 + 4 + 5]
```

If you want to learn more see https://en.wikipedia.org/wiki/Prefix_sum

Answer: {"fn_name": "add", "inputs": [[[5, 10, 15, 20, 25, 30, 35, 40]], [[6, 12, 18, 24, 30, 36, 42]], [[7, 14, 21, 28, 35, 42, 49, 56]], [[8, 16, 24, 32, 40, 48, 56, 64]], [[9, 18, 27, 36, 45, 54]]], "outputs": [[[5, 15, 30, 50, 75, 105, 140, 180]], [[6, 18, 36, 60, 90, 126, 168]], [[7, 21, 42, 70, 105, 147, 196, 252]], [[8, 24, 48, 80, 120, 168, 224, 288]], [[9, 27, 54, 90, 135, 189]]]}
user: A nested list (or *array* in JavaScript) is a list that apears as a value inside another list, 
```python
[item, item, [item, item], item]
```
in the above list, [item, item] is a nested list.  
  
Your goal is to write a function that determines the depth of the deepest nested list within a given list.  
return 1 if there are no nested lists.
The list passed to your function can contain any data types.  
  
A few examples:

```python
list_depth([True])
return 1

list_depth([])
return 1

list_depth([2, "yes", [True, False]])
return 2

list_depth([1, [2, [3, [4, [5, [6], 5], 4], 3], 2], 1])
return 6

list_depth([2.0, [2, 0], 3.7, [3, 7], 6.7, [6, 7]])
return 2
```

Answer: {"fn_name": "list_depth", "inputs": [[[1, [2, [3, [4, [5, [6], 5], 4], 3], 2], 1]], [[true]], [[]], [[2, "yes", [true, false]]], [[2.0, [2, 0], 3.7, [3, 7], 6.7, [6, 7]]], [[[[[]]], [[[]]]]], [[true, false, true, [false], true]], [[[], [], [[], []]]], [[77]], [[2, "yes", [true, [false]]]], [[77, [77]]], [[[77], 77, [[77]]]]], "outputs": [[6], [1], [1], [2], [2], [4], [2], [3], [1], [3], [2], [3]]}
user: In this exercise, you will have to create a function named tiyFizzBuzz. This function will take on a string parameter and will return that string with some characters replaced, depending on the value:

- If a letter is a upper case consonants, replace that character with "Iron".
- If a letter is a lower case consonants or a non-alpha character, do nothing to that character
- If a letter is a upper case vowel, replace that character with "Iron Yard".
- If a letter is a lower case vowel, replace that character with "Yard".

Ready?

Answer: {"fn_name": "tiy_fizz_buzz", "inputs": [[" "], ["H"], ["b"], ["A"], ["a"], ["Hello WORLD!"], ["H6H4Na ./?U"]], "outputs": [[" "], ["Iron"], ["b"], ["Iron Yard"], ["Yard"], ["IronYardllYard IronIron YardIronIronIron!"], ["Iron6Iron4IronYard ./?Iron Yard"]]}
user: Given an array (or list) of scores, return the array of _ranks_ for each value in the array.  The largest value has rank 1, the second largest value has rank 2, and so on. Ties should be handled by assigning the same rank to all tied values. For example:

    ranks([9,3,6,10]) = [2,4,3,1]

and

    ranks([3,3,3,3,3,5,1]) = [2,2,2,2,2,1,7]
    
because there is one 1st place value, a five-way tie for 2nd place, and one in 7th place.

Answer: {"fn_name": "ranks", "inputs": [[[]], [[2]], [[2, 2]], [[1, 2, 3]], [[-5, -10, 3, 1]], [[-1, 3, 3, 3, 5, 5]], [[1, 10, 4]], [[5, 2, 3, 5, 5, 4, 9, 8, 0]]], "outputs": [[[]], [[1]], [[1, 1]], [[3, 2, 1]], [[3, 4, 1, 2]], [[6, 3, 3, 3, 1, 1]], [[3, 1, 2]], [[3, 8, 7, 3, 3, 6, 1, 2, 9]]]}
user: A family of kookaburras are in my backyard.

I can't see them all, but I can hear them!

# How many kookaburras are there?




## Hint 

The trick to counting kookaburras is to listen carefully

* The males go ```HaHaHa```...

* The females go ```hahaha```...

* And they always alternate male/female



^ Kata Note : No validation is necessary; only valid input will be passed :-)

Answer: {"fn_name": "kooka_counter", "inputs": [[""], ["hahahahaha"], ["hahahahahaHaHaHa"], ["HaHaHahahaHaHa"], ["hahahahahahahaHaHa"]], "outputs": [[0], [1], [2], [3], [2]]}
user: Write a function that calculates the *least common multiple* of its arguments; each argument is assumed to be a non-negative integer. In the case that there are no arguments (or the provided array in compiled languages is empty), return `1`.

~~~if:objc
NOTE: The first (and only named) argument of the function `n` specifies the number of arguments in the variable-argument list. Do **not** take `n` into account when computing the LCM of the numbers.
~~~

Answer: {"fn_name": "lcm", "inputs": [[2, 5], [2, 3, 4], [9], [0], [0, 1], [1, 1, 1], [5, 6, 7, 9, 6, 9, 18, 4, 5, 15, 15, 10, 17, 7], [17, 20, 4, 15, 4, 18, 12, 14, 20, 19, 2, 14, 13, 7], [11, 13, 4, 5, 17, 4, 10, 13, 16, 13, 13], [20, 1, 6, 10, 3, 7, 8, 4], [3, 9, 9, 19, 18, 14, 18, 9], [3, 9, 9, 19, 18, 14, 18, 0]], "outputs": [[10], [12], [9], [0], [0], [1], [21420], [5290740], [194480], [840], [2394], [0]]}
user: To celebrate the start of the Rio Olympics (and the return of 'the Last Leg' on C4 tonight) this is an Olympic inspired kata.

Given a string of random letters, you need to examine each. Some letters naturally have 'rings' in them. 'O' is an obvious example, but 'b', 'p', 'e', 'A', etc are all just as applicable. 'B' even has two!! Please note for this kata you can count lower case 'g' as only one ring.

Your job is to count the 'rings' in each letter and divide the total number by 2. Round the answer down. Once you have your final score:

if score is 1 or less,  return 'Not even a medal!';
if score is 2, return 'Bronze!';
if score is 3, return 'Silver!';
if score is more than 3, return 'Gold!';

Dots over i's and any other letters don't count as rings.

Answer: {"fn_name": "olympic_ring", "inputs": [["wHjMudLwtoPGocnJ"], ["eCEHWEPwwnvzMicyaRjk"], ["JKniLfLW"], ["EWlZlDFsEIBufsalqof"], ["IMBAWejlGRTDWetPS"]], "outputs": [["Bronze!"], ["Bronze!"], ["Not even a medal!"], ["Silver!"], ["Gold!"]]}
user: The pizza store wants to know how long each order will take. They know:

- Prepping a pizza takes 3 mins
- Cook a pizza takes 10 mins
- Every salad takes 3 mins to make
- Every appetizer takes 5 mins to make
- There are 2 pizza ovens
- 5 pizzas can fit in a oven
- Prepping for a pizza must be done before it can be put in the oven
- There are two pizza chefs and one chef for appitizers and salads combined
- The two pizza chefs can work on the same pizza

Write a function, order, which will tell the company how much time the order will take.

See example tests for details.

Answer: {"fn_name": "order", "inputs": [[2, 0, 0], [3, 1, 2], [0, 3, 2], [13, 0, 0], [6, 2, 4], [6, 1, 3], [5, 3, 4]], "outputs": [[13], [14.5], [19], [39.5], [26], [19], [29]]}
user: # Solve For X

You will be given an equation as a string and you will need to [solve for X](https://www.mathplacementreview.com/algebra/basic-algebra.php#solve-for-a-variable) and return x's value. For example: 

```python
solve_for_x('x - 5 = 20') # should return 25
solve_for_x('20 = 5 * x - 5') # should return 5
solve_for_x('5 * x = x + 8') # should return 2
solve_for_x('(5 - 3) * x = x + 2') # should return 2
```

NOTES:
 * All numbers will be whole numbers
 * Don't forget about the [order of operations](https://www.mathplacementreview.com/algebra/basic-algebra.php#order-of-operations).
 * If the random tests don't pass the first time, just run them again.

Answer: {"fn_name": "solve_for_x", "inputs": [["x - 5 = 20"], ["5 * x + 5 = 30"], ["20 = 5 * x - 5"], ["24 = 4 + 5 * x"], ["x = 5"], ["x * 100 = 700"], ["2 * x + 5 = 105"], ["2 * x = 198"], ["x - 100 + 2 - 50 = 52"], ["x / 3 = 33"], ["x + 80 = 20"], ["x + 20 = -60"], ["5 * x + 20 - x = 60"], ["x + x + 6 = 10"], ["5 * x = x + 8"], ["x = x / 2 + 25"], ["(5 - 3) * x = x + 2"], ["(x - 30) * 2 = x"]], "outputs": [[25], [5], [5], [4], [5], [7], [50], [99], [200], [99], [-60], [-80], [10], [2], [2], [50], [2], [60]]}
user: Write function heron which calculates the area of a triangle with sides a, b, and c.

Heron's formula: sqrt (s \* (s - a) \* (s - b) \* (s - c)), where s = (a + b + c) / 2.
Output should have 2 digits precision.

Answer: {"fn_name": "heron", "inputs": [[3, 4, 5], [6, 8, 10]], "outputs": [[6], [24]]}
user: Assume that you started to store items in progressively expanding square location, like this for the first 9 numbers:

```
05 04 03
06 01 02
07 08 09
```

And like this for the expanding to include up to the first 25 numbers:

```
17 16 15 14 13
18 05 04 03 12
19 06 01 02 11
20 07 08 09 10
21 22 23 24 25
```

You might easily notice that the first - and innermost - layer containes only one number (`01`), the second one  - immediately around it - contains 8 numbers (number in the `02-09` range) and so on.

Your task is to create a function that given a number `n` simply returns the number of layers required to store up to `n` (included).

```python
layers(1) == 1
layers(5) == 2
layers(25) == 3
layers(30) == 4
layers(50) == 5
```

**Fair warning:** you will always and only get positive integers, but be ready for bigger numbers in the tests!

If you had fun with this, also try some follow up kata: [progressive spiral number branch](https://www.codewars.com/kata/progressive-spiral-number-branch/) and [progressive spiral number distance](https://www.codewars.com/kata/progressive-spiral-number-distance/).

*[Base idea taken from [here](http://adventofcode.com/2017/day/3)]*

Answer: {"fn_name": "layers", "inputs": [[1], [5], [25], [30], [50]], "outputs": [[1], [2], [3], [4], [5]]}
user: HELP! Jason can't find his textbook! It is two days before the test date, and Jason's textbooks are all out of order! Help him sort a list (ArrayList in java) full of textbooks by subject, so he can study before the test.

The sorting should **NOT** be case sensitive

Answer: {"fn_name": "sorter", "inputs": [[["Algebra", "History", "Geometry", "English"]], [["Algebra", "history", "Geometry", "english"]], [["Alg#bra", "$istory", "Geom^try", "**english"]]], "outputs": [[["Algebra", "English", "Geometry", "History"]], [["Algebra", "english", "Geometry", "history"]], [["$istory", "**english", "Alg#bra", "Geom^try"]]]}
user: Complete the function which converts hex number (given as a string) to a decimal number.

Answer: {"fn_name": "hex_to_dec", "inputs": [["1"], ["a"], ["10"]], "outputs": [[1], [10], [16]]}
user: This kata is about multiplying a given number by eight if it is an even number and by nine otherwise.

Answer: {"fn_name": "simple_multiplication", "inputs": [[2], [1], [8], [4], [5]], "outputs": [[16], [9], [64], [32], [45]]}