meetforever/GRPO_CL huggingface dataset:
user: The first input array is the key to the correct answers to an exam, like ["a", "a", "b", "d"]. The second one contains a student's submitted answers. 

The two arrays are not empty and are the same length. Return the score for this array of answers, giving +4 for each correct answer, -1 for each incorrect answer, and +0 for each blank answer, represented as an empty string (in C the space character is used).

If the score < 0, return 0.

For example:
```
checkExam(["a", "a", "b", "b"], ["a", "c", "b", "d"]) → 6
checkExam(["a", "a", "c", "b"], ["a", "a", "b",  ""]) → 7
checkExam(["a", "a", "b", "c"], ["a", "a", "b", "c"]) → 16
checkExam(["b", "c", "b", "a"], ["",  "a", "a", "c"]) → 0
```

Answer: {"fn_name": "check_exam", "inputs": [[["a", "a", "b", "b"], ["a", "c", "b", "d"]], [["a", "a", "c", "b"], ["a", "a", "b", ""]], [["a", "a", "b", "c"], ["a", "a", "b", "c"]], [["b", "c", "b", "a"], ["", "a", "a", "c"]]], "outputs": [[6], [7], [16], [0]]}
user: Say hello!

Write a function to greet a person. Function will take name as input and greet the person by saying hello.
Return null/nil/None if input is empty string or null/nil/None.

Example: 

```python
greet("Niks") --> "hello Niks!"
greet("")    --> None # Return None if input is empty string
greet(None)  --> None # Return None if input is None
```

Answer: {"fn_name": "greet", "inputs": [["Niks"], ["Nick"], [""], [null]], "outputs": [["hello Niks!"], ["hello Nick!"], [null], [null]]}
user: When you divide the successive powers of `10` by `13` you get the following remainders of the integer divisions:  

`1, 10, 9, 12, 3, 4`. 

Then the whole pattern repeats.

Hence the following method:
Multiply the right most digit of the number with the left most number 
in the sequence shown above, the second right most digit to the second 
left most digit of the number in the sequence. The cycle goes on and you sum all these products. Repeat this process until the sequence of sums is stationary.

...........................................................................

Example: What is the remainder when `1234567` is divided by `13`?

`7×1 + 6×10 + 5×9 + 4×12 + 3×3 + 2×4 + 1×1 = 178`

We repeat the process with 178:

`8x1 + 7x10 + 1x9 = 87`

and again with 87:

`7x1 + 8x10 = 87`

...........................................................................

From now on the sequence is stationary and the remainder of `1234567` by `13` is 
the same as the remainder of `87` by `13`: `9`

Call `thirt` the function which processes this sequence of operations on an integer `n (>=0)`. `thirt` will return the stationary number.

`thirt(1234567)` calculates 178, then 87, then 87 and returns `87`.

`thirt(321)` calculates 48, 48 and returns `48`

Answer: {"fn_name": "thirt", "inputs": [[8529], [85299258], [5634], [1111111111], [987654321]], "outputs": [[79], [31], [57], [71], [30]]}
user: Write a regex to validate a 24 hours time string.
See examples to figure out what you should check for:

Accepted:
01:00 - 1:00  

Not accepted:

24:00

You should check for correct length and no spaces.

Answer: {"fn_name": "validate_time", "inputs": [["1:00"], ["13:1"], ["12:60"], ["12: 60"], ["24:00"], ["00:00"], ["24o:00"], ["24:000"], [""], ["09:00"], ["2400"], ["foo12:00bar"], ["010:00"], ["1;00"]], "outputs": [[true], [false], [false], [false], [false], [true], [false], [false], [false], [true], [false], [false], [false], [false]]}
user: # Personalized greeting

Create a function that gives a personalized greeting. This function takes two parameters: `name` and `owner`.

Use conditionals to return the proper message:

case | return
--- | ---
name equals owner | 'Hello boss'
otherwise         | 'Hello guest'

