meetforever/GRPO_CL huggingface dataset:
user: Your task is to get Zodiac Sign using input ```day``` and ```month```.

For exapmle: 

```python
get_zodiac_sign(1,5) => 'Taurus'
get_zodiac_sign(10,10) => 'Libra'
```

Correct answers are (preloaded): 
```python
SIGNS = ['Capricorn', 'Aquarius', 'Pisces', 'Aries', 'Taurus', 'Gemini', 'Cancer', 'Leo', 'Virgo', 'Libra', 'Scorpio', 'Sagittarius']
```

P.S. Each argument is correct integer number.

WESTERN ASTROLOGY STAR SIGN DATES

* Aries (March 21-April 19)
* Taurus (April 20-May 20)
* Gemini (May 21-June 20)
* Cancer (June 21-July 22)
* Leo (July 23-August 22)
* Virgo (August 23-September 22)
* Libra (September 23-October 22)
* Scorpio (October 23-November 21)
* Sagittarius (November 22-December 21)
* Capricorn (December 22-January 19)
* Aquarius (January 20 to February 18)
* Pisces (February 19 to March 20)

Answer: {"fn_name": "get_zodiac_sign", "inputs": [[10, 10], [1, 5], [6, 9], [25, 11]], "outputs": [["Libra"], ["Taurus"], ["Virgo"], ["Sagittarius"]]}
user: This kata is inspired on the problem #50 of the Project Euler. 

The prime ``` 41```  is the result of the sum of many consecutive primes.

In fact, ``` 2 + 3 + 5 + 7 + 11 + 13 = 41 , (6 addens)   ``` 

Furthermore, the prime ``` 41```  is the prime below ``` 100 (val_max)```  that has the longest chain of consecutive prime addens.

The prime with longest chain of addens for ```val_max = 500``` is ```499``` with ```17``` addens. 

In fact:
```3+5+7+11+13+17+19+23+29+31+37+41+43+47+53+59+61= 499```

Find the function ```prime_maxlength_chain()```(primeMaxlengthChain() javascript), that receives an argument ```val_max```, the upper limit, all the found primes should be less than ```val_max``` and outputs this found prime.

Let's see some cases:
```python
prime_maxlength_chain(100) == [41]
prime_maxlength_chain(500) == [499]
```
If we have more than one prime with these features, the function should output an array with the found primes sorted.
```python
prime_maxlength_chain(499) == [379, 491]
```
Random Tests for `val_max` (`valMax`)
```
100 ≤ val_max ≤ 500.000
```
Enjoy it!

Answer: {"fn_name": "prime_maxlength_chain", "inputs": [[100], [200], [500], [1000]], "outputs": [[[41]], [[197]], [[499]], [[953]]]}
user: Write a simple regex to validate a username. Allowed characters are:

- lowercase letters,
- numbers,
- underscore

Length should be between 4 and 16 characters (both included).

Answer: {"fn_name": "validate_usr", "inputs": [["asddsa"], ["a"], ["Hass"], ["Hasd_12assssssasasasasasaasasasasas"], [""], ["____"], ["012"], ["p1pp1"], ["asd43 34"], ["asd43_34"]], "outputs": [[true], [false], [false], [false], [false], [true], [false], [true], [false], [true]]}
user: # Description:

 Count the number of exclamation marks and question marks, return the product.

# Examples

```
Product("") == 0
product("!") == 0
Product("!ab? ?") == 2
Product("!!") == 0
Product("!??") == 2
Product("!???") == 3
Product("!!!??") == 6
Product("!!!???") == 9
Product("!???!!") == 9
Product("!????!!!?") == 20
```

Answer: {"fn_name": "product", "inputs": [[""], ["!"], ["!!??!!"]], "outputs": [[0], [0], [8]]}
user: >When no more interesting kata can be resolved, I just choose to create the new kata, to solve their own, to enjoy the process  --myjinxin2015 said

