meetforever/GRPO_CL huggingface dataset:
user: If this challenge is too easy for you, check out: 
https://www.codewars.com/kata/5cc89c182777b00001b3e6a2

___

Upside-Down Pyramid Addition is the process of taking a list of numbers and consecutively adding them together until you reach one number.

When given the numbers `2, 1, 1` the following process occurs:
```
 2   1   1
   3   2 
     5
```

This ends in the number `5`.

___

### YOUR TASK

Given the right side of an Upside-Down Pyramid (Ascending), write a function that will return the original list.

### EXAMPLE

```python
reverse([5, 2, 1]) == [2, 1, 1]
```

NOTE: The Upside-Down Pyramid will never be empty and will always consist of positive integers ONLY.

Answer: {"fn_name": "reverse", "inputs": [[[5, 2, 1]], [[84, 42, 21, 10, 2]], [[83, 47, 28, 16, 7]], [[101, 57, 29, 13, 6]], [[66, 39, 25, 15, 7]], [[45, 25, 14, 8, 6]], [[60, 32, 16, 7, 4]], [[84, 44, 21, 8, 2]], [[51, 26, 13, 6, 2]], [[78, 42, 22, 11, 6]]], "outputs": [[[2, 1, 1]], [[4, 7, 3, 8, 2]], [[6, 4, 3, 9, 7]], [[1, 3, 9, 7, 6]], [[7, 2, 2, 8, 7]], [[3, 1, 4, 2, 6]], [[4, 1, 6, 3, 4]], [[4, 3, 7, 6, 2]], [[3, 3, 3, 4, 2]], [[4, 3, 6, 5, 6]]]}
user: There is a house with 4 levels.
In that house there is an elevator.
You can program this elevator to go up or down,
depending on what button the user touches inside the elevator.

Valid levels must be only these numbers: `0,1,2,3`

Valid buttons must be only these strings: `'0','1','2','3'` 

Possible return values are these numbers: `-3,-2,-1,0,1,2,3`

If the elevator is on the ground floor(0th level) 
and the user touches button '2'
the elevator must go 2 levels up,
so our function must return 2.

If the elevator is on the 3rd level
and the user touches button '0'
the elevator must go 3 levels down, so our function must return -3.

If the elevator is on the 2nd level,
and the user touches button '2'
the elevator must remain on the same level,
so we return 0.

We cannot endanger the lives of our passengers, 
so if we get erronous inputs, 
our elevator must remain on the same level.
So for example:

- `goto(2,'4')` must return 0, because there is no button '4' in the elevator.
- `goto(4,'0')` must return 0, because there is no level 4.
- `goto(3,undefined)` must return 0.
- `goto(undefined,'2')` must return 0.
- `goto([],'2')` must return 0 because the type of the input level is array instead of a number.
- `goto(3,{})` must return 0 because the type of the input button is object instead of a string.

Answer: {"fn_name": "goto", "inputs": [[0, "0"], [0, "1"], [0, "2"], [0, "3"], [1, "0"], [1, "1"], [1, "2"], [1, "3"], [2, "0"], [2, "1"], [2, "2"], [2, "3"], [3, "0"], [3, "1"], [3, "2"], [3, "3"], [0, "4"], [0, null], [1, "4"], [1, null], [2, "4"], [2, null], [3, "4"], [3, null], [4, "2"], [null, "2"], [[], "2"], [3, {}], ["2", "3"], [2, 3], [1.5, "3"], ["length", "length"]], "outputs": [[0], [1], [2], [3], [-1], [0], [1], [2], [-2], [-1], [0], [1], [-3], [-2], [-1], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0], [0]]}
user: A new school year is approaching, which also means students will be taking tests. 

The tests in this kata are to be graded in different ways. A certain number of points will be given for each correct answer and a certain number of points will be deducted for each incorrect answer. For ommitted answers, points will either be awarded, deducted, or no points will be given at all.

Return the number of points someone has scored on varying tests of different lengths.

The given parameters will be:

* An array containing a series of `0`s, `1`s, and `2`s, where `0` is a correct answer, `1` is an omitted answer, and `2` is an incorrect answer.
* The points awarded for correct answers
* The points awarded for omitted answers (note that this may be negative)
* The points **deducted** for incorrect answers (hint: this value has to be subtracted)


