meetforever/GRPO_CL huggingface dataset:
user: Happy traveller [Part 1]

There is a play grid NxN; Always square! 

   0  1  2  3
0 [o, o, o, X]
1 [o, o, o, o]
2 [o, o, o, o]
3 [o, o, o, o]


You start from a random point. I mean, you are given the coordinates of your start position in format (row, col). 

And your TASK is to define the number of unique paths to reach position X (always in the top right corner).


From any point you can go only UP or RIGHT.


Implement a function count_paths(N, (row, col)) which returns int; 
Assume input params are always valid.


Example:

count_paths(1, (0, 0))
grid 1x1:

[X]
 You are already in the target point, so return 0


count_paths(2, (1, 0))
grid 2x2:

[o, X]
[@, o]
 You are at point @; you can move UP-RIGHT or RIGHT-UP, and there are 2 possible unique paths here

count_paths(2, (1, 1))
grid 2x2:

[o, X]
[o, @]
 You are at point @; you can move only UP, so there is 1 possible unique path here

count_paths(3, (1, 0))
grid 3x3:

[o, o, X]
[@, o, o]
[o, o, o]
 You are at point @; you can move UP-RIGHT-RIGHT or RIGHT-UP-RIGHT, or RIGHT-RIGHT-UP, and there are 3 possible unique paths here


I think it's pretty clear =)

btw. you can use preloaded Grid class, which constructs 2d array for you. It's very very basic and simple. You can use numpy instead or any other way to produce the correct answer =)
 grid = Grid(2, 2, 0) 
samegrid = Grid.square(2) will give you a grid[2][2], which you can print easily to console. 

print(grid)


[0, 0]
[0, 0]


Enjoy!

You can continue adventures:
Happy traveller [Part 2]

Answer: {"fn_name": "count_paths", "inputs": [[1, [0, 0]], [2, [1, 0]], [2, [1, 1]], [3, [1, 0]], [5, [4, 0]], [6, [5, 0]], [7, [6, 0]]], "outputs": [[0], [2], [1], [3], [70], [252], [924]]}
user: You are given a certain integer, ```n, n > 0```. You have to search the partition or partitions, of n, with maximum product value.

Let'see the case for ```n = 8```.
```
Partition                 Product
[8]                          8
[7, 1]                       7
[6, 2]                      12
[6, 1, 1]                    6
[5, 3]                      15
[5, 2, 1]                   10
[5, 1, 1, 1]                 5
[4, 4]                      16
[4, 3, 1]                   12
[4, 2, 2]                   16
[4, 2, 1, 1]                 8
[4, 1, 1, 1, 1]              4
[3, 3, 2]                   18   <---- partition with maximum product value
[3, 3, 1, 1]                 9
[3, 2, 2, 1]                12
[3, 2, 1, 1, 1]              6
[3, 1, 1, 1, 1, 1]           3
[2, 2, 2, 2]                16
[2, 2, 2, 1, 1]              8
[2, 2, 1, 1, 1, 1]           4
[2, 1, 1, 1, 1, 1, 1]        2
[1, 1, 1, 1, 1, 1, 1, 1]     1
```
So our needed function will work in that way for Python and Ruby:
```
find_part_max_prod(8) == [[3, 3, 2], 18]
```
For javascript
```
findPartMaxProd(8) --> [[3, 3, 2], 18]
```
If there are more than one partition with maximum product value, the function should output the patitions in a length sorted way.
Python and Ruby
```
find_part_max_prod(10) == [[4, 3, 3], [3, 3, 2, 2], 36]
```
Javascript
```
findPartMaxProd(10) --> [[4, 3, 3], [3, 3, 2, 2], 36]
```
Enjoy it!

Answer: {"fn_name": "find_part_max_prod", "inputs": [[8], [10]], "outputs": [[[[3, 3, 2], 18]], [[[4, 3, 3], [3, 3, 2, 2], 36]]]}
user: # Exclusive "or" (xor) Logical Operator

## Overview

In some scripting languages like PHP, there exists a logical operator (e.g. ```&&```, ```||```, ```and```, ```or```, etc.) called the "Exclusive Or" (hence the name of this Kata).  The exclusive or evaluates two booleans.  It then returns true if **exactly one of the two expressions are true**, false otherwise.  For example:

## Task