Answer: {"fn_name": "greet", "inputs": [["Daniel", "Daniel"], ["Greg", "Daniel"]], "outputs": [["Hello boss"], ["Hello guest"]]}
user: # Let's play Psychic 

A box contains green, red, and blue balls. The total number of balls is given by `n` (`0 < n < 50`).

Each ball has a mass that depends on the ball color. Green balls weigh `5kg`, red balls weigh `4kg`, and blue balls weigh `3kg`.

Given the total number of balls in the box, `n`, and a total mass, `m`, your task is to craft a program that will determine the quantities of each colored ball. Return a list of these quantities as the answer.

Don't forget that some combinations of `n` and `m` may have more than one possibility!

# Examples

## Python
```python
>>> Guess_it(3, 12)
[[0,3,0], [1,1,1]]
```

## Elixir

*Note: Order of the returned elements is unimportant in the Elixir version.*

# Assumptions

1. You can assume that all inputs are of the correct type
2. You can assume that the range of `n` will be `[1, 50]`
3. Each element of the returned list should return the quantities in the order of `g`, `r`, `b`. 

## Python
```python
[[green, red, blue]]
```

## Elixir

Answer: {"fn_name": "Guess_it", "inputs": [[3, 12], [40, 180], [30, 130], [32, 148], [18, 80], [18, 74], [50, 180], [50, 172]], "outputs": [[[[0, 3, 0], [1, 1, 1]]], [[[20, 20, 0], [21, 18, 1], [22, 16, 2], [23, 14, 3], [24, 12, 4], [25, 10, 5], [26, 8, 6], [27, 6, 7], [28, 4, 8], [29, 2, 9], [30, 0, 10]]], [[[10, 20, 0], [11, 18, 1], [12, 16, 2], [13, 14, 3], [14, 12, 4], [15, 10, 5], [16, 8, 6], [17, 6, 7], [18, 4, 8], [19, 2, 9], [20, 0, 10]]], [[[20, 12, 0], [21, 10, 1], [22, 8, 2], [23, 6, 3], [24, 4, 4], [25, 2, 5], [26, 0, 6]]], [[[8, 10, 0], [9, 8, 1], [10, 6, 2], [11, 4, 3], [12, 2, 4], [13, 0, 5]]], [[[2, 16, 0], [3, 14, 1], [4, 12, 2], [5, 10, 3], [6, 8, 4], [7, 6, 5], [8, 4, 6], [9, 2, 7], [10, 0, 8]]], [[[0, 30, 20], [1, 28, 21], [2, 26, 22], [3, 24, 23], [4, 22, 24], [5, 20, 25], [6, 18, 26], [7, 16, 27], [8, 14, 28], [9, 12, 29], [10, 10, 30], [11, 8, 31], [12, 6, 32], [13, 4, 33], [14, 2, 34], [15, 0, 35]]], [[[0, 22, 28], [1, 20, 29], [2, 18, 30], [3, 16, 31], [4, 14, 32], [5, 12, 33], [6, 10, 34], [7, 8, 35], [8, 6, 36], [9, 4, 37], [10, 2, 38], [11, 0, 39]]]]}
user: Create a function that checks if a number `n` is divisible by two numbers `x` **AND** `y`. All inputs are positive, non-zero digits.

```JS
Examples:
1) n =   3, x = 1, y = 3 =>  true because   3 is divisible by 1 and 3
2) n =  12, x = 2, y = 6 =>  true because  12 is divisible by 2 and 6
3) n = 100, x = 5, y = 3 => false because 100 is not divisible by 3
4) n =  12, x = 7, y = 5 => false because  12 is neither divisible by 7 nor 5
```

Answer: {"fn_name": "is_divisible", "inputs": [[3, 2, 2], [3, 3, 4], [12, 3, 4], [8, 3, 4], [48, 3, 4], [100, 5, 10], [100, 5, 3], [4, 4, 2], [5, 2, 3], [17, 17, 17], [17, 1, 17]], "outputs": [[false], [false], [true], [false], [true], [true], [false], [true], [false], [true], [true]]}
user: Write a function that takes as its parameters *one or more numbers which are the diameters of circles.* 

