meetforever/GRPO_CL huggingface dataset:
user: In number theory, an  **[abundant](https://en.wikipedia.org/wiki/Abundant_number)** number or an **[excessive](https://en.wikipedia.org/wiki/Abundant_number)** number is one for which the sum of it's **[proper divisors](http://mathworld.wolfram.com/ProperDivisor.html)** is greater than the number itself.  The integer **12** is the first abundant number. Its proper divisors are 1, 2, 3, 4 and 6 for a total of **16**. The amount by which the sum exceeds the number is the **abundance**. The number **12** has an abundance of **4**, for example. Other initial abundant numbers are : 12, 18, 20, 24, 30, 36, 40, 42, 48, 54 etc . **Infinitely** many **odd** and **even** abundant numbers exist.    
As you should have guessed by now, in this kata your function will take a positive integer **h** as range input and return a nested array/list that will contain the following informations-    

* Highest available **odd** or **even** abundant number in that range
* It's **abundance**    

Examples
--------
A few examples never hurt nobody, right???    

```rust   
abundant(15)  = [[12], [4]]
abundant(19)  = [[18], [3]]
abundant(100) = [[100], [17]]
abundant(999) = [[996], [360]]
```

Tips
----
The problem involves some pretty big random numbers. So try to optimize your code for performance as far as you can. And yes, the input argument will always be positive integers. So no need to check there.

Good luck!

Answer: {"fn_name": "abundant", "inputs": [[15], [19], [100], [999], [200], [250], [300], [350], [400], [450], [500], [555], [600], [666], [707], [777], [800], [900], [1111]], "outputs": [[[[12], [4]]], [[[18], [3]]], [[[100], [17]]], [[[996], [360]]], [[[200], [65]]], [[[246], [12]]], [[[300], [268]]], [[[350], [44]]], [[[400], [161]]], [[[450], [309]]], [[[500], [92]]], [[[552], [336]]], [[[600], [660]]], [[[666], [150]]], [[[704], [116]]], [[[774], [168]]], [[[800], [353]]], [[[900], [1021]]], [[[1110], [516]]]]}
user: # Problem Statement
Write a function that takes two string parameters, an IP (v4) address and a subnet mask, and returns two strings: the network block, and the host identifier.

The function does not need to support CIDR notation.

# Description
A single IP address with subnet mask actually specifies several addresses: a network block, and a host identifier, and a broadcast address. These addresses can be calculated using a bitwise AND operation on each bit.

(The broadcast address is not used in this kata.)

## Example
A computer on a simple home network might have the following IP and subnet mask:
```
IP: 192.168.2.1
Subnet: 255.255.255.0
(CIDR Notation: 192.168.2.1 /24)
```
In this example, the network block is: **192.168.2.0**. And the host identifier is: **0.0.0.1**. 

## bitwise AND 
To calculate the network block and host identifier the bits in each octet are ANDed together. When the result of the AND operation is '1', the bit specifies a network address (instead of a host address).

To compare the first octet in our example above, convert both the numbers to binary and perform an AND operation on each bit:
```
11000000 (192 in binary)
11111111 (255 in binary)
--------------------------- (AND each bit)
11000000 (192 in binary)
```
So in the first octet, '**192**' is part of the network address. The host identifier is simply '**0**'.

For more information see the [Subnetwork](http://en.wikipedia.org/wiki/Subnetwork) article on Wikipedia.

Answer: {"fn_name": "ipv4__parser", "inputs": [["192.168.50.1", "255.255.255.0"], ["192.168.50.129", "255.255.255.192"], ["192.168.50.153", "255.255.255.225"], ["65.196.188.53", "255.255.240.0"], ["65.196.188.53", "0.0.0.0"]], "outputs": [[["192.168.50.0", "0.0.0.1"]], [["192.168.50.128", "0.0.0.1"]], [["192.168.50.129", "0.0.0.24"]], [["65.196.176.0", "0.0.12.53"]], [["0.0.0.0", "65.196.188.53"]]]}
user: Complete the method which accepts an array of integers, and returns one of the following:

* `"yes, ascending"` - if the numbers in the array are sorted in an ascending order
* `"yes, descending"` - if the numbers in the array are sorted in a descending order
* `"no"` - otherwise


You can assume the array will always be valid, and there will always be one correct answer.

Answer: {"fn_name": "is_sorted_and_how", "inputs": [[[1, 2]], [[15, 7, 3, -8]], [[4, 2, 30]]], "outputs": [["yes, ascending"], ["yes, descending"], ["no"]]}
user: Everyone knows passphrases. One can choose passphrases from poems, songs, movies names and so on but frequently
they can be guessed due to common cultural references.
You  can get your passphrases stronger by different means. One is the following:

choose a text in capital letters including or not digits and non alphabetic characters,
 
1. shift each letter by a given number but the transformed letter must be a letter (circular shift), 
2. replace each digit by its complement to 9, 
3. keep such as non alphabetic and non digit characters, 
4. downcase each letter in odd position, upcase each letter in even position (the first character is in position 0), 
5. reverse the whole result.

#Example:

your text: "BORN IN 2015!", shift 1

1 + 2 + 3 -> "CPSO JO 7984!"

4 "CpSo jO 7984!"

5 "!4897 Oj oSpC"

With longer passphrases it's better to have a small and easy program.
Would you write it?

https://en.wikipedia.org/wiki/Passphrase

Answer: {"fn_name": "play_pass", "inputs": [["I LOVE YOU!!!", 1], ["I LOVE YOU!!!", 0], ["AAABBCCY", 1], ["MY GRANMA CAME FROM NY ON THE 23RD OF APRIL 2015", 2], ["TO BE HONEST WITH YOU I DON'T USE THIS TEXT TOOL TOO OFTEN BUT HEY... MAYBE YOUR NEEDS ARE DIFFERENT.", 5], ["IN 2012 TWO CAMBRIDGE UNIVERSITY RESEARCHERS ANALYSED PASSPHRASES FROM THE AMAZON PAY SYSTEM...", 20], ["IN 2012 TWO CAMBRIDGE UNIVERSITY RESEARCHERS ANALYSED PASSPHRASES FROM THE AMAZON PAY SYSTEM...", 10], ["1ONE2TWO3THREE4FOUR5FIVE6SIX7SEVEN8EIGHT9NINE", 5], ["AZ12345678ZA", 1], ["!!!VPZ FWPM J", 25], ["BOY! YOU WANTED TO SEE HIM? IT'S YOUR FATHER:-)", 15], ["FOR THIS REASON IT IS RECOMMENDED THAT PASSPHRASES NOT BE REUSED ACROSS DIFFERENT OR UNIQUE SITES AND SERVICES.", 15], ["ONCE UPON A TIME YOU DRESSED SO FINE (1968)", 12], ["AH, YOU'VE GONE TO THE FINEST SCHOOL ALL RIGHT, MISS LONELY", 12], ["THE SPECIES, NAMED AFTER THE GREEK GOD OF THE UNDERWORLD, LIVES SOME 3,600 FEET UNDERGROUND.", 8]], "outputs": [["!!!vPz fWpM J"], ["!!!uOy eVoL I"], ["zDdCcBbB"], ["4897 NkTrC Hq fT67 GjV Pq aP OqTh gOcE CoPcTi aO"], [".ySjWjKkNi jWf xIjJs wZtD JgDfR ...dJm yZg sJyKt tTy qTtY YcJy xNmY JxZ Y'StI N ZtD MyNb yXjStM Jg tY"], ["...gYnMsM SuJ HiTuGu yBn gIlZ MyMuLbJmMuJ XyMsFuHu mLyBwLuYmYl sNcMlYpChO YaXcLvGuW IqN 7897 hC"], ["...wOdCiC IkZ XyJkWk oRd wYbP CoCkBrZcCkZ NoCiVkXk cBoRmBkOcOb iDsCbOfSxE OqNsBlWkM YgD 7897 xS"], ["JsNs0yMlNj1sJaJx2cNx3jAnK4WzTk5jJwMy6tBy7jSt8"], ["bA12345678aB"], ["I LoVe yOu!!!"], [")-:gTwIpU GjDn h'iX ?bXw tTh dI StIcPl jDn !NdQ"], [".hTrXkGtH ScP HtIxH TjFxCj gD IcTgTuUxS HhDgRp sThJtG Tq iDc hThPgWeHhPe iPwI StScTbBdRtG Hx iX CdHpTg hXwI GdU"], [")1308( qZuR Ae pQeEqDp gAk qYuF M ZaBg qOzA"], ["KxQzAx eEuY ,fTsUd xXm xAaToE FeQzUr qTf aF QzAs qH'GaK ,tM"], [".LvCwZoZmLvC BmMn 993,6 mUwA AmDqT ,lTzWeZmLvC MpB Nw lWo sMmZo mPb zMbNi lMuIv ,AmQkMxA MpB"]]}
user: Write a function named sumDigits which takes a number as input and returns the sum of the absolute value of each of the number's decimal digits.  For example:

```python
  sum_digits(10)  # Returns 1
  sum_digits(99)  # Returns 18
  sum_digits(-32) # Returns 5
```

Let's assume that all numbers in the input will be integer values.

Answer: {"fn_name": "sum_digits", "inputs": [[10], [99], [-32], [1234567890], [0], [666], [100000002], [800000009]], "outputs": [[1], [18], [5], [45], [0], [18], [3], [17]]}
user: You are asked to write a simple cypher that rotates every character (in range [a-zA-Z], special chars will be ignored by the cipher) by 13 chars. As an addition to the original ROT13 cipher, this cypher will also cypher numerical digits ([0-9]) with 5 chars.

Example:

    "The quick brown fox jumps over the 2 lazy dogs"

will be cyphered to:

    "Gur dhvpx oebja sbk whzcf bire gur 7 ynml qbtf"

Your task is to write a ROT13.5 (ROT135) method that accepts a string and encrypts it.
Decrypting is performed by using the same method, but by passing the encrypted string again.

Note: when an empty string is passed, the result is also empty.

When passing your succesful algorithm, some random tests will also be applied. Have fun!

Answer: {"fn_name": "ROT135", "inputs": [["The quick brown fox jumps over the 2 lazy dogs"], ["Gur dhvpx oebja sbk whzcf bire gur 7 ynml qbtf"], ["1234567890"], ["12_-56789."]], "outputs": [["Gur dhvpx oebja sbk whzcf bire gur 7 ynml qbtf"], ["The quick brown fox jumps over the 2 lazy dogs"], ["6789012345"], ["67_-01234."]]}
user: How can you tell an extrovert from an
introvert at NSA? Va gur ryringbef,
gur rkgebireg ybbxf ng gur BGURE thl'f fubrf.

I found this joke on USENET, but the punchline is scrambled. Maybe you can decipher it?
According to Wikipedia, ROT13 (http://en.wikipedia.org/wiki/ROT13) is frequently used to obfuscate jokes on USENET.

Hint: For this task you're only supposed to substitue characters. Not spaces, punctuation, numbers etc.
Test examples:
```
rot13("EBG13 rknzcyr.") == "ROT13 example.";
rot13("This is my first ROT13 excercise!" == "Guvf vf zl svefg EBG13 rkprepvfr!"
```

Answer: {"fn_name": "rot13", "inputs": [["EBG13 rknzcyr."], ["How can you tell an extrovert from an\nintrovert at NSA? Va gur ryringbef,\ngur rkgebireg ybbxf ng gur BGURE thl'f fubrf."], ["123"], ["Guvf vf npghnyyl gur svefg xngn V rire znqr. Gunaxf sbe svavfuvat vg! :)"], ["@[`{"]], "outputs": [["ROT13 example."], ["Ubj pna lbh gryy na rkgebireg sebz na\nvagebireg ng AFN? In the elevators,\nthe extrovert looks at the OTHER guy's shoes."], ["123"], ["This is actually the first kata I ever made. Thanks for finishing it! :)"], ["@[`{"]]}
user: To celebrate today's launch of my Hero's new book: Alan Partridge: Nomad, We have a new series of kata arranged around the great man himself.

Given an array of terms, if any of those terms relate to Alan Partridge, return Mine's a Pint!

The number of ! after the t should be determined by the number of Alan related terms you find in the provided array (x). The related terms are:

Partridge
PearTree
Chat
Dan
Toblerone
Lynn
AlphaPapa
Nomad

If you don't find any related terms, return 'Lynn, I've pierced my foot on a spike!!'

All Hail King Partridge

Other katas in this series:
Alan Partridge II - Apple Turnover
Alan Partridge III - London

Answer: {"fn_name": "part", "inputs": [[["Grouse", "Partridge", "Pheasant"]], [["Pheasant", "Goose", "Starling", "Robin"]], [["Grouse", "Partridge", "Partridge", "Partridge", "Pheasant"]], [[]], [["Grouse", "Partridge", "Pheasant", "Goose", "Starling", "Robin", "Thrush", "Emu", "PearTree", "Chat", "Dan", "Square", "Toblerone", "Lynn", "AlphaPapa", "BMW", "Graham", "Tool", "Nomad", "Finger", "Hamster"]]], "outputs": [["Mine's a Pint!"], ["Lynn, I've pierced my foot on a spike!!"], ["Mine's a Pint!!!"], ["Lynn, I've pierced my foot on a spike!!"], ["Mine's a Pint!!!!!!!!"]]}
user: Find the greatest common divisor of two positive integers. The integers can be large, so you need to find a clever solution. 

The inputs `x` and `y` are always greater or equal to 1, so the greatest common divisor will always be an integer that is also greater or equal to 1.

Answer: {"fn_name": "mygcd", "inputs": [[1, 3], [60, 12], [2672, 5678], [10927782, 6902514], [1590771464, 1590771620]], "outputs": [[1], [12], [334], [846], [4]]}
user: ## Task

Find the sum of the first `n` elements in the Recamán Sequence.

Input range:

```python
1000 tests
0 <= n <= 2,500,000
```

___

## Sequence

The sequence is formed using the next formula:
* We start with `0`
* At each step `i`, we subtract `i` from the previous number
* If the result is not negative, and not yet present in the sequence, it becomes the `i`th element of the sequence
* Otherwise the `i`th element of the sequence will be previous number plus `i`

The beginning of the sequence is `[0, 1, 3, 6, 2, ...]` because:  
0) `0` <- we start with `0`  
1) `1` <- `0 - 1` is negative, hence we choose `0 + 1`  
2) `3` <- `1 - 2` is negative, hence we choose `1 + 2`  
3) `6` <-`3 - 3` is not negative, but we already have a `0` in the sequence, hence we choose `3 + 3`  
4) `2` <- `6 - 4` is positive, and is not present in the sequence yet, so we go for it

