meetforever/GRPO_CL huggingface dataset:
user: Given a string as input, move all of its vowels to the end of the string, in the same order as they were before.

Vowels are (in this kata): `a, e, i, o, u`

Note: all provided input strings are lowercase.

## Examples
```python
"day"    ==>  "dya"
"apple"  ==>  "pplae"
```

Answer: {"fn_name": "move_vowels", "inputs": [["day"], ["apple"], ["peace"], ["maker"], ["programming"], ["javascript"], ["python"], ["ruby"], ["haskell"], ["clojure"], ["csharp"]], "outputs": [["dya"], ["pplae"], ["pceae"], ["mkrae"], ["prgrmmngoai"], ["jvscrptaai"], ["pythno"], ["rbyu"], ["hskllae"], ["cljroue"], ["cshrpa"]]}
user: Your task is to construct a building which will be a pile of n cubes.
The cube at the bottom will have a volume of n^3, the cube above 
will have  volume of (n-1)^3 and so on until the top which will have a volume of 1^3.

You are given the total volume m of the building.
Being given m can you find the number n of cubes you will have to build?

The parameter of the function findNb `(find_nb, find-nb, findNb)` will be an integer m
and you have to return the integer n such as
n^3 + (n-1)^3 + ... + 1^3 = m
if such a n exists or -1 if there is no such n.

## Examples:
```
findNb(1071225) --> 45
findNb(91716553919377) --> -1
```