The function should return the *total area of all the circles*, rounded to the nearest integer in a string that says "We have this much circle: xyz". 

You don't know how many circles you will be given, but you can assume it will be at least one.

So: 
```python
sum_circles(2) == "We have this much circle: 3"
sum_circles(2, 3, 4) == "We have this much circle: 23"
```

Translations and comments (and upvotes!) welcome!

Answer: {"fn_name": "sum_circles", "inputs": [[48, 7, 8, 9, 10], [1], [1, 1, 1, 2, 3, 4, 5], [894, 5778, 4839, 476], [4.5456, 746.5, 98.34, 344.543], [1, 1, 1], [13.58, 14.9, 56.99, 107.321], [56894.04839, 843975.4839, 4.08437403489], [5, 6, 7, 8, 9, 10, 105083, 48839, 4853, 28, 483]], "outputs": [["We have this much circle: 2040"], ["We have this much circle: 1"], ["We have this much circle: 45"], ["We have this much circle: 45417233"], ["We have this much circle: 538519"], ["We have this much circle: 2"], ["We have this much circle: 11916"], ["We have this much circle: 561977165367"], ["We have this much circle: 10564760498"]]}
user: Complete the solution so that it reverses all of the words within the string passed in. 

Example:

```python
reverseWords("The greatest victory is that which requires no battle")
// should return "battle no requires which that is victory greatest The"
```

Answer: {"fn_name": "reverseWords", "inputs": [["hello world!"]], "outputs": [["world! hello"]]}
user: There is a queue for the self-checkout tills at the supermarket. Your task is write a function to calculate the total time required for all the customers to check out!

### input
```if-not:c
* customers: an array of positive integers representing the queue. Each integer represents a customer, and its value is the amount of time they require to check out.
* n: a positive integer, the number of checkout tills.
```
```if:c
* customers: a pointer to an array of positive integers representing the queue. Each integer represents a customer, and its value is the amount of time they require to check out.
* customers_length: the length of the array that `customers` points to.
* n: a positive integer, the number of checkout tills.
```

### output
The function should return an integer, the total time required.

-------------------------------------------

## Important
**Please look at the examples and clarifications below, to ensure you understand the task correctly :)**

-------

### Examples

```python
queue_time([5,3,4], 1)
# should return 12
# because when n=1, the total time is just the sum of the times

queue_time([10,2,3,3], 2)
# should return 10
# because here n=2 and the 2nd, 3rd, and 4th people in the 
# queue finish before the 1st person has finished.

queue_time([2,3,10], 2)
# should return 12
```

### Clarifications

 * There is only ONE queue serving many tills, and
 * The order of the queue NEVER changes, and
 * The front person in the queue (i.e. the first element in the array/list) proceeds to a till as soon as it becomes free.

N.B. You should assume that all the test input will be valid, as specified above.

P.S. The situation in this kata can be likened to the more-computer-science-related idea of a thread pool, with relation to running multiple processes at the same time: https://en.wikipedia.org/wiki/Thread_pool

Answer: {"fn_name": "queue_time", "inputs": [[[], 1], [[5], 1], [[2], 5], [[1, 2, 3, 4, 5], 1], [[1, 2, 3, 4, 5], 100], [[2, 2, 3, 3, 4, 4], 2]], "outputs": [[0], [5], [2], [15], [5], [9]]}
user: # Problem

In China，there is an ancient mathematical book, called "The Mathematical Classic of Sun Zi"(《孙子算经》). In the book, there is a classic math problem: “今有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二，问物几何？” 

Ahh, Sorry. I forgot that you don't know Chinese. Let's translate it to English:

There is a unkown positive integer `n`. We know: 

`n % 3 = 2`, and `n % 5 = 3`, and `n % 7 = 2`. 

What's the minimum possible positive integer `n`?

The correct answer is `23`.

# Task

You are given three non-negative integers `x,y,z`. They represent the remainders of the unknown positive integer `n` divided by 3,5,7.

