meetforever/GRPO_CL huggingface dataset:
user: ### self_converge
`Goal`: Given a number (with a minimum of 3 digits), return the number of iterations it takes to arrive at a derived number that converges on to itself, as per the following [Kaprekar][Kaprekar] routine. As a learning exercise, come up with a solution that uses recursion. The
following steps would be applicable to a number that originally had
exactly 4 digits.

0. Initialize a counter to count the number of iterations
1. Take any four-digit number `n`, using at least two different digits.
2. Arrange the digits in descending and then in ascending order to get two four-digit numbers, adding leading zeros if necessary. 
    - Add as many zeroes so that the width of the original number is maintained.
3. Subtract the smaller number from the bigger number. Let us call this `nseq`.
4. Check if `nseq` (the remainder) from Step 4 equals the previous value of `n`. If not, increment the iteration counter and go back to step 2 and perform it on the `nseq`. 

If the number of digits to start with was more than 4, convergence occurs on to a `cycle` of numbers. Therefore in Step 5, detect this cycle by comparing to not only the previous value, but to all previous values of `n`.
  - If there is a match, then return the count of iterations
  - If the sequence_number collapses to zero, then return -1 

[Kaprekar]: http://mathworld.wolfram.com/KaprekarRoutine.html

### Converge values  
While 3-digit numbers converge to the same unique number `k` which is also 3 digits long, all 4-digit numbers also converge to the same unique value `k1` which is 4 digits long. However, 5 digit numbers converge to any one of the following values: `53955, 59994, 61974, 62964, 63954, 71973, 74943, 75933, 82962, 83952`.

### Example
`1234`  ->   `4`
```
1. 4321 - 1234 =  3087 /   
2. 8730 - 378  =  8352 /   
3. 8532 - 2358 =  6174 /   
4. 7641 - 1467 =  6174 // same as previous
```
`414` -> `5`
```
1. 441 - 144 =  297 /   
2. 972 - 279 =  693 /   
3. 963 - 369 =  594 /
4. 954 - 459 =  495 /
5. 954 - 459 =  495 // same as previous
```
`50000` -> `4`
```
1. 50000 - 5      =  49995 /   
2. 99954 - 45999  =  53955 /  # first 
3. 95553 - 35559  =  59994 /
4. 99954 - 45999  =  53955 /  # 2nd time
```

Answer: {"fn_name": "self_converge", "inputs": [[4321], [2111], [211], [90900], [992299229]], "outputs": [[4], [6], [7], [9], [22]]}
user: # Task

Given the birthdates of two people, find the date when the younger one is exactly half the age of the other.

# Notes

* The dates are given in the format YYYY-MM-DD and are not sorted in any particular order
* Round **down** to the nearest day
* Return the result as a string, like the input dates

Answer: {"fn_name": "half_life", "inputs": [["1990-12-06", "2000-02-29"], ["2012-03-31", "1990-06-09"], ["1984-08-14", "1990-04-17"], ["2000-06-30", "1978-03-17"], ["1969-12-20", "2000-10-07"]], "outputs": [["2009-05-24"], ["2034-01-21"], ["1995-12-19"], ["2022-10-14"], ["2031-07-26"]]}
user: # Task

Write a function named `sumEvenNumbers`, taking a sequence of numbers as single parameter. Your function must return the sum of **the even values** of this sequence.

Only numbers without decimals like `4` or `4.0` can be even. 

## Input
* sequence of numbers: those numbers could be integers and/or floats. 


For example, considering this input value : `[4,3,1,2,5,10,6,7,9,8]`, then your function should return `30` (because `4 + 2 + 10 + 6 + 8 = 30`).

