meetforever/GRPO_CL huggingface dataset:
user: Goldbach's conjecture is one of the oldest and best-known unsolved problems in number theory and all of mathematics. It states:

Every even integer greater than 2 can be expressed as the sum of two primes.
For example: 

`6 = 3 + 3`
`8 = 3 + 5`
`10 = 3 + 7 = 5 + 5`
`12 = 5 + 7`

Some rules for the conjecture: 

- pairs should be descending like [3,5] not [5,3]

- all pairs should be in ascending order based on the first element of the pair: 
`[[5, 13], [7, 11]]` is accepted 
but `[[7, 11],[5, 13]]` is not accepted.

Write the a function that find all identical pairs of prime numbers:
```python
def goldbach(even_number)
```
You should return an array of containing pairs of primes, like:
```python
[[5, 13], [7, 11]]  # even_number = 18
```
or
```python
[[3, 31], [5, 29], [11, 23], [17, 17]] # even_number = 34
```

Answer: {"fn_name": "goldbach", "inputs": [[2], [4], [6], [8], [10], [52], [54], [56], [58], [100], [200], [1000], [5000]], "outputs": [[[]], [[[2, 2]]], [[[3, 3]]], [[[3, 5]]], [[[3, 7], [5, 5]]], [[[5, 47], [11, 41], [23, 29]]], [[[7, 47], [11, 43], [13, 41], [17, 37], [23, 31]]], [[[3, 53], [13, 43], [19, 37]]], [[[5, 53], [11, 47], [17, 41], [29, 29]]], [[[3, 97], [11, 89], [17, 83], [29, 71], [41, 59], [47, 53]]], [[[3, 197], [7, 193], [19, 181], [37, 163], [43, 157], [61, 139], [73, 127], [97, 103]]], [[[3, 997], [17, 983], [23, 977], [29, 971], [47, 953], [53, 947], [59, 941], [71, 929], [89, 911], [113, 887], [137, 863], [173, 827], [179, 821], [191, 809], [227, 773], [239, 761], [257, 743], [281, 719], [317, 683], [347, 653], [353, 647], [359, 641], [383, 617], [401, 599], [431, 569], [443, 557], [479, 521], [491, 509]]], [[[7, 4993], [13, 4987], [31, 4969], [43, 4957], [67, 4933], [97, 4903], [139, 4861], [199, 4801], [211, 4789], [241, 4759], [271, 4729], [277, 4723], [337, 4663], [349, 4651], [379, 4621], [397, 4603], [409, 4591], [433, 4567], [439, 4561], [487, 4513], [577, 4423], [643, 4357], [661, 4339], [673, 4327], [727, 4273], [739, 4261], [757, 4243], [769, 4231], [823, 4177], [907, 4093], [997, 4003], [1033, 3967], [1069, 3931], [1093, 3907], [1123, 3877], [1153, 3847], [1231, 3769], [1291, 3709], [1303, 3697], [1327, 3673], [1429, 3571], [1453, 3547], [1459, 3541], [1471, 3529], [1483, 3517], [1489, 3511], [1531, 3469], [1543, 3457], [1567, 3433], [1609, 3391], [1627, 3373], [1657, 3343], [1669, 3331], [1693, 3307], [1699, 3301], [1741, 3259], [1747, 3253], [1783, 3217], [1831, 3169], [1879, 3121], [1933, 3067], [1951, 3049], [1999, 3001], [2029, 2971], [2083, 2917], [2113, 2887], [2143, 2857], [2203, 2797], [2251, 2749], [2269, 2731], [2281, 2719], [2287, 2713], [2293, 2707], [2311, 2689], [2341, 2659], [2383, 2617]]]]}
user: Consider a pyramid made up of blocks. Each layer of the pyramid is a rectangle of blocks, and the dimensions of these rectangles increment as you descend the pyramid. So, if a layer is a `3x6` rectangle of blocks, then the next layer will be a `4x7` rectangle of blocks. A `1x10` layer will be on top of a `2x11` layer on top of a `3x12` layer, and so on.

