meetforever/GRPO_CL huggingface dataset:
user: Write a function, `persistence`, that takes in a positive parameter `num` and returns its multiplicative persistence, which is the number of times you must multiply the digits in `num` until you reach a single digit.

For example:

```python
 persistence(39) => 3  # Because 3*9 = 27, 2*7 = 14, 1*4=4
                       # and 4 has only one digit.
                 
 persistence(999) => 4 # Because 9*9*9 = 729, 7*2*9 = 126,
                       # 1*2*6 = 12, and finally 1*2 = 2.
                  
 persistence(4) => 0   # Because 4 is already a one-digit number.
```
```python
 persistence(39) # returns 3, because 3*9=27, 2*7=14, 1*4=4
                 # and 4 has only one digit
                  
 persistence(999) # returns 4, because 9*9*9=729, 7*2*9=126,
                  # 1*2*6=12, and finally 1*2=2

 persistence(4) # returns 0, because 4 is already a one-digit number
```

Answer: {"fn_name": "persistence", "inputs": [[39], [4], [25], [999], [444]], "outputs": [[3], [0], [2], [4], [3]]}
user: # Task
 Given an array `arr` and a number `n`. Call a pair of numbers from the array a `Perfect Pair` if their sum is equal to `n`.

 Find all of the perfect pairs and return the sum of their **indices**. 
 
 Note that any element of the array can only be counted in one Perfect Pair. Also if there are multiple correct answers, return the smallest one.

# Example

 For `arr = [1, 4, 2, 3, 0, 5] and n = 7`, the result should be `11`.
 
 Since the Perfect Pairs are `(4, 3)` and `(2, 5)` with indices `1 + 3 + 2 + 5 = 11`.

 For `arr = [1, 3, 2, 4] and n = 4`, the result should be `1`.
 
 Since the element at `index 0` (i.e. 1) and the element at `index 1` (i.e. 3) form the only Perfect Pair.

# Input/Output


 - `[input]` integer array `arr`

  array of non-negative integers.


 - `[input]` integer `n`

  positive integer


 - `[output]` integer

  sum of indices and 0 if no Perfect Pair exists.

Answer: {"fn_name": "pairwise", "inputs": [[[1, 4, 2, 3, 0, 5], 7], [[1, 3, 2, 4], 4], [[1, 1, 1], 2], [[0, 0, 0, 0, 1, 1], 1], [[15, 1, 1], 5]], "outputs": [[11], [1], [1], [10], [0]]}
user: The number ```1331``` is the first positive perfect cube,  higher than ```1```, having all its digits odd (its cubic root is ```11```).

The next one is ```3375```.

In the interval [-5000, 5000] there are six pure odd digit perfect cubic numbers and are: ```[-3375,-1331, -1, 1, 1331, 3375]```

Give the numbers of this sequence that are in the range ```[a,b] ```(both values inclusive)

Examples:
``` python
odd_dig_cubic(-5000, 5000) == [-3375,-1331, -1, 1, 1331, 3375] # the output should be sorted.
odd_dig_cubic(0, 5000) == [1, 1331, 3375]
odd_dig_cubic(-1, 5000) == [-1, 1, 1331, 3375]
odd_dig_cubic(-5000, -2) == [-3375,-1331]

```
Features of the random tests for python:
```
number of Tests = 94
minimum value for a = -1e17
maximum value for b = 1e17
```
You do not have to check the entries, ```a``` and ```b``` always integers and ```a < b``` 

Working well in Python 2 and Python 3.
Translation into Ruby is coming soon.

Answer: {"fn_name": "odd_dig_cubic", "inputs": [[-5000, 5000], [0, 5000], [-1, 5000], [-5000, -2]], "outputs": [[[-3375, -1331, -1, 1, 1331, 3375]], [[1, 1331, 3375]], [[-1, 1, 1331, 3375]], [[-3375, -1331]]]}
user: You're fed up about changing the version of your software manually. Instead, you will create a little script that will make it for you.