# Description:
 In kindergarten, the teacher gave the children some candies. The number of candies each child gets is not always the same. Here is an array `candies`(all elements are positive integer). It's the number of candy for each child:
 ```
 candies = [10,2,8,22,16,4,10,6,14,20]
 ```
 The teacher asked the children to form a circle and play a game: Each child gives half of his candies to the child on his right(at the same time). If the number of children's candy is an odd number, the teacher will give him an extra candy, so that he can evenly distribute his candy. 
 
 Repeat such distribute process, until all the children's candies are equal in number.
 
 You should return two numbers: 1.How many times of distribution; 2. After the game, the number of each child's candy. Returns the result using an array that contains two elements.
 
  
# Some examples:

```
      candies = [ 1,2,3,4,5 ]
Distribution 1: [ 4,2,3,4,5 ]
Distribution 2: [ 5,3,3,4,5 ]
Distribution 3: [ 6,5,4,4,5 ]
Distribution 4: [ 6,6,5,4,5 ]
Distribution 5: [ 6,6,6,5,5 ]
Distribution 6: [ 6,6,6,6,6 ]
So, we need return: [6,6]

distributionOfCandy([1,2,3,4,5]) === [6,6]

       candies = [ 10,  2,  8, 22, 16,  4, 10,  6, 14, 20 ]
distribution  1: [ 15,  6,  5, 15, 19, 10,  7,  8, 10, 17 ]
distribution  2: [ 17, 11,  6, 11, 18, 15,  9,  8,  9, 14 ]
distribution  3: [ 16, 15,  9,  9, 15, 17, 13,  9,  9, 12 ]
distribution  4: [ 14, 16, 13, 10, 13, 17, 16, 12, 10, 11 ]
distribution  5: [ 13, 15, 15, 12, 12, 16, 17, 14, 11, 11 ]
distribution  6: [ 13, 15, 16, 14, 12, 14, 17, 16, 13, 12 ]
distribution  7: [ 13, 15, 16, 15, 13, 13, 16, 17, 15, 13 ]
distribution  8: [ 14, 15, 16, 16, 15, 14, 15, 17, 17, 15 ]
distribution  9: [ 15, 15, 16, 16, 16, 15, 15, 17, 18, 17 ]
distribution 10: [ 17, 16, 16, 16, 16, 16, 16, 17, 18, 18 ]
distribution 11: [ 18, 17, 16, 16, 16, 16, 16, 17, 18, 18 ]
distribution 12: [ 18, 18, 17, 16, 16, 16, 16, 17, 18, 18 ]
distribution 13: [ 18, 18, 18, 17, 16, 16, 16, 17, 18, 18 ]
distribution 14: [ 18, 18, 18, 18, 17, 16, 16, 17, 18, 18 ]
distribution 15: [ 18, 18, 18, 18, 18, 17, 16, 17, 18, 18 ]
distribution 16: [ 18, 18, 18, 18, 18, 18, 17, 17, 18, 18 ]
distribution 17: [ 18, 18, 18, 18, 18, 18, 18, 18, 18, 18 ]
So, we need return: [17,18]

distributionOfCandy([10,2,8,22,16,4,10,6,14,20]) === [17,18]

```

Answer: {"fn_name": "distribution_of_candy", "inputs": [[[1, 2, 3, 4, 5]], [[10, 2, 8, 22, 16, 4, 10, 6, 14, 20]]], "outputs": [[[6, 6]], [[17, 18]]]}
user: # Task
 You are given a regular array `arr`. Let's call a `step` the difference between two adjacent elements. 
 
 Your task is to sum the elements which belong to the sequence of consecutive elements of length `at least 3 (but as long as possible)`, such that the steps between the elements in this sequence are the same.

 Note that some elements belong to two sequences and have to be counted twice.

# Example

 For `arr = [54, 70, 86, 1, -2, -5, 0, 5, 78, 145, 212, 15]`, the output should be `639`.
```
There are 4 sequences of equal steps in the given array:
{54, 70, 86} => step +16
{1, -2, -5} => step -3
{-5, 0, 5} => step +5
{78, 145, 212} => step +67
So the answer is 
(54 + 70 + 86) + 
(1 - 2 - 5) + 
(-5 + 0 + 5) + 
(78 + 145 + 212) = 639.
The last element 15 was not be counted.
```

 For `arr = [7, 2, 3, 2, -2, 400, 802]`, the output should be `1200`.
 ```
 There is only 1 sequence in arr:
 {-2, 400, 802} => step +402
 So the answer is: -2 + 400 + 802 = 1200
 ```
 
 For `arr = [1, 2, 3, 4, 5]`, the output should be `15`.
 
 Note that we should only count {1, 2, 3, 4, 5} as a whole, any other small subset such as {1, 2, 3},{2, 3, 4},{3, 4, 5} are belong to {1, 2, 3, 4, 5}.
 
