meetforever/GRPO_CL huggingface dataset:
user: Given a certain number, how many multiples of three could you obtain with its digits?

Suposse that you have the number 362. The numbers that can be generated from it are:
```
362 ----> 3, 6, 2, 36, 63, 62, 26, 32, 23, 236, 263, 326, 362, 623, 632 
```
But only:

```3, 6, 36, 63``` are multiple of three.

We need a function that can receive a number ann may output in the following order:

- the amount of multiples

- the maximum multiple

Let's see a case the number has a the digit 0 and repeated digits:
```
6063 ----> 0, 3, 6, 30, 36, 60, 63, 66, 306, 360, 366, 603, 606, 630, 636, 660, 663, 3066, 3606, 3660, 6036, 6063, 6306, 6360, 6603, 6630
```
In this case the multiples of three will be all except 0

```
6063 ----> 3, 6, 30, 36, 60, 63, 66, 306, 360, 366, 603, 606, 630, 636, 660, 663, 3066, 3606, 3660, 6036, 6063, 6306, 6360, 6603, 6630
```

The cases above for the function:
```python
find_mult_3(362) == [4, 63]

find_mult_3(6063) == [25, 6630]
```
In Javascript ```findMult_3()```.
The function will receive only positive integers (num > 0), and you don't have to worry for validating the entries.

Features of the random tests:
```
Number of test = 100
1000 ≤ num ≤ 100000000
```
Enjoy it!!

Answer: {"fn_name": "find_mult_3", "inputs": [[362], [6063], [7766553322]], "outputs": [[[4, 63]], [[25, 6630]], [[55510, 766553322]]]}
user: I need to save some money to buy a gift. I think I can do something like that:

First week (W0) I save nothing on Sunday, 1 on Monday, 2 on Tuesday... 6 on Saturday,
second week (W1) 2 on Monday... 7 on Saturday and so on according to the table below where the days are numbered from 0 to 6.

Can you tell me how much I will have for my gift on Saturday evening after I have saved 12? (Your function finance(6) should return 168 which is the sum of the savings in the table). 

Imagine now that we live on planet XY140Z-n where the days of the week are numbered from 0 to n (integer n > 0) and where
I save from week number 0 to week number n included (in the table below n = 6).

How much money would I have at the end of my financing plan on planet XY140Z-n?



  -- |Su|Mo|Tu|We|Th|Fr|Sa|
   --|--|--|--|--|--|--|--|
  W6 |  |  |  |  |  |  |12|
  W5 |  |  |  |  |  |10|11|
  W4 |  |  |  |  |8 |9 |10|
  W3 |  |  |  |6 |7 |8 |9 |
  W2 |  |  |4 |5 |6 |7 |8 |
  W1 |  |2 |3 |4 |5 |6 |7 |
  W0 |0 |1 |2 |3 |4 |5 |6 |
  
#Example:
```
finance(5) --> 105
finance(6) --> 168
finance(7) --> 252
finance(5000) --> 62537505000
```
#Hint: 
try to avoid nested loops

Answer: {"fn_name": "finance", "inputs": [[5], [6], [8], [15], [100], [365], [730], [999], [2000], [4000], [5000]], "outputs": [[105], [168], [360], [2040], [515100], [24513765], [195308580], [499999500], [4006002000], [32024004000], [62537505000]]}
user: Ronald's uncle left him 3 fertile chickens in his will. When life gives you chickens, you start a business selling chicken eggs which is exactly what Ronald decided to do. 

A chicken lays 300 eggs in its first year. However, each chicken's egg production decreases by 20% every following year (rounded down) until when it dies (after laying its quota of eggs). 

After his first successful year of business, Ronald decides to buy 3 more chickens at the start of each year.  


Your Task: 

For a given year, and life span of chicken span,  calculate how many eggs Ronald's chickens will lay him that year, whereby year=1 is when Ronald first got his inheritance and span>0.

If year=0, make sure to return "No chickens yet!".