Answer: {"fn_name": "sum_even_numbers", "inputs": [[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], [[]], [[1337, 374, 849, 22.5, 19, 16, 0, 0, 16, 32]], [[-16, -32, 20, 21, 41, 42]], [[15397, 12422, 10495, 22729, 23921, 18326, 27955, 24073, 23690, 15002, 11615, 15682, 24346, 16725, 17252, 20467, 20493, 17807, 13041, 25861, 22471, 22747, 24082, 18979, 28543, 26488, 10002, 24740, 17950, 26573, 25851, 19446, 22584, 14857, 17387, 29310, 28265, 19497, 11394, 28111, 20957, 17201, 26647, 26885, 27297, 17252, 25961, 12409, 22858, 27869, 19832, 13906, 11256, 11304, 24186, 28783, 16647, 23073, 11105, 13327, 17102, 10172, 21104, 23001, 24108, 16166, 21690, 14218, 11903, 10286, 19116, 18585, 25511, 18273, 11862, 17166, 13456, 28562, 16262, 11100, 22806, 14748, 17362, 11633, 17165, 16390, 24580, 22498, 26121, 16170, 18917, 26963, 17605, 20839, 22487, 12187, 23752, 12444, 14392, 28313]]], "outputs": [[30], [0], [438], [14], [870822]]}
user: In this kata you will create a function that takes a list of non-negative integers and strings and returns a new list with the strings filtered out.

### Example

```python
filter_list([1,2,'a','b']) == [1,2]
filter_list([1,'a','b',0,15]) == [1,0,15]
filter_list([1,2,'aasf','1','123',123]) == [1,2,123]
```

Answer: {"fn_name": "filter_list", "inputs": [[[1, 2, "a", "b"]], [[1, "a", "b", 0, 15]], [[1, 2, "aasf", "1", "123", 123]], [["a", "b", "1"]]], "outputs": [[[1, 2]], [[1, 0, 15]], [[1, 2, 123]], [[]]]}
user: Given a name, turn that name into a perfect square matrix (nested array with the amount of arrays equivalent to the length of each array). 

You will need to add periods (`.`) to the end of the name if necessary, to turn it into a matrix. 

If the name has a length of 0, return `"name must be at least one letter"`

## Examples

"Bill" ==> [ ["B", "i"],
             ["l", "l"] ]

"Frank" ==> [ ["F", "r", "a"],
              ["n", "k", "."],
              [".", ".", "."] ]

Answer: {"fn_name": "matrixfy", "inputs": [[""], ["G"], ["Beyonce"], ["Franklin"], ["Bill"], ["Frank"]], "outputs": [["name must be at least one letter"], [[["G"]]], [[["B", "e", "y"], ["o", "n", "c"], ["e", ".", "."]]], [[["F", "r", "a"], ["n", "k", "l"], ["i", "n", "."]]], [[["B", "i"], ["l", "l"]]], [[["F", "r", "a"], ["n", "k", "."], [".", ".", "."]]]]}
user: Learning to code around your full time job is taking over your life. You realise that in order to make significant steps quickly, it would help to go to a coding bootcamp in London.

Problem is, many of them cost a fortune, and those that don't still involve a significant amount of time off work - who will pay your mortgage?!

To offset this risk, you decide that rather than leaving work totally, you will request a sabbatical so that you can go back to work post bootcamp and be paid while you look for your next role.

You need to approach your boss. Her decision will be based on three parameters:

val=your value to the organisation
happiness=her happiness level at the time of asking and finally
The numbers of letters from 'sabbatical' that are present in string `s`.

Note that if `s` contains three instances of the letter 'l', that still scores three points, even though there is only one in the word sabbatical.

If the sum of the three parameters (as described above) is > 22, return 'Sabbatical! Boom!', else return 'Back to your desk, boy.'.

~~~if:c
NOTE: For the C translation you should return a string literal.
~~~

Answer: {"fn_name": "sabb", "inputs": [["Can I have a sabbatical?", 5, 5], ["Why are you shouting?", 7, 2], ["What do you mean I cant learn to code??", 8, 9], ["Please calm down", 9, 1], ["I can?! Nice. FaC..Im coming :D", 9, 9]], "outputs": [["Sabbatical! Boom!"], ["Back to your desk, boy."], ["Sabbatical! Boom!"], ["Back to your desk, boy."], ["Sabbatical! Boom!"]]}
user: Find the second-to-last element of a list.