# Input/Output


 - `[input]` array.integer `arr`

 `3 ≤ arr.length ≤ 100`


 - `[output]` an integer
 
 The sum of sequences.

Answer: {"fn_name": "sum_of_regular_numbers", "inputs": [[[54, 70, 86, 1, -2, -5, 0, 5, 78, 145, 212, 15]], [[59, 58, 57, 55, 53, 51]], [[7, 2, -3, 3, 9, 15]], [[-17, -9, 1, 9, 17, 4, -9]], [[7, 2, 3, 2, -2, 400, 802]], [[-1, 7000, 1, -6998, -13997]]], "outputs": [[639], [390], [30], [39], [1200], [-13994]]}
user: Introduction 

The GADERYPOLUKI is a simple substitution cypher used in scouting to encrypt messages. The encryption is based on short, easy to remember key. The key is written as paired letters, which are in the cipher simple replacement.

The most frequently used key is "GA-DE-RY-PO-LU-KI".

```
 G => A
 g => a
 a => g
 A => G
 D => E
  etc.
```

The letters, which are not on the list of substitutes, stays in the encrypted text without changes.

Other keys often used by Scouts:

```
PO-LI-TY-KA-RE-NU
KA-CE-MI-NU-TO-WY
KO-NI-EC-MA-TU-RY
ZA-RE-WY-BU-HO-KI
BA-WO-LE-TY-KI-JU
RE-GU-LA-MI-NO-WY
```

Task

Your task is to help scouts to encrypt and decrypt thier messages.
Write the `Encode` and `Decode` functions. 

Input/Output

The function should have two parameters. 
The `message` input string consists of lowercase and uperrcase characters and whitespace character.
The `key` input string consists of only lowercase characters.
The substitution has to be case-sensitive. 

Example

 
 # GADERYPOLUKI collection



GADERYPOLUKI cypher vol 1


GADERYPOLUKI cypher vol 2


GADERYPOLUKI cypher vol 3 - Missing Key


GADERYPOLUKI cypher vol 4 - Missing key madness

Answer: {"fn_name": "encode", "inputs": [["Gug hgs g cgt", "gaderypoluki"], ["Dkucr pu yhr ykbir", "politykarenu"], ["ABCD", "gaderypoluki"], ["Ala has a cat", "gaderypoluki"]], "outputs": [["Ala has a cat"], ["Dance on the table"], ["GBCE"], ["Gug hgs g cgt"]]}
user: >When no more interesting kata can be resolved, I just choose to create the new kata, to solve their own, to enjoy the process  --myjinxin2015 said

# Description:
 
 Give you two arrays `arr1` and `arr2`. They have the same length(length>=2). The elements of two arrays always be integer.
 
 Sort `arr1` according to the ascending order of arr2; Sort `arr2` according to the ascending order of arr1. Description is not easy to understand, for example:
 ```
 arr1=[5,4,3,2,1], 
 arr2=[6,5,7,8,9]
 ```
 Let us try to sorting arr1. 
 First, we need know the ascending order of arr2:
 ```
 [5,6,7,8,9]
 ```
 We can see, after sort arr2 to ascending order, some elements' index are changed:
 ```
 unsort arr2      ascending order arr2
 [6,5,7,8,9]--->      [5,6,7,8,9]
 
 index0(6)  --->      index1
 index1(5)  --->      index0
 index2(7)            index2(no change)
 index3(8)            index3(no change)
 index4(9)            index4(no change)
 ```
 So, wo need according to these changes to sorting arr1:
 ```
 unsort arr1          sorted arr1
 [5,4,3,2,1]--->      [4,5,3,2,1]
 
 index0(5)  --->      index1
 index1(4)  --->      index0
 index2(3)            index2(no change)
 index3(2)            index3(no change)
 index4(1)            index4(no change)
 
 So: sorted arr1= [4,5,3,2,1]
 ```
 And then, we sorting arr2 with the same process:
 ```
 unsort arr1      ascending order arr1
 [5,4,3,2,1]--->      [1,2,3,4,5]
 
 index0(5)  --->      index4
 index1(4)  --->      index3
 index2(3)            index2(no change)
 index3(2)  --->      index1
 index4(1)  --->      index0
 
 unsort arr2          sorted arr2
 [6,5,7,8,9]--->      [9,8,7,5,6]
 
 index0(6)  --->      index4
 index1(5)  --->      index3
 index2(7)            index2(no change)
 index3(8)  --->      index1
 index4(9)  --->      index0
 
 So: sorted arr2= [9,8,7,5,6]
 
 ```
 Finally, returns the sorted arrays by a 2D array: `[sorted arr1, sorted arr2]`
 
 Note: In ascending order sorting process(not the final sort), if some elements have same value, sort them according to their index; You can modify the original array, but I advise you not to do that. ;-)