Note: 
1. All chickens have the same life span regardless of when they are bought. 
2. Let's assume all calculations are made at the end of the year so don't bother taking eggs laid per month into consideration. 
3. Each chicken's egg production goes down by 20% each year, NOT the total number of eggs produced by each 'batch' of chickens. While this might appear to be the same thing, it doesn't once non-integers come into play so take care that this is reflected in your kata!

Answer: {"fn_name": "egged", "inputs": [[0, 5], [2, 1], [4, 8], [74, 10], [1, 15]], "outputs": [["No chickens yet!"], [900], [2655], [3984], [900]]}
user: # Task
 Initially a number `1` is written on a board. It is possible to do the following operations with it:
```
multiply the number by 3;
increase the number by 5.```
Your task is to determine that using this two operations step by step, is it possible to obtain number `n`?

# Example

 For `n = 1`, the result should be `true`.
 
 `1 = 1`
 
 For `n = 2`, the result should be `false`.
 
 For `n = 3`, the result should be `true`.
 
 `1 x 3 = 3`
 
 For `n = 4`, the result should be `false`.
 
 For `n = 5`, the result should be `false`.
 
 For `n = 6`, the result should be `true`.
 
 `1 + 5 = 6`
 
 For `n = 18`, the result should be `true`.
 
 `1 + 5 = 6  --> 6 x 3 = 18`
 
 For `n = 32`, the result should be `true`.
 
 `1 x 3 x 3 x 3 = 27  --> 27 + 5 = 32`
 
 For `n = 100`, the result should be `false`.
 
 For `n = 101`, the result should be `true`.
 
 `1 + 5 + 5 + 5 ... +5 = 101`
 
# Input / Output


 - `[input]` integer n

  positive integer, n ≤ 100000


 - `[output]` a boolean value

  `true` if N can be obtained using given operations, `false` otherwise.

Answer: {"fn_name": "number_increasing", "inputs": [[1], [2], [3], [4], [5], [6], [100], [101], [12345], [54321]], "outputs": [[true], [false], [true], [false], [false], [true], [false], [true], [false], [true]]}
user: #Description

Everybody has probably heard of the animal heads and legs problem from the earlier years at school. It goes:

```“A farm contains chickens and cows. There are x heads and y legs. How many chickens and cows are there?” ```

Where x <= 1000 and y <=1000

#Task

Assuming there are no other types of animals, work out how many of each animal are there. 

```Return a tuple in Python - (chickens, cows) and an array list - [chickens, cows]/{chickens, cows} in all other languages```

If either the heads & legs is negative, the result of your calculation is negative or the calculation is a float return "No solutions" (no valid cases).

In the form:
```python
(Heads, Legs) = (72, 200)

VALID - (72, 200) =>             (44 , 28) 
                             (Chickens, Cows)

INVALID - (72, 201) => "No solutions"
```

However, ```if 0 heads and 0 legs are given always return [0, 0]``` since zero heads must give zero animals.

There are many different ways to solve this, but they all give the same answer.

You will only be given integers types - however negative values (edge cases) will be given. 

Happy coding!

Answer: {"fn_name": "animals", "inputs": [[72, 200], [116, 282], [12, 24], [6, 24], [344, 872], [158, 616], [25, 555], [12, 25], [54, 956], [5455, 54956], [0, 0], [-1, -1], [500, 0], [0, 500], [-45, 5], [5, -55]], "outputs": [[[44, 28]], [[91, 25]], [[12, 0]], [[0, 6]], [[252, 92]], [[8, 150]], ["No solutions"], ["No solutions"], ["No solutions"], ["No solutions"], [[0, 0]], ["No solutions"], ["No solutions"], ["No solutions"], ["No solutions"], ["No solutions"]]}
user: Math hasn't always been your best subject, and these programming symbols always trip you up!

I mean, does `**` mean *"Times, Times"* or *"To the power of"*?

Luckily, you can create the function `expression_out()` to write out the expressions for you!