Example:
```python
penultimate([1,2,3,4])            # => 3
penultimate(["Python is dynamic"]) # => 'i'
(courtesy of [haskell.org](http://www.haskell.org/haskellwiki/99_questions/1_to_10))
```

Answer: {"fn_name": "penultimate", "inputs": [[[1, 2, 3, 4]], ["hello"]], "outputs": [[3], ["l"]]}
user: Write a function that takes an integer and returns an array `[A, B, C]`, where `A` is the number of multiples of 3 (but not 5) below the given integer, `B` is the number of multiples of 5 (but not 3) below the given integer and `C` is the number of multiples of 3 and 5 below the given integer. 

For example, `solution(20)` should return `[5, 2, 1]`

~~~if:r
```r
# in R, returns a numeric vector
solution(20)
[1] 5 2 1

class(solution(20))
[1] "numeric"
```
~~~

Answer: {"fn_name": "solution", "inputs": [[20], [2020], [4], [2], [30], [300], [14], [141], [1415], [91415]], "outputs": [[[5, 2, 1]], [[539, 269, 134]], [[1, 0, 0]], [[0, 0, 0]], [[8, 4, 1]], [[80, 40, 19]], [[4, 2, 0]], [[37, 19, 9]], [[377, 188, 94]], [[24377, 12188, 6094]]]}
user: A category page displays a set number of products per page, with pagination at the bottom allowing the user to move from page to page.

Given that you know the page you are on, how many products are in the category in total, and how many products are on any given page, how would you output a simple string showing which products you are viewing..

examples

In a category of 30 products with 10 products per page, on page 1 you would see 

'Showing 1 to 10 of 30 Products.'

In a category of 26 products with 10 products per page, on page 3 you would see

'Showing 21 to 26 of 26 Products.'

In a category of 8 products with 10 products per page, on page 1 you would see

'Showing 1 to 8 of 8 Products.'

Answer: {"fn_name": "pagination_text", "inputs": [[1, 10, 30], [3, 10, 26], [1, 10, 8], [2, 30, 350], [1, 23, 30], [2, 23, 30], [43, 15, 3456]], "outputs": [["Showing 1 to 10 of 30 Products."], ["Showing 21 to 26 of 26 Products."], ["Showing 1 to 8 of 8 Products."], ["Showing 31 to 60 of 350 Products."], ["Showing 1 to 23 of 30 Products."], ["Showing 24 to 30 of 30 Products."], ["Showing 631 to 645 of 3456 Products."]]}
user: You are given an array (which will have a length of at least 3, but could be very large) containing integers. The array is either entirely comprised of odd integers or entirely comprised of even integers except for a single integer `N`. Write a method that takes the array as an argument and returns this "outlier" `N`.

## Examples

```python
[2, 4, 0, 100, 4, 11, 2602, 36]
Should return: 11 (the only odd number)

[160, 3, 1719, 19, 11, 13, -21]
Should return: 160 (the only even number)
```

Answer: {"fn_name": "find_outlier", "inputs": [[[0, 1, 2]], [[1, 2, 3]]], "outputs": [[1], [2]]}
user: *Are you a file extension master? Let's find out by checking if Bill's files are images or audio files. Please use regex if available natively for your language.*

You will create 2 string methods:

- **isAudio/is_audio**, matching 1 or + uppercase/lowercase letter(s) (combination possible), with the extension .mp3, .flac, .alac, or .aac.

- **isImage/is_image**, matching 1 or + uppercase/lowercase letter(s) (combination possible), with the extension .jpg, .jpeg, .png, .bmp, or .gif. 


*Note that this is not a generic image/audio files checker. It's meant to be a test for Bill's files only. Bill doesn't like punctuation. He doesn't like numbers, neither. Thus, his filenames are letter-only*