**Note:**
The input will always be valid (an array and three numbers)


## Examples

\#1:
```
[0, 0, 0, 0, 2, 1, 0], 2, 0, 1  -->  9
```
because:
* 5 correct answers: `5*2 = 10`
* 1 omitted answer: `1*0 = 0`
* 1 wrong answer: `1*1 = 1`

which is: `10 + 0 - 1 = 9`

\#2:
```
[0, 1, 0, 0, 2, 1, 0, 2, 2, 1], 3, -1, 2)  -->  3
```
because: `4*3 + 3*-1 - 3*2 = 3`

Answer: {"fn_name": "score_test", "inputs": [[[0, 0, 0, 0, 2, 1, 0], 2, 0, 1], [[0, 1, 0, 0, 2, 1, 0, 2, 2, 1], 3, -1, 2], [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 5, -1, 2], [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 2, 0, 0, 0, 0, 1, 1, 2, 2, 2, 2, 0], 6, 0, 1.5], [[0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 0, 2, 1, 2, 0, 2, 1], 10, -5, 10], [[0, 2, 0, 2, 0, 2, 0, 2], 10, 0, 5], [[0, 1, 2, 0, 0, 2, 0, 1, 2, 1, 0, 0, 1, 0, 2, 1, 0, 2, 2, 0], 9, 3, 2]], "outputs": [[9], [3], [70], [87], [-60], [20], [84]]}
user: ## **Task**

You are given a positive integer (`n`), and your task is to find the largest number **less than** `n`, which can be written in the form `a**b`, where `a` can be any non-negative integer and `b` is an integer greater than or equal to `2`. Try not to make the code time out :)

The input range is from `1` to `1,000,000`.

## **Return**

Return your answer in the form `(x, y)` or (`[x, y]`, depending on the language ), where `x` is the value of `a**b`, and `y` is the number of occurrences of `a**b`. By the way ** means ^ or power, so 2 ** 4 = 16.
If you are given a number less than or equal to `4`, that is not `1`, return `(1, -1)`, because there is an infinite number of values for it: `1**2, 1**3, 1**4, ...`.  
If you are given `1`, return `(0, -1)`.

## **Examples**