The operators you'll need to use are:

```python
{ '+':   'Plus ',
  '-':   'Minus ',
  '*':   'Times ',
  '/':   'Divided By ',  
  '**':  'To The Power Of ',
  '=':   'Equals ',
  '!=':  'Does Not Equal ' }
```

These values will be stored in the preloaded dictionary `OPERATORS` just as shown above.

But keep in mind: INVALID operators will also be tested, to which you should return `"That's not an operator!"`

And all of the numbers will be `1` to`10`!
Isn't that nice!

Here's a few examples to clarify:

```python
expression_out("4 ** 9") == "Four To The Power Of Nine"
expression_out("10 - 5") == "Ten Minus Five"
expression_out("2 = 2")  == "Two Equals Two"
```

Good luck!

Answer: {"fn_name": "expression_out", "inputs": [["1 + 3"], ["2 - 10"], ["6 ** 9"], ["5 = 5"], ["7 * 4"], ["2 / 2"], ["8 != 5"]], "outputs": [["One Plus Three"], ["Two Minus Ten"], ["Six To The Power Of Nine"], ["Five Equals Five"], ["Seven Times Four"], ["Two Divided By Two"], ["Eight Does Not Equal Five"]]}
user: ##Task:
You have to write a function `add` which takes two binary numbers as strings and returns their sum as a string.

##Note:
* You are `not allowed to convert binary to decimal & vice versa`.
* The sum should contain `No leading zeroes`.

##Examples:
```
add('111','10'); => '1001'
add('1101','101'); => '10010'
add('1101','10111') => '100100'
```

Answer: {"fn_name": "add", "inputs": [["111", "10"], ["1101", "101"], ["1101", "10111"], ["10111", "001010101"], ["00", "0"]], "outputs": [["1001"], ["10010"], ["100100"], ["1101100"], ["0"]]}
user: You are the judge at a competitive eating competition and you need to choose a winner!

There are three foods at the competition and each type of food is worth a different amount of points.
Points are as follows:

- Chickenwings: 5 points  

- Hamburgers: 3 points   

- Hotdogs: 2 points

Write a function that helps you create a scoreboard. 
It takes as a parameter a list of objects representing the participants, for example:
```
[
  {name: "Habanero Hillary", chickenwings: 5 , hamburgers: 17, hotdogs: 11},
  {name: "Big Bob" , chickenwings: 20, hamburgers: 4, hotdogs: 11}
]
```
It should return 
"name" and "score" properties sorted by score; if scores are equals, sort alphabetically by name.
```
[
  {name: "Big Bob", score: 134},
  {name: "Habanero Hillary", score: 98}
]
```
Happy judging!

Answer: {"fn_name": "scoreboard", "inputs": [[[{"name": "Billy The Beast", "chickenwings": 17, "hamburgers": 7, "hotdogs": 8}, {"name": "Habanero Hillary", "chickenwings": 5, "hamburgers": 17, "hotdogs": 11}, {"name": "Joey Jaws", "chickenwings": 8, "hamburgers": 8, "hotdogs": 15}, {"name": "Big Bob", "chickenwings": 20, "hamburgers": 4, "hotdogs": 11}]], [[{"name": "Big Bob", "chickenwings": 20, "hamburgers": 4, "hotdogs": 11}]], [[{"name": "Joey Jaws", "chickenwings": 8, "hamburgers": 8, "hotdogs": 15}, {"name": "Big Bob", "chickenwings": 20, "hamburgers": 4, "hotdogs": 11}]], [[{"name": "Joey Jaws", "chickenwings": 0, "hamburgers": 1, "hotdogs": 1}, {"name": "Big Bob", "chickenwings": 1, "hamburgers": 0, "hotdogs": 0}]], [[]]], "outputs": [[[{"name": "Big Bob", "score": 134}, {"name": "Billy The Beast", "score": 122}, {"name": "Habanero Hillary", "score": 98}, {"name": "Joey Jaws", "score": 94}]], [[{"name": "Big Bob", "score": 134}]], [[{"name": "Big Bob", "score": 134}, {"name": "Joey Jaws", "score": 94}]], [[{"name": "Big Bob", "score": 5}, {"name": "Joey Jaws", "score": 5}]], [[]]]}
user: Our AAA company is in need of some software to help with logistics: you will be given the width and height of a map, a list of x coordinates and a list of y coordinates of the supply points, starting to count from the top left corner of the map as 0.