Since we cannot define keywords in Javascript (well, at least I don't know how to do it), your task is to define a function ```xor(a, b)``` where a and b are the two expressions to be evaluated.  Your ```xor``` function should have the behaviour described above, returning true if **exactly one of the two expressions evaluate to true**, false otherwise.

Answer: {"fn_name": "xor", "inputs": [[false, false], [true, false], [false, true], [true, true]], "outputs": [[false], [true], [true], [false]]}
user: ## Problem

There are `n` apples that need to be divided into four piles. We need two mysterious number `x` and `y`. Let The number of first pile equals to `x+y`, the number of second pile equals to `x-y`, the number of third pile equals to `x*y`, the number of fourth pile equals to `x/y`. We need to calculate how many apples are there in each pile.

Of course, there won't be so many unknowns. We know the total number of apples(`n`) and the second mysterious number(`y`). 

For example: there are 48 apples need to divided into four piles. y=3. that is, 1st pile should be x+3, 2nd pile should be x-3, 3rd pile should be x*3, 4th pile should be x/3.
Do you know how much `x` is? `x` should be 9, because:
```
(9 + 3) + (9 - 3) + (9 * 3) + (9 / 3) = 12 + 6 + 27 + 3 = 48
```
So, 48 apples should be divided into `12, 6, 27, 3`.

## Task

Complete function `fourPiles()`/`four_piles()` that accepts two arguments `n` and `y`, return an array contains the number of for piles. Each element in the result array should be a positive integer. If can not divide, please return `[]`.

## Examples

```
fourPiles 48 3 -- [12,6,27,3]  
//The elements are arranged in sequence according to:
//   x+y,x-y,x*y,x/y

fourPiles 100 4 -- [20,12,64,4]  
-- Verify correctness:
-- x=16,y=4
(16+4) + (16-4) + (16*4) + (16/4) -- 100

-- Edge case:
fourPiles 25 4  -- []  -- [8,0,16,1] is not a correct answer

fourPiles 24 4  -- []  -- can not divide
```

Answer: {"fn_name": "four_piles", "inputs": [[48, 3], [100, 4], [25, 4], [24, 4]], "outputs": [[[12, 6, 27, 3]], [[20, 12, 64, 4]], [[]], [[]]]}
user: You will be given a string (x) featuring a cat 'C' and a mouse 'm'. The rest of the string will be made up of '.'. 

You need to find out if the cat can catch the mouse from it's current position. The cat can jump over three characters. So:

C.....m returns 'Escaped!'  <-- more than three characters between

C...m returns 'Caught!'   <-- as there are three characters between the two, the cat can jump.

Answer: {"fn_name": "cat_mouse", "inputs": [["C....m"], ["C..m"], ["C.....m"], ["C.m"], ["m...C"]], "outputs": [["Escaped!"], ["Caught!"], ["Escaped!"], ["Caught!"], ["Caught!"]]}
user: You are given two positive integers `a` and `b` (`a < b <= 20000`). Complete the function which returns a list of all those numbers in the interval `[a, b)` whose digits are made up of prime numbers (`2, 3, 5, 7`) but which are not primes themselves.


Be careful about your timing!


Good luck :)

Answer: {"fn_name": "not_primes", "inputs": [[2, 222], [2, 77], [2700, 3000], [500, 999], [999, 2500]], "outputs": [[[22, 25, 27, 32, 33, 35, 52, 55, 57, 72, 75, 77]], [[22, 25, 27, 32, 33, 35, 52, 55, 57, 72, 75]], [[2722, 2723, 2725, 2727, 2732, 2733, 2735, 2737, 2752, 2755, 2757, 2772, 2773, 2775]], [[522, 525, 527, 532, 533, 535, 537, 552, 553, 555, 572, 573, 575, 722, 723, 725, 732, 735, 737, 752, 753, 755, 772, 775, 777]], [[2222, 2223, 2225, 2227, 2232, 2233, 2235, 2252, 2253, 2255, 2257, 2272, 2275, 2277, 2322, 2323, 2325, 2327, 2332, 2335, 2337, 2352, 2353, 2355, 2372, 2373, 2375]]]}
user: Implement `String#whitespace?(str)` (Ruby), `String.prototype.whitespace(str)` (JavaScript), `String::whitespace(str)` (CoffeeScript), or `whitespace(str)` (Python), which should return `true/True` if given object consists exclusively of zero or more whitespace characters, `false/False` otherwise.