That is: `n % 3 = x, n % 5 = y, n % 7 = z`

Your task is to find the minimum possible positive integer `n` and return it.

# Example

For `x = 2, y = 3, z = 2`, the output should be `23`

`23 % 3 = 2, 23 % 5 = 3, 23 % 7 = 2`

For `x = 1, y = 2, z = 3`, the output should be `52`

`52 % 3 = 1, 52 % 5 = 2, 52 % 7 = 3`

For `x = 1, y = 3, z = 5`, the output should be `103`

`103 % 3 = 1, 103 % 5 = 3, 103 % 7 = 5`

For `x = 0, y = 0, z = 0`, the output should be `105`

For `x = 1, y = 1, z = 1`, the output should be `1`

# Note

- `0 <= x < 3, 0 <= y < 5, 0 <= z < 7`

- Happy Coding `^_^`

Answer: {"fn_name": "find_unknown_number", "inputs": [[2, 3, 2], [1, 2, 3], [1, 3, 5], [0, 0, 0], [1, 1, 1]], "outputs": [[23], [52], [103], [105], [1]]}
user: You receive the name of a city as a string, and you need to return a string that shows how many times each letter shows up in the string by using an asterisk (`*`).

For example:

```
"Chicago"  -->  "c:**,h:*,i:*,a:*,g:*,o:*"
```

As you can see, the letter `c` is shown only once, but with 2 asterisks.

The return string should include **only the letters** (not the dashes, spaces, apostrophes, etc). There should be no spaces in the output, and the different letters are separated by a comma (`,`) as seen in the example above.

Note that the return string must list the letters in order of their first appearence in the original string.

More examples:
```
"Bangkok"    -->  "b:*,a:*,n:*,g:*,k:**,o:*"
"Las Vegas"  -->  "l:*,a:**,s:**,v:*,e:*,g:*"
```

Have fun! ;)

Answer: {"fn_name": "get_strings", "inputs": [["Chicago"], ["Bangkok"], ["Las Vegas"], ["Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch"]], "outputs": [["c:**,h:*,i:*,a:*,g:*,o:*"], ["b:*,a:*,n:*,g:*,k:**,o:*"], ["l:*,a:**,s:**,v:*,e:*,g:*"], ["l:***********,a:***,n:****,f:*,i:***,r:****,p:*,w:****,g:*******,y:*****,o:******,e:*,c:**,h:**,d:*,b:*,t:*,s:*"]]}
user: # It's too hot, and they can't even…

One hot summer day Pete and his friend Billy decided to buy watermelons. They chose the biggest crate. They rushed home, dying of thirst, and decided to divide their loot, however they faced a hard problem.

Pete and Billy are great fans of even numbers, that's why they want to divide the number of watermelons in such a way that each of the two parts consists of an even number of watermelons. However, it is not obligatory that the parts are equal. 

Example: the boys can divide a stack of 8 watermelons into 2+6 melons, or 4+4 melons.

The boys are extremely tired and want to start their meal as soon as possible, that's why you should help them and find out, whether they can divide the fruits in the way they want. For sure, each of them should get a part of positive weight.

# Task
Given an integral number of watermelons `w` (`1 ≤ w ≤ 100`; `1 ≤ w` in Haskell), check whether Pete and Billy can divide the melons so that each of them gets an even amount.

## Examples

Answer: {"fn_name": "divide", "inputs": [[4], [2], [5], [88], [100], [67], [90], [10], [99], [32]], "outputs": [[true], [false], [false], [true], [true], [false], [true], [true], [false], [true]]}
user: The marketing team is spending way too much time typing in hashtags.   
Let's help them with our own Hashtag Generator!

Here's the deal:

- It must start with a hashtag (`#`).
- All words must have their first letter capitalized.
- If the final result is longer than 140 chars it must return `false`.
- If the input or the result is an empty string it must return `false`.


## Examples