Your goal is to return a two dimensional array/list with every item having the value of the distance of the square itself from the closest supply point expressed as a simple integer.

Quick examples:

```python
logistic_map(3,3,[0],[0])
#returns
#[[0,1,2],
# [1,2,3],
# [2,3,4]]
logistic_map(5,2,[0,4],[0,0])
#returns
#[[0,1,2,1,0],
# [1,2,3,2,1]]
```

Remember that our company is operating with trucks, not drones, so you can simply use Manhattan distance. If supply points are present, they are going to be within the boundaries of the map; if no supply point is present on the map, just return `None`/`nil`/`null` in every cell.

```python
logistic_map(2,2,[],[])
#returns
#[[None,None],
# [None,None]]
```

**Note:** this one is taken (and a bit complicated) from a problem a real world AAA company [whose name I won't tell here] used in their interview. It was done by a friend of mine. It is nothing that difficult and I assume it is their own version of the FizzBuzz problem, but consider candidates were given about 30 mins to solve it.

Answer: {"fn_name": "logistic_map", "inputs": [[3, 3, [0], [0]], [3, 3, [2], [2]], [1, 1, [0], [0]], [5, 2, [0, 4], [0, 0]], [2, 2, [], []]], "outputs": [[[[0, 1, 2], [1, 2, 3], [2, 3, 4]]], [[[4, 3, 2], [3, 2, 1], [2, 1, 0]]], [[[0]]], [[[0, 1, 2, 1, 0], [1, 2, 3, 2, 1]]], [[[null, null], [null, null]]]]}
user: The goal of this Kata is to reduce the passed integer to a single digit (if not already) by converting the number to binary, taking the sum of the binary digits, and if that sum is not a single digit then repeat the process.

- n will be an integer such that 0 < n < 10^20
- If the passed integer is already a single digit there is no need to reduce

For example given 5665 the function should return 5:

```
5665 --> (binary) 1011000100001
1011000100001 --> (sum of binary digits) 5
```


Given 123456789 the function should return 1:

```
123456789 --> (binary) 111010110111100110100010101
111010110111100110100010101 --> (sum of binary digits) 16
16 --> (binary) 10000
10000 --> (sum of binary digits) 1
```

Answer: {"fn_name": "single_digit", "inputs": [[5], [999], [1234444123], [443566], [565656565], [9889345778311094737448], [4868872], [234234235], [567448], [10000000000]], "outputs": [[5], [8], [1], [2], [3], [2], [8], [2], [7], [3]]}
user: Complete the function that takes a non-negative integer `n` as input, and returns a list of all the powers of 2 with the exponent ranging from 0 to `n` (inclusive).

## Examples

```python
n = 0  ==> [1]        # [2^0]
n = 1  ==> [1, 2]     # [2^0, 2^1]
n = 2  ==> [1, 2, 4]  # [2^0, 2^1, 2^2]
```

Answer: {"fn_name": "powers_of_two", "inputs": [[0], [1], [4]], "outputs": [[[1]], [[1, 2]], [[1, 2, 4, 8, 16]]]}
user: You get an array of numbers, return the sum of all of the positives ones.

Example `[1,-4,7,12]` => `1 + 7 + 12 = 20`

Note: if there is nothing to sum, the sum is default to `0`.

Answer: {"fn_name": "positive_sum", "inputs": [[[1, 2, 3, 4, 5]], [[1, -2, 3, 4, 5]], [[-1, 2, 3, 4, -5]], [[]], [[-1, -2, -3, -4, -5]]], "outputs": [[15], [13], [9], [0], [0]]}
user: # Task
Two players - `"black"` and `"white"` are playing a game. The game consists of several rounds. If a player wins in a round, he is to move again during the next round. If a player loses a round, it's the other player who moves on the next round. Given whose turn it was on the previous round and whether he won, determine whose turn it is on the next round.



# Input/Output


`[input]` string `lastPlayer`/`$last_player`

`"black"` or `"white"` - whose move it was during the previous round.

`[input]` boolean `win`/`$win`

`true` if the player who made a move during the previous round won, `false` otherwise.

`[output]` a string

Return `"white"` if white is to move on the next round, and `"black"` otherwise.

# Example

For `lastPlayer = "black" and win = false`, the output should be `"white"`.

For `lastPlayer = "white" and win = true`, the output should be `"white"`.

Answer: {"fn_name": "whoseMove", "inputs": [["black", false], ["white", false], ["black", true], ["white", true]], "outputs": [["white"], ["black"], ["black"], ["white"]]}
user: Take an input string and return a string that is made up of the number of occurences of each english letter in the input followed by that letter, sorted alphabetically. The output string shouldn't contain chars missing from input (chars with 0 occurence); leave them out.

An empty string, or one with no letters, should return an empty string.

Notes:

* the input will always be valid;
* treat letters as **case-insensitive**


## Examples

```
"This is a test sentence."  ==>  "1a1c4e1h2i2n4s4t"
""                          ==>  ""
"555"                       ==>  ""
```

Answer: {"fn_name": "string_letter_count", "inputs": [["The quick brown fox jumps over the lazy dog."], ["The time you enjoy wasting is not wasted time."], ["./4592#{}()"], ["This%Sentence\"is$$being^tested."], ["abccdefgdhijklmno_pqrsTuvwxYz"], [""], ["."], ["y"]], "outputs": [["1a1b1c1d3e1f1g2h1i1j1k1l1m1n4o1p1q2r1s2t2u1v1w1x1y1z"], ["2a1d5e1g1h4i1j2m3n3o3s6t1u2w2y"], [""], ["1b1c1d6e1g1h3i3n4s4t"], ["1a1b2c2d1e1f1g1h1i1j1k1l1m1n1o1p1q1r1s1t1u1v1w1x1y1z"], [""], [""], ["1y"]]}
user: ---

# Story

The Pied Piper has been enlisted to play his magical tune and coax all the rats out of town.

But some of the rats are deaf and are going the wrong way!

# Kata Task

How many deaf rats are there?

# Legend

* ```P``` = The Pied Piper
* ```O~``` = Rat going left
* ```~O``` = Rat going right

# Example

* ex1 ```~O~O~O~O P``` has 0 deaf rats


* ex2 ```P O~ O~ ~O O~``` has 1 deaf rat


* ex3 ```~O~O~O~OP~O~OO~``` has 2 deaf rats

---

# Series

* [The deaf rats of Hamelin (2D)](https://www.codewars.com/kata/the-deaf-rats-of-hamelin-2d)

Answer: {"fn_name": "count_deaf_rats", "inputs": [["~O~O~O~O P"], ["P O~ O~ ~O O~"], ["~O~O~O~OP~O~OO~"], ["O~~OO~~OO~~OO~P~OO~~OO~~OO~~O"], ["~OP"], ["PO~"], ["O~P"], ["P~O"], ["         P"], ["P         "], ["         P      "], ["P"]], "outputs": [[0], [1], [2], [8], [0], [0], [1], [1], [0], [0], [0], [0]]}
user: Your job is to build a function which determines whether or not there are double characters in a string (including whitespace characters). For example ```aa```, ``!!`` or ```  ```.
 

You want the function to return true if the string contains double characters and false if not.  The test should not be case sensitive; for example both ```aa``` & ```aA``` return true.

Examples:
```python
  double_check("abca")
  #returns False
  
  double_check("aabc")
  #returns True
  
  double_check("a 11 c d")
  #returns True
  
  double_check("AabBcC")
  #returns True
  
  double_check("a b  c")
  #returns True
  
  double_check("a b c d e f g h i h k")
  #returns False
  
  double_check("2020")
  #returns False
  
  double_check("a!@€£#$%^&*()_-+=}]{[|\"':;?/>.<,~")
  #returns False
```

Answer: {"fn_name": "double_check", "inputs": [["abca"], ["aabc"], ["a 11 c d"], ["AabBcC"], ["a b  c"], ["a b c d e f g h i h k"], ["2020"], ["a!@\u20ac\u00a3#$%^&*()_-+=}]{[|':;?/>.<,~"]], "outputs": [[false], [true], [true], [true], [true], [false], [false], [false]]}
user: Make the 2D list by the sequential integers started by the ```head``` number.

See the example test cases for the expected output.

``` 
Note:

-10**20 < the head number <10**20
1 <=  the number of rows <= 1000
0 <=  the number of columms <= 1000
```

Answer: {"fn_name": "make_2d_list", "inputs": [[1, 2, 3], [2, 3, 4], [5, 6, 1], [7, 1, 1], [0, 1, 0], [-20, 2, 2], [10000000000, 2, 2]], "outputs": [[[[1, 2, 3], [4, 5, 6]]], [[[2, 3, 4, 5], [6, 7, 8, 9], [10, 11, 12, 13]]], [[[5], [6], [7], [8], [9], [10]]], [[[7]]], [[[]]], [[[-20, -19], [-18, -17]]], [[[10000000000, 10000000001], [10000000002, 10000000003]]]]}
user: The four bases found in DNA are adenine (A), cytosine (C), guanine (G) and thymine (T).

In genetics, GC-content is the percentage of Guanine (G) and Cytosine (C) bases on a DNA molecule that are either guanine or cytosine. 

Given a DNA sequence (a string) return the GC-content in percent, rounded up to 2 decimal digits for Python, not rounded in all other languages.

For more information about GC-content you can take a look to [wikipedia GC-content](https://en.wikipedia.org/wiki/GC-content).

**For example**: the GC-content of the following DNA sequence is 50%:
"AAATTTCCCGGG".

**Note**: You can take a look to my others bio-info kata [here](http://www.codewars.com/users/nbeck/authored)

Answer: {"fn_name": "gc_content", "inputs": [[""], ["A"], ["C"], ["CA"]], "outputs": [[0.0], [0.0], [100.0], [50.0]]}
user: In this task you have to code process planner.

You will be given initial thing, target thing and a set of processes to turn one thing into another (in the form of _[process\_name, start\_thing, end\_thing]_). You must return  names of shortest sequence of processes to turn initial thing into target thing, or empty sequence if it's impossible.

If start already equals end, return [], since no path is required.

Example: 

```python
test_processes = [
        ['gather', 'field', 'wheat'],
        ['bake', 'flour', 'bread'],
        ['mill', 'wheat', 'flour']
];

processes('field', 'bread', test_processes) # should return ['gather', 'mill', 'bake']
processes('field', 'ferrari', test_processes) # should return []
processes('field', 'field', test_processes) # should return [], since no processes are needed
```

Good luck!

Answer: {"fn_name": "processes", "inputs": [["a", "c", [["1", "a", "c"], ["2", "a", "b"], ["3", "b", "c"]]], ["a", "d", [["1", "a", "b"], ["2", "b", "c"], ["3", "c", "b"]]], ["a", "d", [["1", "a", "b"], ["2", "b", "c"], ["3", "c", "b"], ["4", "c", "d"]]]], "outputs": [[["1"]], [[]], [["1", "2", "4"]]]}
user: You're hanging out with your friends in a bar, when suddenly one of them is so drunk, that he can't speak, and when he wants to say something, he writes it down on a paper. However, none of the words he writes make sense to you. He wants to help you, so he points at a beer and writes "yvvi". You start to understand what he's trying to say, and you write a script, that decodes his words.

Keep in mind that numbers, as well as other characters, can be part of the input, and you should keep them like they are. You should also test if the input is a string. If it is not, return "Input is not a string".

Answer: {"fn_name": "decode", "inputs": [["yvvi"], ["Blf zoivzwb szw 10 yvvih"], ["Ovg'h hdrn rm gsv ulfmgzrm!"], [{"brand": "Starobrno"}], ["Tl slnv, blf'iv wifmp"], ["Hfiv r xzm wzmxv lm xlk'h xzi, slow nb yvvi"], [true], ["Hvv? R'n mlg gszg wifmp, r xzm hgroo gzpv nb xolgsvh luu"], [123], [["Beer"]]], "outputs": [["beer"], ["You already had 10 beers"], ["Let's swim in the fountain!"], ["Input is not a string"], ["Go home, you're drunk"], ["Sure i can dance on cop's car, hold my beer"], ["Input is not a string"], ["See? I'm not that drunk, i can still take my clothes off"], ["Input is not a string"], ["Input is not a string"]]}
user: Simply find the closest value to zero from the list. Notice that there are negatives in the list.

List is always not empty and contains only integers. Return ```None``` if it is not possible to define only one of such values. And of course, we are expecting 0 as closest value to zero.

Examples:
```code
[2, 4, -1, -3]  => -1
[5, 2, -2]      => None
[5, 2, 2]       => 2
[13, 0, -6]     => 0
```

Answer: {"fn_name": "closest", "inputs": [[[10, 3, 9, 1]], [[2, 4, -1, -3]], [[5, 2, -2]], [[5, 2, 2]], [[13, 0, -6]], [[1]], [[5, 1, -1, 2, -10]], [[5, -5, -2, 5, -3]], [[27, 37, 48, -18, 42, 16, 5, 34, 35, 26, -34, 3, -43, 35, 0, -45, -7, 45, 34, -18, 44, 12, 6, -45, 33, 27, -2, 28, 12, 9]], [[11, -30, -18, 4, -13, 43, 12, -5, -6, -3, 48, 24, -35, 13, -14, 16, 40, -5, 33, -39, -29, 19, -19, -36, 17, 26, 43, 11, 28, -32]], [[28, -36, 49, 39, -33, 22, -5, 23, -24, 47, -47, -30, -20, -18, 40, -21, -45, 10, -48, -26, -12, -21, 48, 16, 26, 21, -9, 33, 8, -49]], [[32, -26, 15, 17, -11, -14, 17, 44, 16, 49, 14, 11, 40, 27, -32, 6, 18, 38, 48, -28, -29, -28, 21, -38, 26, -37, -43, 16, 13, -6]], [[36, 43, 44, -15, 37, 38, -11, 37, 21, 8, 20, -13, -32, -15, 31, -6, -33, -6, -47, 0, 0, 33, 42, 0, -47, -29, -38, 18, -32, -33]], [[20, 26, 13, -47, -35, 39, 24, 46, -16, 5, 46, -30, -33, -38, -47, 23, 10, -39, -36, 41, 5, -24, 28, -30, 40, -24, -28, -17, -36, 41]]], "outputs": [[1], [-1], [null], [2], [0], [1], [null], [-2], [0], [-3], [-5], [null], [0], [5]]}
user: ## Objective

Given a number `n` we will define it's sXORe to be `0 XOR 1 XOR 2 ... XOR n` where `XOR` is the [bitwise XOR operator](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).

Write a function that takes `n` and returns it's sXORe.

## Examples
|    n    | sXORe n
|---------|--------         
| 0       | 0
| 1       | 1
| 50      | 51
| 1000000 | 1000000
---

Answer: {"fn_name": "sxore", "inputs": [[0], [1], [2], [50], [1000000], [1000001], [9999999999999999999999999]], "outputs": [[0], [1], [3], [51], [1000000], [1], [0]]}