# Exercice

Create a function `nextVersion`, that will take a string in parameter, and will return a string containing the next version number.

For example:

# Rules

All numbers, except the first one, must be lower than 10: if there are, you have to set them to 0 and increment the next number in sequence.

You can assume all tests inputs to be valid.

Answer: {"fn_name": "next_version", "inputs": [["1.2.3"], ["0.9.9"], ["1"], ["1.2.3.4.5.6.7.8"], ["9.9"]], "outputs": [["1.2.4"], ["1.0.0"], ["2"], ["1.2.3.4.5.6.7.9"], ["10.0"]]}
user: Remember the game 2048?

The main part of this game is merging identical tiles in a row. 

* Implement a function that models the process of merging all of the tile values in a single row.  
* This function takes the array line as a parameter and returns a new array with the tile values from line slid towards the front of the array (index 0) and merged.
* A given tile can only merge once.
* Empty grid squares are represented as zeros.
* Your function should work on arrays containing arbitrary number of elements.


## Examples

```
merge([2,0,2,2])  -->  [4,2,0,0]
```

Another example with repeated merges: 

```
merge([4,4,8,16])  -->  [8,8,16,0]
merge([8,8,16,0])  -->  [16,16,0,0]
merge([16,16,0,0]) -->  [32,0,0,0]
```

Answer: {"fn_name": "merge", "inputs": [[[2, 0, 2, 2]], [[2, 0, 2, 4]], [[0, 0, 2, 2]], [[2, 2, 0, 0]], [[2, 2, 2, 2, 2]], [[8, 16, 16, 8]]], "outputs": [[[4, 2, 0, 0]], [[4, 4, 0, 0]], [[4, 0, 0, 0]], [[4, 0, 0, 0]], [[4, 4, 2, 0, 0]], [[8, 32, 8, 0]]]}
user: # Summation Of Primes

The sum of the primes below or equal to 10 is **2 + 3 + 5 + 7 = 17**. Find the sum of all the primes **_below or equal to the number passed in_**.

From Project Euler's [Problem #10](https://projecteuler.net/problem=10 "Project Euler - Problem 10").

Answer: {"fn_name": "summationOfPrimes", "inputs": [[5], [6], [7], [8], [9], [10], [20], [30], [40], [50], [100], [200], [300], [400], [500], [1000], [2000], [3000], [4000], [5000], [25000]], "outputs": [[10], [10], [17], [17], [17], [17], [77], [129], [197], [328], [1060], [4227], [8275], [13887], [21536], [76127], [277050], [593823], [1013507], [1548136], [32405717]]}
user: You work in the best consumer electronics corporation, and your boss wants to find out which three products generate the most revenue.
Given 3 lists of the same length like these:

* products: `["Computer", "Cell Phones", "Vacuum Cleaner"]`
* amounts: `[3, 24, 8]`
* prices: `[199, 299, 399]`


return the three product names with the highest revenue (`amount * price`).

**Note**: if multiple products have the same revenue, order them according to their original positions in the input list.

Answer: {"fn_name": "top3", "inputs": [[["Computer", "Cell Phones", "Vacuum Cleaner"], [3, 24, 8], [199, 299, 399]], [["Cell Phones", "Vacuum Cleaner", "Computer", "Autos", "Gold", "Fishing Rods", "Lego", " Speakers"], [5, 25, 2, 7, 10, 3, 2, 24], [51, 225, 22, 47, 510, 83, 82, 124]], [["Cell Phones", "Vacuum Cleaner", "Computer", "Autos", "Gold", "Fishing Rods", "Lego", " Speakers"], [0, 12, 24, 17, 19, 23, 120, 8], [9, 24, 29, 31, 51, 8, 120, 14]], [["Speakers", "Games", "Radios", "Drones", "Scooter"], [1, 1, 1, 1, 1], [10, 10, 10, 10, 10]]], "outputs": [[["Cell Phones", "Vacuum Cleaner", "Computer"]], [["Vacuum Cleaner", "Gold", " Speakers"]], [["Lego", "Gold", "Computer"]], [["Speakers", "Games", "Radios"]]]}
user: ### What is simplifying a square root?

