meetforever/GRPO_CL huggingface dataset:
user: Find the longest substring in alphabetical order.

Example: the longest alphabetical substring in `"asdfaaaabbbbcttavvfffffdf"` is `"aaaabbbbctt"`.

There are tests with strings up to `10 000` characters long so your code will need to be efficient.

The input will only consist of lowercase characters and will be at least one letter long.

If there are multiple solutions, return the one that appears first.

Good luck :)

Answer: {"fn_name": "longest", "inputs": [["asd"], ["nab"], ["abcdeapbcdef"], ["asdfaaaabbbbcttavvfffffdf"], ["asdfbyfgiklag"], ["z"], ["zyba"]], "outputs": [["as"], ["ab"], ["abcde"], ["aaaabbbbctt"], ["fgikl"], ["z"], ["z"]]}
user: Hi there! 
You have to implement the 

`String get_column_title(int num) // syntax depends on programming language`

function that takes an integer number (index of the Excel column) and returns the string represents the title of this column.

#Intro
In the MS Excel lines are numbered by decimals, columns - by sets of letters.

For example, the first column has the title "A", second column - "B", 26th - "Z", 27th - "AA". 

"BA"(53) comes after "AZ"(52), "AAA" comes after "ZZ".




Excel? Columns? More details [here](https://en.wikipedia.org/wiki/Microsoft_Excel)

#Input
It takes only one argument - column decimal index number.
Argument `num` is a natural number.

#Output
Output is the upper-case string represents the title of column. It contains the English letters: A..Z

#Errors
For cases `num < 1` your function should throw/raise `IndexError`. In case of non-integer argument you should throw/raise `TypeError`.

In Java, you should throw `Exceptions`.

Nothing should be returned in Haskell.

#Examples
Python, Ruby:
```
>>> get_column_title(52)
"AZ"
>>> get_column_title(1337)
"AYK"
>>> get_column_title(432778)
"XPEH"
>>> get_column_title()
TypeError:
>>> get_column_title("123")
TypeError:
>>> get_column_title(0)
IndexError:
```
JS, Java:
```
>>> getColumnTitle(52)
"AZ"
>>> getColumnTitle(1337)
"AYK"
>>> getColumnTitle(432778)
"XPEH"
>>> getColumnTitle()
TypeError:
>>> getColumnTitle("123")
TypeError:
>>> getColumnTitle(0)
IndexError:
```

#Hint
The difference between the 26-digits notation and Excel columns numeration that in the first system, after "Z" there are "BA", "BB", ..., while in the Excel columns scale there is a range of 26 elements: AA, AB, ... , AZ between Z and BA. 

It is as if in the decimal notation was the following order: 0, 1, 2, .., 9, 00, 01, 02, .., 09, 10, 11, .., 19, 20..29..99, 000, 001 and so on.

#Also
The task is really sapid and hard. If you're stuck - write to the discussion board, there are many smart people willing to help.

Answer: {"fn_name": "get_column_title", "inputs": [[1], [26], [52], [53], [702]], "outputs": [["A"], ["Z"], ["AZ"], ["BA"], ["ZZ"]]}
user: What's in a name?
..Or rather, what's a name in? For us, a particular string is where we are looking for a name.

Task

Test whether or not the string contains all of the letters which spell a given name, in order.

The format
A function passing two strings, searching for one (the name) within the other.
``function nameInStr(str, name){ return true || false }``

Examples

    nameInStr("Across the rivers", "chris") --> true
                ^      ^  ^^   ^
                c      h  ri   s
                
    Contains all of the letters in "chris", in order.
----------------------------------------------------------
    nameInStr("Next to a lake", "chris") --> false
    
    Contains none of the letters in "chris".
--------------------------------------------------------------------
    nameInStr("Under a sea", "chris") --> false
                   ^   ^
                   r   s
                   
    Contains only some of the letters in "chris".
--------------------------------------------------------------------
    nameInStr("A crew that boards the ship", "chris") --> false
                 cr    h              s i
                 cr                h  s i  
                 c     h      r       s i
                 ...
                 
    Contains all of the letters in "chris", but not in order.
--------------------------------------------------------------------
    nameInStr("A live son", "Allison") --> false
               ^ ^^   ^^^
               A li   son
                 
    Contains all of the correct letters in "Allison", in order, 
    but not enough of all of them (missing an 'l').
    

Note: testing will _not_ be case-sensitive.

Answer: {"fn_name": "name_in_str", "inputs": [["Across the rivers", "chris"], ["Next to a lake", "chris"], ["Under a sea", "chris"], ["A crew that boards the ship", "chris"], ["A live son", "Allison"], ["Just enough nice friends", "Jennifer"], ["thomas", "Thomas"], ["pippippi", "Pippi"], ["pipipp", "Pippi"], ["ppipip", "Pippi"]], "outputs": [[true], [false], [false], [false], [false], [false], [true], [true], [false], [false]]}
user: Write a function that takes in a binary string and returns the equivalent decoded text (the text is ASCII encoded).

Each 8 bits on the binary string represent 1 character on the ASCII table.

The input string will always be a valid binary string.

Characters can be in the range from "00000000" to "11111111" (inclusive)

Note: In the case of an empty binary string your function should return an empty string.

Answer: {"fn_name": "binary_to_string", "inputs": [[""], ["0100100001100101011011000110110001101111"], ["00110001001100000011000100110001"], ["0101001101110000011000010111001001101011011100110010000001100110011011000110010101110111001011100010111000100000011001010110110101101111011101000110100101101111011011100111001100100000011100100110000101101110001000000110100001101001011001110110100000100001"], ["0010000101000000001000110010010000100101010111100010011000101010001010000010100101010001010101110100010101110010011101000111100101010101010010010100111101001100011001000110011001100111011000100110001001101000011011100110110101001001010010110100001001001010010010110100100001001001010101010100111100101000001111110011111000111111001111000111111001111110011111100111111001111110001010010010100000101010001001100010010101011110001110010011100000110111001100010011001100101111001011010010111100101010001011010010101000101111"]], "outputs": [[""], ["Hello"], ["1011"], ["Sparks flew.. emotions ran high!"], ["!@#$%^&*()QWErtyUIOLdfgbbhnmIKBJKHIUO(?>?<~~~~~)(*&%^98713/-/*-*/"]]}
user: Write a function that when given a URL as a string, parses out just the domain name and returns it as a string. For example:
```python
domain_name("http://github.com/carbonfive/raygun") == "github" 
domain_name("http://www.zombie-bites.com") == "zombie-bites"
domain_name("https://www.cnet.com") == "cnet"
```

Answer: {"fn_name": "domain_name", "inputs": [["http://google.com"], ["http://google.co.jp"], ["https://123.net"], ["https://hyphen-site.org"], ["http://codewars.com"], ["www.xakep.ru"], ["https://youtube.com"], ["http://www.codewars.com/kata/"], ["icann.org"]], "outputs": [["google"], ["google"], ["123"], ["hyphen-site"], ["codewars"], ["xakep"], ["youtube"], ["codewars"], ["icann"]]}
user: A [Narcissistic Number](https://en.wikipedia.org/wiki/Narcissistic_number) is a positive number which is the sum of its own digits, each raised to the power of the number of digits in a given base. In this Kata, we will restrict ourselves to decimal (base 10).

For example, take 153 (3 digits):
```
    1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153
```
and 1634 (4 digits):
```
    1^4 + 6^4 + 3^4 + 4^4 = 1 + 1296 + 81 + 256 = 1634
```

The Challenge:

Your code must return **true or false** depending upon whether the given number is a Narcissistic number in base 10.

Error checking for text strings or other invalid inputs is not required, only valid positive non-zero integers will be passed into the function.

Answer: {"fn_name": "narcissistic", "inputs": [[1], [5], [7], [153], [370], [371], [1634]], "outputs": [[true], [true], [true], [true], [true], [true], [true]]}
user: For this exercise you will create a global flatten method. The method takes in any number of arguments and flattens them into a single array. If any of the arguments passed in are an array then the individual objects within the array will be flattened so that they exist at the same level as the other arguments. Any nested arrays, no matter how deep, should be flattened into the single array result.

The following are examples of how this function would be used and what the expected results would be:

```python
flatten(1, [2, 3], 4, 5, [6, [7]]) # returns [1, 2, 3, 4, 5, 6, 7]
flatten('a', ['b', 2], 3, None, [[4], ['c']]) # returns ['a', 'b', 2, 3, None, 4, 'c']
```

Answer: {"fn_name": "flatten", "inputs": [[1, 2, 3], [1, 2], [5, "string"], [-4.5, -3, 1, 4], [[3, 4, 5], [1, 2, 3]], [[1], [], 2, [4, 5, 6]], [[4, "string", 9, 3, 1], [], [], [], [], ["string"]], [1, 2, ["9", [], []], null], [[1, 2], [3, 4, 5], [6, [7], [[8]]]], [["hello", 2, ["text", [4, 5]]], [[]], "[list]"]], "outputs": [[[1, 2, 3]], [[1, 2]], [[5, "string"]], [[-4.5, -3, 1, 4]], [[3, 4, 5, 1, 2, 3]], [[1, 2, 4, 5, 6]], [[4, "string", 9, 3, 1, "string"]], [[1, 2, "9", null]], [[1, 2, 3, 4, 5, 6, 7, 8]], [["hello", 2, "text", 4, 5, "[list]"]]]}
user: Create a function `sierpinski` to generate an ASCII representation of a Sierpinski triangle of order **N**. 

Seperate each line with `\n`. You don't have to check the input value.

The output should look like this: 

     sierpinski(4)
                   *               
                  * *              
                 *   *             
                * * * *            
               *       *           
              * *     * *          
             *   *   *   *         
            * * * * * * * *        
           *               *       
          * *             * *      
         *   *           *   *     
        * * * *         * * * *    
       *       *       *       *   
      * *     * *     * *     * *  
     *   *   *   *   *   *   *   * 
    * * * * * * * * * * * * * * * *

Answer: {"fn_name": "sierpinski", "inputs": [[1], [2], [3]], "outputs": [[" * \n* *"], ["   *   \n  * *  \n *   * \n* * * *"], ["       *       \n      * *      \n     *   *     \n    * * * *    \n   *       *   \n  * *     * *  \n *   *   *   * \n* * * * * * * *"]]}
user: Divisors of 42 are : 1, 2, 3, 6, 7, 14, 21, 42.
These divisors squared are: 1, 4, 9, 36, 49, 196, 441, 1764.
The sum of the squared divisors is 2500 which is 50 * 50, a square!

Given two integers m, n (1 <= m <= n) we want to find all integers 
between m and n whose sum of squared divisors is itself a square.
42 is such a number.

The result will be an array of arrays or of tuples (in C an array of Pair) or a string, each subarray having two elements,
first the number whose squared divisors is a square and then the sum
of the squared divisors.

#Examples:
```
list_squared(1, 250) --> [[1, 1], [42, 2500], [246, 84100]]
list_squared(42, 250) --> [[42, 2500], [246, 84100]]
```

The form of the examples may change according to the language, see `Example Tests:` for more details.

**Note**

In Fortran - as in any other language - the returned string is not permitted to contain any redundant trailing whitespace: you can use dynamically allocated character strings.

Answer: {"fn_name": "list_squared", "inputs": [[1, 250], [42, 250], [250, 500], [300, 600], [600, 1500], [1500, 1800], [1800, 2000], [2000, 2200], [2200, 5000], [5000, 10000]], "outputs": [[[[1, 1], [42, 2500], [246, 84100]]], [[[42, 2500], [246, 84100]]], [[[287, 84100]]], [[]], [[[728, 722500], [1434, 2856100]]], [[[1673, 2856100]]], [[[1880, 4884100]]], [[]], [[[4264, 24304900]]], [[[6237, 45024100], [9799, 96079204], [9855, 113635600]]]]}
user: The Collatz Conjecture states that for any natural number n, if n is even, divide it by 2. If n is odd, multiply it by 3 and add 1. If you repeat the process continuously for n, n will eventually reach 1.

For example, if n = 20, the resulting sequence will be:

[20, 10, 5, 16, 8, 4, 2, 1] 

Write a program that will output the length of the Collatz Conjecture for any given n. In the example above, the output would be 8.

For more reading see: http://en.wikipedia.org/wiki/Collatz_conjecture

Answer: {"fn_name": "collatz", "inputs": [[100], [10], [500], [73567465519280238573], [1000000000], [1000000000000000]], "outputs": [[26], [7], [111], [362], [101], [276]]}
user: Your task is to remove all duplicate words from a string, leaving only single (first) words entries.

Example:

Input:

'alpha beta beta gamma gamma gamma delta alpha beta beta gamma gamma gamma delta'

Output:

'alpha beta gamma delta'

Answer: {"fn_name": "remove_duplicate_words", "inputs": [["alpha beta beta gamma gamma gamma delta alpha beta beta gamma gamma gamma delta"], ["my cat is my cat fat"]], "outputs": [["alpha beta gamma delta"], ["my cat is fat"]]}
user: Write a function that accepts two square matrices (`N x N` two dimensional arrays), and return the sum of the two. Both matrices being passed into the function will be of size `N x N` (square), containing only integers.

How to sum two matrices:

Take each cell `[n][m]` from the first matrix, and add it with the same `[n][m]` cell from the second matrix. This will be cell `[n][m]` of the solution matrix.

Visualization: 
```
|1 2 3|     |2 2 1|     |1+2 2+2 3+1|     |3 4 4|
|3 2 1|  +  |3 2 3|  =  |3+3 2+2 1+3|  =  |6 4 4|
|1 1 1|     |1 1 3|     |1+1 1+1 1+3|     |2 2 4|
```

## Example

Answer: {"fn_name": "matrix_addition", "inputs": [[[[1, 2, 3], [3, 2, 1], [1, 1, 1]], [[2, 2, 1], [3, 2, 3], [1, 1, 3]]], [[[1, 2], [1, 2]], [[2, 3], [2, 3]]], [[[1]], [[2]]]], "outputs": [[[[3, 4, 4], [6, 4, 4], [2, 2, 4]]], [[[3, 5], [3, 5]]], [[[3]]]]}
user: # Introduction 

A grille cipher was a technique for encrypting a plaintext by writing it onto a sheet of paper through a pierced sheet (of paper or cardboard or similar). The earliest known description is due to the polymath Girolamo Cardano in 1550. His proposal was for a rectangular stencil allowing single letters, syllables, or words to be written, then later read, through its various apertures. The written fragments of the plaintext could be further disguised by filling the gaps between the fragments with anodyne words or letters. This variant is also an example of steganography, as are many of the grille ciphers. 
Wikipedia Link 

![Tangiers1](https://upload.wikimedia.org/wikipedia/commons/8/8a/Tangiers1.png)
![Tangiers2](https://upload.wikimedia.org/wikipedia/commons/b/b9/Tangiers2.png)

# Task

Write a function that accepts two inputs: `message` and `code` and returns hidden message decrypted from `message` using the `code`.   
The `code` is a nonnegative integer and it decrypts in binary the `message`.

Answer: {"fn_name": "grille", "inputs": [["abcdef", 5], ["", 5], ["abcd", 1], ["0abc", 2], ["ab", 255], ["ab", 256], ["abcde", 32], ["tcddoadepwweasresd", 77098]], "outputs": [["df"], [""], ["d"], ["b"], ["ab"], [""], [""], ["codewars"]]}
user: In this Kata, we define an arithmetic progression as a series of integers in which the differences between adjacent numbers are the same. You will be given an array of ints of `length > 2` and your task will be to convert it into an arithmetic progression by the following rule:
```Haskell
For each element there are exactly three options: an element can be decreased by 1, an element can be increased by 1 
or it can be left unchanged.
```
Return the minimum number of changes needed to convert the array to an arithmetic progression. If not possible, return `-1`.
```Haskell
For example: 
solve([1,1,3,5,6,5]) == 4 because [1,1,3,5,6,5] can be changed to [1,2,3,4,5,6] by making 4 changes.
solve([2,1,2]) == 1 because it can be changed to [2,2,2]
solve([1,2,3]) == 0  because it is already a progression, and no changes are needed.
solve([1,1,10) == -1 because it's impossible.
solve([5,6,5,3,1,1]) == 4. It becomes [6,5,4,3,2,1]
```

More examples in the test cases. Good luck!

Answer: {"fn_name": "solve", "inputs": [[[1, 1, 3, 5, 6, 5]], [[2, 1, 2]], [[1, 2, 3]], [[1, 1, 10]], [[24, 21, 14, 10]], [[3, 2, 1, 1, 1]], [[1, 3, 6, 9, 12]], [[0, 0, 0, 0, 0]], [[5, 4, 3, 2, 1, 1]], [[1, 2, 1]], [[1, 2, 3, 1, 1]], [[1, 3, 6, 8, 10]], [[5, 6, 5, 3, 1, 1]]], "outputs": [[4], [1], [0], [-1], [3], [4], [1], [0], [1], [1], [4], [2], [4]]}
user: In this kata you will be given a random string of letters and tasked with returning them as a string of comma-separated sequences sorted alphabetically, with each sequence starting with an uppercase character followed by `n-1` lowercase characters, where `n` is the letter's alphabet position `1-26`.

## Example

```python
alpha_seq("ZpglnRxqenU") -> "Eeeee,Ggggggg,Llllllllllll,Nnnnnnnnnnnnnn,Nnnnnnnnnnnnnn,Pppppppppppppppp,Qqqqqqqqqqqqqqqqq,Rrrrrrrrrrrrrrrrrr,Uuuuuuuuuuuuuuuuuuuuu,Xxxxxxxxxxxxxxxxxxxxxxxx,Zzzzzzzzzzzzzzzzzzzzzzzzzz"
```

## Technical Details

- The string will include only letters.
- The first letter of each sequence is uppercase followed by `n-1` lowercase.
- Each sequence is separated with a comma.
- Return value needs to be a string.

Answer: {"fn_name": "alpha_seq", "inputs": [["BfcFA"], ["ZpglnRxqenU"], ["NyffsGeyylB"], ["MjtkuBovqrU"], ["EvidjUnokmM"], ["HbideVbxncC"]], "outputs": [["A,Bb,Ccc,Ffffff,Ffffff"], ["Eeeee,Ggggggg,Llllllllllll,Nnnnnnnnnnnnnn,Nnnnnnnnnnnnnn,Pppppppppppppppp,Qqqqqqqqqqqqqqqqq,Rrrrrrrrrrrrrrrrrr,Uuuuuuuuuuuuuuuuuuuuu,Xxxxxxxxxxxxxxxxxxxxxxxx,Zzzzzzzzzzzzzzzzzzzzzzzzzz"], ["Bb,Eeeee,Ffffff,Ffffff,Ggggggg,Llllllllllll,Nnnnnnnnnnnnnn,Sssssssssssssssssss,Yyyyyyyyyyyyyyyyyyyyyyyyy,Yyyyyyyyyyyyyyyyyyyyyyyyy,Yyyyyyyyyyyyyyyyyyyyyyyyy"], ["Bb,Jjjjjjjjjj,Kkkkkkkkkkk,Mmmmmmmmmmmmm,Ooooooooooooooo,Qqqqqqqqqqqqqqqqq,Rrrrrrrrrrrrrrrrrr,Tttttttttttttttttttt,Uuuuuuuuuuuuuuuuuuuuu,Uuuuuuuuuuuuuuuuuuuuu,Vvvvvvvvvvvvvvvvvvvvvv"], ["Dddd,Eeeee,Iiiiiiiii,Jjjjjjjjjj,Kkkkkkkkkkk,Mmmmmmmmmmmmm,Mmmmmmmmmmmmm,Nnnnnnnnnnnnnn,Ooooooooooooooo,Uuuuuuuuuuuuuuuuuuuuu,Vvvvvvvvvvvvvvvvvvvvvv"], ["Bb,Bb,Ccc,Ccc,Dddd,Eeeee,Hhhhhhhh,Iiiiiiiii,Nnnnnnnnnnnnnn,Vvvvvvvvvvvvvvvvvvvvvv,Xxxxxxxxxxxxxxxxxxxxxxxx"]]}
user: Given an `array` of digital numbers, return a new array of length `number` containing the last even numbers from the original array (in the same order). The original array will be not empty and will contain at least "number" even numbers.

For example:
```
([1, 2, 3, 4, 5, 6, 7, 8, 9], 3) => [4, 6, 8]
([-22, 5, 3, 11, 26, -6, -7, -8, -9, -8, 26], 2) => [-8, 26]
([6, -25, 3, 7, 5, 5, 7, -3, 23], 1) => [6]

```

Answer: {"fn_name": "even_numbers", "inputs": [[[1, 2, 3, 4, 5, 6, 7, 8, 9], 3], [[-22, 5, 3, 11, 26, -6, -7, -8, -9, -8, 26], 2], [[6, -25, 3, 7, 5, 5, 7, -3, 23], 1]], "outputs": [[[4, 6, 8]], [[-8, 26]], [[6]]]}
user: With one die of 6 sides we will have six different possible results:```  1, 2, 3, 4, 5, 6``` .

With 2 dice of six sides, we will have 36 different possible results:
``` 
(1,1),(1,2),(2,1),(1,3),(3,1),(1,4),(4,1),(1,5),
(5,1), (1,6),(6,1),(2,2),(2,3),(3,2),(2,4),(4,2),
(2,5),(5,2)(2,6),(6,2),(3,3),(3,4),(4,3),(3,5),(5,3),
(3,6),(6,3),(4,4),(4,5),(5,4),(4,6),(6,4),(5,5),
(5,6),(6,5),(6,6)
``` 
So, with 2 dice of 6 sides we get 36 different events.
``` 
([6,6] ---> 36)
``` 
But with 2 different dice we can get for this case, the same number of events.
One die of ```4 sides```  and another of ```9 sides```  will produce the exact amount of events.
``` 
([4,9] ---> 36)
``` 
We say that the dice set ```[4,9]``` is equivalent to ```[6,6]``` because both produce the same number of events.

Also we may have an amount of three dice producing the same amount of events. It will be for:
``` 
[4,3,3] ---> 36
``` 
(One die of 4 sides and two dice of 3 sides each)

Perhaps you may think that the following set is equivalent: ```[6,3,2]``` but unfortunately dice have a **minimum of three sides** (well, really a 
tetrahedron with one empty side)

The task for this kata is to get the amount of equivalent dice sets, having **2 dice at least**,for a given set.

For example, for the previous case: [6,6] we will have 3 equivalent sets that are: ``` [4, 3, 3], [12, 3], [9, 4]``` .

You may assume that dice are available from 3 and above for any value up to an icosahedral die (20 sides).
``` 
[5,6,4] ---> 5 (they are [10, 4, 3], [8, 5, 3], [20, 6], [15, 8], [12, 10])
``` 
For the cases we cannot get any equivalent set the result will be `0`.
For example for the set `[3,3]` we will not have equivalent dice.

Range of inputs for Random Tests:
``` 
3 <= sides <= 15
2 <= dices <= 7
``` 
See examples in the corresponding box.

Enjoy it!!

Answer: {"fn_name": "eq_dice", "inputs": [[[6, 6]], [[5, 6, 4]], [[3, 15, 8, 20]], [[6]], [[3, 3]], [[20]], [[3, 6]]], "outputs": [[3], [5], [44], [0], [0], [1], [0]]}
user: **Debug** a function called calculate that takes 3 values. The first and third values are numbers. The second value is a character. If the character is "+" , "-", "\*", or "/", the function will return the result of the corresponding mathematical function on the two numbers. If the string is not one of the specified characters, the function should return null.

```
calculate(2,"+", 4); //Should return 6
calculate(6,"-", 1.5); //Should return 4.5
calculate(-4,"*", 8); //Should return -32
calculate(49,"/", -7); //Should return -7
calculate(8,"m", 2); //Should return null
calculate(4,"/",0) //should return null
```

Kind of a fork (not steal :)) of [Basic Calculator][1] kata by [TheDoctor][2]. 

[1]: http://www.codewars.com/kata/basic-calculator/javascript
[2]: http://www.codewars.com/users/528c45adbd9daa384300068d

Answer: {"fn_name": "calculate", "inputs": [[2, "+", 4], [6, "-", 1.5], [-4, "*", 8], [49, "/", -7], [8, "m", 2], [4, "/", 0], [3.2, "+", 8], [3.2, "-", 8], [3.2, "/", 8], [3.2, "*", 8], [-3, "+", 0], [-3, "-", 0], [-3, "/", 0], [-2, "/", -2], [-2, "codewars", -2], [-3, "*", 0], [0, "*", 0], [0, "**", 0], [-3, "w", 0], [0, "/", 0]], "outputs": [[6], [4.5], [-32], [-7], [null], [null], [11.2], [-4.8], [0.4], [25.6], [-3], [-3], [null], [1], [null], [0], [0], [null], [null], [null]]}
user: This kata focuses on the Numpy python package and you can read up on the Numpy array manipulation functions here: https://docs.scipy.org/doc/numpy-1.13.0/reference/routines.array-manipulation.html

You will get two integers `N` and `M`. You must return an array with two sub-arrays with numbers in ranges `[0, N / 2)` and `[N / 2, N)` respectively, each of them being rotated `M` times.

```
reorder(10, 1)   =>  [[4, 0, 1, 2, 3], [9, 5, 6, 7, 8]]
reorder(10, 3)   =>  [[2, 3, 4, 0, 1], [7, 8, 9, 5, 6]]
reorder(10, 97)  =>  [[3, 4, 0, 1, 2], [8, 9, 5, 6, 7]]
```

Answer: {"fn_name": "reorder", "inputs": [[10, 1], [10, 3], [10, 97]], "outputs": [[[[4, 0, 1, 2, 3], [9, 5, 6, 7, 8]]], [[[2, 3, 4, 0, 1], [7, 8, 9, 5, 6]]], [[[3, 4, 0, 1, 2], [8, 9, 5, 6, 7]]]]}
user: In this Kata, you will be given a string and two indexes (`a` and `b`). Your task is to reverse the portion of that string between those two indices inclusive. 

~~~if-not:fortran
```
solve("codewars",1,5) = "cawedors" -- elements at index 1 to 5 inclusive are "odewa". So we reverse them.
solve("cODEWArs", 1,5) = "cAWEDOrs" -- to help visualize.
```
~~~
~~~if:fortran
```
solve("codewars",2,6) = "cawedors" -- elements at indices 2 to 6 inclusive are "odewa". So we reverse them.
solve("cODEWArs", 2,6) = "cAWEDOrs" -- to help visualize.
```
~~~

Input will be lowercase and uppercase letters only. 

The first index `a` will always be lower that than the string length; the second index `b` can be greater than the string length. More examples in the 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)

~~~if:fortran
*NOTE: You may assume that all input strings will* **not** *contain any (redundant) trailing whitespace.  In return, your returned string is* **not** *permitted to contain any (redundant) trailing whitespace.*
~~~

Answer: {"fn_name": "solve", "inputs": [["codewars", 1, 5], ["codingIsFun", 2, 100], ["FunctionalProgramming", 2, 15], ["abcefghijklmnopqrstuvwxyz", 0, 20], ["abcefghijklmnopqrstuvwxyz", 5, 20]], "outputs": [["cawedors"], ["conuFsIgnid"], ["FuargorPlanoitcnmming"], ["vutsrqponmlkjihgfecbawxyz"], ["abcefvutsrqponmlkjihgwxyz"]]}