```
 3  -->  (1, -1)  # because it's less than 4
 6  -->  (4, 1)   # because the largest such number below 6 is 4,
                  # and there is only one way to write it: 2**2
65  -->  (64, 3)  # because there are three occurrences of 64: 2**6, 4**3, 8**2
90  -->  (81, 2)  # because the largest such number below 90 is 81,
                  # and there are two ways of getting it: 3**4, 9**2
```
By the way, after finishing this kata, please try some of my other katas: [here.](https://www.codewars.com/collections/tonylicodings-authored-katas)

Answer: {"fn_name": "largest_power", "inputs": [[90], [6], [65], [2], [1], [81], [29], [4]], "outputs": [[[81, 2]], [[4, 1]], [[64, 3]], [[1, -1]], [[0, -1]], [[64, 3]], [[27, 1]], [[1, -1]]]}
user: Your job is to write a function that takes a string and a maximum number of characters per line and then inserts line breaks as necessary so that no line in the resulting string is longer than the specified limit.

If possible, line breaks should not split words. However, if a single word is longer than the limit, it obviously has to be split. In this case, the line break should be placed after the first part of the word (see examples below).

Really long words may need to be split multiple times.

#Input

A word consists of one or more letters.

Input text will be the empty string or a string consisting of one or more words separated by single spaces. It will not contain any punctiation or other special characters.

The limit will always be an integer greater or equal to one.

#Examples

**Note:** Line breaks in the results have been replaced with two dashes to improve readability.

1. ("test", 7) -> "test"
2. ("hello world", 7) -> "hello--world"
3. ("a lot of words for a single line", 10) -> "a lot of--words for--a single--line"
4. ("this is a test", 4) -> "this--is a--test"
5. ("a longword", 6) -> "a long--word"
6. ("areallylongword", 6) -> "areall--ylongw--ord"

**Note:** Sometimes spaces are hard to see in the test results window.

Answer: {"fn_name": "word_wrap", "inputs": [["test", 7], ["hello world", 7], ["a lot of words for a single line", 10], ["this is a test", 4], ["a longword", 6], ["areallylongword", 6], ["aa", 3], ["aaa", 3], ["aaaa", 3], ["a a", 3], ["a aa", 3], ["a aaa", 3], ["a aaaa", 3], ["a aaaaa", 3], ["a a a", 3], ["a aa a", 3], ["a aaa a", 3], ["a aaaa a", 3], ["a aaaaa a", 3], ["a a aaa", 3], ["a aa aaa", 3], ["a aaa aaa", 3], ["a aaaa aaa", 3], ["a aaaaa aaa", 3], ["aaa aaaa a", 3], ["a b c dd eee ffff g hhhhh i", 3]], "outputs": [["test"], ["hello\nworld"], ["a lot of\nwords for\na single\nline"], ["this\nis a\ntest"], ["a long\nword"], ["areall\nylongw\nord"], ["aa"], ["aaa"], ["aaa\na"], ["a a"], ["a\naa"], ["a\naaa"], ["a a\naaa"], ["a a\naaa\na"], ["a a\na"], ["a\naa\na"], ["a\naaa\na"], ["a a\naaa\na"], ["a a\naaa\na a"], ["a a\naaa"], ["a\naa\naaa"], ["a\naaa\naaa"], ["a a\naaa\naaa"], ["a a\naaa\na\naaa"], ["aaa\naaa\na a"], ["a b\nc\ndd\neee\nfff\nf g\nhhh\nhh\ni"]]}
user: For encrypting strings this region of chars is given (in this order!):

* all letters (ascending, first all UpperCase, then all LowerCase)
* all digits (ascending)
* the following chars: `.,:;-?! '()$%&"` 

These are 77 chars! (This region is zero-based.)

Write two methods: 
```python
def encrypt(text)
def decrypt(encrypted_text)
```

Prechecks:
1. If the input-string has chars, that are not in the region, throw an Exception(C#, Python) or Error(JavaScript).
2. If the input-string is null or empty return exactly this value!

For building the encrypted string:
1. For every second char do a switch of the case.
2. For every char take the index from the region. Take the difference from the region-index of the char before (from the input text! Not from the fresh encrypted char before!). (Char2 = Char1-Char2)
Replace the original char by the char of the difference-value from the region. In this step the first letter of the text is unchanged.
3. Replace the first char by the mirror in the given region. (`'A' -> '"'`, `'B' -> '&'`, ...)

Simple example:

* Input:  `"Business"`
* Step 1: `"BUsInEsS"`
* Step 2: `"B61kujla"`
  * `B -> U`
    * `B (1) - U (20) = -19`
    * `-19 + 77 = 58`
    * `Region[58] = "6"`
  * `U -> s`
    * `U (20) - s (44) = -24`
    * `-24 + 77 = 53`
    * `Region[53] = "1"`
* Step 3: `"&61kujla"`

This kata is part of the Simple Encryption Series:
Simple Encryption #1 - Alternating Split
Simple Encryption #2 - Index-Difference
Simple Encryption #3 - Turn The Bits Around
Simple Encryption #4 - Qwerty

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

Answer: {"fn_name": "decrypt", "inputs": [["$-Wy,dM79H'i'o$n0C&I.ZTcMJw5vPlZc Hn!krhlaa:khV mkL;gvtP-S7Rt1Vp2RV:wV9VuhO Iz3dqb.U0w"], ["5MyQa9p0riYplZc"], ["5MyQa79H'ijQaw!Ns6jVtpmnlZ.V6p"], [""], [null]], "outputs": [["Do the kata \"Kobayashi-Maru-Test!\" Endless fun and excitement when finding a solution!"], ["This is a test!"], ["This kata is very interesting!"], [""], [null]]}
user: *** Nova polynomial from roots*** 

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 create the polynomial from a list of roots:

[r0, r1 ,r2, r3 ]

p = (x-r0)(x-r1)(x-r2)(x-r3)

note: no roots should return the identity polynomial.

```python 
poly_from_roots([4]) = [-4, 1]
poly_from_roots([0, 0, 0, 0] ) = [0, 0, 0, 0, 1]
poly_from_roots([]) = [1]
```
The first katas of this series is preloaded in the code and can be used: [poly_add](http://www.codewars.com/kata/570eb07e127ad107270005fe) [poly_multiply](http://www.codewars.com/kata/570eb07e127ad107270005fe)

Answer: {"fn_name": "poly_from_roots", "inputs": [[[4]], [[0, 0, 0, 0]], [[1, 1, 1, 1]], [[-1, 1, 2, -2]], [[]]], "outputs": [[[-4, 1]], [[0, 0, 0, 0, 1]], [[1, -4, 6, -4, 1]], [[4, 0, -5, 0, 1]], [[1]]]}
user: Calculate the product of all elements in an array.
```if:csharp
If the array is *null*, you should throw `ArgumentNullException` and if the array is empty, you should throw `InvalidOperationException`.

As a challenge, try writing your method in just one line of code. It's possible to have only 36 characters within your method.
```
```if:javascript
If the array is `null` or is empty, the function should return `null`.
```
```if:haskell
If the array is empty then return Nothing, else return Just product.
```
```if:php
If the array is `NULL` or empty, return `NULL`.
```
```if:python
If the array is empty or `None`, return `None`.
```
```if:ruby
If the array is `nil` or is empty, the function should return `nil`.
```
```if:crystal
If the array is `nil` or is empty, the function should return `nil`.
```
```if:groovy
If the array is `null` or `empty` return `null`.
```
```if:julia
If the input is `nothing` or an empty array, return `nothing`
```

Answer: {"fn_name": "product", "inputs": [[[5, 4, 1, 3, 9]], [[-2, 6, 7, 8]], [[10]], [[0, 2, 9, 7]], [null], [[]]], "outputs": [[540], [-672], [10], [0], [null], [null]]}
user: _This kata is based on [Project Euler Problem 546](https://projecteuler.net/problem=546)_

# Objective

Given the recursive sequence 

fk(n) =


∑

i
=
0


n



fk(floor(i / k)) where fk(0) = 1

Define a function `f` that takes arguments `k` and `n` and returns the nth term in the sequence fk

## Examples

`f(2, 3)` = f2(3) = 6

`f(2, 200)` = f2(200) = 7389572

`f(7, 500)` = f7(500) = 74845

`f(1000, 0)` = f1000(0) = 1


**Note:** 
No error checking is needed, `k` ranges from 2 to 100 and `n` ranges between 0 and 500000 (mostly small and medium values with a few large ones)


As always any feedback would be much appreciated

Answer: {"fn_name": "f", "inputs": [[2, 3], [2, 200], [2, 1000], [7, 500], [100, 0], [3, 50000], [97, 100000], [100, 500000]], "outputs": [[6], [7389572], [264830889564], [74845], [1], [80887845303700596855], [209497156], [21469002551]]}
user: In computer science, cycle detection is the algorithmic problem of finding a cycle in a sequence of iterated function values.

For any function ƒ, and any initial value x0 in S, the sequence of iterated function values

    x0,x1=f(x0), x2=f(x1), ...,xi=f(x{i-1}),...

may eventually use the same value twice under some assumptions: S finite, f periodic ... etc. So there will be some `i ≠ j` such that `xi = xj`. Once this happens, the sequence must continue by repeating the cycle of values from `xi to xj−1`. Cycle detection is the problem of finding `i` and `j`, given `ƒ` and `x0`. Let `μ` be the smallest index such that the value associated will reappears and `λ` the smallest value such that `xμ = xλ+μ, λ` is the loop length.

Example:

Consider the sequence: 
```
2, 0, 6, 3, 1, 6, 3, 1, 6, 3, 1, ....
```

The cycle in this value sequence is 6, 3, 1.
μ is 2 (first 6)
λ is 3 (length of the sequence or difference between position of consecutive 6).

The goal of this kata is to build a function that will return `[μ,λ]` when given a short sequence. Simple loops will be sufficient. The sequence will be given in the form of an array. All array will be valid sequence associated with deterministic function. It means that the sequence will repeat itself when a value is reached a second time. (So you treat two cases: non repeating [1,2,3,4] and repeating [1,2,1,2], no hybrid cases like [1,2,1,4]). If there is no repetition you should return []. 


This kata is followed by two other cycle detection algorithms: 
Loyd's: http://www.codewars.com/kata/cycle-detection-floyds-tortoise-and-the-hare
Bret's: http://www.codewars.com/kata/cycle-detection-brents-tortoise-and-hare

Answer: {"fn_name": "cycle", "inputs": [[[2, 3, 4, 2, 3, 4]], [[1, 2, 3, 4, 2, 3, 4]], [[1, 1, 1, 1, 1, 1, 1, 1]], [[]], [[7]], [[1, 2, 3, 4]]], "outputs": [[[0, 3]], [[1, 3]], [[0, 1]], [[]], [[]], [[]]]}
user: You are given three integers in the range [0-99]. You must determine if any ordering of the numbers forms a date from the 20th century.

- If no ordering forms a date, return the string `"invalid"`.

- If multiple distinct orderings form dates, return the string `"ambiguous"`.

- If only one ordering forms a date, return that date as a string with format `"YY/MM/DD"`.

## Examples

```python
unique_date(13, 12, 77) == '77/12/13' # only the ordering (77, 12, 13) forms a date
unique_date(13, 77, 12) == '77/12/13' # argument order is irrelevant

unique_date(1, 2, 3) == 'ambiguous' # 01/02/03, 02/01/03, ...
unique_date(3, 2, 1) == 'ambiguous'

unique_date(50, 40, 60) == 'invalid' # no ordering could form a date
unique_date(40, 50, 60) == 'invalid'
```

## Note
This kata was inspired by my encounter with [google.com/foobar](http://www.google.com/foobar)

Answer: {"fn_name": "unique_date", "inputs": [["[[2, 3, 4, 2, 3, 4]]", "[[1, 2, 3, 4, 2, 3, 4]]", "[[1, 1, 1, 1, 1, 1, 1, 1]]", "[[]]", "[[7]]", "[[1, 2, 3, 4]]"]], "outputs": [["invalid"]]}
user: Modify the spacify function so that it returns the given string with spaces inserted between each character.

```python
spacify("hello world") # returns "h e l l o   w o r l d"
```

Answer: {"fn_name": "spacify", "inputs": [[""], ["a"], ["Pippi"]], "outputs": [[""], ["a"], ["P i p p i"]]}
user: You were given a string of integer temperature values. Create a function `close_to_zero(t)` and return the closest value to 0 or `0` if the string is empty. If two numbers are equally close to zero, return the positive integer.

Answer: {"fn_name": "close_to_zero", "inputs": [[""], ["-1 50 -4 20 22 -7 0 10 -8"], ["28 35 -21 17 38 -17"]], "outputs": [[0], [0], [17]]}
user: Simple interest on a loan is calculated by simply taking the initial amount (the principal, p) and multiplying it by a rate of interest (r) and the number of time periods (n). 

Compound interest is calculated by adding the interest after each time period to the amount owed, then calculating the next interest payment based on the principal PLUS the interest from all previous periods.

Given a principal *p*, interest rate *r*, and a number of periods *n*, return an array [total owed under simple interest, total owed under compound interest]. 

```
EXAMPLES:

interest(100,0.1,1) = [110,110]
interest(100,0.1,2) = [120,121]
interest(100,0.1,10) = [200,259]
```
 
Round all answers to the nearest integer. Principal will always be an integer between 0 and 9999; interest rate will be a decimal between 0 and 1; number of time periods will be an integer between 0 and 49. 
 
---

More on [Simple interest, compound interest and continuous interest](https://betterexplained.com/articles/a-visual-guide-to-simple-compound-and-continuous-interest-rates/)

Answer: {"fn_name": "interest", "inputs": [[100, 0.1, 1], [100, 0.1, 2], [100, 0.1, 10], [100, 0, 10], [0, 0.1, 10], [100, 0.1, 0]], "outputs": [[[110, 110]], [[120, 121]], [[200, 259]], [[100, 100]], [[0, 0]], [[100, 100]]]}
user: ```if-not:sql
Implement a function that receives two IPv4 addresses, and returns the number of addresses between them (including the first one, excluding the last one).
```

```if:sql
Given a database of first and last IPv4 addresses, calculate the number of addresses between them (including the first one, excluding the last one).

## Input

~~~
---------------------------------
|     Table    | Column | Type  |
|--------------+--------+-------|
| ip_addresses | id     | int   |
|              | first  | text  |
|              | last   | text  |
---------------------------------
~~~

## Output

~~~
----------------------
|   Column    | Type |
|-------------+------|
| id          | int  |
| ips_between | int  |
----------------------
~~~
```

All inputs will be valid IPv4 addresses in the form of strings. The last address will always be greater than the first one.

___

## Examples

```python
ips_between("10.0.0.0", "10.0.0.50")  ==   50 
ips_between("10.0.0.0", "10.0.1.0")   ==  256 
ips_between("20.0.0.10", "20.0.1.0")  ==  246
```

Answer: {"fn_name": "ips_between", "inputs": [["150.0.0.0", "150.0.0.1"], ["10.0.0.0", "10.0.0.50"], ["20.0.0.10", "20.0.1.0"], ["10.11.12.13", "10.11.13.0"], ["160.0.0.0", "160.0.1.0"], ["170.0.0.0", "170.1.0.0"], ["50.0.0.0", "50.1.1.1"], ["180.0.0.0", "181.0.0.0"], ["1.2.3.4", "5.6.7.8"]], "outputs": [[1], [50], [246], [243], [256], [65536], [65793], [16777216], [67372036]]}
user: Your goal is to create a function to format a number given a template; if the number is not present, use the digits `1234567890` to fill in the spaces.

A few rules:

* the template might consist of other numbers, special characters or the like: you need to replace only alphabetical characters (both lower- and uppercase);
* if the given or default string representing the number is shorter than the template, just repeat it to fill all the spaces.

A few examples:

```python
numeric_formatter("xxx xxxxx xx","5465253289") == "546 52532 89"
numeric_formatter("xxx xxxxx xx") == "123 45678 90"
numeric_formatter("+555 aaaa bbbb", "18031978") == "+555 1803 1978"
numeric_formatter("+555 aaaa bbbb") == "+555 1234 5678"
numeric_formatter("xxxx yyyy zzzz") == "1234 5678 9012"
```

Answer: {"fn_name": "numeric_formatter", "inputs": [["xxx xxxxx xx", "5465253289"], ["xxx xxxxx xx"], ["+555 aaaa bbbb", "18031978"], ["+555 aaaa bbbb"], ["xxxx yyyy zzzz"]], "outputs": [["546 52532 89"], ["123 45678 90"], ["+555 1803 1978"], ["+555 1234 5678"], ["1234 5678 9012"]]}
user: ## Story

Your company migrated the last 20 years of it's *very important data* to a new platform, in multiple phases. However, something went wrong: some of the essential time-stamps were messed up! It looks like that some servers were set to use the `dd/mm/yyyy` date format, while others were using the `mm/dd/yyyy` format during the migration. Unfortunately, the original database got corrupted in the process and there are no backups available... Now it's up to you to assess the damage.

## Task

You will receive a list of records as strings in the form of `[start_date, end_date]` given in the ISO `yyyy-mm-dd` format, and your task is to count how many of these records are: 
* **correct**: there can be nothing wrong with the dates, the month/day cannot be mixed up, or it would not make a valid timestamp in any other way; e.g. `["2015-04-04", "2015-05-13"]`
* **recoverable**: invalid in its current form, but the original timestamp can be recovered, because there is only one valid combination possible; e.g. `["2011-10-08", "2011-08-14"]`
* **uncertain**: one or both dates are ambiguous, and they may generate multiple valid timestamps, so the original cannot be retrieved; e.g. `["2002-02-07", "2002-12-10"]`

**Note:** the original records always defined a *non-negative* duration

Return your findings in an array: `[ correct_count, recoverable_count, uncertain_count ]`

## Examples

---

## My other katas

If you enjoyed this kata then please try [my other katas](https://www.codewars.com/collections/katas-created-by-anter69)! :-)

Answer: {"fn_name": "check_dates", "inputs": [[[]]], "outputs": [[[0, 0, 0]]]}