Answer: {"fn_name": "whitespace", "inputs": [[""], [" "], ["\n\r\n\r"], ["a"], ["w\n"], ["\t"], [" a\n"], ["\t \n\r\n  "], ["\n\r\n\r "], ["\n\r\n\r 3"]], "outputs": [[true], [true], [true], [false], [false], [true], [false], [true], [true], [false]]}
user: While most devs know about [big/little-endianness](https://en.wikipedia.org/wiki/Endianness), only a selected few know the secret of real hard core coolness with mid-endians.

Your task is to take a number and return it in its mid-endian format, putting the most significant couple of bytes in the middle and all the others around it, alternating left and right.

For example, consider the number `9999999`, whose hexadecimal representation would be `98967F` in big endian (the classic you get converting); it becomes `7F9698` in little-endian and `96987F` in mid-endian.

Write a function to do that given a positive integer (in base 10) and remembering that you need to pad with `0`s when you get a single hex digit!

Answer: {"fn_name": "mid_endian", "inputs": [[9999999], [0], [658188], [168496141], [43135012110]], "outputs": [["96987F"], ["00"], ["0B0A0C"], ["0D0B0A0C"], ["0D0B0A0C0E"]]}
user: We define the sequence ```SF``` in the following way in terms of four previous sequences: ```S1```, ```S2```, ```S3``` and ```ST```



We are interested in collecting the terms of SF that are multiple of ten.

The first term multiple of ten of this sequence is  ```60```

Make the function ```find_mult10_SF()``` that you introduce the ordinal number of a term multiple of 10 of SF and gives us the value of this term.

Let's see some cases: 
```python
find_mult10_SF(1) == 60

find_mult10_SF(2) == 70080

find_mult10_SF(3) ==  90700800
```
``` haskell
findMult10SF 1 `shouldBe` 60
findMult10SF 2 `shouldBe` 70080
findMult10SF 3 `shouldBe` 90700800
```
Memoization is advisable to have a more agile code for tests.

Your code will be tested up to the 300-th term, multiple of 10.

Happy coding!!

Answer: {"fn_name": "find_mult10_SF", "inputs": [[1], [2], [3]], "outputs": [[60], [70080], [90700800]]}
user: We define the score of permutations of combinations, of an integer number (the function to obtain this value:```sc_perm_comb```) as the total sum of all the numbers obtained from the permutations of all the possible combinations of its digits.
For example we have the number 348.
```python
sc_perm_comb(348) = 3 + 4 + 8 + 34 + 38 + 48 + 43 + 83 + 84 + 348 + 384 + 834 + 843 + 438 + 483  = 3675
```
If the number has a digit 0, the numbers formed by a leading 0 should be discarded:
```python
sc_perm_comb(340) = 3 + 4 + 34 + 30 + 40 + 43 + 340 + 304 + 430 + 403 = 1631
```
If the number has digits that occur more than once, the score the adden will not be taken than twice or more:
```python
sc_perm_comb(333) = 3 + 33 + 333 = 369
```
If the number has only one digit its score is the same number:
```python
sc_perm_comb(6) = 6
sc_perm_comb(0) = 0
```

Enjoy it!!

Answer: {"fn_name": "sc_perm_comb", "inputs": [[348], [340], [333], [6], [0]], "outputs": [[3675], [1631], [369], [6], [0]]}
user: You're given a string of dominos. For each slot, there are 3 options:

  * "|" represents a standing domino

  * "/" represents a knocked over domino

  * " " represents a space where there is no domino

For example: 

```python
"||| ||||//| |/"
```

What you must do is find the resulting string if the first domino is pushed over. Now, tipping a domino will cause the next domino to its right to fall over as well, but if a domino is already tipped over, or there is a domino missing, the reaction will stop.

So in out example above, the result would be:

"/// ||||//| |/"

since the reaction would stop as soon as it gets to a space.

Answer: {"fn_name": "domino_reaction", "inputs": [["||| ||||//| |/"], ["|||||"], [" ///"], [""], [" "], [" |"], ["||||| |||"], ["|||||/|||"]], "outputs": [["/// ||||//| |/"], ["/////"], [" ///"], [""], [" "], [" |"], ["///// |||"], ["//////|||"]]}
user: Make a function that returns the value multiplied by 50 and increased by 6. If the value entered is a string it should return "Error".

Note: in `C#`, you'll always get the input as a string, so the above applies if the string isn't representing a double value.

Answer: {"fn_name": "problem", "inputs": [["hello"], [1], [5], [0], [1.2], [3], ["RyanIsCool"]], "outputs": [["Error"], [56], [256], [6], [66], [156], ["Error"]]}
user: Given a string of integers, return the number of odd-numbered substrings that can be formed. 

For example, in the case of `"1341"`, they are `1, 1, 3, 13, 41, 341, 1341`, a total of `7` numbers. 

`solve("1341") = 7`.  See test cases for more examples.

Good luck!

If you like substring Katas, please try 

[Longest vowel chain](https://www.codewars.com/kata/59c5f4e9d751df43cf000035)

[Alphabet symmetry](https://www.codewars.com/kata/59d9ff9f7905dfeed50000b0)

Answer: {"fn_name": "solve", "inputs": [["1341"], ["1357"], ["13471"], ["134721"], ["1347231"], ["13472315"]], "outputs": [[7], [10], [12], [13], [20], [28]]}
user: In number theory, Euler's totient is an arithmetic function, introduced in 1763 by Euler, that counts the positive integers less than or equal to `n` that are relatively prime to `n`. Thus, if `n` is a positive integer, then `φ(n)`, notation introduced by Gauss in 1801, is the number of positive integers `k ≤ n` for which `gcd(n, k) = 1`.  
The totient function is important in number theory, mainly because it gives the order of the multiplicative group of integers modulo `n`. The totient function also plays a key role in the definition of the RSA encryption system.

For example `let n = 9`.  
Then `gcd(9, 3) = gcd(9, 6) = 3` and `gcd(9, 9) = 9`.  
The other six numbers in the range `1 ≤ k ≤ 9` i.e. `1, 2, 4, 5, 7, 8` are relatively prime to `9`.  
Therefore, `φ(9) = 6`.  
As another example, `φ(1) = 1` since `gcd(1, 1) = 1`.

There are generally two approaches to this function:

* Iteratively counting the numbers `k ≤ n` such that `gcd(n,k) = 1`.

* Using the Euler product formula.  
  This is an explicit formula for calculating `φ(n)` depending on the prime divisor of `n`:  
  `φ(n) = n * Product (1 - 1/p)` where the product is taken over the primes `p ≤ n` that divide `n`.  
  For example: `φ(36) = 36 * (1 - 1/2) * (1 - 1/3) = 36 * 1/2 * 2/3 = 12`.  
  This second method seems more complex and not likely to be faster, but in practice we will often look for `φ(n)` with `n` prime. It correctly gives `φ(n) = n - 1` if `n` is prime. 

You have to code the Euler totient function, that takes an integer `1 ≤ n` as input and returns `φ(n)`.

```if:javascript
You do have to check if `n` is a number, is an integer and that `1 ≤ n`; if that is not the case, the function should return `0`.
```

```if:python
You do have to check if `n` is a number, is an integer and that `1 ≤ n`; if that is not the case, the function should return `0`.
```

```if:racket
`n` is always a positive integer.
```

Input range: `1 ≤ n ≤ 1e10`

Answer: {"fn_name": "totient", "inputs": [[15], [18], [19], [false], ["wow doge"], [0.0435]], "outputs": [[8], [6], [18], [0], [0], [0]]}
user: Implement a function that adds two numbers together and returns their sum in binary. The conversion can be done before, or after the addition.

The binary number returned should be a string.

Answer: {"fn_name": "add_binary", "inputs": [[1, 1], [0, 1], [1, 0], [2, 2], [51, 12], [5, 9], [10, 10], [100, 100], [4096, 1], [0, 2174483647]], "outputs": [["10"], ["1"], ["1"], ["100"], ["111111"], ["1110"], ["10100"], ["11001000"], ["1000000000001"], ["10000001100110111111110010111111"]]}
user: In programming you know the use of the logical negation operator (**!**), it reverses the meaning of a condition.

Your task is to complete the function 'negationValue()' that takes a string of negations with a value and returns what the value would be if those negations were applied to it.

```python
negation_value("!", False) #=> True
negation_value("!!!!!", True) #=> False
negation_value("!!", []) #=> False
```

Do not use the `eval()` function or the `Function()` constructor in JavaScript.

Note: Always return a boolean value, even if there're no negations.

Answer: {"fn_name": "negation_value", "inputs": [["!", false], ["!", true], ["!!!", []]], "outputs": [[true], [false], [true]]}
user: You get an array of different numbers to sum up. But there is one problem, those numbers all have different bases.
For example:
```python
You get an array of numbers with their base as an input:

[["101",16],["7640",8],["1",9]]
```

The output should be the sum as an integer value with a base of 10, so according to the example this would be:

4258
```python
A few more examples:
[["101",2], ["10",8]] --> 13
[["ABC",16], ["11",2]] --> 2751
```
Bases can be between 2 and 36 (2<=base<=36)

Answer: {"fn_name": "sum_it_up", "inputs": [[[["101", 2], ["10", 8]]], [[["ABC", 16], ["11", 2]]], [[["101", 16], ["7640", 8], ["1", 9]]], [[]]], "outputs": [[13], [2751], [4258], [0]]}
user: Challenge:

Given a two-dimensional array, return a new array which carries over only those arrays from the original, which were not empty and whose items are all of the same type (i.e. homogenous). For simplicity, the arrays inside the array will only contain characters and integers.

Example:

Given [[1, 5, 4], ['a', 3, 5], ['b'], [], ['1', 2, 3]], your function should return [[1, 5, 4], ['b']].

Addendum:

Please keep in mind that for this kata, we assume that empty arrays are not homogenous.

The resultant arrays should be in the order they were originally in and should not have its values changed.

No implicit type casting is allowed. A subarray [1, '2'] would be considered illegal and should be filtered out.

Answer: {"fn_name": "filter_homogenous", "inputs": [[[[1, 5, 4], ["a", 3, 5], ["b"], [], ["1", 2, 3]]], [[[123, 234, 432], ["", "abc"], [""], ["", 1], ["", "1"], []]], [[[1, 2, 3], ["1", "2", "3"], ["1", 2, 3]]]], "outputs": [[[[1, 5, 4], ["b"]]], [[[123, 234, 432], ["", "abc"], [""], ["", "1"]]], [[[1, 2, 3], ["1", "2", "3"]]]]}
user: You've just entered a programming contest and have a chance to win a million dollars. This is the last question you have to solve, so your victory (and your vacation) depend on it. Can you guess the function just by looking at the test cases? There are two numerical inputs and one numerical output. Goodluck!

hint: go
 here

Answer: {"fn_name": "code", "inputs": [[9, 8], [123, 456], [3, 2], [1, 1], [12, 8], [200, 100], [100, 200]], "outputs": [[1], [1419], [13], [16], [88], [1698], [1698]]}
user: Here you have to do some mathematical operations on a "dirty string". This kata checks some basics, it's not too difficult.


__So what to do?__

Input: String which consists of two positive numbers (doubles) and exactly one operator like `+, -, * or /` always between these numbers. The string is dirty, which means that there are different characters inside too, not only numbers and the operator. You have to combine all digits left and right, perhaps with "." inside (doubles), and to calculate the result which has to be rounded to an integer and converted to a string at the end.

### Easy example:

```
Input: "gdfgdf234dg54gf*23oP42"
Output: "54929268" (because 23454*2342=54929268)
```

First there are some static tests, later on random tests too...

### Hope you have fun! :-)

Answer: {"fn_name": "calculate_string", "inputs": [[";$%\u00a7fsdfsd235??df/sdfgf5gh.000kk0000"], ["sdfsd23454sdf*2342"], ["fsdfsd235???34.4554s4234df-sdfgf2g3h4j442"], ["fsdfsd234.4554s4234df+sf234442"], ["a1a2b3c.c0c/a1a0b.cc00c"]], "outputs": [["47"], ["54929268"], ["-210908"], ["234676"], ["12"]]}
user: In mathematics, the factorial of integer 'n' is written as 'n!'.
It is equal to the product of n and every integer preceding it.
For example: **5! = 1 x 2 x 3 x 4 x 5 = 120**

Your mission is simple: write a function that takes an integer 'n' and returns 'n!'.

You are guaranteed an integer argument. For any values outside the positive range, return `null`, `nil` or `None` .

**Note:** 0! is always equal to 1. Negative values should return null; 

For more on Factorials : http://en.wikipedia.org/wiki/Factorial

Answer: {"fn_name": "factorial", "inputs": [[-1]], "outputs": [[null]]}
user: Poor Cade has got his number conversions mixed up again!

Fix his ```convert_num()``` function so it correctly converts a base-10 ```int```eger, 
to the selected of ```bin```ary or ```hex```adecimal.

```#The output should be a string at all times```

```python
convert_num(number, base):
    if 'base' = hex:
        return int(number, 16)
    if 'base' = bin:
        return int(number, 2)
    return (Incorrect base input)
```
Please note, invalid ```number``` or ```base``` inputs will be tested.
In the event of an invalid ```number/base``` you should return:
```python
"Invalid number input"
or
"Invalid base input"
```
For each respectively.

Good luck coding! :D

Answer: {"fn_name": "convert_num", "inputs": [[122, "bin"], ["dog", "bin"], [0, "hex"], [123, "lol"]], "outputs": [["0b1111010"], ["Invalid number input"], ["0x0"], ["Invalid base input"]]}
user: # Task
 You are given two string `a` an `s`. Starting with an empty string we can do the following two operations:
```
append the given string a to the end of the current string.
erase one symbol of the current string.```
Your task is to find the least number of operations needed to construct the given string s. Assume that all the letters from `s` appear in `a` at least once.

# Example

 For `a = "aba", s = "abbaab"`, the result should be `6`.
 
 Coinstruction:
 
 `"" -> "aba" -> "ab" -> "ababa" -> "abba" -> "abbaaba" -> "abbaab".`
 
 So, the result is 6.

 For `a = "aba", s = "a"`, the result should be `3`.
 
 Coinstruction:
 
 `"" -> "aba" -> "ab" -> "a".`
 
 So, the result is 3.

 For `a = "aba", s = "abaa"`, the result should be `4`.
 
 Coinstruction:
 
 `"" -> "aba" -> "abaaba" -> "abaab" -> "abaa".`
 
 So, the result is 4.

# Input/Output


 - `[input]` string `a`

  string to be appended. Contains only lowercase English letters. 
  
  1 <= a.length <= 20


 - `[input]` string `s`

  desired string containing only lowercase English letters.
  
  1 <= s.length < 1000


 - `[output]` an integer

  minimum number of operations

Answer: {"fn_name": "string_constructing", "inputs": [["aba", "abbabba"], ["aba", "abaa"], ["aba", "a"], ["a", "a"], ["a", "aaa"], ["abcdefgh", "hgfedcba"]], "outputs": [[9], [4], [3], [1], [3], [64]]}
user: In this kata, you've to count lowercase letters in a given string and return the letter count in a hash with 'letter' as key and count as 'value'. The key must be 'symbol' instead of string in Ruby and 'char' instead of string in Crystal.

Example: 

```python
letter_count('arithmetics') #=> {"a": 1, "c": 1, "e": 1, "h": 1, "i": 2, "m": 1, "r": 1, "s": 1, "t": 2}
```

Answer: {"fn_name": "letter_count", "inputs": [["codewars"], ["activity"], ["arithmetics"], ["traveller"], ["daydreamer"]], "outputs": [[{"a": 1, "c": 1, "d": 1, "e": 1, "o": 1, "r": 1, "s": 1, "w": 1}], [{"a": 1, "c": 1, "i": 2, "t": 2, "v": 1, "y": 1}], [{"a": 1, "c": 1, "e": 1, "h": 1, "i": 2, "m": 1, "r": 1, "s": 1, "t": 2}], [{"a": 1, "e": 2, "l": 2, "r": 2, "t": 1, "v": 1}], [{"a": 2, "d": 2, "e": 2, "m": 1, "r": 2, "y": 1}]]}
user: Suppose I have two vectors: `(a1, a2, a3, ..., aN)` and `(b1, b2, b3, ..., bN)`. The dot product between these two vectors is defined as:

```
a1*b1 + a2*b2 + a3*b3 + ... + aN*bN
```

The vectors are classified as orthogonal if the dot product equals zero.


Complete the function that accepts two sequences as inputs and returns `true` if the vectors are orthogonal, and `false` if they are not. The sequences will always be correctly formatted and of the same length, so there is no need to check them first.


## Examples
```
[1, 1, 1], [2, 5, 7]        --> false
[1, 0, 0, 1], [0, 1, 1, 0]  --> true
```

Answer: {"fn_name": "is_orthogonal", "inputs": [[[1, 2], [2, 1]], [[1, -2], [2, 1]], [[7, 8], [7, -6]], [[-13, -26], [-8, 4]], [[1, 2, 3], [0, -3, 2]], [[3, 4, 5], [6, 7, -8]], [[3, -4, -5], [-4, -3, 0]], [[1, -2, 3, -4], [-4, 3, 2, -1]], [[2, 4, 5, 6, 7], [-14, -12, 0, 8, 4]], [[5, 10, 1, 20, 2], [-2, -20, -1, 10, 5]]], "outputs": [[false], [true], [false], [true], [true], [false], [true], [true], [true], [false]]}