___

## Examples

```
rec(0) == 0
rec(1) == 0
rec(2) == 1
rec(3) == 4
rec(4) == 10
rec(5) == 12
```

Answer: {"fn_name": "rec", "inputs": [[0], [1], [2], [5], [100], [200], [1000], [10000]], "outputs": [[0], [0], [1], [12], [7496], [36190], [837722], [82590002]]}
user: Implement a method that accepts 3 integer values a, b, c. The method should return true if a triangle can be built with the sides of given length and false in any other case.

(In this case, all triangles must have surface greater than 0 to be accepted).

Answer: {"fn_name": "is_triangle", "inputs": [[1, 2, 2], [7, 2, 2], [1, 2, 3], [1, 3, 2], [3, 1, 2], [5, 1, 2], [1, 2, 5], [2, 5, 1], [4, 2, 3], [5, 1, 5], [2, 2, 2], [-1, 2, 3], [1, -2, 3], [1, 2, -3], [0, 2, 3]], "outputs": [[true], [false], [false], [false], [false], [false], [false], [false], [true], [true], [true], [false], [false], [false], [false]]}
user: Consider the numbers `6969` and `9116`. When you rotate them `180 degrees` (upside down), these numbers remain the same. To clarify, if we write them down on a paper and turn the paper upside down, the numbers will be the same. Try it and see! Some numbers such as `2` or `5` don't yield numbers when rotated.

