meetforever/GRPO_CL huggingface dataset:
user: # Task

Christmas is coming, and your task is to build a custom Christmas tree with the specified characters and the specified height.

# Inputs:
- `chars`: the specified characters. 
- `n`: the specified height. A positive integer greater than 2.

# Output:
- A multiline string. Each line is separated by `\n`. A tree contains two parts: leaves and trunks. 

The leaves should be `n` rows. The first row fill in 1 char, the second row fill in 3 chars, and so on. A single space will be added between two adjust chars, and some of the necessary spaces will be added to the left side, to keep the shape of the tree. No space need to be added to the right side.

The trunk should be at least 1 unit height, it depends on the value of the `n`. The minimum value of n is 3, and the height of the tree trunk is 1 unit height. If `n` increased by 3, and the tree trunk increased by 1 unit. For example, when n is 3,4 or 5, trunk should be 1 row; when n is 6,7 or 8, trunk should be 2 row; and so on.

Still not understand the task? Look at the following example ;-)

# Examples

For `chars = "*@o" and n = 3`,the output should be:
```
  *
 @ o
* @ o
  |
```

For `chars = "*@o" and n = 6`,the output should be:
```
     *
    @ o
   * @ o
  * @ o *
 @ o * @ o
* @ o * @ o
     |
     |
```

For `chars = "1234" and n = 6`,the output should be:
```
     1
    2 3
   4 1 2
  3 4 1 2
 3 4 1 2 3
4 1 2 3 4 1
     |
     |
```

For `chars = "123456789" and n = 3`,the output should be:
```
  1
 2 3
4 5 6
  |
```

Answer: {"fn_name": "custom_christmas_tree", "inputs": [["*@o", 3], ["*@o", 6], ["1234", 6], ["123456789", 3]], "outputs": [["  *\n @ o\n* @ o\n  |"], ["     *\n    @ o\n   * @ o\n  * @ o *\n @ o * @ o\n* @ o * @ o\n     |\n     |"], ["     1\n    2 3\n   4 1 2\n  3 4 1 2\n 3 4 1 2 3\n4 1 2 3 4 1\n     |\n     |"], ["  1\n 2 3\n4 5 6\n  |"]]}
user: The Fibonacci numbers are the numbers in the following integer sequence (Fn):
>0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, ...

such as 
>F(n) = F(n-1) + F(n-2) with F(0) = 0 and F(1) = 1.

Given a number, say prod (for product), we search two Fibonacci numbers F(n) and F(n+1) verifying 
>F(n) * F(n+1) = prod.

Your function productFib takes an integer (prod) and returns
an array: 
```
[F(n), F(n+1), true] or {F(n), F(n+1), 1} or (F(n), F(n+1), True)
```
depending on the language if F(n) * F(n+1) = prod.

If you don't find two consecutive F(m) verifying `F(m) * F(m+1) = prod`you will return
```
[F(m), F(m+1), false] or {F(n), F(n+1), 0} or (F(n), F(n+1), False)
```
F(m) being the smallest one such as `F(m) * F(m+1) > prod`.


### Some Examples of Return:
(depend on the language)

```
productFib(714) # should return (21, 34, true), 
                # since F(8) = 21, F(9) = 34 and 714 = 21 * 34

productFib(800) # should return (34, 55, false), 
                # since F(8) = 21, F(9) = 34, F(10) = 55 and 21 * 34 < 800 < 34 * 55
-----
productFib(714) # should return [21, 34, true], 
productFib(800) # should return [34, 55, false], 
-----
productFib(714) # should return {21, 34, 1}, 
productFib(800) # should return {34, 55, 0},        
-----
productFib(714) # should return {21, 34, true}, 
productFib(800) # should return {34, 55, false}, 
```

### Note:

- You can see examples for your language in "Sample Tests".

