meetforever/GRPO_CL huggingface dataset:
user: Give the summation of all even numbers in a Fibonacci sequence up to, but not including, the maximum value.

The Fibonacci sequence is a series of numbers where the next value is the addition of the previous two values. The series starts with 0 and 1:

0 1 1 2 3 5 8 13 21...

For example:
```python
eve_fib(0)==0
eve_fib(33)==10
eve_fib(25997544)==19544084
```

Answer: {"fn_name": "even_fib", "inputs": [[0], [10], [5], [100], [1000], [1000000], [100000000], [1000000000], [2147483647], [-1]], "outputs": [[0], [10], [2], [44], [798], [1089154], [82790070], [350704366], [1485607536], [0]]}
user: # Task
 Define crossover operation over two equal-length strings A and B as follows:

 the result of that operation is a string of the same length as the input strings result[i] is chosen at random between A[i] and B[i]. 
 
 Given array of strings `arr` and a string result, find for how many pairs of strings from `arr` the result of the crossover operation over them may be equal to result.

 Note that (A, B) and (B, A) are the same pair. Also note that the pair cannot include the same element of the array twice (however, if there are two equal elements in the array, they can form a pair).

# Example

 For `arr = ["abc", "aaa", "aba", "bab"]` and `result = "bbb"`, the output should be `2`.

 ```
"abc" and "bab" can crossover to "bbb"
"aba" and "bab" can crossover to "bbb"
```
# Input/Output


 - `[input]` string array `arr`

   A non-empty array of equal-length strings.

   Constraints: `2 ≤ arr.length ≤ 10, 1 ≤ arr[i].length ≤ 10.`


 - `[input]` string `result`

   A string of the same length as each of the arr elements.

   Constraints: `result.length = arr[i].length.`


 - `[output]` an integer

Answer: {"fn_name": "strings_crossover", "inputs": [[["abc", "aaa", "aba", "bab"], "bbb"], [["aacccc", "bbcccc"], "abdddd"], [["a", "b", "c", "d", "e"], "c"], [["aa", "ab", "ba"], "bb"], [["a", "b", "c", "d", "e"], "f"], [["aaa", "aaa"], "aaa"]], "outputs": [[2], [0], [4], [1], [0], [1]]}
user: Given a mixed array of number and string representations of integers, add up the string integers and subtract this from the total of the non-string integers. 

Return as a number.

Answer: {"fn_name": "div_con", "inputs": [[[9, 3, "7", "3"]], [["5", "0", 9, 3, 2, 1, "9", 6, 7]], [["3", 6, 6, 0, "5", 8, 5, "6", 2, "0"]], [["1", "5", "8", 8, 9, 9, 2, "3"]], [[8, 0, 0, 8, 5, 7, 2, 3, 7, 8, 6, 7]]], "outputs": [[2], [14], [13], [11], [61]]}
user: An array is defined to be `inertial`if the following conditions hold:
```
a. it contains at least one odd value  
b. the maximum value in the array is even 
c. every odd value is greater than every even value that is not the maximum value.
```
eg:-
```
So [11, 4, 20, 9, 2, 8] is inertial because 
a. it contains at least one odd value [11,9] 
b. the maximum value in the array is 20 which is even 
c. the two odd values (11 and 9) are greater than all the even values that are not equal to 20 (the maximum), i.e., [4, 2, 8]
```
Write a function called `is_inertial` that accepts an integer array and returns `true` if the array is inertial; otherwise it returns `false`.

Answer: {"fn_name": "is_inertial", "inputs": [[[]], [[581, -384, 140, -287]], [[11, 4, 20, 9, 2, 8]]], "outputs": [[false], [false], [true]]}
user: ## TL;DR

Given a number of vertices `N` and a list of weighted directed edges in a directed acyclic graph (each edge is written as `[start, end, weight]` where `from < to`), compute the weight of the shortest path from vertex `0` to vertex `N - 1`.  If there is no such path, return `-1`.

## Background

A weighted DAG is a directed acyclic graph where each edge has a weight associated with it:













1
5
3
1
5




A
B
C
D


In this example, the shortest path from A to D is given by A -> B -> D, which has a total weight of 4.

Finding shortest distances in DAGs is made easier by the fact that the nodes can be _linearized:_ they can be given an order `A1, A2, ..., An` such that edges only point forward (that is, there are no edges from `Aj` to `Ai` when `j > i`).  In the example above, the two possible linear orderings are `A, B, C, D` and `A, C, B, D.`