Given a range, return the count of upside down numbers within that range.  For example, `solve(0,10) = 3`, because there are only `3` upside down numbers `>= 0 and < 10`. They are `0, 1, 8`.

More examples in the test cases.

Good luck!

If you like this Kata, please try 

[Simple Prime Streaming](https://www.codewars.com/kata/5a908da30025e995880000e3)

[Life without primes](https://www.codewars.com/kata/59f8750ac374cba8f0000033)

Please also try the performance version of this kata at [Upside down numbers - Challenge Edition ](https://www.codewars.com/kata/59f98052120be4abfa000304)

Answer: {"fn_name": "solve", "inputs": [[0, 10], [10, 100], [100, 1000], [1000, 10000], [10000, 15000], [15000, 20000], [60000, 70000], [60000, 130000]], "outputs": [[3], [4], [12], [20], [6], [9], [15], [55]]}
user: A rectangle can be split up into a grid of 1x1 squares, the amount of which being equal to the product of the two dimensions of the rectangle. Depending on the size of the rectangle, that grid of 1x1 squares can also be split up into larger squares, for example a 3x2 rectangle has a total of 8 squares, as there are 6 distinct 1x1 squares, and two possible 2x2 squares. A 4x3 rectangle contains 20 squares.
Your task is to write a function `findSquares` that returns the total number of squares for any given rectangle, the dimensions of which being given as two integers with the first always being equal to or greater than the second.

Answer: {"fn_name": "findSquares", "inputs": [[3, 2], [4, 3], [11, 4]], "outputs": [[8], [20], [100]]}
user: In English and programming, groups can be made using symbols such as `()` and `{}` that change meaning. However, these groups must be closed in the correct order to maintain correct syntax.

Your job in this kata will be to make a program that checks a string for correct grouping. For instance, the following groups are done correctly:

```
({})
[[]()]
[{()}]
```

The next are done incorrectly:
```
{(})
([]
[])
```

A correct string cannot close groups in the wrong order, open a group but fail to close it, or close a group before it is opened.

Your function will take an input string that may contain any of the symbols `()`, `{}` or `[]` to create groups.

It should return `True` if the string is empty or otherwise grouped correctly, or `False` if it is grouped incorrectly.

Answer: {"fn_name": "group_check", "inputs": [["({})"], ["[[]()]"], ["[{()}]"], ["()"], ["([])"], ["{}([])"], ["{[{}[]()[]{}{}{}{}{}{}()()()()()()()()]{{{[[[((()))]]]}}}}(())[[]]{{}}[][][][][][][]({[]})"], [""], ["{(})"], ["[{}{}())"], ["{)[}"], ["[[[]])"], ["()[]{]"], ["{([]})"], ["([]"], ["[])"], ["([]))"], ["{{{{{{{{{{{((((((([])))))))}}}}}}}}}}"]], "outputs": [[true], [true], [true], [true], [true], [true], [true], [true], [false], [false], [false], [false], [false], [false], [false], [false], [false], [false]]}
user: Write a function that checks if all the letters in the second string are present in the first one at least once, regardless of how many times they appear:

```
["ab", "aaa"]    =>  true
["trances", "nectar"]    =>  true
["compadres", "DRAPES"]  =>  true
["parses", "parsecs"]    =>  false
```

Function should not be case sensitive, as indicated in example #2. Note: both strings are presented as a **single argument** in the form of an array.

Answer: {"fn_name": "letter_check", "inputs": [[["abcd", "aaa"]], [["trances", "nectar"]], [["THE EYES", "they see"]], [["assert", "staring"]], [["arches", "later"]], [["dale", "caller"]], [["parses", "parsecs"]], [["replays", "adam"]], [["mastering", "streaming"]], [["drapes", "compadres"]], [["deltas", "slated"]], [["deltas", ""]], [["", "slated"]]], "outputs": [[true], [true], [true], [false], [false], [false], [false], [false], [true], [false], [true], [true], [false]]}
user: *** Nova polynomial multiply*** 

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 multiply two polynomials:

```python 
poly_multiply([1, 2], [1] ) = [1, 2]
poly_multiply([2, 4], [4, 5] ) = [8, 26, 20]
```
The first kata of this series is preloaded in the code and can be used: [poly_add](http://www.codewars.com/kata/nova-polynomial-1-add-1)

Answer: {"fn_name": "poly_multiply", "inputs": [[[], []], [[1, 2, 3, 4, 5, 6], []], [[], [1, 2, 3, 4, 5, 6]]], "outputs": [[[]], [[]], [[]]]}
user: Every day we can send from the server a certain limit of e-mails.

Task:
Write a function that will return the integer number of e-mails sent in the percentage of the limit.

Example:
```
limit       - 1000;
emails sent - 101;
return      - 10%; // becouse integer from 10,1 = 10
```

Arguments:

Integer, limit;
Integer, number of e-mails sent today;

When:

the argument ```$sent = 0```, then return the message: "No e-mails sent";
the argument ```$sent >= $limit```, then return the message: "Daily limit is reached";
the argument ```$limit is empty```, then default ```$limit = 1000``` emails;

Good luck!

Answer: {"fn_name": "get_percentage", "inputs": [[101, 1000], [256, 500], [259], [0], [1000, 1000]], "outputs": [["10%"], ["51%"], ["25%"], ["No e-mails sent"], ["Daily limit is reached"]]}
user: Here's a way to construct a list containing every positive rational number:

Build a binary tree where each node is a rational and the root is `1/1`, with the following rules for creating the nodes below:
* The value of the left-hand node below `a/b` is `a/a+b`
* The value of the right-hand node below `a/b` is `a+b/b`

So the tree will look like this:

```
                       1/1
                  /           \ 
            1/2                  2/1
           /    \              /     \
       1/3        3/2        2/3       3/1
      /   \      /   \      /   \     /   \
   1/4    4/3  3/5   5/2  2/5   5/3  3/4   4/1
 
 ...
```

Now traverse the tree, breadth first, to get a list of rationals.

```
[ 1/1, 1/2, 2/1, 1/3, 3/2, 2/3, 3/1, 1/4, 4/3, 3/5, 5/2, .. ]
```

Every positive rational will occur, in its reduced form, exactly once in the list, at a finite index.

```if:haskell
In the kata, we will use tuples of type `(Integer, Integer)` to represent rationals, where `(a, b)` represents `a / b`
```
```if:javascript
In the kata, we will use tuples of type `[ Number, Number ]` to represent rationals, where `[a,b]` represents `a / b`
```

Using this method you could create an infinite list of tuples:

matching the list described above:

However, constructing the actual list is too slow for our purposes. Instead, study the tree above, and write two functions:

For example:

Answer: {"fn_name": "rat_at", "inputs": [[0], [3], [4], [10], [1000000000]], "outputs": [[[1, 1]], [[1, 3]], [[3, 2]], [[5, 2]], [[73411, 65788]]]}
user: Andrzej was given a task:
There are n jars with pills. In every jar there is a different type of pill and the amount of pills in each jar is infinite. One type of pill makes a person glow about 30 minutes after taking and none of the other types has any effect.
His job is to determine, in which jar are the pills that make a person glow.
But there is one catch, he only has 35 minutes to do so.(so he can't take a pill, wait for the results and then take another one, because he wouldn't be able to see the results)
Fortunetely, he can take any number of friends he needs with him.
On completing the task Andrzej receives one million dollars. You know that Andrzej is very honest, so he will split the money equally with his friends.
Your job is to determine how many friends does Andrzej need to complete the task.(He also wants to make the highest amount of money.)
For example for n = 2
The answer is 0 because he doesn't need any friends, he just needs to take a pill from the first jar and wait for the effects.
For another example for n = 4
The answer is 1 because having pills A B C D Andrzej can take pills A B and the friend can take pills B C

Answer: {"fn_name": "friends", "inputs": [[0], [1], [2], [4], [3], [16]], "outputs": [[0], [0], [0], [1], [1], [3]]}
user: An array is called `centered-N` if some `consecutive sequence` of elements of the array sum to `N` and this sequence is preceded and followed by the same number of elements. 

Example:
```
[3,2,10,4,1,6,9] is centered-15
because the sequence 10,4,1 sums to 15 and the sequence 
is preceded by two elements [3,2] and followed by two elements [6,9]

```

Write a method called `isCenteredN` that returns :

- `true` if its array argument is `not empty` and `centered-N` or empty and centered-0
- otherwise returns `false`.

Answer: {"fn_name": "is_centered", "inputs": [[[0, 0, 0], 0], [[3, 2, 10, 4, 1, 6, 9], 15], [[2, 10, 4, 1, 6, 9], 15], [[3, 2, 10, 4, 1, 6], 15], [[1, 1, 8, 3, 1, 1], 15], [[1, 1, 8, 3, 1, 1], 11], [[1, 1, 8, 3, 1, 1], 13], [[9, 0, 6], 0], [[], 25], [[25], 25], [[25, 26, 23, 24], 0], [[2, 1, 2], 0], [[1, 1, 15, -1, -1], 15], [[1, 1, 15, -1, -1], 6], [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 0], [[0, 0, 0, -1, 1, 1, -1, 0, 0, 0], 0]], "outputs": [[true], [true], [false], [false], [true], [true], [true], [true], [false], [true], [true], [false], [true], [false], [true], [true]]}
user: Write a function named `first_non_repeating_letter` that takes a string input, and returns the first character that is not repeated anywhere in the string.

For example, if given the input `'stress'`, the function should return `'t'`, since the letter *t* only occurs once in the string, and occurs first in the string.

As an added challenge, upper- and lowercase letters are considered the **same character**, but the function should return the correct case for the initial letter.  For example, the input `'sTreSS'` should return `'T'`.

If a string contains *all repeating characters*, it should return an empty string (`""`) or `None` -- see sample tests.

Answer: {"fn_name": "first_non_repeating_letter", "inputs": [["a"], ["stress"], ["moonmen"], [""], ["abba"], ["aa"], ["~><#~><"], ["hello world, eh?"], ["sTreSS"], ["Go hang a salami, I'm a lasagna hog!"]], "outputs": [["a"], ["t"], ["e"], [""], [""], [""], ["#"], ["w"], ["T"], [","]]}