**Rules**

1. It should return true or false, simply.
2. File extensions should consist of lowercase letters and numbers only.
3. File names should consist of letters only (uppercase, lowercase, or both)

Good luck!

Answer: {"fn_name": "is_audio", "inputs": [["Nothing Else Matters.mp3"], ["NothingElseMatters.mp3"], ["DaftPunk.FLAC"], ["DaftPunk.flac"], ["AmonTobin.aac"], [" Amon Tobin.alac"], ["tobin.alac"]], "outputs": [[false], [true], [false], [true], [true], [false], [true]]}
user: Given a random string consisting of numbers, letters, symbols, you need to sum up the numbers in the string. 

Note:

- Consecutive integers should be treated as a single number. eg, `2015` should be treated as a single number `2015`, NOT four numbers
- All the numbers should be treaded as positive integer. eg, `11-14` should be treated as two numbers `11` and `14`. Same as `3.14`, should be treated as two numbers `3` and `14`
- If no number was given in the string, it should return `0`


Example:

```
str = "In 2015, I want to know how much does iPhone 6+ cost?"
```

 The numbers are `2015`, `6`

Sum is `2021`.

Answer: {"fn_name": "sum_from_string", "inputs": [["In 2015, I want to know how much does iPhone 6+ cost?"], ["1+1=2"], ["e=mc^2"], ["aHR0cDovL3d3dy5jb2Rld2Fycy5jb20va2F0YS9uZXcvamF2YXNjcmlwdA=="], ["a30561ff4fb19170aa598b1431b52edad1fcc3e0"], ["x1KT   CmZ__\rYouOY8Uqu-ETtz"], ["x1KT-8&*@\"CmZ__\rYouO  __Y8Uq\\u-ETtz"], [""], ["Hello World"]], "outputs": [[2021], [4], [2], [53], [51820], [9], [17], [0], [0]]}
user: The characters of Chima need your help. Their weapons got mixed up! They need you to write a program that accepts the name of a character in Chima then tells which weapon he/she owns.

For example: for the character `"Laval"` your program should return the solution `"Laval-Shado Valious"`

You must complete the following character-weapon pairs:

* Laval-Shado Valious, 
* Cragger-Vengdualize, 
* Lagravis-Blazeprowlor, 
* Crominus-Grandorius, 
* Tormak-Tygafyre, 
* LiElla-Roarburn. 
    
Return `"Not a character"` for invalid inputs.

Answer: {"fn_name": "identify_weapon", "inputs": [["Laval"], ["Crominus"], ["Lagravis"], ["Cragger"], ["Tormak"], ["LiElla"], ["G'loona"], ["Stinkin gorillas"], ["qwertyuiopasdfghjklzxcvbnm"]], "outputs": [["Laval-Shado Valious"], ["Crominus-Grandorius"], ["Lagravis-Blazeprowlor"], ["Cragger-Vengdualize"], ["Tormak-Tygafyre"], ["LiElla-Roarburn"], ["Not a character"], ["Not a character"], ["Not a character"]]}
user: ## Emotional Sort ( ︶︿︶)

You'll have a function called "**sortEmotions**" that will return an array of **emotions** sorted. It has two parameters, the first parameter called "**arr**" will expect an array of **emotions** where an **emotion** will be one of the following:

