meetforever/GRPO_CL huggingface dataset:
user: In genetic the reverse complement of a sequence is formed by **reversing** the sequence and then taking the complement of each symbol.

The four nucleotides in DNA is Adenine (A), Cytosine (C), Guanine (G) and Thymine (Thymine). 

- A is the complement of T 
- C is the complement of G.

This is a bi-directional relation so:

- T is the complement of A
- G is the complement of C.

For this kata you need to complete the reverse complement function that take a DNA string and return the reverse complement string.

**Note**: You need to take care of lower and upper case. And if a sequence conatains some invalid characters you need to return "Invalid sequence".

This kata is based on the following [one](http://www.codewars.com/kata/complementary-dna/ruby) but with a little step in addition.

Answer: {"fn_name": "reverse_complement", "inputs": [["TTCCGGAA"], ["GACTGACTGTA"], [""], ["XYZ"]], "outputs": [["TTCCGGAA"], ["TACAGTCAGTC"], [""], ["Invalid sequence"]]}
user: Every now and then people in the office moves teams or departments. Depending what people are doing with their time they can become more or less boring. Time to assess the current team.

```if-not:java
You will be provided with an object(staff) containing the staff names as keys, and the department they work in as values.
```

```if:java
You will be provided with an array of `Person` objects with each instance containing the name and department for a staff member.
~~~java
public class Person {
  public final String name;        // name of the staff member
  public final String department;  // department they work in
}
~~~
```

Each department has a different boredom assessment score, as follows:

accounts = 1
finance = 2 
canteen = 10 
regulation = 3 
trading = 6 
change = 6
IS = 8
retail = 5 
cleaning = 4
pissing about = 25

Depending on the cumulative score of the team, return the appropriate sentiment:

<=80: 'kill me now'
< 100 & > 80: 'i can handle this'
100 or over: 'party time!!'

The Office I - Outed
The Office III - Broken Photocopier
The Office IV - Find a Meeting Room
The Office V - Find a Chair

Answer: {"fn_name": "boredom", "inputs": [[{"tim": "change", "jim": "accounts", "randy": "canteen", "sandy": "change", "andy": "change", "katie": "IS", "laura": "change", "saajid": "IS", "alex": "trading", "john": "accounts", "mr": "finance"}], [{"tim": "IS", "jim": "finance", "randy": "pissing about", "sandy": "cleaning", "andy": "cleaning", "katie": "cleaning", "laura": "pissing about", "saajid": "regulation", "alex": "regulation", "john": "accounts", "mr": "canteen"}], [{"tim": "accounts", "jim": "accounts", "randy": "pissing about", "sandy": "finance", "andy": "change", "katie": "IS", "laura": "IS", "saajid": "canteen", "alex": "pissing about", "john": "retail", "mr": "pissing about"}]], "outputs": [["kill me now"], ["i can handle this"], ["party time!!"]]}
user: Bob has a server farm crunching numbers. He has `nodes` servers in his farm. His company has a lot of work to do. 

The work comes as a number `workload` which indicates how many jobs there are. Bob wants his servers to get an equal number of jobs each. If that is impossible, he wants the first servers to receive more jobs. He also wants the jobs sorted, so that the first server receives the first jobs.

The way this works, Bob wants an array indicating which jobs are going to which servers.

Can you help him distribute all this work as evenly as possible onto his servers?

Example
-------

Bob has `2` servers and `4` jobs. The first server should receive job 0 and 1 while the second should receive 2 and 3.

```
distribute(2, 4) # => [[0, 1], [2, 3]]
```

On a different occasion Bob has `3` servers and `3` jobs. Each should get just one.

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

A couple of days go by and Bob sees a spike in jobs. Now there are `10`, but he hasn't got more than `4` servers available. He boots all of them. This time the first and second should get a job more than the third and fourth.

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

Input
-----

Don't worry about invalid inputs. That is, `nodes > 0` and `workload > 0` and both will always be integers.

Answer: {"fn_name": "distribute", "inputs": [[2, 4], [3, 3], [3, 9], [2, 5], [4, 10], [4, 5], [1, 1], [2, 1], [5, 4], [5, 1]], "outputs": [[[[0, 1], [2, 3]]], [[[0], [1], [2]]], [[[0, 1, 2], [3, 4, 5], [6, 7, 8]]], [[[0, 1, 2], [3, 4]]], [[[0, 1, 2], [3, 4, 5], [6, 7], [8, 9]]], [[[0, 1], [2], [3], [4]]], [[[0]]], [[[0], []]], [[[0], [1], [2], [3], []]], [[[0], [], [], [], []]]]}
user: Yup!! The problem name reflects your task; just add a set of numbers. But you may feel yourselves condescended, to write a C/C++ program just to add a set of numbers. Such a problem will simply question your erudition. So, lets add some flavor of ingenuity to it. Addition operation requires cost now, and the cost is the summation of those two to be added. So,to add 1 and 10, you need a cost of 11. If you want to add 1, 2 and 3. There are several ways

```c++
1 + 2 = 3, cost = 3,
3 + 3 = 6, cost = 6,
Total = 9.
```
```c++
1 + 3 = 4, cost = 4,
2 + 4 = 6, cost = 6,
Total = 10.
```
```c++
2 + 3 = 5, cost = 5,
1 + 5 = 6, cost = 6,
Total = 11.
```
I hope you have understood already your mission, to add a set of integers so that the cost is minimal

# Your Task 
Given a vector of integers, return the minimum total cost of addition.

Answer: {"fn_name": "add_all", "inputs": [[[1, 2, 3]], [[1, 2, 3, 4]], [[1, 2, 3, 4, 5]]], "outputs": [[9], [19], [33]]}
user: Find the difference between two collections. The difference means that either the character is present in one collection or it is present in other, but not in both. Return a sorted set with difference.

The collections can contain any character and can contain duplicates.

For instance:

A = [a,a,t,e,f,i,j]

B = [t,g,g,i,k,f]

difference = [a,e,g,j,k]

Answer: {"fn_name": "diff", "inputs": [[["a", "b"], ["a", "b"]], [[], []]], "outputs": [[[]], [[]]]}
user: We have an integer array with unique elements and we want to do the permutations that have an element fixed, in other words, these permutations should have a certain element at the same position than the original.

These permutations will be called: **permutations with one fixed point**.

Let's see an example with an array of four elements and we want the permutations that have a coincidence **only at  index 0**, so these permutations are (the permutations between parenthesis):
``` 
arr = [1, 2, 3, 4]
      (1, 3, 4, 2)
      (1, 4, 2, 3)
Two permutations matching with arr only at index 0
``` 

Let's see the permutations of the same array with only one coincidence at index **1**:
``` 
arr = [1, 2, 3, 4]
      (3, 2, 4, 1)
      (4, 2, 1, 3)
Two permutations matching with arr only at index 1
```
Once again, let's see the permutations of the same array with only one coincidence at index **2**:
``` 
arr = [1, 2, 3, 4]
      (2, 4, 3, 1)
      (4, 1, 3, 2)
Two permutations matching with arr only at index 2
```
Finally, let's see the permutations of the same array with only one coincidence at index **3**:
``` 
arr = [1, 2, 3, 4]
      (2, 3, 1, 4)
      (3, 1, 2, 4)
Two permutations matching with arr only at index 3
```
For this array given above (arr) :

- We conclude that we have 8 permutations with one fixed point (two at each index of arr).

- We may do the same development for our array, `arr`, with two fixed points and we will get `6` permutations.

- There are no permutations with coincidences only at three indexes.

- It's good to know that the amount of permutations with no coincidences at all are `9`. See the kata Shuffle It Up!!

In general:

- When the amount of fixed points is equal to the array length, there is only one permutation, the original array.

- When the amount of fixed points surpasses the length of the array, obvously, there are no permutations at all.

Create a function that receives the length of the array and the number of fixed points and may output the total amount of permutations for these constraints.

Features of the random tests:
```
length of the array = l
number of fixed points = k
10 ≤ k ≤ l ≤ 9000
```
See the example tests!
Enjoy it!!

Ruby versin will be released soon.

#Note: This kata was published previously but in a version not well optimized.

Answer: {"fn_name": "fixed_points_perms", "inputs": [[4, 1], [4, 2], [4, 3], [10, 3], [10, 4], [20, 2], [4, 0], [4, 4], [4, 5]], "outputs": [[8], [6], [0], [222480], [55650], [447507315596451070], [9], [1], [0]]}
user: In this Kata, you will be given an array of unique elements, and your task is to rerrange the values so that the first max value is followed by the first minimum, followed by second max value then second min value, etc. 

For example:
The first max is `15` and the first min is `7`. The second max is `12` and the second min is `10` and so on. 

More examples in the test cases. 

Good luck!

Answer: {"fn_name": "solve", "inputs": [[[15, 11, 10, 7, 12]], [[91, 75, 86, 14, 82]], [[84, 79, 76, 61, 78]], [[52, 77, 72, 44, 74, 76, 40]], [[1, 6, 9, 4, 3, 7, 8, 2]], [[78, 79, 52, 87, 16, 74, 31, 63, 80]]], "outputs": [[[15, 7, 12, 10, 11]], [[91, 14, 86, 75, 82]], [[84, 61, 79, 76, 78]], [[77, 40, 76, 44, 74, 52, 72]], [[9, 1, 8, 2, 7, 3, 6, 4]], [[87, 16, 80, 31, 79, 52, 78, 63, 74]]]}
user: Write a function that takes a string which has integers inside it separated by spaces, and your task is to convert each integer in the string into an integer and return their sum.

### Example
```python
summy("1 2 3")  ==> 6
```

Good luck!

Answer: {"fn_name": "summy", "inputs": [["1 2 3"], ["1 2 3 4"], ["1 2 3 4 5"], ["10 10"], ["0 0"]], "outputs": [[6], [10], [15], [20], [0]]}
user: You are a biologist working on the amino acid  composition of proteins. Every protein consists of a long chain of 20 different amino acids with different properties. 
Currently, you are collecting data on the percentage, various amino acids make up a protein you are working on. As manually counting the occurences of amino acids takes too long (especially when counting more than one amino acid), you decide to write a program for this task:

Write a function that takes two arguments,
 1. A (snippet of a) protein sequence
 2. A list of amino acid residue codes 

and returns the rounded percentage of the protein that the given amino acids make up. 
If no amino acid list is given, return the percentage of hydrophobic amino acid residues ["A", "I", "L", "M", "F", "W", "Y", "V"].

Answer: {"fn_name": "aa_percentage", "inputs": [["MSRSLLLRFLLFLLLLPPLP", ["M"]], ["MSRSLLLRFLLFLLLLPPLP", ["M", "L"]], ["MSRSLLLRFLLFLLLLPPLP", ["F", "S", "L"]], ["MSRSLLLRFLLFLLLLPPLP"], ["RLMADDFFGQTLMAAAAAAQERRR", ["A"]], ["RLMADDFFGQTLMAAAAAAQERRR", ["A", "R", "D"]], ["RLMADDFFGQTLMAAAAAAQERRR"], ["PLPPLPLLEELELRPFFMAAGGTPLAMMGG", ["X"]], ["PLPPLPLLEELELRPFFMAAGGTPLAMMGG", ["P", "L"]], ["PLPPLPLLEELELRPFFMAAGGTPLAMMGG", ["P", "E", "L", "R", "F", "M", "A", "G", "T"]], ["PLPPLPLLEELELRPFFMAAGGTPLAMMGG"]], "outputs": [[5], [55], [70], [65], [29], [54], [54], [0], [43], [100], [50]]}
user: Assume we take a number `x` and perform any one of the following operations:
```Pearl
a) Divide x by 3 (if it is divisible by 3), or
b) Multiply x by 2
```
After each operation, we write down the result. If we start with `9`, we can get a sequence such as:
```
[9,3,6,12,4,8] -- 9/3=3 -> 3*2=6 -> 6*2=12 -> 12/3=4 -> 4*2=8
```
You will be given a shuffled sequence of integers and your task is to reorder them so that they conform to the above sequence. There will always be an answer. 
```
For the above example:
solve([12,3,9,4,6,8]) = [9,3,6,12,4,8].
```

More examples in the test cases. Good luck!

Answer: {"fn_name": "solve", "inputs": [[[1, 3]], [[4, 2]], [[12, 3, 9, 4, 6, 8]], [[4, 8, 6, 3, 12, 9]], [[558, 744, 1488, 279, 2232, 1116]], [[9, 1, 3]], [[3000, 9000]], [[4, 1, 2]], [[10, 5]]], "outputs": [[[3, 1]], [[2, 4]], [[9, 3, 6, 12, 4, 8]], [[9, 3, 6, 12, 4, 8]], [[279, 558, 1116, 2232, 744, 1488]], [[9, 3, 1]], [[9000, 3000]], [[1, 2, 4]], [[5, 10]]]}
user: # Grains

Write a program that calculates the number of grains of wheat on a chessboard given that the number on each square is double the previous one.

There are 64 squares on a chessboard.

#Example:
square(1) = 1
square(2) = 2
square(3) = 4
square(4) = 8
etc...

Write a program that shows how many grains were on each square

Answer: {"fn_name": "square", "inputs": [[1], [3], [4], [16], [32]], "outputs": [[1], [4], [8], [32768], [2147483648]]}
user: I have started studying electronics recently, and I came up with a circuit made up of 2 LEDs and 3 buttons.

Here 's how it works: 2 buttons (`red` and `blue`) are connected to the LEDs (`red` and `blue` respectively). Buttons pressing pattern will be remembered and represented through the LEDs when the third button is pressed.

 - Only one LED can blink at a time.
 - The LED will only blink once even if the button is held down.
 - The button must be released to be pressed again.
 - If a button is pressed while the other button is being held down, it will be ignored.
 - If two buttons are pressed simultaneously, the red button will be preferred.
 - If a button is released while the other is being held down, the other 's LED will blink.
 - `0` is up and `1` is down.
 - The two inputs will always have the same length.
 
Here is an example:

```Python
Red:  "10011010"
Blue: "10110111"
#=> "RBRB"

Red:  "01001000"
Blue: "01011100"
#=> "RB"

Red:  "01101000"
Blue: "00111000"
#=> "RB"
```

PS:

This is my first time making a kata, so there may be some errors. 
You may report to me if the description is too confusing. 
Sorry for my poor grammar.

Answer: {"fn_name": "button_sequences", "inputs": [["10011010", "10110111"], ["01001000", "01011100"], ["00010100", "01011100"], ["10101010", "01010101"], ["11011011", "11111011"]], "outputs": [["RBRB"], ["RB"], ["BRB"], ["RBRBRBRB"], ["RBR"]]}
user: # Task

Write a function that accepts `msg` string and returns local tops of string from the highest to the lowest.  
The string's tops are from displaying the string in the below way:

```

                                         7891012
                             TUWvXY      6     3
                   ABCDE     S    Z      5
           lmno    z   F     R    1      4
     abc   k  p    v   G     Q    2      3
.34..9 d...j  q....x   H.....P    3......2
125678 efghi  rstuwy   IJKLMNO    45678901

```
The next top is always 1 character higher than the previous one. 
For the above example, the solution for the `123456789abcdefghijklmnopqrstuwyxvzABCDEFGHIJKLMNOPQRSTUWvXYZ123456789012345678910123` input string is `7891012TUWvXYABCDElmnoabc34`. 

- When the `msg` string is empty, return an empty string.
- The input strings may be very long. Make sure your solution has good performance.
- The (.)dots on the sample dispaly of string are only there to help you to understand the pattern  

Check the test cases for more samples.

# Series

- [String tops](https://www.codewars.com/kata/59b7571bbf10a48c75000070)
- [Square string tops](https://www.codewars.com/kata/5aa3e2b0373c2e4b420009af)

Answer: {"fn_name": "tops", "inputs": [[""], ["abcde"], ["123456789abcdefghijklmnopqrstuwyxvzABCDEFGHIJKLMNOPQRSTU"], ["123456789abcdefghijklmnopqrstuwyxvzABCDEFGHIJKLMNOPQRSTUWvXYZ123456789012345678910123"]], "outputs": [[""], ["cd"], ["TUABCDElmnoabc34"], ["7891012TUWvXYABCDElmnoabc34"]]}
user: Complete the function that takes 3 numbers `x, y and k` (where `x ≤ y`), and returns the number of integers within the range `[x..y]` (both ends included) that are divisible by `k`.

More scientifically:  `{ i : x ≤ i ≤ y, i mod k = 0 }`


## Example

Given ```x = 6, y = 11, k = 2``` the function should return `3`, because there are three numbers divisible by `2` between `6` and `11`: `6, 8, 10`

- **Note**: The test cases are very large. You will need a O(log n) solution or better to pass. (A constant time solution is possible.)

Answer: {"fn_name": "divisible_count", "inputs": [[6, 11, 2], [11, 345, 17], [0, 1, 7], [20, 20, 2], [20, 20, 8], [19, 20, 2], [0, 10, 1], [11, 14, 2], [101, 9999999999999999999999999999999999999999999, 11], [1005, 9999999999999999999999999999999999999999999, 109]], "outputs": [[3], [20], [1], [1], [0], [1], [11], [2], [909090909090909090909090909090909090909081], [91743119266055045871559633027522935779807]]}
user: ## Task

Given `n` representing the number of floors build a beautiful multi-million dollar mansions like the ones in the example below:

```
     /\
    /  \
   /    \
  /______\  number of floors 3
  |      |
  |      |
  |______|

     /\
    /  \
   /____\
   |    |   2 floors
   |____|

     /\
    /__\    1 floor
    |__|
```

**Note:** whitespace should be preserved on both sides of the roof. Number of floors will go up to 30. There will be no tests with invalid input.

If you manage to complete it, you can try a harder version [here](https://www.codewars.com/kata/58360d112fb0ba255300008b).

Good luck!

Answer: {"fn_name": "my_crib", "inputs": [[1], [2], [3]], "outputs": [[" /\\ \n/__\\\n|__|"], ["  /\\  \n /  \\ \n/____\\\n|    |\n|____|"], ["   /\\   \n  /  \\  \n /    \\ \n/______\\\n|      |\n|      |\n|______|"]]}
user: Given a rational number n

``` n >= 0, with denominator strictly positive```  

- as a string (example: "2/3" in Ruby, Python, Clojure, JS, CS, Go) 
- or as two strings (example: "2" "3" in Haskell, Java, CSharp, C++, Swift) 
- or as a rational or decimal number (example: 3/4, 0.67 in R) 
- or two integers (Fortran)

decompose 
this number as a sum of rationals with numerators equal to one and without repetitions
(2/3 = 1/2 + 1/6 is correct but not 2/3 = 1/3 + 1/3, 1/3 is repeated).
    
The algorithm must be "greedy", so at each stage the new rational obtained in the decomposition must have a denominator as small as possible. 
In this manner the sum of a few fractions in the decomposition gives a rather good approximation of the rational to decompose.
    
2/3 = 1/3 + 1/3 doesn't fit because of the repetition but also because the first 1/3 has a denominator bigger than the one in 1/2 
in the decomposition 2/3 = 1/2 + 1/6.
    
### Example: 
(You can see other examples in "Sample Tests:")
```
decompose("21/23") or "21" "23" or 21/23 should return 

["1/2", "1/3", "1/13", "1/359", "1/644046"] in Ruby, Python, Clojure, JS, CS, Haskell, Go

"[1/2, 1/3, 1/13, 1/359, 1/644046]" in Java, CSharp, C++

"1/2,1/3,1/13,1/359,1/644046" in C, Swift, R
```  

### Notes
1) The decomposition of 21/23 as
```
21/23 = 1/2 + 1/3 + 1/13 + 1/598 + 1/897
```
is exact but don't fulfill our requirement because 598 is bigger than 359.
Same for 
```
21/23 = 1/2 + 1/3 + 1/23 + 1/46 + 1/69 (23 is bigger than 13)
or 
21/23 = 1/2 + 1/3 + 1/15 + 1/110 + 1/253 (15 is bigger than 13).
```
    
2) The rational given to decompose could be greater than one or equal to one, in which case the first "fraction" will be an integer 
(with an implicit denominator of 1). 

3) If the numerator parses to zero the function "decompose" returns [] (or "".

4) The number could also be a decimal which can be expressed as a rational. 

examples:

`0.6` in Ruby, Python, Clojure,JS, CS, Julia, Go
  
`"66" "100"` in Haskell, Java, CSharp, C++, C, Swift, Scala, Kotlin

`0.67` in R.

**Ref:**
http://en.wikipedia.org/wiki/Egyptian_fraction

Answer: {"fn_name": "decompose", "inputs": [["0"], ["3/4"], ["12/4"], ["4/5"], ["0.66"], ["22/23"], ["1001/3456"], ["16/17"], ["30/45"], ["1.25"], ["75/3"], ["2/8"], ["0.9"]], "outputs": [[[]], [["1/2", "1/4"]], [["3"]], [["1/2", "1/4", "1/20"]], [["1/2", "1/7", "1/59", "1/5163", "1/53307975"]], [["1/2", "1/3", "1/9", "1/83", "1/34362"]], [["1/4", "1/26", "1/848", "1/2381184"]], [["1/2", "1/3", "1/10", "1/128", "1/32640"]], [["1/2", "1/6"]], [["1", "1/4"]], [["25"]], [["1/4"]], [["1/2", "1/3", "1/15"]]]}
user: Write a program that will take a string of digits and give you all the possible consecutive slices of length `n` in that string.

Raise an error if `n` is larger than the length of the string.


## Examples

For example, the string `"01234"` has the following 2-digit slices:
```
[0, 1], [1, 2], [2, 3], [3, 4]
```


The same string has the following 4-digit slices:
```
[0, 1, 2, 3], [1, 2, 3, 4]
```

Answer: {"fn_name": "series_slices", "inputs": [["01234", 1], ["01234", 2], ["01234", 3], ["01234", 4], ["01234", 5]], "outputs": [[[[0], [1], [2], [3], [4]]], [[[0, 1], [1, 2], [2, 3], [3, 4]]], [[[0, 1, 2], [1, 2, 3], [2, 3, 4]]], [[[0, 1, 2, 3], [1, 2, 3, 4]]], [[[0, 1, 2, 3, 4]]]]}
user: Your job is to change the given string `s` using a non-negative integer `n`.

Each bit in `n` will specify whether or not to swap the case for each alphabetic character in `s`: if the bit is `1`, swap the case; if its `0`, leave it as is. When you finished with the last bit of `n`, start again with the first bit.

You should skip the checking of bits when a non-alphabetic character is encountered, but they should be preserved in their original positions.

## Examples

```
swap('Hello world!', 11)  -->  'heLLO wORLd!'
```
...because `11` is `1011` in binary, so the 1st, 3rd, 4th, 5th, 7th, 8th and 9th alphabetical characters have to be swapped:
```
H e l l o  w o r l d !
1 0 1 1 1  0 1 1 1 0
^   ^ ^ ^    ^ ^ ^
```

More examples:
```
swap("gOOd MOrniNg", 7864)  -->  "GooD MorNIng"
swap('', 11345)  -->  ''
swap('the lord of the rings', 0)  -->  'the lord of the rings'
```

Answer: {"fn_name": "swap", "inputs": [["Hello world!", 11], ["the quick broWn fox leapt over the fence", 9], ["eVerybody likes ice cReam", 85], ["gOOd MOrniNg", 7864], ["how are you today?", 12345], ["the lord of the rings", 0], ["", 11345]], "outputs": [["heLLO wORLd!"], ["The QUicK BrowN foX LeaPT ovER thE FenCE"], ["EVErYbODy LiKeS IcE creAM"], ["GooD MorNIng"], ["HOw are yoU TOdaY?"], ["the lord of the rings"], [""]]}
user: Consider X as the  aleatory  variable that count the number of letters in a word. Write a function that, give in input an array of words (strings), calculate the  variance  of X.
Max decimal of the variance : 4.

Some wiki: Variance ,
 Aleatory variable 

Example:

Consider "Hello" and "World":

X is { 5 } with P(X = 5) = 1 beacuse the two words has the same length.  
So E[X] = 5 x 1 = 5 and the standard formula for variance is E[(X - u)^2] so  1 x (5-5)^2 = 0
or you can calculate with the other formula E[X^2] - E[X]^2 = 5^2 x 1 - 5^2 = 0

Consider "Hi" and "World":

X is { 2, 5 } with P(X = 5) = 1/2 and P(X = 2) = 1/2.  
So E[X] = 5 x 1/2 + 2 x 1/2 = 3.5 and the standard formula for variance is E[(X - u)^2] so  1/2 x (2-3.5)^2 + 1/2 x (5 - 3.5)^2 = 2.25
or you can calculate with the other formula E[X^2] - E[X]^2 = (5^2 x 1/2 + 2^2 x 1/2) - 3.5^2 = 2.25

Answer: {"fn_name": "variance", "inputs": [[["Hello", "world"]], [["Hi", "world"]], [["Variance", "is", "not", "a", "good", "stimator"]]], "outputs": [[0], [2.25], [7.5556]]}