```
" Hello there thanks for trying my Kata"  =>  "#HelloThereThanksForTryingMyKata"
"    Hello     World   "                  =>  "#HelloWorld"
""                                        =>  false
```

Answer: {"fn_name": "generate_hashtag", "inputs": [[""], ["Codewars"], ["Codewars      "], ["Codewars Is Nice"], ["codewars is nice"], ["CodeWars is nice"], ["c i n"], ["codewars  is  nice"], ["Looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong Cat"]], "outputs": [[false], ["#Codewars"], ["#Codewars"], ["#CodewarsIsNice"], ["#CodewarsIsNice"], ["#CodewarsIsNice"], ["#CIN"], ["#CodewarsIsNice"], [false]]}
user: Beaches are filled with sand, water, fish, and sun. Given a string, calculate how many times the words `"Sand"`, `"Water"`, `"Fish"`, and `"Sun"` appear without overlapping (regardless of the case).

## Examples

```python
sum_of_a_beach("WAtErSlIde")                    ==>  1
sum_of_a_beach("GolDeNSanDyWateRyBeaChSuNN")    ==>  3
sum_of_a_beach("gOfIshsunesunFiSh")             ==>  4
sum_of_a_beach("cItYTowNcARShoW")               ==>  0
```

Answer: {"fn_name": "sum_of_a_beach", "inputs": [["SanD"], ["sunshine"], ["sunsunsunsun"], ["123FISH321"], ["weoqipurpoqwuirpousandiupqwoieurioweuwateruierqpoiweurpouifiShqowieuqpwoeuisUn"], ["sAnDsandwaTerwatErfishFishsunsunsandwater"], ["joifjepiojfoiejfoajoijawoeifjowejfjoiwaefjiaowefjaofjwoj fawojef "], ["jwefjwjfsandsandwaterwaterfishfishsunsunsandwateriojwhefa;jawof;jawio;f"], ["saNdsandwaterwAterfishfishsunsunsandwatersandsandwaterwaterfishfishsunsunsandwatersandsandwaterwaterfishfishsunsunsandwatersandsandwaterwaterfishfishsunsunsandwatersandsandwaterwaterfishfishsunsunsandwatersandsandwaterwaterfishfishsunsunsandwatersandsandwaterwaterfishfishsunsunsandwatersandsandwaterwaterfishfishsunsunsandwatersandsandwaterwaterfishfishsunsunsandwatersandsandwaterwaterfishfishsunsunsandwater"], ["sununsu"], ["sandandndsansa"], ["wateratertererwatewatwa"], ["fishishshfisfi"]], "outputs": [[1], [1], [4], [1], [4], [10], [0], [10], [100], [1], [1], [1], [1]]}
user: Create a function which accepts one arbitrary string as an argument, and return a string of length 26.

The objective is to set each of the 26 characters of the output string to either `'1'` or `'0'` based on the fact whether the Nth letter of the alphabet is present in the input (independent of its case).

So if an `'a'` or an `'A'` appears anywhere in the input string (any number of times), set the first character of the output string to `'1'`, otherwise to `'0'`. if `'b'` or `'B'` appears in the string, set the second character to `'1'`, and so on for the rest of the alphabet.

For instance:

```
"a   **&  cZ"  =>  "10100000000000000000000001"
```

Answer: {"fn_name": "change", "inputs": [["a **&  bZ"], ["Abc e  $$  z"], ["!!a$%&RgTT"], [""], ["abcdefghijklmnopqrstuvwxyz"], ["aaaaaaaaaaa"], ["&%&%/$%$%$%$%GYtf67fg34678hgfdyd"]], "outputs": [["11000000000000000000000001"], ["11101000000000000000000001"], ["10000010000000000101000000"], ["00000000000000000000000000"], ["11111111111111111111111111"], ["10000000000000000000000000"], ["00010111000000000001000010"]]}
user: ## Number pyramid

Number pyramid is a recursive structure where each next row is constructed by adding adjacent values of the current row. For example:

```
Row 1     [1     2     3     4]
Row 2        [3     5     7]
Row 3           [8    12]
Row 4             [20]
```