```if:haskell
 Note: In Haskell, you are expected to return a tuple of arrays, and good luck trying to modifiy the original array. :]
```

# Some Examples and explain

```
sortArrays([5,4,3,2,1],[6,5,7,8,9]) should return
[[4,5,3,2,1],[9,8,7,5,6]]

sortArrays([2,1,3,4,5],[5,6,7,8,9]) should return
[[2,1,3,4,5],[6,5,7,8,9]]

sortArrays([5,6,9,2,6,5],[3,6,7,4,8,1]) should return
[[5,5,2,6,9,6],[4,3,1,6,8,7]]
```

Answer: {"fn_name": "sort_two_arrays", "inputs": [[[5, 4, 3, 2, 1], [6, 5, 7, 8, 9]], [[2, 1, 3, 4, 5], [5, 6, 7, 8, 9]], [[5, 6, 9, 2, 6, 5], [3, 6, 7, 4, 8, 1]]], "outputs": [[[[4, 5, 3, 2, 1], [9, 8, 7, 5, 6]]], [[[2, 1, 3, 4, 5], [6, 5, 7, 8, 9]]], [[[5, 5, 2, 6, 9, 6], [4, 3, 1, 6, 8, 7]]]]}
user: > 
**Note**: This kata is a translation of this (Java) one: http://www.codewars.com/kata/rotate-array. I have not translated this first one as usual because I did not solved it, and I fear not being able to solve it (Java is **not** my cup of... tea). @cjmcgraw, if you want to use my translation on your kata feel free to use it.

Create a function named "rotate" that takes an array and returns a new one with the elements inside rotated n spaces.

If n is greater than 0 it should rotate the array to the right. If n is less than 0 it should rotate the array to the left. If n is 0, then it should return the array unchanged.

Example:
```python
data = [1, 2, 3, 4, 5];

rotate(data, 1) # => [5, 1, 2, 3, 4]
rotate(data, 2) # => [4, 5, 1, 2, 3]
rotate(data, 3) # => [3, 4, 5, 1, 2]
rotate(data, 4) # => [2, 3, 4, 5, 1]
rotate(data, 5) # => [1, 2, 3, 4, 5]

rotate(data, 0) # => [1, 2, 3, 4, 5]

rotate(data, -1) # => [2, 3, 4, 5, 1]
rotate(data, -2) # => [3, 4, 5, 1, 2]
rotate(data, -3) # => [4, 5, 1, 2, 3]
rotate(data, -4) # => [5, 1, 2, 3, 4]
rotate(data, -5) # => [1, 2, 3, 4, 5]
```

Furthermore the method should take ANY array of objects and perform this operation on them:
```python
rotate(['a', 'b', 'c'], 1)     # => ['c', 'a', 'b']
rotate([1.0, 2.0, 3.0], 1)     # => [3.0, 1.0, 2.0]
rotate([True, True, False], 1) # => [False, True, True]
```

Finally the rotation shouldn't be limited by the indices available in the array. Meaning that if we exceed the indices of the array it keeps rotating.