## Task

Given the dimensions of a pyramid's topmost layer `w,l`, and its height `h` (aka the number of layers), return the total number of blocks in the pyramid.

## Examples

`num_blocks(1, 1, 2)` will return `5`. This pyramid starts with a `1x1` layer and has 2 layers total. So, there is 1 block in the first layer, and `2x2=4` blocks in the second. Thus, 5 is the total number of blocks.

`num_blocks(2, 4, 3)` will return `47`. This pyramid has 3 layers: `2x4`, `3x5`, and `4x6`. So, there are `47` blocks total.

## Notes

All parameters will always be postive nonzero integers.

Efficiency is important. There will be:

* 100 'small' cases with `w`, `l`, and `h` below `20`.
* 100 'big' cases with `w`, `l`, and `h` between `1e9` and `1e10`.

Answer: {"fn_name": "num_blocks", "inputs": [[1, 1, 2], [2, 4, 3], [1, 10, 10], [20, 30, 40]], "outputs": [[5], [47], [880], [83540]]}
user: Implement a function, so it will produce a sentence out of the given parts.

Array of parts could contain:
- words;
- commas in the middle;
- multiple periods at the end.

Sentence making rules:
- there must always be a space between words;
- there must not be a space between a comma and word on the left;
- there must always be one and only one period at the end of a sentence.

**Example:**

Answer: {"fn_name": "make_sentences", "inputs": [[["hello", "world"]], [["Quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog"]], [["hello", ",", "my", "dear"]], [["one", ",", "two", ",", "three"]], [["One", ",", "two", "two", ",", "three", "three", "three", ",", "4", "4", "4", "4"]], [["hello", "world", "."]], [["Bye", "."]], [["hello", "world", ".", ".", "."]], [["The", "Earth", "rotates", "around", "The", "Sun", "in", "365", "days", ",", "I", "know", "that", ".", ".", ".", ".", ".", ".", ".", ".", ".", ".", ".", "."]]], "outputs": [["hello world."], ["Quick brown fox jumped over the lazy dog."], ["hello, my dear."], ["one, two, three."], ["One, two two, three three three, 4 4 4 4."], ["hello world."], ["Bye."], ["hello world."], ["The Earth rotates around The Sun in 365 days, I know that."]]}
user: You're a statistics professor and the deadline for submitting your students' grades is tonight at midnight. Each student's grade is determined by their mean score across all of the tests they took this semester.

You've decided to automate grade calculation by writing a function `calculate_grade()` that takes a list of test scores as an argument and returns a one character string representing the student's grade calculated as follows:

 * 90% <= mean score <= 100%: `"A"`,
 * 80% <= mean score < 90%: `"B"`,
 * 70% <= mean score < 80%: `"C"`,
 * 60% <= mean score < 70%: `"D"`,
 * mean score < 60%: `"F"`

For example, `calculate_grade([92, 94, 99])` would return `"A"` since the mean score is `95`, and `calculate_grade([50, 60, 70, 80, 90])` would return `"C"` since the mean score is `70`.

Your function should handle an input list of any length greater than zero.