1

1
5
5
3





A
B
C
D


## Your Task

Given a number `N` (indicating a graph with vertices `0, 1, ..., N-1`) and a list of weighted edges `[start, end, weight]` for a DAG, where `start < end` for each edge, find the weight (a.k.a. length) of the shortest path from node `0` to node `N-1`.

For example, if the input is

```
N = 4
edgeList = [
  [0, 1, 1], [0, 2, 5], [0, 3, 5], [1, 3, 3], [2, 3, 1]
]
```

then we have the graph depicted above (with `0 = A`, `1 = B`, etc.) and the answer is `4`.

If there is no path from node `0` to node `N-1`, return `-1`.

## Notes and Warnings

**Precondition:** `N` will always be greater than 1, and edge weights will always be positive integers.  There may be multiple edges going between two nodes.

**Warning:** You will probably need to use a dynamic programming solution if you want your solution to run fast enough not to time out--that's the whole point of this kata!


However, a well-written general shortest-path algorithm such as Dijkstra's Algorithm may also be fast enough to past the soak tests.  (The reason is that the dividing line between linear and linearithmic time is hard to define and depends on a variety of external factors, so the kata's tests err on the safe side.)

Answer: {"fn_name": "shortest", "inputs": [[4, [[0, 1, 1], [0, 2, 5], [0, 3, 5], [1, 3, 3], [2, 3, 1]]], [3, [[0, 1, 7], [1, 2, 5], [0, 2, 12]]], [5, [[0, 2, 1], [1, 2, 1], [0, 3, 1], [1, 4, 1]]]], "outputs": [[4], [12], [-1]]}
user: You will be given two strings `a` and `b` consisting of lower case letters, but `a` will have at most one asterix character. The asterix (if any) can be replaced with an arbitrary sequence (possibly empty) of lowercase letters. No other character of string `a` can be replaced. If it is possible to replace the asterix in `a` to obtain string `b`, then string `b` matches the pattern. 

If the string matches, return `true` else `false`. 

```
For example:
solve("code*s","codewars") = true, because we can replace the asterix(*) with "war" to match the second string. 
solve("codewar*s","codewars") = true, because we can replace the asterix(*) with "" to match the second string. 
solve("codewars","codewars") = true, because the strings already match.
solve("a","b") = false
```
More examples in test cases. 

Good luck!

Answer: {"fn_name": "solve", "inputs": [["code*s", "codewars"], ["codewar*s", "codewars"], ["code*warrior", "codewars"], ["c", "c"], ["*s", "codewars"], ["*s", "s"], ["s*", "s"], ["aa", "aaa"], ["aa*", "aaa"], ["aaa", "aa"], ["aaa*", "aa"], ["*", "codewars"], ["aaa*aaa", "aaa"]], "outputs": [[true], [true], [false], [true], [true], [true], [true], [false], [true], [false], [false], [true], [false]]}
user: Freddy has a really fat left pinky finger, and every time Freddy tries to type an ```A```, he accidentally hits the CapsLock key!

Given a string that Freddy wants to type, emulate the keyboard misses where each ```A``` supposedly pressed is replaced with CapsLock, and return the string that Freddy actually types. It doesn't matter if the ```A``` in the string is capitalized or not. When CapsLock is enabled, capitalization is reversed, but punctuation is not affected.

Examples:

```
"The quick brown fox jumps over the lazy dog."
-> "The quick brown fox jumps over the lZY DOG."

"The end of the institution, maintenance, and administration of government, is to secure the existence of the body politic, to protect it, and to furnish the individuals who compose it with the power of enjoying in safety and tranquillity their natural rights, and the blessings of life: and whenever these great objects are not obtained, the people have a right to alter the government, and to take measures necessary for their safety, prosperity and happiness."
-> "The end of the institution, mINTENnce, ND dministrTION OF GOVERNMENT, IS TO SECURE THE EXISTENCE OF THE BODY POLITIC, TO PROTECT IT, nd to furnish the individuLS WHO COMPOSE IT WITH THE POWER OF ENJOYING IN Sfety ND TRnquillity their nTURl rights, ND THE BLESSINGS OF LIFE: nd whenever these greT OBJECTS re not obtINED, THE PEOPLE Hve  RIGHT TO lter the government, ND TO Tke meSURES NECESSry for their sFETY, PROSPERITY nd hPPINESS."

"aAaaaaAaaaAAaAa"
-> ""
```