Answer: {"fn_name": "productFib", "inputs": [[4895], [5895], [74049690], [84049690], [193864606], [447577], [602070], [602070602070], [1120149658760], [256319508074468182850], [203023208030065646654504166904697594722575], [203023208030065646654504166904697594722576], [0], [1], [2], [3], [4], [5], [6], [7], [105]], "outputs": [[[55, 89, true]], [[89, 144, false]], [[6765, 10946, true]], [[10946, 17711, false]], [[10946, 17711, true]], [[610, 987, false]], [[610, 987, true]], [[832040, 1346269, false]], [[832040, 1346269, true]], [[12586269025, 20365011074, true]], [[354224848179261915075, 573147844013817084101, true]], [[573147844013817084101, 927372692193078999176, false]], [[0, 1, true]], [[1, 1, true]], [[1, 2, true]], [[2, 3, false]], [[2, 3, false]], [[2, 3, false]], [[2, 3, true]], [[3, 5, false]], [[13, 21, false]]]}
user: # Task
 Imagine a standard chess board with only two white and two black knights placed in their standard starting positions: the white knights on b1 and g1; the black knights on b8 and g8.

 There are two players: one plays for `white`, the other for `black`. During each move, the player picks one of his knights and moves it to an unoccupied square according to standard chess rules. Thus, a knight on d5 can move to any of the following squares: b6, c7, e7, f6, f4, e3, c3, and b4, as long as it is not occupied by either a friendly or an enemy knight.

 The players take turns in making moves, starting with the white player. Given the configuration `positions` of the knights after an unspecified number of moves, determine whose turn it is.

# Example

 For `positions = "b1;g1;b8;g8"`, the output should be `true`.

 The configuration corresponds to the initial state of the game. Thus, it's white's turn.

# Input/Output


 - `[input]` string `positions`

    The positions of the four knights, starting with white knights, separated by a semicolon, in the chess notation.


 - `[output]` a boolean value

    `true` if white is to move, `false` otherwise.

Answer: {"fn_name": "whose_turn", "inputs": [["b1;g1;b8;g8"], ["c3;g1;b8;g8"], ["g1;g2;g3;g4"], ["f8;h1;f3;c2"]], "outputs": [[true], [false], [true], [false]]}
user: Positive integers have so many gorgeous features. 
Some of them could be expressed as a sum of two or more consecutive positive numbers.
___

# Consider an Example :

* `10` , could be expressed as a sum of `1 + 2 + 3 + 4 `.
___
# Task

**_Given_** *Positive integer*, N , **_Return_** true if it could be expressed as a sum of two or more consecutive positive numbers , OtherWise return false .
___

# Notes 

~~~if-not:clojure,csharp,java
* Guaranteed constraint  :  **_2  ≤  N  ≤  (2^32) -1_** .
~~~
~~~if:clojure,csharp,java
* Guaranteed constraint  :  **_2  ≤  N  ≤  (2^31) -1_** .
~~~
___
# Input >> Output Examples:

___
___
___

# [Playing with Numbers Series](https://www.codewars.com/collections/playing-with-numbers)

# [Playing With Lists/Arrays Series](https://www.codewars.com/collections/playing-with-lists-slash-arrays)

# [Bizarre Sorting-katas](https://www.codewars.com/collections/bizarre-sorting-katas)

# [For More Enjoyable Katas](http://www.codewars.com/users/MrZizoScream/authored)
___

## ALL translations are welcomed

## Enjoy Learning !!
# Zizou