___

## Task

Given the first row of the number pyramid, find the value stored in its last row.

___

## Examples

```python
reduce_pyramid([1])        ==  1
reduce_pyramid([3, 5])     ==  8
reduce_pyramid([3, 9, 4])  ==  25
```

___

## Performance tests

```python
Number of tests: 10
List size: 10,000
```

Answer: {"fn_name": "reduce_pyramid", "inputs": [[[1]], [[3, 5]], [[3, 9, 4]], [[5, 6, 7, 8]], [[13, 1, 21, 9]], [[13, 76, 21, 42, 63]]], "outputs": [[1], [8], [25], [52], [88], [674]]}
user: My friend John likes to go to the cinema. He can choose between system A and system B.
```
System A : he buys a ticket (15 dollars) every time
System B : he buys a card (500 dollars) and a first ticket for 0.90 times the ticket price, 
then for each additional ticket he pays 0.90 times the price paid for the previous ticket.
```
#Example: 
If John goes to the cinema 3 times:
```
System A : 15 * 3 = 45
System B : 500 + 15 * 0.90 + (15 * 0.90) * 0.90 + (15 * 0.90 * 0.90) * 0.90 ( = 536.5849999999999, no rounding for each ticket)
```
John wants to know how many times he must go to the cinema so that the *final result* of System B, when rounded *up* to the next dollar, will be cheaper than System A.

The function `movie` has 3 parameters: `card` (price of the card), `ticket` (normal price of 
a ticket), `perc` (fraction of what he paid for the previous ticket) and returns the first `n` such that
```
ceil(price of System B) < price of System A.
```
More examples:
```
movie(500, 15, 0.9) should return 43 
    (with card the total price is 634, with tickets 645)
movie(100, 10, 0.95) should return 24 
    (with card the total price is 235, with tickets 240)
```

Answer: {"fn_name": "movie", "inputs": [[500, 15, 0.9], [100, 10, 0.95], [0, 10, 0.95], [250, 20, 0.9], [500, 20, 0.9], [2500, 20, 0.9]], "outputs": [[43], [24], [2], [21], [34], [135]]}
user: You will have a list of rationals in the form

```
lst = [ [numer_1, denom_1] , ... , [numer_n, denom_n] ]
```
or
```
lst = [ (numer_1, denom_1) , ... , (numer_n, denom_n) ]
```

where all numbers are positive integers. You have to produce their sum `N / D` in an irreducible form: this means that `N` and `D` have only `1` as a common divisor.

Return the result in the form:

- `[N, D]` in Ruby, Crystal, Python, Clojure, JS, CS, PHP, Julia
- `Just "N D"` in Haskell, PureScript
- `"[N, D]"` in Java, CSharp, TS, Scala, PowerShell, Kotlin
- `"N/D"` in Go, Nim
- `{N, D}` in C++, Elixir
- `{N, D}` in C
- `Some((N, D))` in Rust
- `Some "N D"` in F#, Ocaml
- `c(N, D)` in R
- `(N, D)` in Swift
- `'(N D)` in Racket

If the result is an integer (`D` evenly divides `N`) return:

- an integer in Ruby, Crystal, Elixir, Clojure, Python, JS, CS, PHP, R, Julia
- `Just "n"` (Haskell, PureScript)
- `"n"` Java, CSharp, TS, Scala, PowerShell, Go, Nim, Kotlin
- `{n, 1}` in C++
- `{n, 1}` in C
- `Some((n, 1))` in Rust
- `Some "n"` in F#, Ocaml,
- `(n, 1)` in Swift
- `n` in Racket 

If the input list is empty, return 

- `nil/None/null/Nothing` 
- `{0, 1}` in C++
- `{0, 1}` in C
- `"0"` in Scala, PowerShell, Go, Nim
- `O` in Racket
- `""` in Kotlin


### Example:

```
[ [1, 2], [1, 3], [1, 4] ]  -->  [13, 12]

    1/2  +  1/3  +  1/4     =      13/12
```

