meetforever/GRPO_CL huggingface dataset:
user: The prime numbers are not regularly spaced. For example from `2` to `3` the gap is `1`.
From `3` to `5` the gap is `2`. From `7` to `11` it is `4`.
Between 2 and 50 we have the following pairs of 2-gaps primes:
`3-5, 5-7, 11-13, 17-19, 29-31, 41-43`

A prime gap of length n is a run of n-1 consecutive composite numbers between two **successive** primes (see: http://mathworld.wolfram.com/PrimeGaps.html).

We will write a function gap with parameters:

`g` (integer >= 2) which indicates the gap we are looking for

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

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

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

So this function should return the **first** pair of two prime numbers spaced with a gap of `g`
between the limits `m`, `n` if these numbers exist otherwise `nil or null or None or Nothing` (depending on the language). 

In C++ return in such a case `{0, 0}`. In F# return `[||]`. In Kotlin return `[]`

#Examples:
`gap(2, 5, 7) --> [5, 7] or (5, 7) or {5, 7}`

`gap(2, 5, 5) --> nil. In C++ {0, 0}. In F# [||]. In Kotlin return `[]`

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

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

`gap(6,100,110) --> nil or {0, 0}` : between 100 and 110 we have `101, 103, 107, 109` but `101-107`is not a
6-gap because there is `103`in between and `103-109`is not a 6-gap because there is `107`in between.

# Note for Go
For Go: nil slice is expected when there are no gap between m and n.
Example: gap(11,30000,100000) --> nil

#Ref
https://en.wikipedia.org/wiki/Prime_gap

Answer: {"fn_name": "gap", "inputs": [[2, 3, 10], [3, 3, 10], [2, 100, 110], [4, 100, 110], [6, 100, 110], [8, 300, 400], [10, 300, 400], [4, 30000, 100000], [6, 30000, 100000], [8, 30000, 100000], [11, 30000, 100000], [2, 10000000, 11000000]], "outputs": [[[3, 5]], [null], [[101, 103]], [[103, 107]], [null], [[359, 367]], [[337, 347]], [[30109, 30113]], [[30091, 30097]], [[30161, 30169]], [null], [[10000139, 10000141]]]}
user: Given two integers `a` and `x`, return the minimum non-negative number to **add to** / **subtract from** `a` to make it a multiple of `x`.

```python
minimum(10, 6)  #= 2

10+2 = 12 which is a multiple of 6
```

## Note
- 0 is always a multiple of `x`

## Constraints

**1 <= a <= 10^(6)**

**1 <= x <= 10^(5)**

Answer: {"fn_name": "minimum", "inputs": [[9, 4], [10, 6]], "outputs": [[1], [2]]}
user: Your colleagues have been looking over you shoulder. When you should have been doing your boring real job, you've been using the work computers to smash in endless hours of codewars.

In a team meeting, a terrible, awful person declares to the group that you aren't working. You're in trouble. You quickly have to gauge the feeling in the room to decide whether or not you should gather your things and leave. 

```if-not:java
Given an object (meet) containing team member names as keys, and their happiness rating out of 10 as the value, you need to assess the overall happiness rating of the group. If <= 5, return 'Get Out Now!'. Else return 'Nice Work Champ!'.
```
```if:java
Given a `Person` array (meet) containing team members, you need to assess the overall happiness rating of the group. If <= 5, return "Get Out Now!". Else return "Nice Work Champ!".

The `Person` class looks like:
~~~java
class Person {
  final String name;    // team memnber's name
  final int happiness;  // happiness rating out of 10
}
~~~
```

Happiness rating will be total score / number of people in the room.

Note that your boss is in the room (boss), their score is worth double it's face value (but they are still just one person!).

The Office II - Boredom Score
The Office III - Broken Photocopier
The Office IV - Find a Meeting Room
The Office V - Find a Chair

Answer: {"fn_name": "outed", "inputs": [[{"tim": 0, "jim": 2, "randy": 0, "sandy": 7, "andy": 0, "katie": 5, "laura": 1, "saajid": 2, "alex": 3, "john": 2, "mr": 0}, "laura"], [{"tim": 1, "jim": 3, "randy": 9, "sandy": 6, "andy": 7, "katie": 6, "laura": 9, "saajid": 9, "alex": 9, "john": 9, "mr": 8}, "katie"], [{"tim": 2, "jim": 4, "randy": 0, "sandy": 5, "andy": 8, "katie": 6, "laura": 2, "saajid": 2, "alex": 3, "john": 2, "mr": 8}, "john"]], "outputs": [["Get Out Now!"], ["Nice Work Champ!"], ["Get Out Now!"]]}
user: You receive some random elements as a space-delimited string. Check if the elements are part of an ascending sequence of integers starting with 1, with an increment of 1 (e.g. 1, 2, 3, 4).

Return:

* `0` if the elements can form such a sequence, and no number is missing ("not broken", e.g. `"1 2 4 3"`)
* `1` if there are any non-numeric elements in the input ("invalid", e.g. `"1 2 a"`)
* `n` if the elements are part of such a sequence, but some numbers are missing, and `n` is the lowest of them ("broken", e.g. `"1 2 4"` or `"1 5"`)


## Examples
```
"1 2 3 4"  ==>  return 0, because the sequence is complete

"1 2 4 3"  ==>  return 0, because the sequence is complete (order doesn't matter)

"2 1 3 a"  ==>  return 1, because it contains a non numerical character

"1 3 2 5"  ==>  return 4, because 4 is missing from the sequence

"1 5"      ==>  return 2, because the sequence is missing 2, 3, 4 and 2 is the lowest

```

Answer: {"fn_name": "find_missing_number", "inputs": [["1 2 3 5"], ["1 5"], [""], ["1 2 3 4 5"], ["2 3 4 5"], ["2 6 4 5 3"], ["_______"], ["2 1 4 3 a"], ["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 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 91 92 93 94 95 96 97 98 99 100 101 102"]], "outputs": [[4], [2], [0], [0], [1], [1], [1], [1], [90]]}
user: When working with color values it can sometimes be useful to extract the individual red, green, and blue (RGB) component values for a color. Implement a function that meets these requirements:

+ Accepts a case-insensitive hexadecimal color string as its parameter (ex. `"#FF9933"` or `"#ff9933"`)
+ Returns an object with the structure `{r: 255, g: 153, b: 51}` where *r*, *g*, and *b* range from 0 through 255

**Note:** your implementation does not need to support the shorthand form of hexadecimal notation (ie `"#FFF"`)


## Example

```
"#FF9933" --> {r: 255, g: 153, b: 51}
```

Answer: {"fn_name": "hex_string_to_RGB", "inputs": [["#FF9933"], ["#beaded"], ["#000000"], ["#111111"], ["#Fa3456"]], "outputs": [[{"r": 255, "g": 153, "b": 51}], [{"r": 190, "g": 173, "b": 237}], [{"r": 0, "g": 0, "b": 0}], [{"r": 17, "g": 17, "b": 17}], [{"r": 250, "g": 52, "b": 86}]]}
user: # Task
`EvilCode` is a game similar to `Codewars`. You have to solve programming tasks as quickly as possible. However, unlike `Codewars`, `EvilCode` awards you with a medal, depending on the time you took to solve the task.

To get a medal, your time must be (strictly) inferior to the time corresponding to the medal. You can be awarded `"Gold", "Silver" or "Bronze"` medal, or `"None"` medal at all. Only one medal (the best achieved) is awarded.

You are given the time achieved for the task and the time corresponding to each medal. Your task is to return the awarded medal.

Each time is given in the format `HH:MM:SS`.


# Input/Output

`[input]` string `userTime`

The time the user achieved.

`[input]` string `gold`

The time corresponding to the gold medal.

`[input]` string `silver`

The time corresponding to the silver medal.

`[input]` string `bronze`

The time corresponding to the bronze medal.

It is guaranteed that `gold < silver < bronze`.

`[output]` a string

The medal awarded, one of for options: `"Gold", "Silver", "Bronze" or "None"`.

# Example

For 
```
userTime = "00:30:00", gold = "00:15:00",
silver = "00:45:00" and bronze = "01:15:00"```

the output should be `"Silver"`

For 
```
userTime = "01:15:00", gold = "00:15:00",
silver = "00:45:00" and bronze = "01:15:00"```

the output should be `"None"`

# For Haskell version
```
In Haskell, the result is a Maybe, returning Just String indicating 
the medal if they won or Nothing if they don't.
```

Answer: {"fn_name": "evil_code_medal", "inputs": [["00:30:00", "00:15:00", "00:45:00", "01:15:00"], ["01:15:00", "00:15:00", "00:45:00", "01:15:00"], ["00:00:01", "00:00:10", "00:01:40", "01:00:00"], ["00:10:01", "00:00:10", "00:01:40", "01:00:00"], ["00:00:01", "00:00:02", "00:00:03", "00:00:04"], ["90:00:01", "60:00:02", "70:00:03", "80:00:04"], ["03:15:00", "03:15:00", "03:15:01", "03:15:02"], ["99:59:58", "99:59:57", "99:59:58", "99:59:59"], ["14:49:03", "77:39:08", "92:11:36", "94:07:41"], ["61:01:40", "64:19:53", "79:30:02", "95:24:48"]], "outputs": [["Silver"], ["None"], ["Gold"], ["Bronze"], ["Gold"], ["None"], ["Silver"], ["Bronze"], ["Gold"], ["Gold"]]}
user: Find the number with the most digits.

If two numbers in the argument array have the same number of digits, return the first one in the array.

Answer: {"fn_name": "find_longest", "inputs": [[[1, 10, 100]], [[9000, 8, 800]], [[8, 900, 500]], [[3, 40000, 100]], [[1, 200, 100000]]], "outputs": [[100], [9000], [900], [40000], [100000]]}
user: *** Nova polynomial subtract*** 

This kata is from a series on polynomial handling. ( [#1](http://www.codewars.com/kata/nova-polynomial-1-add-1)   [#2](http://www.codewars.com/kata/570eb07e127ad107270005fe)  [#3](http://www.codewars.com/kata/5714041e8807940ff3001140 )   [#4](http://www.codewars.com/kata/571a2e2df24bdfd4e20001f5))


Consider a polynomial in a list where each element in the list element corresponds to the factors. The factor order is the position in the list. The first element is the zero order factor (the constant).

p = [a0, a1, a2, a3] signifies the polynomial a0 + a1x + a2x^2 + a3*x^3

In this kata subtract two polynomials:

```python 
poly_subtract([1, 2], [1] ) = [0, 2]
poly_subtract([2, 4], [4, 5] ) = [-2, -1]
```
The first and second katas of this series are preloaded in the code and can be used: 

 * [poly_add](http://www.codewars.com/kata/nova-polynomial-1-add-1) 
 * [poly_multiply](http://www.codewars.com/kata/570eb07e127ad107270005fe).

Answer: {"fn_name": "poly_subtract", "inputs": [[[], []], [[1, 2, 3, 4, 5, 6], []], [[], [1, 2, 3, 4, 5, 6]]], "outputs": [[[]], [[1, 2, 3, 4, 5, 6]], [[-1, -2, -3, -4, -5, -6]]]}
user: Implement a function which convert the given boolean value into its string representation.

Answer: {"fn_name": "boolean_to_string", "inputs": [[true], [false]], "outputs": [["True"], ["False"]]}
user: In this Kata, you will be given a number and your task will be to rearrange the number so that it is divisible by `25`, but without leading zeros. Return the minimum number of digit moves that are needed to make this possible. If impossible, return `-1` ( `Nothing` in Haskell ).

For example:

More examples in test cases.

Good luck!

Answer: {"fn_name": "solve", "inputs": [[50], [25], [52], [57], [75], [100], [521], [1], [5071], [705], [1241367], [50011117], [1002], [50011111112], [2057], [50001111312], [500111117], [64954713879], [71255535569], [72046951686], [68151901446], [3848363615], [75733989998], [87364011400], [2992127830], [98262144757], [81737102196], [50892869177], [5000033333337], [7000033333335], [500033332], [50303332], [5003033332], [20], [5], [7], [2], [60], [100000], [500000], [507], [502], [205]], "outputs": [[0], [0], [1], [1], [0], [0], [3], [-1], [4], [1], [-1], [9], [2], [12], [1], [13], [10], [8], [9], [12], [10], [-1], [17], [0], [-1], [1], [-1], [11], [16], [8], [10], [8], [11], [-1], [-1], [-1], [-1], [-1], [0], [0], [2], [2], [1]]}
user: # Kata Task

Given a list of random integers, return the Three Amigos.

These are 3 numbers that live next to each other in the list, and who have the **most** in common with each other by these rules:
* lowest statistical range
* same parity

# Notes

* The list will contain at least 3 numbers
* If there is more than one answer then return the first one found (reading the list left to right)
* If there is no answer (e.g. no 3 adjacent numbers with same parity) then return an empty list.

# Examples

* ex1
 * Input = ```[1, 2, 34, 2, 1, 5, 3, 5, 7, 234, 2, 1]```
 * Result = ```[5,3,5]```
 

* ex2
 * Input = ```[2, 4, 6, 8, 10, 2, 2, 2, 1, 1, 1, 5, 3]```
 * Result = ```[2,2,2]```
 

* ex3
 * Input = ```[2, 4, 5, 3, 6, 3, 1, 56, 7, 6, 3, 12]```
 * Result = ```[]```

Answer: {"fn_name": "three_amigos", "inputs": [[[1, 2, 34, 2, 1, 5, 3, 5, 7, 234, 2, 1]], [[2, 4, 6, 8, 10, 2, 2, 2, 1, 1, 1, 5, 3]], [[2, 4, 5, 3, 6, 3, 1, 56, 7, 6, 3, 12]], [[1, 3, 5]], [[1, 3, 2]], [[1, 3, 5, 7, 9, 11, 13, 15]], [[1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 3, 5]], [[-5, -4, -2, 0, 1, 2, 3, 4, 5]], [[-8, -25, 21, -7, -5]], [[8, 5, 20, 17, -18, -11, 19, 5]], [[6, 9, -18, -19, -14, -10, -24]], [[0, -1, -1, 1, -1, -1, -3]], [[-8, -2, 0, 2, 4, 6, 8]]], "outputs": [[[5, 3, 5]], [[2, 2, 2]], [[]], [[1, 3, 5]], [[]], [[1, 3, 5]], [[1, 3, 5]], [[-4, -2, 0]], [[21, -7, -5]], [[-11, 19, 5]], [[-14, -10, -24]], [[-1, -1, 1]], [[-2, 0, 2]]]}
user: You are given an array of `n+1` integers `1` through `n`. In addition there is a single duplicate integer.

The array is unsorted.

An example valid array would be `[3, 2, 5, 1, 3, 4]`. It has the integers `1` through `5` and `3` is duplicated. `[1, 2, 4, 5, 5]` would not be valid as it is missing `3`.

You should return the duplicate value as a single integer.

Answer: {"fn_name": "find_dup", "inputs": [[[1, 1, 2, 3]], [[1, 2, 2, 3]], [[5, 4, 3, 2, 1, 1]], [[1, 3, 2, 5, 4, 5, 7, 6]], [[8, 2, 6, 3, 7, 2, 5, 1, 4]]], "outputs": [[1], [2], [1], [5], [2]]}
user: Character recognition software is widely used to digitise printed texts. Thus the texts can be edited, searched and stored on a computer.

When documents (especially pretty old ones written with a typewriter), are digitised character recognition softwares often make mistakes.

Your task is correct the errors in the digitised text. You only have to handle the following mistakes:

* `S`  is misinterpreted as `5`
* `O` is misinterpreted as `0`
* `I` is misinterpreted as `1`

The test cases contain numbers only by mistake.

Answer: {"fn_name": "correct", "inputs": [["1F-RUDYARD K1PL1NG"], ["R0BERT MERLE - THE DAY 0F THE D0LPH1N"], ["R1CHARD P. FEYNMAN - THE FEYNMAN LECTURE5 0N PHY51C5"], ["R1CHARD P. FEYNMAN - 5TAT15T1CAL MECHAN1C5"], ["5TEPHEN HAWK1NG - A BR1EF H15T0RY 0F T1ME"], ["5TEPHEN HAWK1NG - THE UN1VER5E 1N A NUT5HELL"], ["ERNE5T HEM1NGWAY - A FARWELL T0 ARM5"], ["ERNE5T HEM1NGWAY - F0R WH0M THE BELL T0LL5"], ["ERNE5T HEM1NGWAY - THE 0LD MAN AND THE 5EA"], ["J. R. R. T0LK1EN - THE L0RD 0F THE R1NG5"], ["J. D. 5AL1NGER - THE CATCHER 1N THE RYE"], ["J. K. R0WL1NG - HARRY P0TTER AND THE PH1L050PHER'5 5T0NE"], ["J. K. R0WL1NG - HARRY P0TTER AND THE CHAMBER 0F 5ECRET5"], ["J. K. R0WL1NG - HARRY P0TTER AND THE PR150NER 0F Azkaban"], ["J. K. R0WL1NG - HARRY P0TTER AND THE G0BLET 0F F1RE"], ["J. K. R0WL1NG - HARRY P0TTER AND THE 0RDER 0F PH0EN1X"], ["J. K. R0WL1NG - HARRY P0TTER AND THE HALF-BL00D PR1NCE"], ["J. K. R0WL1NG - HARRY P0TTER AND THE DEATHLY HALL0W5"], ["UR5ULA K. LE GU1N - A W1ZARD 0F EARTH5EA"], ["UR5ULA K. LE GU1N - THE T0MB5 0F ATUAN"], ["UR5ULA K. LE GU1N - THE FARTHE5T 5H0RE"], ["UR5ULA K. LE GU1N - TALE5 FR0M EARTH5EA"]], "outputs": [["IF-RUDYARD KIPLING"], ["ROBERT MERLE - THE DAY OF THE DOLPHIN"], ["RICHARD P. FEYNMAN - THE FEYNMAN LECTURES ON PHYSICS"], ["RICHARD P. FEYNMAN - STATISTICAL MECHANICS"], ["STEPHEN HAWKING - A BRIEF HISTORY OF TIME"], ["STEPHEN HAWKING - THE UNIVERSE IN A NUTSHELL"], ["ERNEST HEMINGWAY - A FARWELL TO ARMS"], ["ERNEST HEMINGWAY - FOR WHOM THE BELL TOLLS"], ["ERNEST HEMINGWAY - THE OLD MAN AND THE SEA"], ["J. R. R. TOLKIEN - THE LORD OF THE RINGS"], ["J. D. SALINGER - THE CATCHER IN THE RYE"], ["J. K. ROWLING - HARRY POTTER AND THE PHILOSOPHER'S STONE"], ["J. K. ROWLING - HARRY POTTER AND THE CHAMBER OF SECRETS"], ["J. K. ROWLING - HARRY POTTER AND THE PRISONER OF Azkaban"], ["J. K. ROWLING - HARRY POTTER AND THE GOBLET OF FIRE"], ["J. K. ROWLING - HARRY POTTER AND THE ORDER OF PHOENIX"], ["J. K. ROWLING - HARRY POTTER AND THE HALF-BLOOD PRINCE"], ["J. K. ROWLING - HARRY POTTER AND THE DEATHLY HALLOWS"], ["URSULA K. LE GUIN - A WIZARD OF EARTHSEA"], ["URSULA K. LE GUIN - THE TOMBS OF ATUAN"], ["URSULA K. LE GUIN - THE FARTHEST SHORE"], ["URSULA K. LE GUIN - TALES FROM EARTHSEA"]]}
user: Write a function 

`titleToNumber(title) or title_to_number(title) or titleToNb title ...`

(depending on the language)

that given a column title as it appears in an Excel sheet, returns its corresponding column number. All column titles will be uppercase.

Examples:
```
titleTonumber('A') === 1
titleTonumber('Z') === 26
titleTonumber('AA') === 27
```

Answer: {"fn_name": "title_to_number", "inputs": [["A"], ["Z"], ["AA"], ["AZ"], ["BA"], ["CODEWARS"], ["ZZZTOP"], ["OYAJI"], ["LONELINESS"], ["UNFORGIVABLE"]], "outputs": [[1], [26], [27], [52], [53], [28779382963], [321268054], [7294985], [68400586976949], [79089429845931757]]}
user: ## Description

Peter enjoys taking risks, and this time he has decided to take it up a notch!

Peter asks his local barman to pour him **n** shots, after which Peter then puts laxatives in **x** of them. He then turns around and lets the barman shuffle the shots. Peter approaches the shots and drinks **a** of them one at a time. Just one shot is enough to give Peter a runny tummy. What is the probability that Peter doesn't need to run to the loo?

## Task

You are given:

**n** - The total number of shots.

**x** - The number of laxative laden shots.

**a** - The number of shots that peter drinks.


return the probability that Peter won't have the trots after drinking. **n** will always be greater than **x**, and **a** will always be less than **n**.

**You must return the probability rounded to two decimal places i.e. 0.05 or 0.81**

Answer: {"fn_name": "get_chance", "inputs": [[2, 1, 1], [4, 1, 3], [100, 10, 10], [1000, 150, 20], [25, 5, 5], [9, 3, 2], [4000, 200, 30], [10000, 100, 100], [1000000, 5000, 200], [1000000, 5000, 20000]], "outputs": [[0.5], [0.25], [0.33], [0.04], [0.29], [0.42], [0.21], [0.36], [0.37], [0.0]]}
user: ~~~if:csharp,javascript,cfml,php
Given a 2D array of size `m * n`. Your task is to find the sum of minimum value in each row.
~~~
~~~if:cpp
Given a 2D vector of size `m * n`. Your task is to find the sum of minimum value in each row.
~~~
~~~if:python,ruby
Given a 2D list of size `m * n`. Your task is to find the sum of minimum value in each row.
~~~

For Example:
```python
[
  [1, 2, 3, 4, 5],       # minimum value of row is 1
  [5, 6, 7, 8, 9],       # minimum value of row is 5
  [20, 21, 34, 56, 100]  # minimum value of row is 20
]
```
So, the function should return `26` because sum of minimums is as `1 + 5 + 20 = 26`

~~~if:javascript,php
Note: You will be always given non-empty array containing Positive values.
~~~
~~~if:python
Note: You will be always given non-empty list containing Positive values.
~~~
~~~if:cpp
Note: You will be always given non-empty vector containing Positive values.
~~~
~~~if:c#
Note: You will be always given non-empty vector containing Positive values.
~~~
~~~if:cfml
Note: You will be always given non-empty array containing Positive values.
~~~

ENJOY CODING :)

Answer: {"fn_name": "sum_of_minimums", "inputs": [[[[7, 9, 8, 6, 2], [6, 3, 5, 4, 3], [5, 8, 7, 4, 5]]], [[[11, 12, 14, 54], [67, 89, 90, 56], [7, 9, 4, 3], [9, 8, 6, 7]]]], "outputs": [[9], [76]]}
user: Given an array of integers as strings and numbers, return the sum of the array values as if all were numbers.

Return your answer as a number.

Answer: {"fn_name": "sum_mix", "inputs": [[[9, 3, "7", "3"]], [["5", "0", 9, 3, 2, 1, "9", 6, 7]], [["3", 6, 6, 0, "5", 8, 5, "6", 2, "0"]], [["1", "5", "8", 8, 9, 9, 2, "3"]], [[8, 0, 0, 8, 5, 7, 2, 3, 7, 8, 6, 7]]], "outputs": [[22], [42], [41], [45], [61]]}
user: This program tests the life of an
evaporator containing a gas. 

We know the content of the evaporator (content in ml),
the percentage of foam or gas lost every day (evap_per_day)
and the threshold (threshold) in percentage beyond which
the evaporator is no longer useful.
All numbers are strictly positive.

The program reports the nth day (as an integer)
on which the evaporator will be out of use.

**Note** : Content is in fact not necessary in the body of the function "evaporator", you can use it or not use it, as you wish. Some people might prefer to reason with content, some other with percentages only. It's up to you but you must keep it as a parameter because the tests have it as an argument.

Answer: {"fn_name": "evaporator", "inputs": [[10, 10, 10], [10, 10, 5], [100, 5, 5], [50, 12, 1], [47.5, 8, 8], [100, 1, 1], [10, 1, 1], [100, 1, 5]], "outputs": [[22], [29], [59], [37], [31], [459], [459], [299]]}
user: My grandfather always predicted how old people would get, and right before he passed away he revealed his secret!

In honor of my grandfather's memory we will write a function using his formula!

* Take a list of ages when each of your great-grandparent died.  
* Multiply each number by itself.  
* Add them all together.  
* Take the square root of the result.  
* Divide by two.

## Example

```R
predict_age(65, 60, 75, 55, 60, 63, 64, 45) == 86
```
```python
predict_age(65, 60, 75, 55, 60, 63, 64, 45) == 86
```

Note: the result should be rounded down to the nearest integer.

Some random tests might fail due to a bug in the JavaScript implementation. Simply resubmit if that happens to you.

Answer: {"fn_name": "predict_age", "inputs": [[65, 60, 75, 55, 60, 63, 64, 45], [32, 54, 76, 65, 34, 63, 64, 45]], "outputs": [[86], [79]]}