meetforever/GRPO_CL huggingface dataset:
user: A [Word Square](https://en.wikipedia.org/wiki/Word_square) is a set of words written out in a square grid, such that the same words can be read both horizontally and vertically. The number of words, equal to the number of letters in each word, is known as the *order* of the square.

For example, this is an *order* `5` square found in the ruins of Herculaneum:

![](https://i.gyazo.com/e226262e3ada421d4323369fb6cf66a6.jpg)

Given a string of various uppercase `letters`, check whether a *Word Square* can be formed from it. 

Note that you should use each letter from `letters` the exact number of times it occurs in the string. If a *Word Square* can be formed, return `true`, otherwise return `false`.

__Example__

  * For `letters = "SATORAREPOTENETOPERAROTAS"`, the output should be
  `WordSquare(letters) = true`.
    It is possible to form a *word square* in the example above.

  * For `letters = "AAAAEEEENOOOOPPRRRRSSTTTT"`, (which is sorted form of `"SATORAREPOTENETOPERAROTAS"`), the output should also be
  `WordSquare(letters) = true`.

  * For `letters = "NOTSQUARE"`, the output should be
  `WordSquare(letters) = false`.
  
__Input/Output__

* [input] string letters

  A string of uppercase English letters.
  
  Constraints: `3 ≤ letters.length ≤ 100`.


* [output] boolean

  `true`, if a Word Square can be formed;
  
  `false`, if a Word Square cannot be formed.

Answer: {"fn_name": "word_square", "inputs": [["SATORAREPOTENETOPERAROTAS"], ["NOTSQUARE"], ["BITICETEN"], ["CARDAREAREARDART"], ["CODEWARS"], ["AAAAACEEELLRRRTT"], ["AAACCEEEEHHHMMTT"], ["AAACCEEEEHHHMMTTXXX"], ["ABCD"], ["GHBEAEFGCIIDFHGG"], ["AAHHFDKIHHFCXZBFDERRRTXXAA"], ["AABBCCDDEEFFGGGG"], ["ABCABCABC"], ["FRACTUREOUTLINEDBLOOMINGSEPTETTE"], ["GLASSESRELAPSEIMITATESMEAREDTANNERY"], ["LIMBAREACORKKNEE"], ["DESCENDANTECHENEIDAESHORTCOATSCERBERULUSENTEROMERENECROLATERDIOUMABANAADALETABATNATURENAMETESSERATED"], ["CONGRATUALATIONS"], ["HEARTEMBERABUSERESINTREND"], ["OHLOLWHAT"]], "outputs": [[true], [false], [true], [true], [false], [true], [true], [false], [false], [true], [false], [true], [true], [false], [false], [false], [true], [false], [true], [true]]}
user: Write a function to calculate compound tax using the following table:

For $10 and under, the tax rate should be 10%.
For $20 and under, the tax rate on the first $10 is %10, and the tax on the rest is 7%.
For $30 and under, the tax rate on the first $10 is still %10, the rate for the next $10 is still 7%, and everything else is 5%.
Tack on an additional 3% for the portion of the total above $30.
Return 0 for invalid input(anything that's not a positive real number).


Examples:

An input of 10, should return 1 (1 is 10% of 10)
An input of 21, should return 1.75 (10% of 10 + 7% of 10 + 5% of 1)

* Note that the returned value should be rounded to the nearest penny.

Answer: {"fn_name": "tax_calculator", "inputs": [[1], [10], [11], [15], [18], [21], [26], [30], [30.49], [35], [100], [1000000], [0], [-3], [null], ["monkey"], [[]], [{}]], "outputs": [[0.1], [1], [1.07], [1.35], [1.56], [1.75], [2], [2.2], [2.21], [2.35], [4.3], [30001.3], [0], [0], [0], [0], [0], [0]]}
user: There is an array with some numbers. All numbers are equal except for one. Try to find it!

```python
find_uniq([ 1, 1, 1, 2, 1, 1 ]) == 2
find_uniq([ 0, 0, 0.55, 0, 0 ]) == 0.55
```

It’s guaranteed that array contains at least 3 numbers.

The tests contain some very huge arrays, so think about performance.

This is the first kata in series:

1. Find the unique number (this kata)
2. [Find the unique string](https://www.codewars.com/kata/585d8c8a28bc7403ea0000c3)
3. [Find The Unique](https://www.codewars.com/kata/5862e0db4f7ab47bed0000e5)

Answer: {"fn_name": "find_uniq", "inputs": [[[1, 1, 1, 2, 1, 1]], [[0, 0, 0.55, 0, 0]], [[4, 4, 4, 3, 4, 4, 4, 4]], [[5, 5, 5, 5, 4, 5, 5, 5]], [[6, 6, 6, 6, 6, 5, 6, 6]], [[7, 7, 7, 7, 7, 7, 6, 7]], [[8, 8, 8, 8, 8, 8, 8, 7]], [[3, 3, 3, 3, 3, 3, 3, 2]], [[2, 2, 2, 2, 2, 2, 2, 1]], [[0, 1, 1, 1, 1, 1, 1, 1]]], "outputs": [[2], [0.55], [3], [4], [5], [6], [7], [2], [1], [0]]}
user: Complete the function ```circleArea``` so that it will return the area of a circle with the given ```radius```. Round the returned number to two decimal places (except for Haskell). If the radius is not positive or not a number, return ```false```.

Example:

```python
circleArea(-1485.86)     #returns false
circleArea(0)            #returns false
circleArea(43.2673)      #returns 5881.25
circleArea(68)           #returns 14526.72
circleArea("number")     #returns false
```

Answer: {"fn_name": "circleArea", "inputs": [[0], ["An integer"]], "outputs": [[false], [false]]}
user: You were given a string of integer temperature values. Create a function `lowest_temp(t)` and return the lowest value or `None/null/Nothing` if the string is empty.

Answer: {"fn_name": "lowest_temp", "inputs": [[""], ["-1 50 -4 20 22 -7 0 10 -8"]], "outputs": [[null], [-8]]}
user: # A wolf in sheep's clothing

Wolves have been reintroduced to Great Britain. You are a sheep farmer, and are now plagued by wolves which pretend to be sheep. Fortunately, you are good at spotting them. 

Warn the sheep in front of the wolf that it is about to be eaten. Remember that you are standing **at the front of the queue** which is at the end of the array:

```
[sheep, sheep, sheep, sheep, sheep, wolf, sheep, sheep]      (YOU ARE HERE AT THE FRONT OF THE QUEUE)
   7      6      5      4      3            2      1
```

If the wolf is the closest animal to you, return `"Pls go away and stop eating my sheep"`. Otherwise, return `"Oi! Sheep number N! You are about to be eaten by a wolf!"` where `N` is the sheep's position in the queue.

**Note:** there will always be exactly one wolf in the array.

## Examples

```python
warn_the_sheep(["sheep", "sheep", "sheep", "wolf", "sheep"]) == 'Oi! Sheep number 1! You are about to be eaten by a wolf!'

warn_the_sheep(['sheep', 'sheep', 'wolf']) == 'Pls go away and stop eating my sheep'
```

Answer: {"fn_name": "warn_the_sheep", "inputs": [[["sheep", "sheep", "sheep", "sheep", "sheep", "wolf", "sheep", "sheep"]], [["sheep", "wolf", "sheep", "sheep", "sheep", "sheep", "sheep"]], [["wolf", "sheep", "sheep", "sheep", "sheep", "sheep", "sheep"]], [["sheep", "wolf", "sheep"]], [["sheep", "sheep", "wolf"]]], "outputs": [["Oi! Sheep number 2! You are about to be eaten by a wolf!"], ["Oi! Sheep number 5! You are about to be eaten by a wolf!"], ["Oi! Sheep number 6! You are about to be eaten by a wolf!"], ["Oi! Sheep number 1! You are about to be eaten by a wolf!"], ["Pls go away and stop eating my sheep"]]}
user: You have been presented with a cipher, your goal is to re-create the cipher with little information. Use the examples provided to see if you can find a solution to how this cipher is made. You will be given no hints, only the handful of phrases that have already been deciphered for you. 

Your only hint: Spaces are left alone, they are not altered in any way. Anytime there is a space, it should remain untouched and in place.

I hope you enjoy, but this one should be genuinely infuriating.

Answer: {"fn_name": "cipher", "inputs": [["this will probably not be fun"], ["hopefully you will find satisfaction at least"], ["really this is very tedious"], ["if you made it this far you are a better programmer than i am"]], "outputs": [["tiks zjop twrggfrf uwz kl pcx"], ["hprehxmoc ctx cmrs mqtl zjdqcqjnfsaa nh ztnhj"], ["rfclnb wlkw lx zkyd bklrvdc"], ["ig yqx pefi ly xnpx ngz fxe kcn m nregsd eedwfqdbvj larg a vf"]]}
user: Given an array containing only zeros and ones, find the index of the zero that, if converted to one, will make the longest sequence of ones.

For instance, given the array:

```
[1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1]
```

replacing the zero at index 10 (counting from 0) forms a sequence of 9 ones:

```
[1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1]
                  '------------^------------'
```


Your task is to complete the function that determines where to replace a zero with a one to make the maximum length subsequence.


**Notes:**
- If there are multiple results, return the last one:

 `[1, 1, 0, 1, 1, 0, 1, 1] ==> 5`


- The array will always contain only zeros and ones.


Can you do this in one pass?

Answer: {"fn_name": "replace_zero", "inputs": [[[1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1]], [[1, 1, 0, 1, 1, 0, 1, 1]], [[1, 1, 1, 0, 1, 1, 0, 1, 1, 1]], [[0, 1, 1, 1]], [[1, 1, 1, 0]], [[1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1]], [[0, 0, 0, 0, 0, 1]], [[0, 0, 0, 0, 1, 0]], [[1, 0, 0, 0, 0, 0]], [[0, 1, 0, 0, 0, 0]]], "outputs": [[10], [5], [6], [0], [3], [10], [4], [5], [1], [2]]}
user: You will be given two numbers `m,n`. The numbers could span from `0` to `10000`. We can get their product by using binary reduction as show in the table below.
Example (to understand the table please read the description below it) 





real value of m(r)
m
n
(r*n)


0
100
15
0


0
50
30
0


1
25
60
60


0
12
120
0


0
6
240
0


1
3
480
480


1
1
960
960



Above, we are given two numbers `100` and `15`. we keep reducing the bigger number by dividing it by `2` and hold the integer part of the division till it is no more divisible by `2`. Then we assign the real values to these reduced parts of `m`. Any reduced number `[1,m]` has real value of `0` if it is even, and it will have real value of `1` if it is odd. On the other hand the smaller number in this case `n` keeps on doubling itself the same amount of times `m` reduces itself. The idea of this method is to change multiplication of two big number to a sequence of multiplication by `0` or `1` and perform addition to get the final product. You can see that from the last column `(r*n)` above. 
if we sum the last column we get `0+60+0+0+480+960=1500=100*15`
Now your task for this kata will be to get those non-zero number in the last column in an array and return it sorted in descending order.so for the above example the return will be `[960,480,60]`.

_Beware: _`m,n`_ are not necessarily ordered._

Answer: {"fn_name": "bin_mul", "inputs": [[100, 15], [15, 0], [0, 0]], "outputs": [[[960, 480, 60]], [[]], [[]]]}
user: # Introduction

There is a war and nobody knows - the alphabet war!  
There are two groups of hostile letters. The tension between left side letters and right side letters was too high and the war began. The letters called airstrike to help them in war - dashes and dots are spreaded everywhere on the battlefield.

# Task

Write a function that accepts `fight` string consists of only small letters and `*` which means a bomb drop place. Return who wins the fight after bombs are exploded. When the left side wins return `Left side wins!`, when the right side wins return `Right side wins!`, in other case return `Let's fight again!`.

The left side letters and their power:
```
 w - 4
 p - 3 
 b - 2
 s - 1
```
The right side letters and their power:
```
 m - 4
 q - 3 
 d - 2
 z - 1
```
The other letters don't have power and are only victims.  
The `*` bombs kills the adjacent letters ( i.e. `aa*aa` => `a___a`, `**aa**` => `______` );

# Example

# Alphabet war Collection



Alphavet war 


Alphabet war - airstrike - letters massacre


Alphabet wars - reinforces massacre


Alphabet wars - nuclear strike


Alphabet war - Wo lo loooooo priests join the war

Answer: {"fn_name": "alphabet_war", "inputs": [["z"], ["z*dq*mw*pb*s"], ["zdqmwpbs"], ["zz*zzs"], ["sz**z**zs"], ["z*z*z*zs"], ["*wwwwww*z*"]], "outputs": [["Right side wins!"], ["Let's fight again!"], ["Let's fight again!"], ["Right side wins!"], ["Left side wins!"], ["Left side wins!"], ["Left side wins!"]]}
user: Description

In English we often use "neutral vowel sounds" such as "umm", "err", "ahh" as fillers in conversations to help them run smoothly.

Bob always finds himself saying "err". Infact he adds an "err" to every single word he says that ends in a consonant! Because Bob is odd, he likes to stick to this habit even when emailing. 

Task

Bob is begging you to write a function that adds "err" to the end of every word whose last letter is a consonant (not a vowel, y counts as a consonant). 

The input is a string that can contain upper and lowercase characters, some punctuation but no numbers. The solution should be returned as a string.

NOTE: If the word ends with an uppercase consonant, the following "err" will be uppercase --> "ERR".

eg:
```
"Hello, I am Mr Bob" --> "Hello, I amerr Mrerr Boberr"

"THIS IS CRAZY!"  --> "THISERR ISERR CRAZYERR!"
```


Good luck!

Answer: {"fn_name": "err_bob", "inputs": [["r r r r r r r r"], ["THIS, is crazy!"], ["hI, hi. hI hi skY! sky? skY sky"], ["Hello, I am Mr Bob."], ["This, is. another! test? case to check your beautiful code."], ["Hello from the other siiiiideeee"], ["Punctuation? is, important!  double space also"]], "outputs": [["rerr rerr rerr rerr rerr rerr rerr rerr"], ["THISERR, iserr crazyerr!"], ["hI, hi. hI hi skYERR! skyerr? skYERR skyerr"], ["Hello, I amerr Mrerr Boberr."], ["Thiserr, iserr. anothererr! testerr? case to checkerr yourerr beautifulerr code."], ["Hello fromerr the othererr siiiiideeee"], ["Punctuationerr? iserr, importanterr!  double space also"]]}
user: You are given a secret message you need to decipher. Here are the things you need to know to decipher it:

For each word:
- the second and the last letter is switched (e.g. `Hello` becomes `Holle`)
- the first letter is replaced by its character code (e.g. `H` becomes `72`)

Note: there are no special characters used, only letters and spaces

Examples
```
decipherThis('72olle 103doo 100ya'); // 'Hello good day'
decipherThis('82yade 115te 103o'); // 'Ready set go'
```

Answer: {"fn_name": "decipher_this", "inputs": [["65 119esi 111dl 111lw 108dvei 105n 97n 111ka"], ["84eh 109ero 104e 115wa 116eh 108sse 104e 115eokp"], ["84eh 108sse 104e 115eokp 116eh 109ero 104e 104dare"], ["87yh 99na 119e 110to 97ll 98e 108eki 116tah 119esi 111dl 98dri"], ["84kanh 121uo 80roti 102ro 97ll 121ruo 104ple"]], "outputs": [["A wise old owl lived in an oak"], ["The more he saw the less he spoke"], ["The less he spoke the more he heard"], ["Why can we not all be like that wise old bird"], ["Thank you Piotr for all your help"]]}
user: Given an integer `n`, find two integers `a` and `b` such that:
```Pearl
A) a >= 0 and b >= 0
B) a + b = n
C) DigitSum(a) + Digitsum(b) is maximum of all possibilities.  
```
You will return the digitSum(a) + digitsum(b). 

```
For example:
solve(29) = 11. If we take 15 + 14 = 29 and digitSum = 1 + 5 + 1 + 4 = 11. There is no larger outcome.
```
`n` will not exceed `10e10`.

More examples in test cases. 

Good luck!

Answer: {"fn_name": "solve", "inputs": [[18], [29], [45], [1140], [7019], [50000000], [15569047737], [2452148459], [1], [0]], "outputs": [[18], [11], [18], [33], [35], [68], [144], [116], [1], [0]]}
user: # Description

Given a number `n`, you should find a set of numbers for which the sum equals `n`. This set must consist exclusively of values that are a power of `2` (eg: `2^0 => 1, 2^1 => 2, 2^2 => 4, ...`).

The function `powers` takes a single parameter, the number `n`, and should return an array of unique numbers.

## Criteria

The function will always receive a valid input: any positive integer between `1` and the max integer value for your language (eg: for JavaScript this would be `9007199254740991` otherwise known as `Number.MAX_SAFE_INTEGER`).

The function should return an array of numbers that are a **power of 2** (`2^x = y`).

Each member of the returned array should be **unique**. (eg: the valid answer for `powers(2)` is `[2]`, not `[1, 1]`)

Members should be sorted in **ascending order** (small -> large). (eg: the valid answer for `powers(6)` is `[2, 4]`, not `[4, 2]`)

Answer: {"fn_name": "powers", "inputs": [[1], [2], [4], [32], [128], [512], [6], [14], [688], [8197], [1966], [9007199254740991]], "outputs": [[[1]], [[2]], [[4]], [[32]], [[128]], [[512]], [[2, 4]], [[2, 4, 8]], [[16, 32, 128, 512]], [[1, 4, 8192]], [[2, 4, 8, 32, 128, 256, 512, 1024]], [[1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864, 134217728, 268435456, 536870912, 1073741824, 2147483648, 4294967296, 8589934592, 17179869184, 34359738368, 68719476736, 137438953472, 274877906944, 549755813888, 1099511627776, 2199023255552, 4398046511104, 8796093022208, 17592186044416, 35184372088832, 70368744177664, 140737488355328, 281474976710656, 562949953421312, 1125899906842624, 2251799813685248, 4503599627370496]]]}
user: It's the academic year's end, fateful moment of your school report.
The averages must be calculated. All the students come to you and entreat you to calculate their average for them.
Easy ! You just need to write a script.

Return the average of the given array rounded **down** to its nearest integer.

The array will never be empty.

Answer: {"fn_name": "get_average", "inputs": [[[2, 2, 2, 2]], [[1, 5, 87, 45, 8, 8]], [[2, 5, 13, 20, 16, 16, 10]], [[1, 2, 15, 15, 17, 11, 12, 17, 17, 14, 13, 15, 6, 11, 8, 7]]], "outputs": [[2], [25], [11], [11]]}
user: In genetics 2 differents DNAs sequences can code for the same protein. 

This is due to the redundancy of the genetic code, in fact 2 different tri-nucleotide can code for the same amino-acid.
For example the tri-nucleotide 'TTT' and the tri-nucleotide 'TTC' both code for the amino-acid 'F'. For more information you can take a look [here](https://en.wikipedia.org/wiki/DNA_codon_table).

Your goal in this kata is to define if two differents DNAs sequences code for exactly the same protein. Your function take the 2 sequences you should compare.
For some kind of simplicity here the sequences will respect the following rules:

- It is a full protein sequence beginning with a Start codon and finishing by an Stop codon
- It will only contain valid tri-nucleotide. 

The translation hash is available for you under a translation hash `$codons` [Ruby] or `codons` [Python and JavaScript].

To better understand this kata you can take a look at this [one](https://www.codewars.com/kata/5708ef48fe2d018413000776), it can help you to start.

Answer: {"fn_name": "code_for_same_protein", "inputs": [["ATGTCGTCAATTTAA", "ATGTCGTCAATTTAA"], ["ATGTTTTAA", "ATGTTCTAA"], ["ATGTTTTAA", "ATGATATAA"], ["ATGTTTGGGAATAATTAAGGGTAA", "ATGTTCGGGAATAATGGGAGGTAA"]], "outputs": [[true], [true], [false], [false]]}
user: A system is transmitting messages in binary, however it is not a perfect transmission, and sometimes errors will occur which result in a single bit flipping from 0 to 1, or from 1 to 0.

To resolve this, A 2-dimensional Parity Bit Code is used: https://en.wikipedia.org/wiki/Multidimensional_parity-check_code

In this system, a message is arrayed out on a M x N grid. A 24-bit message could be put on a 4x6 grid like so:


>1 0 1 0 0 1
>1 0 0 1 0 0
>0 1 1 1 0 1
>1 0 0 0 0 1

Then, Parity bits are computed for each row and for each column, equal to 1 if there is an odd number of 1s in the row of column, and 0 if it is an even number. The result for the above message looks like:


>1 0 1 0 0 1 1
>1 0 0 1 0 0 0
>0 1 1 1 0 1 0
>1 0 0 0 0 1 0
>1 1 0 0 0 1

Since the 1st row, and 1st, 2nd and 6th column each have an odd number of 1s in them, and the others all do not.

Then the whole message is sent, including the parity bits. This is arranged as:

> message + row_parities + column_parities
> 101001100100011101100001 + 1000 + 110001
> 1010011001000111011000011000110001

If an error occurs in transmission, the parity bit for a column and row will be incorrect, which can be used to identify and correct the error. If a row parity bit is incorrect, but all column bits are correct, then we can assume the row parity bit was the one flipped, and likewise if a column is wrong but all rows are correct.

 Your Task: 

Create a function correct, which takes in integers M and N, and a string of bits where the first M\*N represent the content of the message, the next M represent the parity bits for the rows, and the final N represent the parity bits for the columns. A single-bit error may or may not have appeared in the bit array.

The function should check to see if there is a single-bit error in the coded message, correct it if it exists, and return the corrected string of bits.

Answer: {"fn_name": "correct", "inputs": [[1, 1, "111"], [1, 1, "011"], [1, 1, "101"], [1, 1, "110"], [2, 3, "11111010001"], [2, 3, "11011010001"], [2, 3, "11111011001"], [2, 3, "11111010011"]], "outputs": [["111"], ["111"], ["111"], ["111"], ["11111010001"], ["11111010001"], ["11111010001"], ["11111010001"]]}
user: # Task
 You're given a substring s of some cyclic string. What's the length of the smallest possible string that can be concatenated to itself many times to obtain this cyclic string?

# Example

 For` s = "cabca"`, the output should be `3`

 `"cabca"` is a substring of a cycle string "abcabcabcabc..." that can be obtained by concatenating `"abc"` to itself. Thus, the answer is 3.

# Input/Output


 - `[input]` string `s`

  Constraints: `3 ≤ s.length ≤ 15.`
  

 - `[output]` an integer

Answer: {"fn_name": "cyclic_string", "inputs": [["cabca"], ["aba"], ["ccccccccccc"], ["abaca"]], "outputs": [[3], [2], [1], [4]]}
user: Given the sum and gcd of two numbers, return those two numbers in ascending order. If the numbers do not exist, return `-1`, (or `NULL` in C, `tuple (-1,-1)` in C#, `pair (-1,-1)` in C++,`None` in Rust, `array {-1,-1} ` in Java and Golang).

```
For example: 
Given sum = 12 and gcd = 4...

solve(12,4) = [4,8]. The two numbers 4 and 8 sum to 12 and have a gcd of 4.

solve(12,5) = -1. No two numbers exist that sum to 12 and have gcd of 5.

solve(10,2) = [2,8]. Note that [4,6] is also a possibility but we pick the one with the lower first element: 2 < 4, so we take [2,8].
```

More examples in test cases. 

Good luck!

Answer: {"fn_name": "solve", "inputs": [[6, 3], [8, 2], [10, 3], [12, 4], [12, 5], [50, 10], [50, 4], [10, 5], [100, 5], [1000, 5]], "outputs": [[[3, 3]], [[2, 6]], [-1], [[4, 8]], [-1], [[10, 40]], [-1], [[5, 5]], [[5, 95]], [[5, 995]]]}
user: Write a function name `nextPerfectSquare` that returns the first perfect square that is greater than its integer argument. A `perfect square` is a integer that is equal to some integer squared. For example 16 is a perfect square because `16=4*4`. 
```
example

n   next perfect sqare

6    9
36   49 
0    1
-5   0 
```
```if-not:csharp
caution! the largest number tested is closer to `Number.MAX_SAFE_INTEGER`
```
```if:csharp
Caution! The largest number test is close to `Int64.MaxValue`
```

Answer: {"fn_name": "next_perfect_square", "inputs": [[6], [36], [0], [-5]], "outputs": [[9], [49], [1], [0]]}
user: Due to another of his misbehaved, 
the primary school's teacher of the young Gauß,  Herr J.G. Büttner, to keep the bored and unruly young schoolboy Karl Friedrich Gauss busy for a good long time, while he teaching arithmetic to his mates,
assigned him the problem of adding up all the whole numbers from 1 through a given number `n`.

Your task is to help the young Carl Friedrich to solve this problem as quickly as you can; so, he can astonish his teacher and rescue his recreation interval.

Here's, an example:

```
f(n=100) // returns 5050 
```

It's your duty to verify that n is a valid positive integer number. If not, please, return false (None for Python, null for C#).

> **Note:** the goal of this kata is to invite you to think about some 'basic' mathematic formula and how you can do performance optimization on your code. 

> Advanced - experienced users should try to solve it in one line, without loops, or optimizing the code as much as they can.

-----

**Credits:** this kata was inspired by the farzher's kata 'Sum of large ints' . In fact, it can be seen as a sort of prep kata for that one.

Answer: {"fn_name": "f", "inputs": [[100], [300], [303], [50000], ["n"], [3.14], [0], [-10]], "outputs": [[5050], [45150], [46056], [1250025000], [null], [null], [null], [null]]}