Example:
```python
data = [1, 2, 3, 4, 5]

rotate(data, 7)     # => [4, 5, 1, 2, 3]
rotate(data, 11)    # => [5, 1, 2, 3, 4]
rotate(data, 12478) # => [3, 4, 5, 1, 2]
```

Answer: {"fn_name": "rotate", "inputs": [[["a", "b", "c"], 1], [[1.0, 2.0, 3.0], 1], [[true, true, false], 1]], "outputs": [[["c", "a", "b"]], [[3.0, 1.0, 2.0]], [[false, true, true]]]}
user: Mash 2 arrays together so that the returning array has alternating elements of the 2 arrays . Both arrays will always be the same length.

eg. [1,2,3] + ['a','b','c'] =  [1, 'a', 2, 'b', 3, 'c']

Answer: {"fn_name": "array_mash", "inputs": [[[1, 2, 3], ["a", "b", "c"]], [[1, 2, 3, 4, 5], ["a", "b", "c", "d", "e"]], [[1, 1, 1, 1], [2, 2, 2, 2]], [[1, 8, "hello", "dog"], ["fish", "2", 9, 10]], [[null, 4], [null, "hello"]], [[1], [2]], [["h", "l", "o", "o", "l"], ["e", "l", "w", "r", "d"]]], "outputs": [[[1, "a", 2, "b", 3, "c"]], [[1, "a", 2, "b", 3, "c", 4, "d", 5, "e"]], [[1, 2, 1, 2, 1, 2, 1, 2]], [[1, "fish", 8, "2", "hello", 9, "dog", 10]], [[null, null, 4, "hello"]], [[1, 2]], [["h", "e", "l", "l", "o", "w", "o", "r", "l", "d"]]]}
user: Given two numbers and an arithmetic operator (the name of it, as a string), return the result of the two numbers having that operator used on them. 

```a``` and ```b``` will both be positive integers, and ```a``` will always be the first number in the operation, and ```b``` always the second.

The four operators are "add", "subtract", "divide", "multiply". 

A few examples: 

``` javascript
ArithmeticFunction.arithmetic(5, 2, "add")      => returns 7
ArithmeticFunction.arithmetic(5, 2, "subtract") => returns 3
ArithmeticFunction.arithmetic(5, 2, "multiply") => returns 10
ArithmeticFunction.arithmetic(5, 2, "divide")   => returns 2
```

Try to do it without using if statements!

Answer: {"fn_name": "arithmetic", "inputs": [[1, 2, "add"], [8, 2, "subtract"], [5, 2, "multiply"], [8, 2, "divide"]], "outputs": [[3], [6], [10], [4]]}
user: Time to win the lottery!

Given a lottery ticket (ticket), represented by an array of 2-value arrays, you must find out if you've won the jackpot.  Example ticket:

To do this, you must first count the 'mini-wins' on your ticket.  Each sub array has both a string and a number within it. If the character code of any of the characters in the string matches the number, you get a mini win. Note you can only have one mini win per sub array.

Once you have counted all of your mini wins, compare that number to the other input provided (win). If your total is more than or equal to (win), return 'Winner!'. Else return 'Loser!'.

All inputs will be in the correct format. Strings on tickets are not always the same length.

Answer: {"fn_name": "bingo", "inputs": [[[["ABC", 65], ["HGR", 74], ["BYHT", 74]], 2], [[["ABC", 65], ["HGR", 74], ["BYHT", 74]], 1], [[["HGTYRE", 74], ["BE", 66], ["JKTY", 74]], 3]], "outputs": [["Loser!"], ["Winner!"], ["Loser!"]]}
user: The __Hamming weight__ of a string is the number of symbols that are different from the zero-symbol of the alphabet used. There are several algorithms for efficient computing of the Hamming weight for numbers. In this Kata, speaking technically, you have to find out the number of '1' bits in a binary representation of a number. Thus,

The interesting part of this task is that you have to do it *without* string operation (hey, it's not really interesting otherwise)

 ;)

Answer: {"fn_name": "hamming_weight", "inputs": [[0], [1], [2], [10], [21], [2048]], "outputs": [[0], [1], [1], [2], [3], [1]]}
user: You have to create a function named reverseIt.