- **:D** -> Super Happy
- **:)** -> Happy
- **:|** -> Normal
- **:(** -> Sad
- **T\_T** -> Super Sad

Example of the array:``[ 'T_T', ':D', ':|', ':)', ':(' ]``

And the second parameter is called "**order**", if this parameter is **true** then the order of the emotions will be descending (from **Super Happy** to **Super Sad**) if it's **false** then it will be ascending (from **Super Sad** to **Super Happy**)

Example if **order** is true with the above array: ``[ ':D', ':)', ':|', ':(', 'T_T' ]``

- Super Happy -> Happy -> Normal -> Sad -> Super Sad

If **order** is false: ``[ 'T_T', ':(', ':|', ':)', ':D' ]``

- Super Sad -> Sad -> Normal -> Happy -> Super Happy

Example:
```
arr = [':D', ':|', ':)', ':(', ':D']
sortEmotions(arr, true) // [ ':D', ':D', ':)', ':|', ':(' ]
sortEmotions(arr, false) // [ ':(', ':|', ':)', ':D', ':D' ]

```

**More in test cases!**

Notes:
- The array could be empty, in that case return the same empty array ¯\\\_( ツ )\_/¯
- All **emotions** will be valid

## Enjoy! (づ｡◕‿‿◕｡)づ

Answer: {"fn_name": "sort_emotions", "inputs": [[[":D", "T_T", ":D", ":("], true], [["T_T", ":D", ":(", ":("], true], [[":)", "T_T", ":)", ":D", ":D"], true], [[":D", "T_T", ":D", ":("], false], [["T_T", ":D", ":(", ":("], false], [[":)", "T_T", ":)", ":D", ":D"], false], [[], false], [[], true]], "outputs": [[[":D", ":D", ":(", "T_T"]], [[":D", ":(", ":(", "T_T"]], [[":D", ":D", ":)", ":)", "T_T"]], [["T_T", ":(", ":D", ":D"]], [["T_T", ":(", ":(", ":D"]], [["T_T", ":)", ":)", ":D", ":D"]], [[]], [[]]]}
user: Python dictionaries are inherently unsorted. So what do you do if you need to sort the contents of a dictionary?

Create a function that returns a sorted list of `(key, value)` tuples (Javascript: arrays of 2 items).

The list must be sorted by the `value` and be sorted **largest to smallest**.

## Examples

```python
sort_dict({3:1, 2:2, 1:3}) == [(1,3), (2,2), (3,1)]
sort_dict({1:2, 2:4, 3:6}) == [(3,6), (2,4), (1,2)]
```

Answer: {"fn_name": "sort_dict", "inputs": [[{"1": 3, "2": 2, "3": 1}], [{"1": 2, "2": 4, "3": 6}], [{"1": 5, "3": 10, "2": 2, "6": 3, "8": 8}], [{"a": 6, "b": 2, "c": 4}]], "outputs": [[[[1, 3], [2, 2], [3, 1]]], [[[3, 6], [2, 4], [1, 2]]], [[[3, 10], [8, 8], [1, 5], [6, 3], [2, 2]]], [[["a", 6], ["c", 4], ["b", 2]]]]}
user: You are making your very own boardgame. The game is played by two opposing players, featuring a 6 x 6 tile system, with the players taking turns to move their pieces (similar to chess). The design is finished, now it's time to actually write and implement the features. Being the good programmer you are, you carefully plan the procedure and break the program down into smaller managable sections. You decide to start coding the logic for resolving "fights" when two pieces engage in combat on a tile. 

Your boardgame features four unique pieces: 

Swordsman, Cavalry, Archer and Pikeman

Each piece has unique movement and has advantages and weaknesses in combat against one of the other pieces. 

Task

You must write a function ```fightResolve``` that takes the attacking and defending piece as input parameters, and returns the winning piece. It may be the case that both the attacking and defending piece belong to the same player, after which you must return an error value to indicate an illegal move. 

In C++ and C, the pieces will be represented as ```chars```. Values will be case-sensitive to display ownership. Let the following char values represent each piece from their respective player.

Player 1:  ```p```= Pikeman, ```k```= Cavalry, ```a```= Archer, ```s```= Swordsman 

Player 2:  ```P```= Pikeman, ```K```= Cavalry, ```A```= Archer, ```S```= Swordsman 

The outcome of the fight between two pieces depends on which piece attacks, the type of the attacking piece and the type of the defending piece. Archers always win against swordsmens, swordsmen always win against pikemen, pikemen always win against cavalry and cavalry always win against archers. If a matchup occurs that was not previously mentioned (for example Archers vs Pikemen) the attacker will always win. This table represents the winner of each possible engagement between an attacker and a defender.


(Attacker→)
    (Defender↓)
Archer
Pikeman
Swordsman
Knight


Knight
Defender
Attacker
Attacker
Attacker


Swordsman
Attacker
Defender
Attacker
Attacker


Archer
Attacker
Attacker
Defender
Attacker


Pikeman
Attacker
Attacker
Attacker
Defender



If two pieces from the same player engage in combat, i.e P vs S or k vs a, the function must return -1 to signify and illegal move. Otherwise assume that no other illegal values will be passed.

Examples

Function prototype: fightResolve(defender, attacker)
1. fightResolve('a', 'P') outputs 'P'. No interaction defined between Pikemen and Archer. Pikemen is the winner here because it is the attacking piece.

2. fightResolve('k', 'A') outputs 'k'. Knights always defeat archers, even if Archer is the attacking piece here.

3. fightResolve('S', 'A') outputs -1. Friendly units don't fight. Return -1 to indicate error.

Answer: {"fn_name": "fight_resolve", "inputs": [["K", "A"], ["S", "A"], ["k", "s"], ["a", "a"], ["k", "A"], ["K", "a"]], "outputs": [[-1], [-1], [-1], [-1], ["k"], ["K"]]}
user: This is the simple version of Shortest Code series. If you need some challenges, please try the [challenge version](http://www.codewars.com/kata/56f928b19982cc7a14000c9d)

## Task: 

  Every uppercase letter is Father, The corresponding lowercase letters is the Son.
    
  Give you a string ```s```, If the father and son both exist, keep them. If it is a separate existence, delete them. Return the result.
    
  For example: 
    
   ```sc("Aab")``` should return ```"Aa"```
    
   ```sc("AabBc")``` should return ```"AabB"```
   
   ```sc("AaaaAaab")``` should return ```"AaaaAaa"```(father can have a lot of son)
    
   ```sc("aAAAaAAb")``` should return ```"aAAAaAA"```(son also can have a lot of father ;-)
    
    
### Series:
 - [Bug in Apple](http://www.codewars.com/kata/56fe97b3cc08ca00e4000dc9)
 - [Father and Son](http://www.codewars.com/kata/56fe9a0c11086cd842000008)
 - [Jumping Dutch act](http://www.codewars.com/kata/570bcd9715944a2c8e000009)
 - [Planting Trees](http://www.codewars.com/kata/5710443187a36a9cee0005a1)
 - [Give me the equation](http://www.codewars.com/kata/56fe9b65cc08cafbc5000de3)
 - [Find the murderer](http://www.codewars.com/kata/570f3fc5b29c702c5500043e)
 - [Reading a Book](http://www.codewars.com/kata/570ca6a520c69f39dd0016d4)
 - [Eat watermelon](http://www.codewars.com/kata/570df12ce6e9282a7d000947)
 - [Special factor](http://www.codewars.com/kata/570e5d0b93214b1a950015b1)
 - [Guess the Hat](http://www.codewars.com/kata/570ef7a834e61306da00035b)
 - [Symmetric Sort](http://www.codewars.com/kata/5705aeb041e5befba20010ba)
 - [Are they symmetrical?](http://www.codewars.com/kata/5705cc3161944b10fd0004ba)
 - [Max Value](http://www.codewars.com/kata/570771871df89cf59b000742)
 - [Trypophobia](http://www.codewars.com/kata/56fe9ffbc25bf33fff000f7c)
 - [Virus in Apple](http://www.codewars.com/kata/5700af83d1acef83fd000048)
 - [Balance Attraction](http://www.codewars.com/kata/57033601e55d30d3e0000633)
 - [Remove screws I](http://www.codewars.com/kata/5710a50d336aed828100055a)
 - [Remove screws II](http://www.codewars.com/kata/5710a8fd336aed00d9000594)
 - [Regular expression compression](http://www.codewars.com/kata/570bae4b0237999e940016e9)
 - [Collatz Array(Split or merge)](http://www.codewars.com/kata/56fe9d579b7bb6b027000001)
 - [Tidy up the room](http://www.codewars.com/kata/5703ace6e55d30d3e0001029)
 - [Waiting for a Bus](http://www.codewars.com/kata/57070eff924f343280000015)

Answer: {"fn_name": "sc", "inputs": [["Aab"], ["AabBc"], ["SONson"], ["FfAaTtHhEeRr"], ["SONsonfather"], ["sonfather"], ["DONKEYmonkey"], ["monkeyDONKEY"], ["BANAna"]], "outputs": [["Aa"], ["AabB"], ["SONson"], ["FfAaTtHhEeRr"], ["SONson"], [""], ["ONKEYonkey"], ["onkeyONKEY"], ["ANAna"]]}
user: A pair of numbers has a unique LCM but a single number can be the LCM of more than one possible
pairs. For example `12` is the LCM of `(1, 12), (2, 12), (3,4)` etc. For a given positive integer N, the number of different integer pairs with LCM is equal to N can be called the LCM cardinality of that number N. In this kata your job is to find out the LCM cardinality of a number.

Answer: {"fn_name": "lcm_cardinality", "inputs": [[1], [12], [24], [25], [101101291], [12345676], [1251562], [625], [9801], [30858025]], "outputs": [[1], [8], [11], [3], [5], [68], [41], [5], [23], [63]]}
user: Write a program to determine if a string contains only unique characters.
Return true if it does and false otherwise.

The string may contain any of the 128 ASCII characters.
Characters are case-sensitive, e.g. 'a' and 'A' are considered different characters.

Answer: {"fn_name": "has_unique_chars", "inputs": [["  nAa"], ["abcdef"], ["++-"]], "outputs": [[false], [true], [false]]}
user: You would like to get the 'weight' of a name by getting the sum of the ascii values. However you believe that capital letters should be worth more than mere lowercase letters. Spaces, numbers, or any other character are worth 0.

Normally in ascii

    a has a value of 97
    A has a value of 65
    ' ' has a value of 32
    0 has a value of 48

To find who has the 'weightier' name you will switch all the values so:

    A will be 97
    a will be 65
    ' ' will be 0
    0 will be 0
    etc...

For example Joe will have a weight of 254, instead of 286 using normal ascii values.

Answer: {"fn_name": "get_weight", "inputs": [["Joe"], ["CJ"], ["cj"], ["George Washington"], ["Billy Bob Joe"], ["King George II"], ["r2d2"], ["R2D2"], ["C3PO"]], "outputs": [[254], [205], [141], [1275], [909], [1012], [150], [214], [322]]}
user: # Story

Due to lack of maintenance the minute-hand has fallen off Town Hall clock face.

And because the local council has lost most of our tax money to a Nigerian email scam there are no funds to fix the clock properly. 

Instead, they are asking for volunteer programmers to write some code that tell the time by only looking at the remaining hour-hand!

What a bunch of cheapskates!

Can you do it?

# Kata

Given the ```angle``` (in degrees) of the hour-hand, return the time in HH:MM format. Round _down_ to the nearest minute.

# Examples

* ```12:00``` = 0 degrees


* ```03:00``` = 90 degrees


* ```06:00``` = 180 degrees


* ```09:00``` = 270 degrees


* ```12:00``` = 360 degrees

# Notes

* 0 <= ```angle``` <= 360

Answer: {"fn_name": "what_time_is_it", "inputs": [[0], [360], [90], [180], [270], [30], [40], [45], [50], [60]], "outputs": [["12:00"], ["12:00"], ["03:00"], ["06:00"], ["09:00"], ["01:00"], ["01:20"], ["01:30"], ["01:40"], ["02:00"]]}