Answer: {"fn_name": "consecutive_ducks", "inputs": [[69], [8], [57], [6], [13], [16], [91], [75], [38], [25], [32], [65], [99], [522], [974], [755], [512], [739], [1006], [838], [1092], [727], [648], [1024], [851], [541], [1011], [822], [382131], [118070], [17209], [32768], [161997], [400779], [198331], [325482], [88441], [65536], [323744], [183540], [65271], [5263987]], "outputs": [[true], [false], [true], [true], [true], [false], [true], [true], [true], [true], [false], [true], [true], [true], [true], [true], [false], [true], [true], [true], [true], [true], [true], [false], [true], [true], [true], [true], [true], [true], [true], [false], [true], [true], [true], [true], [true], [false], [true], [true], [true], [true]]}
user: Implement the [Polybius square cipher](http://en.wikipedia.org/wiki/Polybius_square).

Replace every letter with a two digit number. The first digit is the row number, and the second digit is the column number of following square. Letters `'I'` and `'J'` are both 24 in this cipher:


table#polybius-square {width: 100px;}
table#polybius-square td {background-color: #2f2f2f;}
table#polybius-square th {background-color: #3f3f3f;}


12345
1ABCDE
2FGHI/JK
3LMNOP
4QRSTU
5VWXYZ


Input will be valid (only spaces and uppercase letters from A to Z), so no need to validate them.

## Examples

```python
polybius('A')  # "11"
polybius('IJ') # "2424"
polybius('CODEWARS') # "1334141552114243"
polybius('POLYBIUS SQUARE CIPHER') # "3534315412244543 434145114215 132435231542"
```

Answer: {"fn_name": "polybius", "inputs": [["POLYBIUS"], ["CODEWARS"], ["POLYBIUS SQUARE CIPHER"]], "outputs": [["3534315412244543"], ["1334141552114243"], ["3534315412244543 434145114215 132435231542"]]}
user: # Convert number to reversed array of digits

Given a random non-negative number, you have to return the digits of this number within an array in reverse order.

## Example:

```
348597 => [7,9,5,8,4,3]
```

Answer: {"fn_name": "digitize", "inputs": [[35231], [23582357], [984764738], [45762893920], [548702838394]], "outputs": [[[1, 3, 2, 5, 3]], [[7, 5, 3, 2, 8, 5, 3, 2]], [[8, 3, 7, 4, 6, 7, 4, 8, 9]], [[0, 2, 9, 3, 9, 8, 2, 6, 7, 5, 4]], [[4, 9, 3, 8, 3, 8, 2, 0, 7, 8, 4, 5]]]}
user: Consider the word `"abode"`. We can see that the letter `a` is in position `1` and `b` is in position `2`. In the alphabet, `a` and `b` are also in positions `1` and `2`. Notice also that `d` and `e` in `abode` occupy the positions they would occupy in the alphabet, which are positions `4` and `5`. 

Given an array of words, return an array of the number of letters that occupy their positions in the alphabet for each word. For example,
```
solve(["abode","ABc","xyzD"]) = [4, 3, 1]
```
See test cases for more examples.

Input will consist of alphabet characters, both uppercase and lowercase. No spaces.

Good luck!

If you like this Kata, please try: 

[Last digit symmetry](https://www.codewars.com/kata/59a9466f589d2af4c50001d8)

[Alternate capitalization](https://www.codewars.com/kata/59cfc000aeb2844d16000075)

~~~if:fortran
## Fortran-Specific Notes

Due to how strings and arrays work in Fortran, some of the strings in the input array will inevitably contain trailing whitespace.  **For this reason, please [trim](https://gcc.gnu.org/onlinedocs/gcc-4.3.4/gfortran/TRIM.html) your input strings before processing them.**
~~~

Answer: {"fn_name": "solve", "inputs": [[["abode", "ABc", "xyzD"]], [["abide", "ABc", "xyz"]], [["IAMDEFANDJKL", "thedefgh", "xyzDEFghijabc"]], [["encode", "abc", "xyzD", "ABmD"]]], "outputs": [[[4, 3, 1]], [[4, 3, 0]], [[6, 5, 7]], [[1, 3, 1, 3]]]}
user: ##Task:

You have to write a function **pattern** which creates the following pattern upto n number of rows. 

* If the Argument is 0 or a Negative Integer then it should return "" i.e. empty string.

* If any odd number is passed as argument then the pattern should last upto the largest even number which is smaller than the passed odd number.

* If the argument is 1 then also it should return "".

##Examples:

pattern(8):

    22
    4444
    666666
    88888888
    
pattern(5):
 
    22
    4444



```Note: There are no spaces in the pattern```

```Hint: Use \n in string to jump to next line```

Answer: {"fn_name": "pattern", "inputs": [[2], [1], [5], [6], [0], [-25]], "outputs": [["22"], [""], ["22\n4444"], ["22\n4444\n666666"], [""], [""]]}
user: Given an array of numbers (in string format), you must return a string. The numbers correspond to the letters of the alphabet in reverse order: a=26, z=1 etc. You should also account for `'!'`, `'?'` and `' '` that are represented by '27', '28' and '29' respectively.

All inputs will be valid.

Answer: {"fn_name": "switcher", "inputs": [[["24", "12", "23", "22", "4", "26", "9", "8"]], [["25", "7", "8", "4", "14", "23", "8", "25", "23", "29", "16", "16", "4"]], [["4", "24"]], [["12"]], [["12", "28", "25", "21", "25", "7", "11", "22", "15"]]], "outputs": [["codewars"], ["btswmdsbd kkw"], ["wc"], ["o"], ["o?bfbtpel"]]}
user: Triangular number is the amount of points that can fill equilateral triangle. 

Example: the number 6 is a triangular number because all sides of a triangle has the same amount of points.

```
Hint!
T(n) = n * (n + 1) / 2,
n - is the size of one side.
T(n) - is the triangular number.
```

Given a number 'T' from interval [1; 2147483646], find if it is triangular number or not.

Answer: {"fn_name": "is_triangular", "inputs": [[1], [3], [6], [10], [15], [21], [28], [2], [7], [14], [27]], "outputs": [[true], [true], [true], [true], [true], [true], [true], [false], [false], [false], [false]]}
user: Your task is to make a program takes in a sentence (without puncuation), adds all words to a list and returns the sentence as a string which is the positions of the word in the list. Casing should not matter too.


Example
-----

`"Ask not what your COUNTRY can do for you ASK WHAT YOU CAN DO FOR YOUR country"`

becomes

`"01234567802856734"`

Another example
-----

`"the one bumble bee one bumble the bee"`

becomes

`"01231203"`

Answer: {"fn_name": "compress", "inputs": [["The bumble bee"], ["SILLY LITTLE BOYS silly little boys"], ["Ask not what your COUNTRY can do for you ASK WHAT YOU CAN DO FOR YOUR country"], ["The number 0 is such a strange number Strangely it has zero meaning"]], "outputs": [["012"], ["012012"], ["01234567802856734"], ["012345617891011"]]}
user: In this kata, you will do addition and subtraction on a given string. The return value must be also a string.

**Note:** the input will not be empty.

## Examples

```
"1plus2plus3plus4"  --> "10"
"1plus2plus3minus4" -->  "2"
```

Answer: {"fn_name": "calculate", "inputs": [["1plus2plus3plus4"], ["1minus2minus3minus4"], ["1plus2plus3minus4"], ["1minus2plus3minus4"], ["1plus2minus3plus4minus5"]], "outputs": [["10"], ["-8"], ["2"], ["-2"], ["-1"]]}
user: Deoxyribonucleic acid (DNA) is a chemical found in the nucleus of cells and carries the "instructions" for the development and functioning of living organisms.

If you want to know more http://en.wikipedia.org/wiki/DNA

In DNA strings, symbols "A" and "T" are complements of each other, as "C" and "G". 
You have function with one side of the DNA (string, except for Haskell); you need to get the other complementary side. DNA strand is never empty or there is no DNA at all (again, except for Haskell).

More similar exercise are found here http://rosalind.info/problems/list-view/ (source)

```python
DNA_strand ("ATTGC") # return "TAACG"

DNA_strand ("GTAT") # return "CATA"
```

Answer: {"fn_name": "DNA_strand", "inputs": [["AAAA"], ["ATTGC"], ["GTAT"], ["AAGG"], ["CGCG"], ["GTATCGATCGATCGATCGATTATATTTTCGACGAGATTTAAATATATATATATACGAGAGAATACAGATAGACAGATTA"]], "outputs": [["TTTT"], ["TAACG"], ["CATA"], ["TTCC"], ["GCGC"], ["CATAGCTAGCTAGCTAGCTAATATAAAAGCTGCTCTAAATTTATATATATATATGCTCTCTTATGTCTATCTGTCTAAT"]]}
user: The goal of this exercise is to convert a string to a new string where each character in the new string is `"("` if that character appears only once in the original string, or `")"` if that character appears more than once in the original string. Ignore capitalization when determining if a character is a duplicate.

## Examples
```
"din"      =>  "((("
"recede"   =>  "()()()"
"Success"  =>  ")())())"
"(( @"     =>  "))((" 
```

**Notes**

Assertion messages may be unclear about what they display in some languages. If you read `"...It Should encode XXX"`, the `"XXX"` is the expected result, not the input!

Answer: {"fn_name": "duplicate_encode", "inputs": [["din"], ["recede"], ["Success"], ["CodeWarrior"], ["Supralapsarian"], ["iiiiii"], ["(( @"], [" ( ( )"]], "outputs": [["((("], ["()()()"], [")())())"], ["()(((())())"], [")()))()))))()("], ["))))))"], ["))(("], [")))))("]]}
user: ### Problem Context

The [Fibonacci](http://en.wikipedia.org/wiki/Fibonacci_number) sequence is traditionally used to explain tree recursion.  

```python
def fibonacci(n):
    if n in [0, 1]:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)
```

This algorithm serves welll its educative purpose but it's [tremendously inefficient](http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-11.html#%_sec_1.2.2), not only because of recursion, but because we invoke the fibonacci function twice, and the right branch of recursion (i.e. `fibonacci(n-2)`) recalculates all the Fibonacci numbers already calculated by the left branch (i.e. `fibonacci(n-1)`).

This algorithm is so inefficient that the time to calculate any Fibonacci number over 50 is simply too much. You may go for a cup of coffee or go take a nap while you wait for the answer. But if you try it here in Code Wars you will most likely get a code timeout before any answers.

For this particular Kata we want to **implement the memoization solution**. This will be cool because it will let us *keep using the tree recursion* algorithm while still keeping it sufficiently optimized to get an answer very rapidly.

The trick of the memoized version is that we will keep a cache data structure (most likely an associative array) where we will store the Fibonacci numbers as we calculate them. When a Fibonacci number is calculated, we first look it up in the cache, if it's not there, we calculate it and put it in the cache, otherwise we returned the cached number.

Refactor the function into a recursive Fibonacci function that using  a memoized data structure avoids the deficiencies of tree recursion Can you make it so the memoization cache is private to this function?

Answer: {"fn_name": "fibonacci", "inputs": [[70], [60], [50]], "outputs": [[190392490709135], [1548008755920], [12586269025]]}
user: This kata is part of the collection [Mary's Puzzle Books](https://www.codewars.com/collections/marys-puzzle-books).

Mary brought home a "spot the differences" book. The book is full of a bunch of problems, and each problem consists of two strings that are similar. However, in each string there are a few characters that are different. An example puzzle from her book is:
```
String 1: "abcdefg"
String 2: "abcqetg"
```
Notice how the "d" from String 1 has become a "q" in String 2, and "f" from String 1 has become a "t" in String 2.

It's your job to help Mary solve the puzzles. Write a program `spot_diff`/`Spot` that will compare the two strings and return a list with the positions where the two strings differ. In the example above, your program should return `[3, 5]` because String 1 is different from String 2 at positions 3 and 5.

NOTES:

```if-not:csharp
• If both strings are the same, return `[]`
```
```if:csharp
• If both strings are the same, return `new List()`
```

• Both strings will always be the same length

• Capitalization and punctuation matter

Answer: {"fn_name": "spot_diff", "inputs": [["abcdefg", "abcqetg"], ["Hello World!", "hello world."], ["FixedGrey", "FixedGrey"], ["HACKER", "H4CK3R"], ["This is a really long sentence.", "That is a_really long sentence,"], ["", ""], ["abcdefghijklmnopqrstuvwxyz", "zyxwvutsrqponmlkjihgfedcba"], ["YOLO lol", "ROLO mom"], ["www.youtube.com/zedaphplays", "www.twitter.com/zedaphplays"], ["Congratulations! You did it!", "Conglaturations! U did this!"]], "outputs": [[[3, 5]], [[0, 6, 11]], [[]], [[1, 4]], [[2, 3, 9, 30]], [[]], [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]], [[0, 5, 7]], [[4, 5, 6, 8, 9, 10]], [[4, 8, 17, 18, 19, 20, 22, 23, 24, 26]]]}
user: Today was a sad day. Having bought a new beard trimmer, I set it to the max setting and shaved away at my joyous beard. Stupidly, I hadnt checked just how long the max setting was, and now I look like Ive just started growing it!

Your task, given a beard represented as an arrayof arrays, is to trim the beard as follows:

['|', 'J', '|', '|'],
['|', '|', '|', 'J'],
['...', '...', '...', '...'];

To trim the beard use the following rules:

trim any curled hair --> replace 'J' with '|'
trim any hair from the chin (last array) --> replace '|' or 'J' with '...'

All sub arrays will be same length. Return the corrected array of arrays

Answer: {"fn_name": "trim", "inputs": [[[["J", "|"], ["J", "|"], ["...", "|"]]], [[["J", "|", "J"], ["J", "|", "|"], ["...", "|", "J"]]], [[["J", "|", "J", "J"], ["J", "|", "|", "J"], ["...", "|", "J", "|"]]]], "outputs": [[[["|", "|"], ["|", "|"], ["...", "..."]]], [[["|", "|", "|"], ["|", "|", "|"], ["...", "...", "..."]]], [[["|", "|", "|", "|"], ["|", "|", "|", "|"], ["...", "...", "...", "..."]]]]}
user: In this kata, you'll be given an integer of range `0 <= x <= 99` and have to return that number spelt out in English. A few examples:

```python
name_that_number(4)   # returns "four"
name_that_number(19)  # returns "nineteen"
name_that_number(99)  # returns "ninety nine"
```

Words should be separated by only spaces and not hyphens. No need to validate parameters, they will always be in the range [0, 99]. Make sure that the returned String has no leading of trailing spaces. Good luck!

Answer: {"fn_name": "name_that_number", "inputs": [[1], [52], [21], [99], [0], [53], [23], [76]], "outputs": [["one"], ["fifty two"], ["twenty one"], ["ninety nine"], ["zero"], ["fifty three"], ["twenty three"], ["seventy six"]]}
user: Given an array, find the duplicates in that array, and return a new array of those duplicates. The elements of the returned array should appear in the order when they first appeared as duplicates.

__*Note*__: numbers and their corresponding string representations should not be treated as duplicates (i.e., `"1" != 1`).

## Examples
```
[1, 2, 4, 4, 3, 3, 1, 5, 3, "5"]  ==>  [4, 3, 1]
[0, 1, 2, 3, 4, 5]                ==>  []
```

Answer: {"fn_name": "duplicates", "inputs": [[[1, 2, 4, 4, 3, 3, 1, 5, 3, "5"]], [[0, 1, 2, 3, 4, 5]], [[1, 1, 2, 3, 4, 5, 4]]], "outputs": [[[4, 3, 1]], [[]], [[1, 4]]]}
user: *This is the second Kata in the Ciphers series. This series is meant to test our coding knowledge.*

## Ciphers #2 - The reversed Cipher
This is a lame method I use to write things such that my friends don't understand. It's still fairly readable if you think about it.

## How this cipher works
First, you need to reverse the string. Then, the last character in the original string (the first character in the reversed string) needs to be moved to the back. Words will be separated by spaces, and punctuation marks can be counted as part of the word.

## Example

This is because `"Hello"` reversed is `"olleH"` and `"o"` is moved to the back, and so on. The exclamation mark is considered to be part of the word `"World"`.

Have fun (en)coding!

Answer: {"fn_name": "encode", "inputs": [["Hello World!"]], "outputs": [["lleHo dlroW!"]]}
user: A Magic Square contains the integers 1 to n^(2), arranged in an n by n array such that the columns, rows and both main diagonals add up to the same number.For doubly even positive integers (multiples of 4) the following method can be used to create a magic square.
Fill an array with the numbers 1 to n^(2) in succession. Then, for each 4 by 4 subarray, replace the entries on the blue and red diagonals by n^(2)+1-aij.
So, in the following example, a11 (row 1, column 1) was initially 1 and is replaced by 8^(2)+1-1 = 64


    tab1 { padding-left: 2em; }
    fc1  { font color="blue"}


n=8
642 3 61606 7 57 
9 55541213515016
1747462021434224
4026273736303133
3234352928383925
4123224445191848
4915145253111056
8 58595 4 62631 

The function even_magic() should return a 2D array as follows:-
Example:
n=4: Output: [[16,2,3,13],[5,11,10,8],[9,7,6,12],[4,14,15,1]]

162 3 13
5 11108 
9 7 6 12
4 14151 


Only doubly even numbers will be passed to the function in the tests.

See mathworld.wolfram.com for further details.

Answer: {"fn_name": "even_magic", "inputs": [[4], [8]], "outputs": [[[[16, 2, 3, 13], [5, 11, 10, 8], [9, 7, 6, 12], [4, 14, 15, 1]]], [[[64, 2, 3, 61, 60, 6, 7, 57], [9, 55, 54, 12, 13, 51, 50, 16], [17, 47, 46, 20, 21, 43, 42, 24], [40, 26, 27, 37, 36, 30, 31, 33], [32, 34, 35, 29, 28, 38, 39, 25], [41, 23, 22, 44, 45, 19, 18, 48], [49, 15, 14, 52, 53, 11, 10, 56], [8, 58, 59, 5, 4, 62, 63, 1]]]]}
user: Write a function that when given a number >= 0, returns an Array of ascending length subarrays.

```
pyramid(0) => [ ]
pyramid(1) => [ [1] ]
pyramid(2) => [ [1], [1, 1] ]
pyramid(3) => [ [1], [1, 1], [1, 1, 1] ]
```

**Note:** the subarrays should be filled with `1`s

Answer: {"fn_name": "pyramid", "inputs": [[0], [1], [2], [3]], "outputs": [[[]], [[[1]]], [[[1], [1, 1]]], [[[1], [1, 1], [1, 1, 1]]]]}
user: When provided with a number between 0-9, return it in words.

Input :: 1

Output :: "One".

If your language supports it, try using a switch statement.

Answer: {"fn_name": "switch_it_up", "inputs": [[0], [1], [2], [3], [4], [5], [6], [7], [8], [9]], "outputs": [["Zero"], ["One"], ["Two"], ["Three"], ["Four"], ["Five"], ["Six"], ["Seven"], ["Eight"], ["Nine"]]}