Write your function so that in the case a string or a number is passed in as the data , you will return the data in reverse order. If the data is any other type, return it as it is.


Examples of inputs and subsequent outputs:
```
"Hello" -> "olleH"

"314159" -> "951413"

[1,2,3] -> [1,2,3]
```

Answer: {"fn_name": "reverse_it", "inputs": [["Hello"], [314159], ["314159"], [[]], [{}], [true], [[1, 2, 3]]], "outputs": [["olleH"], [951413], ["951413"], [[]], [{}], [true], [[1, 2, 3]]]}
user: Every  positive integer number, that is not prime, may be decomposed in prime factors. For example the prime factors of 20, are:
```
2, 2, and 5, because: 20 = 2 . 2 . 5
```
The first prime factor (the smallest one) of ```20``` is ```2``` and the last one (the largest one) is ```5```. The sum of the first and the last prime factors, ```sflpf``` of 20 is: ```sflpf = 2 + 5 = 7```

The number ```998 ```is the only integer in the range ```[4, 1000]``` that has a value of ```501``` , so its ```sflpf``` equals to 501, but in the range ```[4, 5000]``` we will have more integers with ```sflpf = 501``` and are: ```998, 1996, 2994, 3992, 4990```.

We need a function ```sflpf_data()``` (javascript: ```sflpfData()```that receives two arguments, ```val``` as the value of sflpf and ```nMax``` as a limit, and the function will output a sorted list of the numbers between ```4``` to ```nMax```(included) that have the same value of sflpf equals to ```val```.

Let's see some cases:
```python
sflpf_data(10, 100) == [21, 25, 63]
/// the prime factorization of these numbers are:
Number  Prime Factorization     Sum First and Last Prime Factor
21       = 3 . 7      ---->                 3 + 7 = 10
25       = 5 . 5      ---->                 5 + 5 = 10
63       = 3 . 3 . 7  ---->                 3 + 7 = 10
```
```python
sflpf_data(10, 200) == [21, 25, 63, 105, 125, 147, 189]
sflpf_data(15, 150) == [26, 52, 78, 104, 130]
```
(Advice:Try to discard primes in a fast way to have a more agile code)

Enjoy it!

Answer: {"fn_name": "sflpf_data", "inputs": [[10, 100], [10, 200], [15, 150], [501, 1000], [501, 5000]], "outputs": [[[21, 25, 63]], [[21, 25, 63, 105, 125, 147, 189]], [[26, 52, 78, 104, 130]], [[998]], [[998, 1996, 2994, 3992, 4990]]]}
user: Working from left-to-right if no digit is exceeded by the digit to its left it is called an increasing number; for example, 134468.

Similarly if no digit is exceeded by the digit to its right it is called a decreasing number; for example, 66420.

We shall call a positive integer that is neither increasing nor decreasing a "bouncy" number; for example, 155349.

Clearly there cannot be any bouncy numbers below one-hundred, but just over half of the numbers below one-thousand (525) are bouncy. In fact, the least number for which the proportion of bouncy numbers first reaches 50% is 538.

Surprisingly, bouncy numbers become more and more common and by the time we reach 21780 the proportion of bouncy numbers is equal to 90%.

#### Your Task

Complete the bouncyRatio function.

The input will be the target ratio.

The output should be the smallest number such that the proportion of bouncy numbers reaches the target ratio.

You should throw an Error for a ratio less than 0% or greater than 99%.

**Source**

  - https://projecteuler.net/problem=112
  
**Updates**

  - 26/10/2015: Added a higher precision test case.

Answer: {"fn_name": "bouncy_ratio", "inputs": [[0.1], [0.15], [0.5], [0.75], [0.9]], "outputs": [[132], [160], [538], [3088], [21780]]}
user: # Definition (Primorial Of a Number)

*Is similar to factorial of a number*, **_In primorial_**, not all the natural numbers get multiplied, **_only prime numbers are multiplied to calculate the primorial of a number_**. It's denoted with **_P_****_#_** and it is the product of the first n prime numbers.
___ 

# Task

**_Given_** *a number N* , **_calculate its primorial_**. ![!alt](https://i.imgur.com/mdX8dJP.png)  ![!alt](https://i.imgur.com/mdX8dJP.png)  
___

# Notes

* **_Only positive_** numbers *will be passed (N > 0)* .
___

# Input >> Output Examples:

``` cpp
1- numPrimorial (3) ==> return (30)
```

## **_Explanation_**:

**_Since_** *the passed number is (3)* ,**_Then_** **_the primorial_** *should obtained by multiplying*  ```2 * 3 * 5 = 30 .```

### Mathematically written as , **_P_**3**_#_** = 30 .
___ 

## **_Explanation_**:

**_Since_** *the passed number is (5)* ,**_Then_** **_the primorial_** *should obtained by multiplying*  ``` 2 * 3 * 5 * 7 * 11 = 2310 .```

### Mathematically written as , **_P_**5**_#_** = 2310 .
___

## **_Explanation_**: 

**_Since_** *the passed number is (6)* ,**_Then_** **_the primorial_** *should obtained by multiplying*  ``` 2 * 3 * 5 * 7 * 11 * 13 = 30030 .```

### Mathematically written as , **_P_**6**_#_** = 30030 .
___
___
___

# [Playing with Numbers Series](https://www.codewars.com/collections/playing-with-numbers)

# [Playing With Lists/Arrays Series](https://www.codewars.com/collections/playing-with-lists-slash-arrays)

# [For More Enjoyable Katas](http://www.codewars.com/users/MrZizoScream/authored)
___

## ALL translations are welcomed

## Enjoy Learning !!
# Zizou

Answer: {"fn_name": "num_primorial", "inputs": [[3], [4], [5], [8], [9]], "outputs": [[30], [210], [2310], [9699690], [223092870]]}
user: Gematria is an Assyro-Babylonian-Greek system of code and numerology later adopted into Jewish culture. The system assigns numerical value to a word or a phrase in the belief that words or phrases with identical numerical values bear some relation to each other or bear some relation to the number itself. While more commonly used on Hebrew words, there is also an English version.

Each letter has a value and the gematrian value of a word or a phrase is the sum of those values. The code takes a word or an expression and returns the gematrian value of it.

The calculation is case insensitive and counts no spaces. 

Example: The gematrian value of "love" is 20+50+700+5 = 775

‎These are the values of the different letters:

a=1, b=2, c=3, d=4, e=5, f=6, g=7, h=8, i=9, k=10, l=20,
m=30, n=40, o=50, p=60, q=70, r=80, s=90, t=100, u=200,
x=300, y=400, z=500, j=600, v=700, w=900

Answer: {"fn_name": "gematria", "inputs": [["love"], ["jaels"], ["JAELS"], ["Devil"], ["Coding is fun"]], "outputs": [[775], [716], [716], [738], [458]]}
user: Ever the learned traveller, Alan Partridge has pretty strong views on London:

```
"Go to London. I guarantee you'll either be mugged or not appreciated.
Catch the train to London, stopping at Rejection, Disappointment, Backstabbing Central and Shattered Dreams Parkway."
```
Your job is to check that the provided list of stations contains all of the stops Alan mentions. There will be other stations in the array.  Example:

```
['Rejection', 'Disappointment', 'Backstabbing Central', 'Shattered Dreams Parkway']
```

If the stations all appear, return 'Smell my cheese you mother!', if not,  return 'No, seriously, run. You will miss it.'.

Other katas in this series:
Alan Partridge I - Partridge Watch
Alan Partridge II - Apple Turnover

Answer: {"fn_name": "alan", "inputs": [[["Norwich", "Rejection", "Disappointment", "Backstabbing Central", "Shattered Dreams Parkway", "London"]], [["London", "Norwich"]], [["Norwich", "Tooting", "Bank", "Rejection", "Disappointment", "Backstabbing Central", "Exeter", "Shattered Dreams Parkway", "Belgium", "London"]], [["London", "Shattered Dreams Parkway", "Backstabbing Central", "Disappointment", "Rejection", "Norwich"]]], "outputs": [["Smell my cheese you mother!"], ["No, seriously, run. You will miss it."], ["Smell my cheese you mother!"], ["Smell my cheese you mother!"]]}