Answer: {"fn_name": "find_nb", "inputs": [[4183059834009], [24723578342962], [135440716410000], [40539911473216], [26825883955641], [41364076483082], [9541025211025], [112668204662785], [79172108332642], [1788719004901], [131443152397956], [1801879360282], [18262169777476], [11988186060816], [826691919076], [36099801072722], [171814395026], [637148782657], [6759306226], [33506766981009], [108806345136785], [14601798712901], [56454575667876], [603544088161], [21494785321], [1025292944081385001], [10252519345963644753025], [10252519345963644753026], [102525193459636447530260], [4], [16]], "outputs": [[2022], [-1], [4824], [3568], [3218], [-1], [2485], [-1], [-1], [-1], [4788], [-1], [2923], [2631], [1348], [-1], [-1], [-1], [-1], [3402], [-1], [-1], [3876], [1246], [541], [45001], [450010], [-1], [-1], [-1], [-1]]}
user: > [Run-length encoding](https://en.wikipedia.org/w/index.php?title=Run-length_encoding) (RLE) is a very simple form of data compression in which runs of data (that is, sequences in which the same data value occurs in many consecutive data elements) are stored as a single data value and count, rather than as the original run. Wikipedia

## Task

Your task is to write such a run-length encoding. For a given string, return a list (or array) of pairs (or arrays) 
[
 (i1, s1),
 (i2, s2),
 …,
 (in, sn)
], such that one can reconstruct the original string by replicating the character sx ix times and concatening all those strings. Your run-length encoding should be minimal, ie. for all i the values si and si+1 should differ.

## Examples

As the article states, RLE is a _very_ simple form of data compression. It's only suitable for runs of data, as one can see in the following example:

```python
run_length_encoding("hello world!")
 //=>      [[1,'h'], [1,'e'], [2,'l'], [1,'o'], [1,' '], [1,'w'], [1,'o'], [1,'r'], [1,'l'], [1,'d'], [1,'!']]
```

It's very effective if the same data value occurs in many consecutive data elements:
```python
run_length_encoding("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbb")
# => [[34,'a'], [3,'b']]
```

Answer: {"fn_name": "run_length_encoding", "inputs": [[""], ["abc"], ["aab"], ["hello world!"], ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbb"]], "outputs": [[[]], [[[1, "a"], [1, "b"], [1, "c"]]], [[[2, "a"], [1, "b"]]], [[[1, "h"], [1, "e"], [2, "l"], [1, "o"], [1, " "], [1, "w"], [1, "o"], [1, "r"], [1, "l"], [1, "d"], [1, "!"]]], [[[34, "a"], [3, "b"]]]]}
user: Timmy & Sarah think they are in love, but around where they live, they will only know once they pick a flower each. If one of the flowers has an even number of petals and the other has an odd number of petals it means they are in love. 

Write a function that will take the number of petals of each flower and return true if they are in love and false if they aren't.

Answer: {"fn_name": "lovefunc", "inputs": [[1, 4], [2, 2], [0, 1], [0, 0]], "outputs": [[true], [false], [true], [false]]}
user: This kata is based on a [variation](https://www.codewars.com/kata/happy-numbers-5) of *Happy Numbers* by TySlothrop. It is advisable to complete it first to grasp the idea and then move on to this one.

___

Hello, my dear friend, and welcome to another *Happy Numbers* kata! What? You're not interested in them anymore? They are all the same? But what if I say that this one is a *performance version*...  

___

# Your task:

Write a function `performant_numbers` which takes a number `n` as an argument and returns a list of all *happy numbers* from `1` to `n` inclusive. For example:

```
performant_numbers(10)   =>  [1, 7, 10]
performant_numbers(50)   =>  [1, 7, 10, 13, 19, 23, 28, 31, 32, 44, 49]
performant_numbers(100)  =>  [1, 7, 10, 13, 19, 23, 28, 31, 32, 44, 49, 68, 70, 79, 82, 86, 91, 94, 97, 100]
```

# Test suite:

* `5000` tests with number `n` being up to `300000`
* The reference solution takes around `4.9` seconds to calculate the result
* you are not allowed to hardcode the sequence: you'll have to compute it (max length of the code: 1700 characters)

___

Will you take up the challenge?

Answer: {"fn_name": "performant_numbers", "inputs": [[10], [50], [100]], "outputs": [[[1, 7, 10]], [[1, 7, 10, 13, 19, 23, 28, 31, 32, 44, 49]], [[1, 7, 10, 13, 19, 23, 28, 31, 32, 44, 49, 68, 70, 79, 82, 86, 91, 94, 97, 100]]]}
user: In the drawing below we have a part of the Pascal's triangle, lines are numbered from **zero** (top).
The left diagonal in pale blue with only numbers equal to 1 is diagonal **zero**, then in dark green 
(1, 2, 3, 4, 5, 6, 7) is diagonal 1, then in pale green (1, 3, 6, 10, 15, 21) is
diagonal 2 and so on.

We want to calculate the sum of the binomial coefficients on a given diagonal.
The sum on diagonal 0 is 8 (we'll write it S(7, 0), 7 is the number of the line where we start, 
0 is the number of the diagonal). In the same way S(7, 1) is 28, S(7, 2) is 56.

Can you write a program which calculate S(n, p) where n is the line where we start and p 
is the number of the diagonal?

The function will take n and p (with: `n >= p >= 0`) as parameters and will return the sum.

## Examples:
```
diagonal(20, 3) => 5985
diagonal(20, 4) => 20349
```
## Hint:
When following a diagonal from top to bottom have a look at the numbers on the diagonal at its right.

## Ref:
http://mathworld.wolfram.com/BinomialCoefficient.html

![alternative text](http://i.imgur.com/eUGaNvIm.jpg)

Answer: {"fn_name": "diagonal", "inputs": [[20, 3], [20, 4], [20, 5], [20, 15], [100, 0], [1291, 5], [1291, 56], [1291, 1234], [12910, 15], [129100, 5]], "outputs": [[5985], [20349], [54264], [20349], [101], [6385476296235036], [15478983586799578981605681450735426444083026237083755223526535252775423299626083333014485638841019200], [15478983586799578981605681450735426444083026237083755223526535252775423299626083333014485638841019200], [28229317689300804466421113746024782373551037613710510], [6429758786797926366807779220]]}
user: In this kata, your task is to identify the pattern underlying a sequence of numbers. For example, if the sequence is [1, 2, 3, 4, 5], then the pattern is [1], since each number in the sequence is equal to the number preceding it, plus 1. See the test cases for more examples.

A few more rules :

pattern may contain negative numbers.
sequence will always be made of a whole number of repetitions of the pattern.
Your answer must correspond to the shortest form of the pattern, e.g. if the pattern is [1], then [1, 1, 1, 1] will not be considered a correct answer.

Answer: {"fn_name": "find_pattern", "inputs": [[[1, 2, 3, 4, 5]], [[1, 2, 3, 4, 5, 4, 3, 2, 1, 2, 3, 4, 5, 4, 3, 2, 1]], [[1, 5, 2, 3, 1, 5, 2, 3, 1]], [[1, 5, 4, 8, 7, 11, 10, 14, 13]], [[0, 1]], [[4, 5, 6, 8, 3, 4, 5, 6, 8, 3, 4, 5, 6, 8, 3, 4]], [[4, 5, 3, -2, -1, 0, -2, -7, -6]], [[4, 5, 6, 5, 3, 2, 3, 4, 5, 6, 5, 3, 2, 3, 4, 5, 6, 5, 3, 2, 3, 4]], [[-67, -66, -64, -61, -57, -52, -46, -39, -31, -22, -12, -2, 7, 15, 22, 28, 33, 37, 40, 42, 43]], [[4, 5, 7, 6, 4, 2, 3, 5, 4, 2, 3, 5, 4, 2, 0, 1, 3, 2, 0, 1, 3, 2, 0, -2, -1, 1, 0, -2]]], "outputs": [[[1]], [[1, 1, 1, 1, -1, -1, -1, -1]], [[4, -3, 1, -2]], [[4, -1]], [[1]], [[1, 1, 2, -5, 1]], [[1, -2, -5, 1]], [[1, 1, -1, -2, -1, 1, 1]], [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]], [[1, 2, -1, -2, -2, 1, 2, -1, -2]]]}
user: Not considering number 1, the integer 153 is the first integer having this property:
the sum of the third-power of each of its digits  is equal to 153. Take a look:
153 = 1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153

The next number that experiments this particular behaviour is 370 with the same power.

Write the function `eq_sum_powdig()`, that finds the numbers below a given upper limit `hMax` that fulfill this property but with different exponents as a power for the digits.

eq_sum_powdig(hMax, exp): ----> sequence of numbers (sorted list) (Number one should not be considered).

Let's see some cases:
```python
eq_sum_powdig(100, 2) ----> []

eq_sum_powdig(1000, 2) ----> []

eq_sum_powdig(200, 3) ----> [153]

eq_sum_powdig(370, 3) ----> [153, 370]
```
Enjoy it !!

Answer: {"fn_name": "eq_sum_powdig", "inputs": [[100, 2], [1000, 2], [2000, 2], [200, 3], [370, 3], [400, 3], [500, 3], [1000, 3], [1500, 3]], "outputs": [[[]], [[]], [[]], [[153]], [[153, 370]], [[153, 370, 371]], [[153, 370, 371, 407]], [[153, 370, 371, 407]], [[153, 370, 371, 407]]]}
user: *`This kata is a tribute/fanwork to the TV-show: Supernatural`*


Balls!

Those wayward Winchester boys are in trouble again, hunting something down in New Orleans.
You are Bobby Singer, you know how "idjits" they can be, so you have to prepare.
They will call you any minute with the race of the thing, and you want to answer as soon as possible. By answer, I mean: tell them how to kill, or fight it.

You have something like a database (more like drunken doodling) to help them:

- werewolf           : Silver knife or bullet to the heart
- vampire            : Behead it with a machete
- wendigo            : Burn it to death
- shapeshifter       : Silver knife or bullet to the heart
- angel              : Use the angelic blade
- demon              : Use Ruby's knife, or some Jesus-juice
- ghost              : Salt and iron, and don't forget to burn the corpse
- dragon             : You have to find the excalibur for that
- djinn              : Stab it with silver knife dipped in a lamb's blood 
- pagan god          : It depends on which one it is
- leviathan          : Use some Borax, then kill Dick
- ghoul              : Behead it
- jefferson starship : Behead it with a silver blade
- reaper             : If it's nasty, you should gank who controls it
- rugaru             : Burn it alive
- skinwalker         : A silver bullet will do it
- phoenix            : Use the colt
- witch              : They are humans
- else               : I have friggin no idea yet

You can access the database as `drunkenDoodling`/`drunken_doodling`/`DrunkenDoodling` depending on your language.

---

So a call would go down like this:

The guys call you:
```bob('rugaru')```

...and you reply (return) with the info, and your signature saying of yours!
```Burn it alive, idjits!```

Answer: {"fn_name": "bob", "inputs": [["vampire"], ["pagan god"], ["werepuppy"]], "outputs": [["Behead it with a machete, idjits!"], ["It depends on which one it is, idjits!"], ["I have friggin no idea yet, idjits!"]]}
user: An onion array is an array that satisfies the following condition for all values of `j` and `k`:

If all of the following are `true`:

* `j >= 0`
* `k >= 0`
* `j + k = array.length - 1`
* `j != k`
  
then:

* `a[j] + a[k] <= 10`

### Examples:

```
[1, 2, 19, 4, 5]   =>  true  (as 1+5 <= 10 and 2+4 <= 10)
[1, 2, 19, 4, 10]  =>  false (as 1+10 > 10)
```

Write a function named `isOnionArray`/`IsOnionArray`/`is_onion_array()` that returns `true` if its argument is an onion array and returns `false` if it is not.

~~~if:php
Your solution should at least be moderately efficient.  Make sure you don't do any unnecessary looping ;)
~~~

Answer: {"fn_name": "is_onion_array", "inputs": [[[6, 0, 4]], [[1, 1, 15, 10, -1]]], "outputs": [[true], [false]]}
user: ## Fixed xor

Write a function that takes two hex strings as input and XORs them against each other. If the strings are different lengths the output should be the length of the shortest string.

Hint: The strings would first need to be converted to binary to be XOR'd. 

## Note:
If the two strings are of different lengths, the output string should be the same length as the smallest string. This means that the longer string will be cut down to the same size as the smaller string, then xor'd

### Further help

More information on the XOR operation can be found here https://www.khanacademy.org/computing/computer-science/cryptography/ciphers/a/xor-bitwise-operation

More information of the binary and hex bases can be found here https://www.khanacademy.org/math/algebra-home/alg-intro-to-algebra/algebra-alternate-number-bases/v/number-systems-introduction

Examples:

```python
fixed_xor("ab3f", "ac") == "07"
fixed_xor("aadf", "bce2") == "163d"
fixed_xor("1c0111001f010100061a024b53535009181c", "686974207468652062756c6c277320657965") == "746865206b696420646f6e277420706c6179"
```

Answer: {"fn_name": "fixed_xor", "inputs": [["1c0111001f010100061a024b53535009181c", "686974207468652062756c6c277320657965"], ["aadf", "bce2"], ["ab3f", "ac"], ["", ""], ["c611d9bdd9de38b9eb", "23a0745505d4d25494"], ["7d1e875da9d5e89b54c7eaf", "3541599be591709795cebd5"], ["785a6677b3e52f0e7", "a8d97da7441"], ["6cbd75511e7f750c6827", "1753547c813bfcd"]], "outputs": [["746865206b696420646f6e277420706c6179"], ["163d"], ["07"], [""], ["e5b1ade8dc0aeaed7f"], ["485fdec64c44980cc10957a"], ["d0831bd0f7f"], ["7bee212d9f4489d"]]}
user: In some ranking people collects points. The challenge is sort by points and calulate position for every person. But remember if two or more persons have same number of points, they should have same position number and sorted by name (name is unique).

For example:
Input structure:

Output should be:

Answer: {"fn_name": "ranking", "inputs": [[[]]], "outputs": [[[]]]}
user: A country has coins with denominations
```python
coins_list = d1 < d2 < · · · < dn.
```
You want to make change for n cents, using the smallest number of coins.

```python
# Example 1: U.S. coins
d1 = 1 d2 = 5 d3 = 10 d4 = 25

## Optimal change for 37 cents – 1 quarter, 1 dime, 2 pennies.

# Example 2: Alien Planet Z coins
Z_coin_a = 1 Z_coin_b = 3 Z_coin_c = 4

## Optimal change for 6 cents - 2 Z_coin_b's
```

Write a function that will take a list of coin denominations and a desired amount and provide the least amount of coins needed.

Answer: {"fn_name": "loose_change", "inputs": [[[1, 5, 10, 25], 37], [[1, 3, 4], 6], [[25, 5, 10, 1, 21], 63], [[1, 4, 5, 10], 8], [[1, 2, 5, 10, 20, 50, 100, 200], 93]], "outputs": [[4], [2], [3], [2], [5]]}
user: # Task
 A ciphertext alphabet is obtained from the plaintext alphabet by means of rearranging some characters. For example "bacdef...xyz" will be a simple ciphertext alphabet where a and b are rearranged.

 A substitution cipher is a method of encoding where each letter of the plaintext alphabet is replaced with the corresponding (i.e. having the same index) letter of some ciphertext alphabet.

 Given two strings, check whether it is possible to obtain them from each other using some (possibly, different) substitution ciphers.

# Example

 For `string1 = "aacb" and string2 = "aabc"`, the output should be `true`

 Any ciphertext alphabet that starts with acb... would make this transformation possible.

 For `string1 = "aa" and string2 = "bc"`, the output should be `false`

# Input/Output


 - `[input]` string `string1`

    A string consisting of lowercase characters.

    Constraints: `1 ≤ string1.length ≤ 10`.


 - `[input]` string `string2`

    A string consisting of lowercase characters of the same length as string1.

    Constraints: `string2.length = string1.length`.


 - `[output]` a boolean value

Answer: {"fn_name": "is_substitution_cipher", "inputs": [["aacb", "aabc"], ["aa", "bc"], ["aaxxaaz", "aazzaay"], ["aaxyaa", "aazzaa"], ["aazzaa", "aaxyaa"], ["jpeuizmi", "mxxcwriq"]], "outputs": [[true], [false], [true], [false], [false], [false]]}
user: A group of friends (n >= 2) have reunited for a get-together after 
a very long time. 

They agree that they will make presentations on holiday destinations 
or expeditions they have been to only if it satisfies **one simple rule**: 
> the holiday/journey being presented must have been visited _only_ by the presenter and no one else from the audience.

Write a program to output the presentation agenda, including the
presenter and their respective presentation titles. 

---
### EXAMPLES

```python
presentation_agenda([
    {'person': 'Abe', 'dest': ['London', 'Dubai']},
    {'person': 'Bond', 'dest': ['Melbourne', 'Dubai']}
]) == [{'person': 'Abe', 'dest': ['London']},
       {'person': 'Bond', 'dest': ['Melbourne']}]

presentation_agenda([
    {'person': 'Abe', 'dest': ['Dubai']},
    {'person': 'Brad', 'dest': ['Dubai']}
]) == []

presentation_agenda([
    {'person': 'Abe', 'dest': ['London', 'Dubai']},
    {'person': 'Bond', 'dest': ['Melbourne', 'Dubai']},
    {'person': 'Carrie', 'dest': ['Melbourne']},
    {'person': 'Damu', 'dest': ['Melbourne', 'Dubai', 'Paris']}
]) == [{'person': 'Abe',  'dest': ['London']},
       {'person': 'Damu', 'dest': ['Paris']}]

```

Answer: {"fn_name": "presentation_agenda", "inputs": [[[{"person": "Abe", "dest": ["London", "Dubai"]}, {"person": "Bond", "dest": ["Melbourne", "Dubai"]}]], [[{"person": "Abe", "dest": ["Dubai"]}, {"person": "Brad", "dest": ["Dubai"]}]], [[{"person": "Abe", "dest": ["London", "Dubai"]}, {"person": "Bond", "dest": ["Melbourne", "Dubai"]}, {"person": "Carrie", "dest": ["Melbourne"]}, {"person": "Damu", "dest": ["Melbourne", "Dubai", "Paris"]}]], [[{"person": "John", "dest": ["Ahmedabad", "Baghdad", "Delhi", "Dhaka"]}, {"person": "Mickeal Angelo", "dest": ["Ahmedabad", "Baghdad", "Delhi", "Hong Kong", "Istanbul", "Jakarta", "Mumbai", "Santiago", "Singapore"]}, {"person": "Gandalf", "dest": ["Chennai", "Hong Kong"]}]]], "outputs": [[[{"person": "Abe", "dest": ["London"]}, {"person": "Bond", "dest": ["Melbourne"]}]], [[]], [[{"person": "Abe", "dest": ["London"]}, {"person": "Damu", "dest": ["Paris"]}]], [[{"person": "John", "dest": ["Dhaka"]}, {"person": "Mickeal Angelo", "dest": ["Istanbul", "Jakarta", "Mumbai", "Santiago", "Singapore"]}, {"person": "Gandalf", "dest": ["Chennai"]}]]]}
user: Define a "prime prime" number to be a rational number written as one prime number over another prime number: `primeA / primeB` (e.g. `7/31`)

Given a whole number `N`, generate the number of "prime prime" rational numbers less than 1, using only prime numbers between `0` and `N` (non inclusive).

Return the count of these "prime primes", and the integer part  of their sum.

## Example

```python
N = 6

# The "prime primes" less than 1 are:
2/3, 2/5, 3/5               # count: 3

2/3 + 2/5 + 3/5 = 1.6667    # integer part: 1

Thus, the function should return 3 and 1.
```

Answer: {"fn_name": "prime_primes", "inputs": [[6], [4], [10], [65], [0], [1000], [666]], "outputs": [[[3, 1]], [[1, 0]], [[6, 3]], [[153, 63]], [[0, 0]], [[14028, 6266]], [[7260, 3213]]]}
user: An array is called `zero-balanced` if its elements sum to `0` and for each positive element `n`, there exists another element that is the negative of `n`. Write a function named `ìsZeroBalanced` that returns `true` if its argument is `zero-balanced` array, else return `false`. Note that an `empty array` will not sum to `zero`.

Answer: {"fn_name": "is_zero_balanced", "inputs": [[[3]], [[-3]], [[0, 0, 0, 0, 0, 0]], [[0, 1, -1]], [[]], [[3, -2, -1]], [[0]], [[1, 1, -2]], [[-1, 1, -2, 2, -2, -2, -4, 4]], [[0, 0, 0, 0, 0]]], "outputs": [[false], [false], [true], [true], [false], [false], [true], [false], [false], [true]]}
user: A core idea of several left-wing ideologies is that the wealthiest should *support* the poorest, no matter what and that is exactly what you are called to do using this kata (which, on a side note, was born out of the necessity to redistribute the width of `div`s into a given container).

You will be given two parameters, `population` and `minimum`: your goal is to give to each one according to his own needs (which we assume to be equal to `minimum` for everyone, no matter what), taking from the richest (bigger numbers) first.

For example, assuming a population `[2,3,5,15,75]` and `5` as a minimum, the expected result should be `[5,5,5,15,70]`. Let's punish those filthy capitalists, as we all know that being rich has to be somehow a fault and a shame!

If you happen to have few people as the richest, just take from the ones with the lowest index (the closest to the left, in few words) in the array first, on a 1:1 based heroic proletarian redistribution, until everyone is satisfied.

To clarify this rule, assuming a population `[2,3,5,45,45]` and `5` as `minimum`, the expected result should be `[5,5,5,42,43]`.

If you want to see it in steps, consider removing `minimum` from every member of the population, then iteratively (or recursively) adding 1 to the poorest while removing 1 from the richest. Pick the element most at left if more elements exist with the same level of minimal poverty, as they are certainly even more aligned with the party will than other poor people; similarly, it is ok to take from the richest one on the left first, so they can learn their lesson and be more kind, possibly giving more *gifts* to the inspectors of the State!

In steps:
```
[ 2, 3, 5,45,45] becomes
[-3,-2, 0,40,40] that then becomes
[-2,-2, 0,39,40] that then becomes
[-1,-2, 0,39,39] that then becomes
[-1,-1, 0,38,39] that then becomes
[ 0,-1, 0,38,38] that then becomes
[ 0, 0, 0,37,38] that then finally becomes (adding the minimum again, as no value is no longer under the poverty threshold
[ 5, 5, 5,42,43]
```

If giving `minimum` is unfeasable with the current resources (as it often comes to be the case in socialist communities...), for example if the above starting population had set a goal of giving anyone at least `30`, just return an empty array `[]`.

Answer: {"fn_name": "socialist_distribution", "inputs": [[[2, 3, 5, 15, 75], 5], [[2, 3, 5, 15, 75], 20], [[2, 3, 5, 45, 45], 5], [[2, 3, 5, 45, 45], 30], [[24, 48, 22, 19, 37], 30]], "outputs": [[[5, 5, 5, 15, 70]], [[20, 20, 20, 20, 20]], [[5, 5, 5, 42, 43]], [[]], [[30, 30, 30, 30, 30]]]}
user: In this kata, we want to discover a small property of numbers. 
We say that a number is a **dd** number if it contains d occurences of a digit d, (d is in [1,9]).

## Examples

* 664444309 is a **dd** number, as it contains 4 occurences of the number 4
* 30313, 122 are **dd** numbers as they respectively contain 3 occurences of the number 3, and (1 occurence of the number 1 AND 2 occurences of the number 2)
* 123109, 0, 56542 are not **dd** numbers

## Task 

Your task is to implement a function called `is_dd` (`isDd` in javascript) that takes a **positive** number (type depends on the language) and returns a boolean corresponding to whether the number is a **dd** number or not.

Answer: {"fn_name": "is_dd", "inputs": [[664444309], [122], [30313], [5023011], [9081231]], "outputs": [[true], [true], [true], [false], [false]]}