Answer: {"fn_name": "calculate_grade", "inputs": [[[92, 94, 99]], [[50, 60, 70, 80, 90]], [[50, 55]]], "outputs": [["A"], ["C"], ["F"]]}
user: I assume most of you are familiar with the ancient legend of the rice (but I see wikipedia suggests [wheat](https://en.wikipedia.org/wiki/Wheat_and_chessboard_problem), for some reason) problem, but a quick recap for you: a young man asks as a compensation only `1` grain of rice for the first square, `2` grains for the second, `4` for the third, `8` for the fourth and so on, always doubling the previous.

Your task is pretty straightforward (but not necessarily easy): given an amount of grains, you need to return up to which square of the chessboard one should count in order to get at least as many.

As usual, a few examples might be way better than thousands of words from me:

```python
squares_needed(0) == 0
squares_needed(1) == 1
squares_needed(2) == 2
squares_needed(3) == 2
squares_needed(4) == 3
```

Input is always going to be valid/reasonable: ie: a non negative number; extra cookie for *not* using a loop to compute square-by-square (at least not directly) and instead trying a smarter approach [hint: some peculiar operator]; a trick converting the number might also work: impress me!

Answer: {"fn_name": "squares_needed", "inputs": [[0], [1], [2], [3], [4]], "outputs": [[0], [1], [2], [2], [3]]}
user: Write a function called "filterEvenLengthWords".

Given an array of strings, "filterEvenLengthWords" returns an array containing only the elements of the given array whose length is an even number.

var output = filterEvenLengthWords(['word', 'words', 'word', 'words']);

console.log(output); // --> ['word', 'word']

Answer: {"fn_name": "filter_even_length_words", "inputs": [[["Hello", "World"]], [["One", "Two", "Three", "Four"]]], "outputs": [[[]], [["Four"]]]}
user: Your task is to make function, which returns the sum of a sequence of integers.

The sequence is defined by 3 non-negative values: **begin**, **end**, **step**.

If **begin** value is greater than the **end**, function should returns **0**

*Examples*

~~~if-not:nasm

~~~

This is the first kata in the series:

1) Sum of a sequence (this kata)  
2) [Sum of a Sequence [Hard-Core Version]](https://www.codewars.com/kata/sum-of-a-sequence-hard-core-version/javascript)

Answer: {"fn_name": "sequence_sum", "inputs": [[2, 6, 2], [1, 5, 1], [1, 5, 3], [0, 15, 3], [16, 15, 3], [2, 24, 22], [2, 2, 2], [2, 2, 1], [1, 15, 3], [15, 1, 3]], "outputs": [[12], [15], [5], [45], [0], [26], [2], [2], [35], [0]]}
user: # Task
 You're standing at the top left corner of an `n × m` grid and facing towards the `right`. 
 
 Then you start walking one square at a time in the direction you are facing. 
 
 If you reach the border of the grid or if the next square you are about to visit has already been visited, you turn right. 
 
 You stop when all the squares in the grid are visited. What direction will you be facing when you stop?

 You can see the example of your long walk in the image below. The numbers denote the order in which you visit the cells.

 ![](https://i.gyazo.com/2fc5884d2c227a0ddeca503e6a0261be.png)

 Given two integers n and m, denoting the number of rows and columns respectively, find out the direction you will be facing at the end. 
 
 Output `"L"` for left, `"R"` for right, `"U"` for up, and `"D"` for down.

# Example:

 For `n = 3, m = 3`, the output should be `"R"`.

 This example refers to the picture given in the description. At the end of your walk you will be standing in the middle of the grid facing right.

# Input/Output


 - `[input]` integer `n`
 
 number of rows.

 `1 <= n <= 1000`


 - `[input]` integer `m`
 
 number of columns.

 `1 <= m <= 1000`
 
 
 - `[output]` a string

 The final direction.

Answer: {"fn_name": "direction_in_grid", "inputs": [[1, 1], [2, 2], [2, 3], [2, 4], [3, 1], [3, 2], [3, 3], [3, 4], [3, 5], [4, 2], [4, 3], [4, 4], [4, 5], [4, 6], [5, 4], [5, 5], [5, 6], [100, 100]], "outputs": [["R"], ["L"], ["L"], ["L"], ["D"], ["U"], ["R"], ["R"], ["R"], ["U"], ["D"], ["L"], ["L"], ["L"], ["U"], ["R"], ["R"], ["L"]]}
user: Write function avg which calculates average of numbers in given list.

Answer: {"fn_name": "find_average", "inputs": [[[1, 2, 3]]], "outputs": [[2]]}
user: A palindrome is a word, phrase, number, or other sequence of characters which reads the same backward as forward. Examples of numerical palindromes are: 

* 232
* 110011
* 54322345

Complete the function to test if the given number (`num`) **can be rearranged** to form a numerical palindrome or not. Return a boolean (`true` if it can be rearranged to a palindrome, and `false` if it cannot). Return `"Not valid"` if the input is not an integer or is less than 0.

For this kata, single digit numbers are **NOT** considered numerical palindromes.  


## Examples

```
5        =>  false
2121     =>  true
1331     =>  true 
3357665  =>  true 
1294     =>  false 
"109982" =>  "Not valid"
-42      =>  "Not valid"
```

Answer: {"fn_name": "palindrome", "inputs": [[5], [1212], ["ololo"], [1331], [194], [111222], ["Hello world!"], [3357665], ["357665"], [-42]], "outputs": [[false], [true], ["Not valid"], [true], [false], [false], ["Not valid"], [true], ["Not valid"], ["Not valid"]]}
user: You are given an initial 2-value array (x). You will use this to calculate a score.

If both values in (x) are numbers, the score is the sum of the two. If only one is a number, the score is that number. If neither is a number, return 'Void!'.


Once you have your score, you must return an array of arrays. Each sub array will be the same as (x) and the number of sub arrays should be equal to the score.

For example:

if (x) == ['a', 3]  you should return [['a', 3], ['a', 3], ['a', 3]].

Answer: {"fn_name": "explode", "inputs": [[[9, 3]], [["a", 3]], [[6, "c"]], [["a", "b"]], [[1, 0]]], "outputs": [[[[9, 3], [9, 3], [9, 3], [9, 3], [9, 3], [9, 3], [9, 3], [9, 3], [9, 3], [9, 3], [9, 3], [9, 3]]], [[["a", 3], ["a", 3], ["a", 3]]], [[[6, "c"], [6, "c"], [6, "c"], [6, "c"], [6, "c"], [6, "c"]]], ["Void!"], [[[1, 0]]]]}
user: # Covfefe


Your are given a string. You must replace the word(s) `coverage` by `covfefe`, however, if you don't find the word `coverage` in the string, you must add `covfefe` at the end of the string with a leading space.

For the languages where the string is not immutable (such as ruby), don't modify the given string, otherwise this will break the test cases.

Answer: {"fn_name": "covfefe", "inputs": [["coverage"], ["coverage coverage"], ["nothing"], ["double space "], ["covfefe"]], "outputs": [["covfefe"], ["covfefe covfefe"], ["nothing covfefe"], ["double space  covfefe"], ["covfefe covfefe"]]}
user: # Task
 Mr.Odd is my friend. Some of his common dialogues are “Am I looking odd?” , “It’s looking very odd” etc. Actually “odd” is his favorite word.

 In this valentine when he went to meet his girlfriend. But he forgot to take gift. Because of this he told his gf that he did an odd thing. His gf became angry and gave him punishment.

 His gf gave him a string str of contain only lowercase letter and told him,
 
 “You have to take 3 index `i,j,k` such that `i ".u..dbo"(no more odd)`
 
 For `str="ooudddbd"`, the result should be `2`.
 
 `"ooudddbd"(cut 1st odd)--> ".ou..dbd"(cut 2nd odd) --> "..u...b."`
 
# Input/Output


 - `[input]` string `str`

  a non-empty string that contains only lowercase letters.
  
  `0 < str.length <= 10000`


 - `[output]` an integer

  the maximum number of "odd".

Answer: {"fn_name": "odd", "inputs": [["oudddbo"], ["ouddddbo"], ["ooudddbd"], ["qoddoldfoodgodnooofostorodrnvdmddddeidfoi"]], "outputs": [[1], [1], [2], [6]]}
user: # Base64 Numeric Translator

Our standard numbering system is (Base 10). That includes 0 through 9. Binary is (Base 2), only 1’s and 0’s.  And Hexadecimal is (Base 16) (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F). A hexadecimal “F” has a (Base 10) value of 15. (Base 64) has 64 individual characters which translate in value in (Base 10) from between 0 to 63.

####Write a method that will convert a string from (Base 64) to it's (Base 10) integer value.

The (Base 64) characters from least to greatest will be
```
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/
```
Where 'A' is equal to 0 and '/' is equal to 63.

Just as in standard (Base 10) when you get to the highest individual integer 9 the next number adds an additional place and starts at the beginning 10; so also (Base 64) when you get to the 63rd digit '/' and the next number adds an additional place and starts at the beginning "BA".

Example:
```
base64_to_base10("/") # => 63
base64_to_base10("BA") # => 64
base64_to_base10("BB") # => 65
base64_to_base10("BC") # => 66
```

Write a method `base64_to_base10` that will take a string (Base 64) number and output it's (Base 10) value as an integer.

Answer: {"fn_name": "base64_to_base10", "inputs": [["WIN"], ["b64"], ["B64"], ["/+/"], ["HelloWorld"]], "outputs": [[90637], [114360], [7864], [262079], [134710352538679645]]}
user: This kata aims to show the vulnerabilities of hashing functions for short messages.

When provided with a SHA-256 hash, return the value that was hashed. You are also given the characters that make the expected value, but in alphabetical order.

The returned value is less than 10 characters long. Return `nil` for Ruby and Crystal, `None` for Python, `null` for Java when the hash cannot be cracked with the given characters.

---

Example:
--------
```
Example arguments: '5694d08a2e53ffcae0c3103e5ad6f6076abd960eb1f8a56577040bc1028f702b', 'cdeo'
Correct output: 'code'
```

Answer: {"fn_name": "sha256_cracker", "inputs": [["b8c49d81cb795985c007d78379e98613a4dfc824381be472238dbd2f974e37ae", "deGioOstu"], ["f58262c8005bb64b8f99ec6083faf050c502d099d9929ae37ffed2fe1bb954fb", "abc"]], "outputs": [["GoOutside"], [null]]}
user: *Recreation of [Project Euler problem #6](https://projecteuler.net/problem=6)*

Find the difference between the sum of the squares of the first `n` natural numbers `(1 <= n <= 100)` and the square of their sum.

## Example
For example, when `n = 10`:

* The square of the sum of the numbers is:

  (1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10)^(2) = 55^(2) = 3025


* The sum of the squares of the numbers is:

 1^(2) + 2^(2) + 3^(2) + 4^(2) + 5^(2) + 6^(2) + 7^(2) + 8^(2) + 9^(2) + 10^(2) = 385

Hence the difference between square of the sum of the first ten natural numbers and the sum of the squares of those numbes is: 3025 - 385 = 2640

Answer: {"fn_name": "difference_of_squares", "inputs": [[5], [10], [100]], "outputs": [[170], [2640], [25164150]]}
user: Write a function that merges two sorted arrays into a single one. The arrays only contain integers. Also, the final outcome must be sorted and not have any duplicate.

Answer: {"fn_name": "merge_arrays", "inputs": [[[1, 3, 5], [2, 4, 6]], [[2, 4, 8], [2, 4, 6]], [[1, 2, 3], []], [[], []]], "outputs": [[[1, 2, 3, 4, 5, 6]], [[2, 4, 6, 8]], [[1, 2, 3]], [[]]]}
user: In this Kata, you will be given two numbers, n and k and your task will be to return the k-digit array that sums to n and has the maximum possible GCD.

For example, given `n = 12, k = 3`, there are a number of possible `3-digit` arrays that sum to `12`, such as `[1,2,9], [2,3,7], [2,4,6], ...` and so on. Of all the possibilities, the one with the highest GCD is `[2,4,6]`. Therefore, `solve(12,3) = [2,4,6]`.

Note also that digits cannot be repeated within the sub-array, so `[1,1,10]` is not a possibility. Lastly, if there is no such array, return an empty array.

More examples in the test cases.

Good luck!

Answer: {"fn_name": "solve", "inputs": [[12, 7], [12, 3], [12, 4], [18, 3], [18, 5], [24, 3], [24, 4], [24, 5], [24, 6], [276, 12]], "outputs": [[[]], [[2, 4, 6]], [[1, 2, 3, 6]], [[3, 6, 9]], [[1, 2, 3, 4, 8]], [[4, 8, 12]], [[2, 4, 6, 12]], [[1, 2, 3, 4, 14]], [[1, 2, 3, 4, 5, 9]], [[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 78]]]}
user: Given a mathematical equation that has `*,+,-,/`, reverse it as follows:

```Haskell
solve("100*b/y") = "y/b*100"
solve("a+b-c/d*30") = "30*d/c-b+a"
```

More examples in test cases. 

Good luck!

Please also try:

[Simple time difference](https://www.codewars.com/kata/5b76a34ff71e5de9db0000f2)

[Simple remove duplicates](https://www.codewars.com/kata/5ba38ba180824a86850000f7)

Answer: {"fn_name": "solve", "inputs": [["100*b/y"], ["a+b-c/d*30"], ["a*b/c+50"]], "outputs": [["y/b*100"], ["30*d/c-b+a"], ["50+c/b*a"]]}
user: Write a function which converts the input string to uppercase.

~~~if:bf
For BF all inputs end with \0, all inputs are lowercases and there is no space between. 
~~~

Answer: {"fn_name": "make_upper_case", "inputs": [["hello"], ["hello world"], ["hello world !"], ["heLlO wORLd !"], ["1,2,3 hello world!"]], "outputs": [["HELLO"], ["HELLO WORLD"], ["HELLO WORLD !"], ["HELLO WORLD !"], ["1,2,3 HELLO WORLD!"]]}
user: You have to create a function,named `insertMissingLetters`, that takes in a `string` and outputs the same string processed in a particular way.

The function should insert **only after the first occurrence** of each character of the input string, all the **alphabet letters** that:

-**are NOT** in the original string  
-**come after** the letter of the string you are processing  

Each added letter should be in `uppercase`, the letters of the original string will always be in `lowercase`.


Example:  


`input`: "holly"  

`missing letters`: "a,b,c,d,e,f,g,i,j,k,m,n,p,q,r,s,t,u,v,w,x,z"  

`output`: "hIJKMNPQRSTUVWXZoPQRSTUVWXZlMNPQRSTUVWXZlyZ"  


You don't need to validate input, the input string will always contain a certain amount of lowercase letters  (min 1 / max 50).

Answer: {"fn_name": "insert_missing_letters", "inputs": [["hello"], ["abcdefghijklmnopqrstuvwxyz"], ["hellllllllllllooooo"], ["pixxa"], ["xpixax"], ["z"]], "outputs": [["hIJKMNPQRSTUVWXYZeFGIJKMNPQRSTUVWXYZlMNPQRSTUVWXYZloPQRSTUVWXYZ"], ["abcdefghijklmnopqrstuvwxyz"], ["hIJKMNPQRSTUVWXYZeFGIJKMNPQRSTUVWXYZlMNPQRSTUVWXYZllllllllllloPQRSTUVWXYZoooo"], ["pQRSTUVWYZiJKLMNOQRSTUVWYZxYZxaBCDEFGHJKLMNOQRSTUVWYZ"], ["xYZpQRSTUVWYZiJKLMNOQRSTUVWYZxaBCDEFGHJKLMNOQRSTUVWYZx"], ["z"]]}
user: Given n number of people in a room, calculate the probability that any two people in that room have the same birthday (assume 365 days every year = ignore leap year). Answers should be two decimals unless whole (0 or 1) eg 0.05

Answer: {"fn_name": "calculate_probability", "inputs": [[5], [15], [1], [365], [366]], "outputs": [[0.03], [0.25], [0], [1], [1]]}
user: ## Task:

Your task is to write a function which returns the sum of following series upto nth term(parameter).

    Series: 1 + 1/4 + 1/7 + 1/10 + 1/13 + 1/16 +...
 
## Rules:
 
* You need to round the answer to 2 decimal places and return it as String.

* If the given value is 0 then it should return 0.00

* You will only be given Natural Numbers as arguments.

## Examples:

    SeriesSum(1) => 1 = "1.00"
    SeriesSum(2) => 1 + 1/4 = "1.25"
    SeriesSum(5) => 1 + 1/4 + 1/7 + 1/10 + 1/13 = "1.57"
    
**NOTE**: In PHP the function is called `series_sum()`.

Answer: {"fn_name": "series_sum", "inputs": [[1], [2], [3], [4], [5], [6], [7], [8], [9], [15], [39], [58], [0]], "outputs": [["1.00"], ["1.25"], ["1.39"], ["1.49"], ["1.57"], ["1.63"], ["1.68"], ["1.73"], ["1.77"], ["1.94"], ["2.26"], ["2.40"], ["0.00"]]}
user: You've made it through the moat and up the steps of knowledge. You've won the temples games and now you're hunting for treasure in the final temple run. There's good news and bad news. You've found the treasure but you've triggered a nasty trap. You'll surely perish in the temple chamber.

With your last movements, you've decided to draw an "X" marks the spot for the next archeologist.

Given an odd number, n, draw an X for the next crew. Follow the example below.

`
`
If n = 1 return 'X\n' and if you're given an even number or invalid input, return '?'.

The output should be a string with no spaces after the final X on each line, but a \n to indicate a new line.


Check out my other 80's Kids Katas:


80's Kids #1: How Many Licks Does It Take
80's Kids #2: Help Alf Find His Spaceship
80's Kids #3: Punky Brewster's Socks
80's Kids #4: Legends of the Hidden Temple
80's Kids #5: You Can't Do That on Television
80's Kids #6: Rock 'Em, Sock 'Em Robots
80's Kids #7: She's a Small Wonder
80's Kids #8: The Secret World of Alex Mack
80's Kids #9: Down in Fraggle Rock 
80's Kids #10: Captain Planet

Answer: {"fn_name": "mark_spot", "inputs": [[5], [1], [[]], [11], ["treasure"], ["5"], [-1], [3], [2], [0.5]], "outputs": [["X       X\n  X   X\n    X\n  X   X\nX       X\n"], ["X\n"], ["?"], ["X                   X\n  X               X\n    X           X\n      X       X\n        X   X\n          X\n        X   X\n      X       X\n    X           X\n  X               X\nX                   X\n"], ["?"], ["?"], ["?"], ["X   X\n  X\nX   X\n"], ["?"], ["?"]]}
user: # Task
 A robot is standing at the `(0, 0)` point of the Cartesian plane and is oriented towards the vertical (y) axis in the direction of increasing y values (in other words, he's facing up, or north). The robot executes several commands each of which is a single positive integer. When the robot is given a positive integer K it moves K squares forward and then turns 90 degrees clockwise.

 The commands are such that both of the robot's coordinates stay non-negative.

 Your task is to determine if there is a square that the robot visits at least twice after executing all the commands.

# Example

 For `a = [4, 4, 3, 2, 2, 3]`, the output should be `true`.

 The path of the robot looks like this:

 ![](https://codefightsuserpics.s3.amazonaws.com/tasks/robotWalk/img/path.png?_tm=1486563151922)

 The point `(4, 3)` is visited twice, so the answer is `true`.

# Input/Output


 - `[input]` integer array a

  An array of positive integers, each number representing a command.

  Constraints:
  
  `3 ≤ a.length ≤ 100`
  
  `1 ≤ a[i] ≤ 10000`


 - `[output]` a boolean value

  `true` if there is a square that the robot visits at least twice, `false` otherwise.

Answer: {"fn_name": "robot_walk", "inputs": [[[4, 4, 3, 2, 2, 3]], [[7, 5, 4, 5, 2, 3]], [[10, 3, 10, 2, 5, 1, 2]], [[11, 8, 6, 6, 4, 3, 7, 2, 1]], [[5, 5, 5, 5]], [[34241, 23434, 2341]], [[9348, 2188, 9348]]], "outputs": [[true], [true], [false], [true], [true], [false], [false]]}