If you have a number, like 80, for example, you would start by finding the greatest perfect square divisible by 80. In this case, that's 16. Find the square root of 16, and multiply it by 80 / 16. Answer = 4 √5. 

##### The above example:

![simplify_roots_example.png](https://i.postimg.cc/gjv2NwCm/simplify-roots-example.png)

### Task:

Your job is to write two functions, `simplify`, and `desimplify`, that simplify and desimplify square roots, respectively. (Desimplify isn't a word, but I couldn't come up with a better way to put it.) `simplify` will take an integer and return a string like "x sqrt y", and `desimplify` will take a string like "x sqrt y" and return an integer. For `simplify`, if a square root cannot be simplified, return "sqrt y". 

_Do not modify the input._

### Some examples:

```python
simplify(1)  #=> "1"
simplify(2)  #=> "sqrt 2"
simplify(3)  #=> "sqrt 3"
simplify(8)  #=> "2 sqrt 2"
simplify(15) #=> "sqrt 15"
simplify(16) #=> "4"
simplify(18) #=> "3 sqrt 2"
simplify(20) #=> "2 sqrt 5"
simplify(24) #=> "2 sqrt 6"
simplify(32) #=> "4 sqrt 2"

desimplify("1")        #=> 1
desimplify("sqrt 2")   #=> 2
desimplify("sqrt 3")   #=> 3
desimplify("2 sqrt 2") #=> 8
desimplify("sqrt 15")  #=> 15
desimplify("4")        #=> 16
desimplify("3 sqrt 2") #=> 18
desimplify("2 sqrt 5") #=> 20
desimplify("2 sqrt 6") #=> 24
desimplify("4 sqrt 2") #=> 32
```

Also check out my other creations — [Square Roots: Approximation](https://www.codewars.com/kata/square-roots-approximation), [Square and Cubic Factors](https://www.codewars.com/kata/square-and-cubic-factors), [Keep the Order](https://www.codewars.com/kata/keep-the-order), [Naming Files](https://www.codewars.com/kata/naming-files), [Elections: Weighted Average](https://www.codewars.com/kata/elections-weighted-average), [Identify Case](https://www.codewars.com/kata/identify-case), [Split Without Loss](https://www.codewars.com/kata/split-without-loss), [Adding Fractions](https://www.codewars.com/kata/adding-fractions),
[Random Integers](https://www.codewars.com/kata/random-integers), [Implement String#transpose](https://www.codewars.com/kata/implement-string-number-transpose), [Implement Array#transpose!](https://www.codewars.com/kata/implement-array-number-transpose), [Arrays and Procs #1](https://www.codewars.com/kata/arrays-and-procs-number-1), and [Arrays and Procs #2](https://www.codewars.com/kata/arrays-and-procs-number-2).

Answer: {"fn_name": "simplify", "inputs": [[1], [2], [3], [8], [15], [16], [18], [20], [24], [32], [4], [7], [9], [10], [12], [13], [14], [50], [80], [200]], "outputs": [["1"], ["sqrt 2"], ["sqrt 3"], ["2 sqrt 2"], ["sqrt 15"], ["4"], ["3 sqrt 2"], ["2 sqrt 5"], ["2 sqrt 6"], ["4 sqrt 2"], ["2"], ["sqrt 7"], ["3"], ["sqrt 10"], ["2 sqrt 3"], ["sqrt 13"], ["sqrt 14"], ["5 sqrt 2"], ["4 sqrt 5"], ["10 sqrt 2"]]}
user: Complete the function that returns an array of length `n`, starting with the given number `x` and the squares of the previous number. If `n` is negative or zero, return an empty array/list.

## Examples

```
2, 5  -->  [2, 4, 16, 256, 65536]
3, 3  -->  [3, 9, 81]
```

Answer: {"fn_name": "squares", "inputs": [[2, 5], [3, 3], [5, 3], [10, 4], [2, 0], [2, -4]], "outputs": [[[2, 4, 16, 256, 65536]], [[3, 9, 81]], [[5, 25, 625]], [[10, 100, 10000, 100000000]], [[]], [[]]]}
user: You get a "text" and have to shift the vowels by "n" positions to the right.
(Negative value for n should shift to the left.)
"Position" means the vowel's position if taken as one item in a list of all vowels within the string.
A shift by 1 would mean, that every vowel shifts to the place of the next vowel.
Shifting over the edges of the text should continue at the other edge.

Example:

text = "This is a test!"
n = 1
output = "Thes is i tast!"

text = "This is a test!"
n = 3
output = "This as e tist!"

If text is null or empty return exactly this value.
Vowels are "a,e,i,o,u".



Have fun coding it and please don't forget to vote and rank this kata! :-)

I have created other katas. Have a look if you like coding and challenges.

Answer: {"fn_name": "vowel_shift", "inputs": [[null, 0], ["", 0], ["This is a test!", 0], ["This is a test!", 1], ["This is a test!", 3], ["This is a test!", 4], ["This is a test!", -1], ["This is a test!", -5], ["Brrrr", 99], ["AEIOUaeiou", 1]], "outputs": [[null], [""], ["This is a test!"], ["Thes is i tast!"], ["This as e tist!"], ["This is a test!"], ["This as e tist!"], ["This as e tist!"], ["Brrrr"], ["uAEIOUaeio"]]}
user: An Arithmetic Progression is defined as one in which there is a constant difference between the consecutive terms of a given series of numbers. You are provided with consecutive elements of an Arithmetic Progression. There is however one hitch: exactly one term from the original series is missing from the set of numbers which have been given to you. The rest of the given series is the same as the original AP.  Find the missing term.  

You have to write a function that receives a list, list size will always be at least 3 numbers. The missing term will never be the first or last one.

## Example
```python
find_missing([1, 3, 5, 9, 11]) == 7
```

PS: This is a sample question of the facebook engineer challenge on interviewstreet.
I found it quite fun to solve on paper using math, derive the algo that way.
Have fun!

Answer: {"fn_name": "find_missing", "inputs": [[[1, 2, 3, 4, 6, 7, 8, 9]]], "outputs": [[5]]}
user: The Ulam sequence `U` is defined by `u0 = u`, `u1 = v`, with the general term `uN` for `N > 2` given by the least integer expressible uniquely as the sum of two distinct earlier terms. In other words, the next number is always the smallest, unique sum of any two previous terms.

Complete the function that creates an Ulam Sequence starting with the given `u0` and `u1`, and contains `n` terms.

## Example

The first 10 terms of the sequence `U(u0=1, u1=2)` are: 1, 2, 3, 4, 6, 8, 11, 13, 16, 18.

Let's see it in details:
* The first term after the initial 1, 2 is obviously 3, because 1 + 2 = 3
* The next term is 1 + 3 = 4 (we don't have to worry about 4 = 2 + 2 since it is a sum of a *single term* instead of *distinct terms*)
* 5 is not a member of the sequence since it is representable in two ways: 1 + 4 and 2 + 3
* 6 is a memeber, as 2 + 4 = 6
* etc.


Description Reference: http://mathworld.wolfram.com/UlamSequence.html

---

Performance version: https://www.codewars.com/kata/ulam-sequences-performance-edition

Answer: {"fn_name": "ulam_sequence", "inputs": [[1, 2, 5], [3, 4, 5], [5, 6, 8]], "outputs": [[[1, 2, 3, 4, 6]], [[3, 4, 7, 10, 11]], [[5, 6, 11, 16, 17, 21, 23, 26]]]}
user: Complete the function ```caffeineBuzz```, which takes a non-zero integer as it's one argument.

If the integer is divisible by 3, return the string ```"Java"```.

If the integer is divisible by 3 and divisible by 4, return the string ```"Coffee"```

If the integer is one of the above and is even, add ```"Script"``` to the end of the string.

Otherwise, return the string ```"mocha_missing!"```

```python
caffeineBuzz(1)   => "mocha_missing!"
caffeineBuzz(3)   => "Java"
caffeineBuzz(6)   => "JavaScript"
caffeineBuzz(12)  => "CoffeeScript"
```

Answer: {"fn_name": "caffeineBuzz", "inputs": [[1], [3], [6], [12]], "outputs": [["mocha_missing!"], ["Java"], ["JavaScript"], ["CoffeeScript"]]}
user: A palindrome is a word, phrase, number, or other sequence of characters which reads the same backward as forward. Examples of numerical palindromes are: 

2332
110011
54322345

For a given number ```num```, return its closest numerical palindrome which can either be smaller or larger than ```num```. If there are 2 possible values, the larger value should be returned. If ```num``` is a numerical palindrome itself, return it. 

For this kata, single digit numbers will NOT be considered numerical palindromes. 

Also, you know the drill - be sure to return "Not valid" if the input is not an integer or is less than 0.

```
palindrome(8) => 11
palindrome(281) => 282 
palindrome(1029) => 1001
palindrome(1221) => 1221
palindrome("1221") => "Not valid"

```

```Haskell
In Haskell the function should return a Maybe Int with Nothing for cases where the argument is less than zero.
```
Other Kata in this Series:
Numerical Palindrome #1
Numerical Palindrome #1.5
Numerical Palindrome #2
Numerical Palindrome #3
Numerical Palindrome #3.5
Numerical Palindrome #4
Numerical Palindrome #5

Answer: {"fn_name": "palindrome", "inputs": [[8], [281], [1029], [1221], ["BGHHGB"], ["11029"], [-1029]], "outputs": [[11], [282], [1001], [1221], ["Not valid"], ["Not valid"], ["Not valid"]]}
user: Ahoy Matey!

Welcome to the seven seas.

You are the captain of a pirate ship.

You are in battle against the royal navy.

You have cannons at the ready.... or are they?

Your task is to check if the gunners are loaded and ready, if they are: ```Fire!```

If they aren't ready: ```Shiver me timbers!```

Your gunners for each test case are 4 or less.

When you check if they are ready their answers are in a dictionary and will either be: ```aye``` or ```nay```

Firing with less than all gunners ready is non-optimum (this is not fire at will, this is fire by the captain's orders or walk the plank, dirty sea-dog!)

If all answers are 'aye' then Fire!
if one or more are 'nay' then Shiver me timbers!

Also, check out the new Pirates!! Kata:
https://www.codewars.com/kata/57e2d5f473aa6a476b0000fe

Answer: {"fn_name": "cannons_ready", "inputs": [[{"Joe": "nay", "Johnson": "nay", "Peter": "aye"}]], "outputs": [["Shiver me timbers!"]]}
user: # Task
 Dudka has `n` details. He must keep exactly 3 of them.

 To do this, he performs the following operations until he has only 3 details left:
```
He numbers them.
He keeps those with either odd or even numbers and throws the others away.```

 Dudka wants to know how many ways there are to get exactly 3 details. Your task is  to help him calculate it.

# Example

 For `n = 6`, the output should be `2`.
 ```
Dudka has 6 details, numbered 1 2 3 4 5 6. 
He can keep either details with numbers 1, 3, 5, 
or with numbers 2, 4, 6. 
Both options leave him with 3 details, 
so the answer is 2.```

 For `n = 7`, the output should be `1`.
 ```
Dudka has 7 details, numbered 1 2 3 4 5 6 7. 
He can keep either details 1 3 5 7, or details 2 4 6. 
If he keeps details 1 3 5 7 , 
he won't be able to get 3 details in the future, 
because at the next step he will number them 1 2 3 4 
and will have to keep either details 1 3, or 2 4, 
only two details anyway. 
That's why he must keep details 2 4 6 at the first step, 
so the answer is 1.```

# Input/Output


 - `[input]` integer `n`

  `3 ≤ n ≤ 10^9`


 - `[output]` an integer

  The number of ways to get exactly 3 details.

Answer: {"fn_name": "three_details", "inputs": [[3], [6], [4], [10], [15]], "outputs": [[1], [2], [0], [2], [1]]}
user: Write a function that takes a positive integer n, sums all the cubed values from 1 to n, and returns that sum.

Assume that the input n will always be a positive integer.

Examples:

```python
sum_cubes(2)
> 9 
# sum of the cubes of 1 and 2 is 1 + 8
```

Answer: {"fn_name": "sum_cubes", "inputs": [[1], [2], [3], [4], [10], [123]], "outputs": [[1], [9], [36], [100], [3025], [58155876]]}
user: ## Task

Generate a sorted list of all possible IP addresses in a network.

For a subnet that is not a valid IPv4 network return `None`.

## Examples
```
ipsubnet2list("192.168.1.0/31") == ["192.168.1.0", "192.168.1.1"]
ipsubnet2list("213.256.46.160/28") == None
```

Answer: {"fn_name": "ipsubnet2list", "inputs": [["192.168.1.0/31"], ["195.20.15.0/28"], ["174.0.153.152/29"], ["213.192.46.160/28"], ["213.256.46.160/28"]], "outputs": [[["192.168.1.0", "192.168.1.1"]], [["195.20.15.1", "195.20.15.2", "195.20.15.3", "195.20.15.4", "195.20.15.5", "195.20.15.6", "195.20.15.7", "195.20.15.8", "195.20.15.9", "195.20.15.10", "195.20.15.11", "195.20.15.12", "195.20.15.13", "195.20.15.14"]], [["174.0.153.153", "174.0.153.154", "174.0.153.155", "174.0.153.156", "174.0.153.157", "174.0.153.158"]], [["213.192.46.161", "213.192.46.162", "213.192.46.163", "213.192.46.164", "213.192.46.165", "213.192.46.166", "213.192.46.167", "213.192.46.168", "213.192.46.169", "213.192.46.170", "213.192.46.171", "213.192.46.172", "213.192.46.173", "213.192.46.174"]], [null]]}
user: You have a two-dimensional list in the following format:

```python
data = [[2, 5], [3, 4], [8, 7]]
```

Each sub-list contains two items, and each item in the sub-lists is an integer.

Write a function `process_data()` that processes each sub-list like so:

 * `[2, 5]` --> `2 - 5` --> `-3`
 * `[3, 4]` --> `3 - 4` --> `-1`
 * `[8, 7]` --> `8 - 7` --> `1`
 
and then returns the product of all the processed sub-lists: `-3 * -1 * 1` --> `3`.

For input, you can trust that neither the main list nor the sublists will be empty.

Answer: {"fn_name": "process_data", "inputs": [[[[2, 5], [3, 4], [8, 7]]], [[[2, 9], [2, 4], [7, 5]]], [[[5, 4], [6, 4]]], [[[2, 1], [5, 3], [7, 4], [10, 6]]]], "outputs": [[3], [28], [2], [24]]}
user: You are going to be given a word. Your job will be to make sure that each character in that word has the exact same number of occurrences. You will return `true` if it is valid, or `false` if it is not.

For example:

`"abcabc"` is a valid word because `'a'` appears twice, `'b'` appears twice, and`'c'` appears twice.  
`"abcabcd"` is **NOT** a valid word because `'a'` appears twice, `'b'` appears twice, `'c'` appears twice, but `'d'` only appears once!  
`"123abc!"` is a valid word because all of the characters only appear once in the word.

For this kata, capitals are considered the same as lowercase letters. Therefore: `'A' == 'a'` .

#Input 
A string (no spaces) containing `[a-z],[A-Z],[0-9]` and common symbols. The length will be `0 < string < 100`.

#Output
`true` if the word is a valid word, or `false` if the word is not valid.

Answer: {"fn_name": "validate_word", "inputs": [["abcabc"], ["Abcabc"], ["AbcabcC"], ["AbcCBa"], ["pippi"], ["?!?!?!"], ["abc123"], ["abcabcd"], ["abc!abc!"], ["abc:abc"]], "outputs": [[true], [true], [false], [true], [false], [true], [true], [false], [true], [false]]}
user: Write a function that takes one or more arrays and returns a new array of unique values in the order of the original provided arrays.

In other words, all values present from all arrays should be included in their original order, but with no duplicates in the final array.

The unique numbers should be sorted by their original order, but the final array should not be sorted in numerical order.

Check the assertion tests for examples.

*Courtesy of [FreeCodeCamp](https://www.freecodecamp.com/challenges/sorted-union), a great place to learn web-dev; plus, its founder Quincy Larson is pretty cool and amicable. I made the original one slightly more tricky ;)*

Answer: {"fn_name": "unite_unique", "inputs": [[[1, 2], [3, 4]], [[1, 3, 2], [5, 2, 1, 4], [2, 1]], [[4, 3, 2, 2]], [[4, "a", 2], []], [[], [4, "a", 2]], [[], [4, "a", 2], []], [[]], [[], []], [[], [1, 2]], [[], [1, 2, 1, 2], [2, 1, 1, 2, 1]]], "outputs": [[[1, 2, 3, 4]], [[1, 3, 2, 5, 4]], [[4, 3, 2]], [[4, "a", 2]], [[4, "a", 2]], [[4, "a", 2]], [[]], [[]], [[1, 2]], [[1, 2]]]}
user: Brief
=====
Sometimes we need information about the list/arrays we're dealing with. You'll have to write such a function in this kata. Your function must provide the following informations:  

* Length of the array
* Number of integer items in the array
* Number of float items in the array
* Number of string character items in the array
* Number of whitespace items in the array
   
The informations will be supplied in arrays that are items of another array. Like below:

`Output array = [[array length],[no of integer items],[no of float items],[no of string chars items],[no of whitespace items]]`

Added Difficulty
----------------
If any item count in the array is zero, you'll have to replace it with a **None/nil/null** value (according to the language). And of course, if the array is empty then return **'Nothing in the array!**. For the sake of simplicity, let's just suppose that there are no nested structures.   
Output
======
If you're head is spinning (just kidding!) then these examples will help you out-   
```
   
array_info([1,2,3.33,4,5.01,'bass','kick',' '])--------->[[8],[3],[2],[2],[1]]    
array_info([0.001,2,' '])------------------------------>[[3],[1],[1],[None],[1]]   
array_info([])----------------------------------------->'Nothing in the array!'
array_info([' '])-------------------------------------->[[1],[None],[None],[None],[1]]
  
  ```    
Remarks
-------
The input will always be arrays/lists. So no need to check the inputs.    
Hint
====
See the tags!!!   
Now let's get going !

Answer: {"fn_name": "array_info", "inputs": [[[1, 2, 3.33, 4, 5.01, "bass", "kick", " "]], [[0.001, 2, " "]], [[]], [[" "]], [[" ", " "]], [["jazz"]], [[4]], [[3.1416]], [[11, 22, 33.33, 44.44, "hasan", "ahmad"]], [["a", "b", "c", "d", " "]], [[1, 2, 3, 4, 5, 6, 7, 8, 9]], [[1, 2.23, "string", " "]]], "outputs": [[[[8], [3], [2], [2], [1]]], [[[3], [1], [1], [null], [1]]], ["Nothing in the array!"], [[[1], [null], [null], [null], [1]]], [[[2], [null], [null], [null], [2]]], [[[1], [null], [null], [1], [null]]], [[[1], [1], [null], [null], [null]]], [[[1], [null], [1], [null], [null]]], [[[6], [2], [2], [2], [null]]], [[[5], [null], [null], [4], [1]]], [[[9], [9], [null], [null], [null]]], [[[4], [1], [1], [1], [1]]]]}