**Note!**

If (Caps Lock is Enabled) and then you (HOLD Shift + alpha character) it will always be the reverse

Examples:
```
(Caps Lock Enabled) + (HOLD Shift + Press 'b') = b
(Caps Lock Disabled) + (HOLD Shift + Press 'b') = B
```

If the given string is `""`, the answer should be evident.

Happy coding!

~~~if:fortran
*NOTE: In Fortran, your returned string is* **not** *permitted to contain any unnecessary leading/trailing whitespace.*
~~~


(Adapted from https://codegolf.stackexchange.com/questions/158132/no-a-just-caps-lock)

Answer: {"fn_name": "fat_fingers", "inputs": [["aAaaaaAaaaAAaAa"], ["The end of the institution, maintenance, and administration of government, is to secure the existence of the body politic, to protect it, and to furnish the individuals who compose it with the power of enjoying in safety and tranquillity their natural rights, and the blessings of life: and whenever these great objects are not obtained, the people have a right to alter the government, and to take measures necessary for their safety, prosperity and happiness."], ["a99&a6/<a}"]], "outputs": [[""], ["The end of the institution, mINTENnce, ND dministrTION OF GOVERNMENT, IS TO SECURE THE EXISTENCE OF THE BODY POLITIC, TO PROTECT IT, nd to furnish the individuLS WHO COMPOSE IT WITH THE POWER OF ENJOYING IN Sfety ND TRnquillity their nTURl rights, ND THE BLESSINGS OF LIFE: nd whenever these greT OBJECTS re not obtINED, THE PEOPLE Hve  RIGHT TO lter the government, ND TO Tke meSURES NECESSry for their sFETY, PROSPERITY nd hPPINESS."], ["99&6/<}"]]}
user: In telecomunications we use information coding to detect and prevent errors while sending data. 

A parity bit is a bit added to a string of binary code that indicates whether the number of 1-bits in the string is even or odd. Parity bits are used as the simplest form of error detecting code, and can detect a 1 bit error.

In this case we are using even parity: the parity bit is set to `0` if the number of `1`-bits is even, and is set to `1` if odd.  

We are using them for the transfer of ASCII characters in binary (7-bit strings): the parity is added to the end of the 7-bit string, forming the 8th bit.

In this Kata you are to test for 1-bit errors and return a new string consisting of all of the correct ASCII caracters **in 7 bit format** (removing the parity bit), or `"error"` in place of ASCII characters in which errors were detected.

For more information on parity bits: https://en.wikipedia.org/wiki/Parity_bit


## Examples

Correct 7 bit string with an even parity bit as the 8th bit:
```
"01011001" <-- The "1" on the right is the parity bit.
```

In this example, there are three 1-bits. Three is an odd number, and the parity bit is set to `1`. No errors are detected, so return `"0101100"` (7 bits).

Example of a string of ASCII characters:
```
"01011001 01101110 01100000 01010110 10001111 01100011"
```
This should return:
```
"0101100 error 0110000 0101011 error 0110001"
```

Answer: {"fn_name": "parity_bit", "inputs": [["01011001"], ["00110001"], ["11111111"], ["00000000"], ["11100111"], ["00111100 00111101"], ["00001111 11100001"], ["01011110 00011000"], ["11111111 11011100 11100011"], ["00111110 00110100 00111011"], ["01101110 01100000 01010110 10001111 01100011"], ["10100011 00111001 11001100 01010100 10110110 00111111"]], "outputs": [["0101100"], ["error"], ["1111111"], ["0000000"], ["1110011"], ["0011110 error"], ["0000111 1110000"], ["error 0001100"], ["1111111 error error"], ["error error error"], ["error 0110000 0101011 error 0110001"], ["1010001 0011100 1100110 error error 0011111"]]}
user: Reverse and invert all integer values in a given list. 

Python:

    reverse_invert([1,12,'a',3.4,87,99.9,-42,50,5.6]) = [-1,-21,-78,24,-5]
    
Ignore all other types than integer.

Answer: {"fn_name": "reverse_invert", "inputs": [[[1, 2, 3, 4, 5]], [[-10]], [[-9, -18, 99]], [[1, 12, "a", 3.4, 87, 99.9, -42, 50, 5.6]], [[]]], "outputs": [[[-1, -2, -3, -4, -5]], [[1]], [[9, 81, -99]], [[-1, -21, -78, 24, -5]], [[]]]}
user: An anagram is a word, a phrase, or a sentence formed from another by rearranging its letters. An example of this is "angel", which is an anagram of "glean".

Write a function that receives an array of words, and returns the total number of distinct pairs of anagramic words inside it.

Some examples:

- There are 2 anagrams in the array `["dell", "ledl", "abc", "cba"]`
- There are 7 anagrams in the array `["dell", "ledl", "abc", "cba", "bca", "bac"]`

Answer: {"fn_name": "anagram_counter", "inputs": [[[]], [["dell", "ledl", "abc", "cba"]], [["dell", "ledl", "lled", "cba"]], [["dell", "ledl", "abc", "cba", "bca", "bac", "cab"]]], "outputs": [[0], [2], [3], [11]]}
user: In this Kata, you will be given two numbers, `a` and `b`, and your task is to determine if the first number `a` is divisible by `all` the prime factors of the second number `b`. For example: `solve(15,12) = False` because `15` is not divisible by all the prime factors of `12` (which include`2`).

See test cases for more examples. 

Good luck!

If you like this Kata, please try:

[Sub-array division](https://www.codewars.com/kata/59eb64cba954273cd4000099)

[Divisor harmony](https://www.codewars.com/kata/59bf97cd4f98a8b1cd00007e)

Answer: {"fn_name": "solve", "inputs": [[2, 256], [2, 253], [9, 243], [15, 12], [21, 2893401], [21, 2893406], [54, 2834352], [54, 2834359], [1000013, 7187761], [1000013, 7187762]], "outputs": [[true], [false], [true], [false], [true], [false], [true], [false], [true], [false]]}
user: A strongness of an even number is the number of times we can successively divide by 2 until we reach an odd number starting with an even number n.

For example, if n = 12, then
* 12 / 2 = 6
* 6 / 2 = 3

So we divided successively 2 times and we reached 3, so the strongness of 12 is `2`.

If n = 16 then
* 16 / 2 = 8
* 8 / 2 = 4
* 4 / 2 = 2
* 2 / 2 = 1

we divided successively 4 times and we reached 1, so the strongness of 16 is `4`


# Task

Given a closed interval `[n, m]`, return the even number that is the strongest in the interval. If multiple solutions exist return the smallest strongest even number.

Note that programs must run within the allotted server time; a naive solution will probably time out.


# Constraints
```if-not:ruby
1 <= n < m <= INT_MAX
```
```if:ruby
1 <= n < m <= 2^64
```


# Examples
```
[1, 2]    -->   2  # 1 has strongness 0, 2 has strongness 1
[5, 10]   -->   8  # 5, 7, 9 have strongness 0; 6, 10 have strongness 1; 8 has strongness 3
[48, 56]  -->  48

Answer: {"fn_name": "strongest_even", "inputs": [[1, 2], [5, 10], [48, 56], [129, 193], [2, 3], [4, 6], [3, 310], [33, 40], [456445, 678860], [324243, 897653214], [1151592177, 2129680158], [2085422641, 2128923730], [1082012216, 1876572332], [1806570867, 2067832928], [206346325, 1289058842]], "outputs": [[2], [8], [48], [192], [2], [4], [256], [40], [524288], [536870912], [1610612736], [2113929216], [1610612736], [1879048192], [1073741824]]}
user: Inspired by the development team at Vooza, write the function `howManyLightsabersDoYouOwn`/`how_many_light_sabers_do_you_own` that 

* accepts the name of a programmer, and
* returns the number of lightsabers owned by that person.

The only person who owns lightsabers is Zach, by the way. He owns 18, which is an awesome number of lightsabers. Anyone else owns 0.

```if:coffeescript,javascript,php,python,ruby,typescript
**Note**: your function should have a default parameter.
```

```c#
Kata.HowManyLightsabersDoYouOwn("Adam") == 0
Kata.HowManyLightsabersDoYouOwn("Zach") == 18
```
```python
how_many_light_sabers_do_you_own('Zach') == 18
how_many_light_sabers_do_you_own('Adam') == 0
how_many_light_sabers_do_you_own()       == 0
```

Answer: {"fn_name": "how_many_light_sabers_do_you_own", "inputs": [["Zach"], ["zach"]], "outputs": [[18], [0]]}
user: **Getting Familiar:**
LEET: (sometimes written as "1337" or "l33t"), also known as eleet or leetspeak, is another alphabet for the English language that is used mostly on the internet. It uses various combinations of ASCII characters to replace Latinate letters. For example, leet spellings of the word leet include 1337 and l33t; eleet may be spelled 31337 or 3l33t.

GREEK: 
The Greek alphabet has been used to write the Greek language since the 8th century BC. It was derived from the earlier Phoenician alphabet, and was the first alphabetic script to have distinct letters for vowels as well as consonants. It is the ancestor of the Latin and Cyrillic scripts.Apart from its use in writing the Greek language, both in its ancient and its modern forms, the Greek alphabet today also serves as a source of technical symbols and labels in many domains of mathematics, science and other fields.

**Your Task :** 

    You have to create a function **GrεεκL33t** which    
    takes a string as input and returns it in the form of 
    (L33T+Grεεκ)Case.
    Note: The letters which are not being converted in 
    (L33T+Grεεκ)Case should be returned in the lowercase.

**(L33T+Grεεκ)Case:**

    A=α (Alpha)      B=β (Beta)      D=δ (Delta)
    E=ε (Epsilon)    I=ι (Iota)      K=κ (Kappa)
    N=η (Eta)        O=θ (Theta)     P=ρ (Rho)
    R=π (Pi)         T=τ (Tau)       U=μ (Mu)      
    V=υ (Upsilon)    W=ω (Omega)     X=χ (Chi)
    Y=γ (Gamma)
    
**Examples:**

    GrεεκL33t("CodeWars") = "cθδεωαπs"
    GrεεκL33t("Kata") = "κατα"

Answer: {"fn_name": "gr33k_l33t", "inputs": [["codewars"], ["kata"], ["kumite"], ["greekleet"], ["This Kata's Sensei is Divyansh"], ["Any reviews about CS50"], ["Man is still the most extraordinary computer of all."], ["I do not fear computers. I fear the lack of them."], ["Do you also think these quotes are conflicting each other?"]], "outputs": [["c\u03b8\u03b4\u03b5\u03c9\u03b1\u03c0s"], ["\u03ba\u03b1\u03c4\u03b1"], ["\u03ba\u03bcm\u03b9\u03c4\u03b5"], ["g\u03c0\u03b5\u03b5\u03bal\u03b5\u03b5\u03c4"], ["\u03c4h\u03b9s \u03ba\u03b1\u03c4\u03b1's s\u03b5\u03b7s\u03b5\u03b9 \u03b9s \u03b4\u03b9\u03c5\u03b3\u03b1\u03b7sh"], ["\u03b1\u03b7\u03b3 \u03c0\u03b5\u03c5\u03b9\u03b5\u03c9s \u03b1\u03b2\u03b8\u03bc\u03c4 cs50"], ["m\u03b1\u03b7 \u03b9s s\u03c4\u03b9ll \u03c4h\u03b5 m\u03b8s\u03c4 \u03b5\u03c7\u03c4\u03c0\u03b1\u03b8\u03c0\u03b4\u03b9\u03b7\u03b1\u03c0\u03b3 c\u03b8m\u03c1\u03bc\u03c4\u03b5\u03c0 \u03b8f \u03b1ll."], ["\u03b9 \u03b4\u03b8 \u03b7\u03b8\u03c4 f\u03b5\u03b1\u03c0 c\u03b8m\u03c1\u03bc\u03c4\u03b5\u03c0s. \u03b9 f\u03b5\u03b1\u03c0 \u03c4h\u03b5 l\u03b1c\u03ba \u03b8f \u03c4h\u03b5m."], ["\u03b4\u03b8 \u03b3\u03b8\u03bc \u03b1ls\u03b8 \u03c4h\u03b9\u03b7\u03ba \u03c4h\u03b5s\u03b5 q\u03bc\u03b8\u03c4\u03b5s \u03b1\u03c0\u03b5 c\u03b8\u03b7fl\u03b9c\u03c4\u03b9\u03b7g \u03b5\u03b1ch \u03b8\u03c4h\u03b5\u03c0?"]]}
user: # Task
 Two integer numbers are added using the column addition method. When using this method, some additions of digits produce non-zero carries to the next positions. Your task is to calculate the number of non-zero carries that will occur while adding the given numbers.

 The numbers are added in base 10.

# Example

 For `a = 543 and b = 3456,` the output should be `0`
 
 For `a = 1927 and b = 6426`, the output should be `2`
 
 For `a = 9999 and b = 1`, the output should be `4`
 
 
# Input/Output


 - `[input]` integer `a`

  A positive integer.

  Constraints: `1 ≤ a ≤ 10^7`


 - `[input]` integer `b`

  A positive integer.

  Constraints: `1 ≤ b ≤ 10^7`

 
 - `[output]` an integer

Answer: {"fn_name": "number_of_carries", "inputs": [[543, 3456], [1927, 6426], [9999, 1], [1234, 5678]], "outputs": [[0], [2], [4], [2]]}
user: Complete the method/function so that it converts dash/underscore delimited words into camel casing. The first word within the output should be capitalized **only** if the original word was capitalized (known as Upper Camel Case, also often referred to as Pascal case). 

## Examples

```python
to_camel_case("the-stealth-warrior") # returns "theStealthWarrior"

to_camel_case("The_Stealth_Warrior") # returns "TheStealthWarrior"
```

Answer: {"fn_name": "to_camel_case", "inputs": [[""], ["the_stealth_warrior"], ["The-Stealth-Warrior"], ["A-B-C"]], "outputs": [[""], ["theStealthWarrior"], ["TheStealthWarrior"], ["ABC"]]}
user: The number n is Evil if it has an even number of 1's in its binary representation.
The first few Evil numbers: 3, 5, 6, 9, 10, 12, 15, 17, 18, 20
The number n is Odious if it has an odd number of 1's in its binary representation.
The first few Odious numbers: 1, 2, 4, 7, 8, 11, 13, 14, 16, 19
You have to write a function that determine if a number is Evil of Odious, function should return "It's Evil!" in case of evil number and "It's Odious!" in case of odious number.

good luck :)

Answer: {"fn_name": "evil", "inputs": [[1], [2], [3]], "outputs": [["It's Odious!"], ["It's Odious!"], ["It's Evil!"]]}
user: # Number encrypting: cypher
## Part I of Number encrypting Katas
***

## Introduction
Back then when the internet was coming up, most search functionalities simply looked for keywords in text to show relevant documents. Hackers weren't very keen on having their information displayed on websites, bulletin boards, newsgroups or any other place, so they started to replace certain letters in words. It started out with simple vowel substitutions like a 4 instead of an A, or a 3 instead of an E. This meant that topics like cracking or hacking remained undetected.

Here we will use a reduced version of the *Leet Speak alphabet*, but you can find more information [here](http://www.gamehouse.com/blog/leet-speak-cheat-sheet/) or at [Wikipedia](https://en.wikipedia.org/wiki/Leet).

## Task
You will receive a string composed by English words, `string`. You will have to return a cyphered version of that string.

The numbers corresponding to each letter are represented at the table below. Notice that different letters can share the same number. In those cases, one letter will be upper case and the other one lower case.


  .cell {
    border: 1px solid white;
    text-align: center;
    width: 7%;
  }
  
  .title {
    border: 1px solid white;
    border-bottom: 1px solid white;
    text-align: center;
    min-width: 11em;
  }
  
  .no-border {border: none}
  
  table {
    margin-bottom: 10px
  }



  
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    0
  
  
    Upper case
    I
    R
    E
    A
    S
    G
    T
    B
    
    O
  
  
    Lower case
    l
    z
    e
    a
    s
    b
    t
    
    g
    o
  
  



Any character that is not at the table, does not change when cyphered.

## Examples

  * **Input:** "Hello World". **Output**: "H3110 W0r1d"
  * **Input:** "I am your father". **Output**: "1 4m y0ur f47h3r"
  * **Input:** "I do not know what else I can test. Be cool. Good luck". **Output**: "1 d0 n07 kn0w wh47 3153 1 c4n 7357. 83 c001. 600d 1uck"

## Part II
If you liked this Kata, you can find the [part II: *Number encrypting: decypher*](https://www.codewars.com/kata/number-encrypting-decypher), where your goal is to decypher the strings.

Answer: {"fn_name": "cypher", "inputs": [["Hello World"], ["I am your father"], ["I do not know what else I can test. Be cool. Good luck"], ["IlRzEeAaSsGbTtBgOo"], [""]], "outputs": [["H3110 W0r1d"], ["1 4m y0ur f47h3r"], ["1 d0 n07 kn0w wh47 3153 1 c4n 7357. 83 c001. 600d 1uck"], ["112233445566778900"], [""]]}