### Note
See sample tests for more examples and the form of results.

Answer: {"fn_name": "sum_fracts", "inputs": [[[[1, 2], [1, 3], [1, 4]]], [[[1, 3], [5, 3]]], [[[12, 3], [15, 3]]], [[[2, 7], [1, 3], [1, 12]]], [[[69, 130], [87, 1310], [3, 4]]], [[[77, 130], [84, 131], [60, 80]]], [[[6, 13], [187, 1310], [31, 41]]], [[[8, 15], [7, 111], [4, 25]]], [[]], [[[81345, 15786], [87546, 11111111], [43216, 255689]]], [[[1, 8], [1, 9]]], [[[2, 8], [1, 9]]]], "outputs": [[[13, 12]], [2], [9], [[59, 84]], [[9177, 6812]], [[67559, 34060]], [[949861, 698230]], [[2099, 2775]], [null], [[79677895891146625, 14949283383840498]], [[17, 72]], [[13, 36]]]}
user: Scheduling is how the processor decides which jobs(processes) get to use the processor and for how long. This can cause a lot of problems. Like a really long process taking the entire CPU and freezing all the other processes. One solution is Shortest Job First(SJF), which today you will be implementing.

SJF works by, well, letting the shortest jobs take the CPU first. If the jobs are the same size then it is First In First Out (FIFO). The idea is that the shorter jobs will finish quicker, so theoretically jobs won't get frozen because of large jobs. (In practice they're frozen because of small jobs).

You will be implementing:
```python
  def SJF(jobs, index)
```

It takes in:

1. "jobs" a non-empty array of positive integers. They represent the clock-cycles(cc) needed to finish the job.
2. "index" a positive integer. That represents the job we're interested in.

SJF returns:

1. A positive integer representing the cc it takes to complete the job at index.

Here's an example:
```
SJF([3, 10, 20, 1, 2], 0)
at 0cc [3, 10, 20, 1, 2] jobs[3] starts
at 1cc [3, 10, 20, 0, 2] jobs[3] finishes, jobs[4] starts
at 3cc [3, 10, 20, 0, 0] jobs[4] finishes, jobs[0] starts
at 6cc [0, 10, 20, 0, 0] jobs[0] finishes
```

so:
```
SJF([3,10,20,1,2], 0) == 6
```

Answer: {"fn_name": "SJF", "inputs": [[[100], 0], [[3, 10, 20, 1, 2], 0], [[3, 10, 20, 1, 2], 1], [[3, 10, 10, 20, 1, 2], 1], [[3, 10, 10, 20, 1, 2], 2], [[3, 10, 20, 1, 2, 3], 5], [[3, 10, 20, 1, 2, 10, 10], 5]], "outputs": [[100], [6], [16], [16], [26], [9], [26]]}
user: We are interested in collecting the sets of six prime numbers, that having a starting prime p, the following values are also primes forming the sextuplet ```[p, p + 4, p + 6, p + 10, p + 12, p + 16]```

The first sextuplet that we find is ```[7, 11, 13, 17, 19, 23]```

The second one is ```[97, 101, 103, 107, 109, 113]```

Given a number ```sum_limit```, you should give the first sextuplet which sum (of its six primes) surpasses the sum_limit value.

```python
find_primes_sextuplet(70) == [7, 11, 13, 17, 19, 23]

find_primes_sextuplet(600) == [97, 101, 103, 107, 109, 113]
```
Features of the tests:
```
Number Of Tests = 18
10000 < sum_limit < 29700000
```
If you have solved this kata perhaps you will find easy to solve this one:
https://www.codewars.com/kata/primes-with-two-even-and-double-even-jumps/
Enjoy it!!

Answer: {"fn_name": "find_primes_sextuplet", "inputs": [[70], [600], [2000000]], "outputs": [[[7, 11, 13, 17, 19, 23]], [[97, 101, 103, 107, 109, 113]], [[1091257, 1091261, 1091263, 1091267, 1091269, 1091273]]]}