meetforever/GRPO_CL huggingface dataset:
user: My friend John and I are members of the "Fat to Fit Club (FFC)". John is worried because
each month a list with the weights of members is published and each month he is the last on the list
which means he is the heaviest. 

I am the one who establishes the list so I told him:
"Don't worry any more, I will modify the order of the list".
It was decided to attribute a "weight" to numbers. The weight of a number will be from now on
the sum of its digits. 

For example `99` will have "weight" `18`, `100` will have "weight"
`1` so in the list `100` will come before `99`.
Given a string with the weights of FFC members in normal order can you give this string ordered by "weights" of these numbers?

# Example:

`"56 65 74 100 99 68 86 180 90"` ordered by numbers weights becomes: 
`"100 180 90 56 65 74 68 86 99"`

When two numbers have the same "weight", let us class them as if they were strings (alphabetical ordering) and not numbers:
`100` is before `180` because its "weight" (1) is less than the one of `180` (9)
and `180` is before `90` since, having the same "weight" (9),  it comes before as a *string*.

All numbers in the list are positive numbers and the list can be empty.

# Notes

- it may happen that the input string have leading, trailing whitespaces and more than a unique whitespace between two consecutive numbers
- Don't modify the input
- For C: The result is freed.

Answer: {"fn_name": "order_weight", "inputs": [["103 123 4444 99 2000"], ["2000 10003 1234000 44444444 9999 11 11 22 123"], [""], ["10003 1234000 44444444 9999 2000 123456789"], ["3 16 9 38 95 1131268 49455 347464 59544965313 496636983114762 85246814996697"], ["71899703 200 6 91 425 4 67407 7 96488 6 4 2 7 31064 9 7920 1 34608557 27 72 18 81"], ["387087 176 351832 100 430372 8 58052 54 175432 120 269974 147 309754 91 404858 67 271476 164 295747 111 40"]], "outputs": [["2000 103 123 4444 99"], ["11 11 2000 10003 22 123 1234000 44444444 9999"], [""], ["2000 10003 1234000 44444444 9999 123456789"], ["3 16 9 38 95 1131268 49455 347464 59544965313 496636983114762 85246814996697"], ["1 2 200 4 4 6 6 7 7 18 27 72 81 9 91 425 31064 7920 67407 96488 34608557 71899703"], ["100 111 120 40 8 54 91 164 147 67 176 430372 58052 175432 351832 271476 309754 404858 387087 295747 269974"]]}
user: Write a simple function that takes polar coordinates (an angle in degrees and a radius) and returns the equivalent cartesian coordinates (rouded to 10 places).

```
For example:

coordinates(90,1)
=> (0.0, 1.0)

coordinates(45, 1)
=> (0.7071067812, 0.7071067812)
```

Answer: {"fn_name": "coordinates", "inputs": [[90, 1], [90, 2], [0, 1], [45, 1], [1090, 10000], [-270, 1]], "outputs": [[[0.0, 1.0]], [[0.0, 2.0]], [[1.0, 0.0]], [[0.7071067812, 0.7071067812]], [[9848.0775301221, 1736.4817766693]], [[0.0, 1.0]]]}
user: Given few numbers, you need to print out the digits that are not being used.

Example:

```python
unused_digits(12, 34, 56, 78) # "09"
unused_digits(2015, 8, 26) # "3479"
```

Note:

- Result string should be sorted
- The test case won't pass Integer with leading zero

Answer: {"fn_name": "unused_digits", "inputs": [[12, 34, 56, 78], [2015, 8, 26], [276, 575], [643], [864, 896, 744], [364, 500, 715, 730], [93, 10, 11, 40], [1, 11, 111, 1111, 11111], [9, 87, 654, 3210]], "outputs": [["09"], ["3479"], ["013489"], ["0125789"], ["01235"], ["289"], ["25678"], ["023456789"], [""]]}
user: Implement a function called makeAcronym that returns the first letters of each word in a passed in string.

Make sure the letters returned are uppercase.

If the value passed in is not a string return 'Not a string'.

If the value passed in is a string which contains characters other than spaces and alphabet letters, return 'Not letters'.

If the string is empty, just return the string itself: "".

**EXAMPLES:**
```
'Hello codewarrior' -> 'HC'

'a42' -> 'Not letters'

42 -> 'Not a string'

[2,12] -> 'Not a string'

{name: 'Abraham'} -> 'Not a string'
```

Answer: {"fn_name": "make_acronym", "inputs": [["My aunt sally"], ["Please excuse my dear aunt Sally"], ["How much wood would a woodchuck chuck if a woodchuck could chuck wood"], ["Unique New York"], ["a42"], ["1111"], [64], [[]], [{}], [""]], "outputs": [["MAS"], ["PEMDAS"], ["HMWWAWCIAWCCW"], ["UNY"], ["Not letters"], ["Not letters"], ["Not a string"], ["Not a string"], ["Not a string"], [""]]}
user: # Description:

 Replace the pair of exclamation marks and question marks to spaces(from the left to the right). A pair of exclamation marks and question marks must has the same number of "!" and "?". 
 
 That is: "!" and "?" is a pair; "!!" and "??" is a pair; "!!!" and "???" is a pair; and so on..

# Examples

```
replace("!!") === "!!"
replace("!??") === "!??"
replace("!?") === "  "
replace("!!??") === "    "
replace("!!!????") === "!!!????"
replace("!??!!") === "!    "
replace("!????!!!?") === " ????!!! " 
replace("!?!!??!!!?") === "      !!!?"
```

Answer: {"fn_name": "replace", "inputs": [["!!?!!?!!?!!?!!!??!!!??!!!??"], ["??!??!??!??!???!!???!!???!!"], ["?!!?!!?!!?!!!??!!!??!!!??!!!??!!!??"]], "outputs": [["  ?  ?  ?!!?!!!  !!!  !!!  "], ["  !  !  !??!???  ???  ???  "], ["?  ?  ?  ?!!!  !!!  !!!  !!!??!!!??"]]}
user: When provided with a String, capitalize all vowels

For example:

Input : "Hello World!"

Output : "HEllO WOrld!"

Note: Y is not a vowel in this kata.

Answer: {"fn_name": "swap", "inputs": [["HelloWorld!"], ["Sunday"], ["Codewars"], ["Monday"], ["Friday"], ["abracadabra"]], "outputs": [["HEllOWOrld!"], ["SUndAy"], ["COdEwArs"], ["MOndAy"], ["FrIdAy"], ["AbrAcAdAbrA"]]}
user: Consider the range `0` to `10`. The primes in this range are: `2, 3, 5, 7`, and thus the prime pairs are: `(2,2), (2,3), (2,5), (2,7), (3,3), (3,5), (3,7),(5,5), (5,7), (7,7)`.

Let's take one pair `(2,7)` as an example and get the product, then sum the digits of the result as follows:  `2 * 7 = 14`, and `1 + 4 = 5`. We see that `5` is a prime number. Similarly, for the pair `(7,7)`, we get: `7 * 7 = 49`, and `4 + 9 = 13`, which is a prime number. 

You will be given a range and your task is to return the number of pairs that revert to prime as shown above. In the range `(0,10)`, there are only `4` prime pairs that end up being primes in a similar way: `(2,7), (3,7), (5,5), (7,7)`. Therefore, `solve(0,10) = 4)`

Note that the upperbound of the range will not exceed `10000`. A range of `(0,10)` means that: `0 <= n < 10`.

Good luck!

If you like this Kata, please try 

[Simple Prime Streaming](https://www.codewars.com/kata/5a908da30025e995880000e3)

[Prime reduction](https://www.codewars.com/kata/59aa6567485a4d03ff0000ca)

[Dominant primes](https://www.codewars.com/kata/59ce11ea9f0cbc8a390000ed)

Answer: {"fn_name": "solve", "inputs": [[0, 20], [2, 200], [2, 2000], [1000, 3000], [2000, 5000]], "outputs": [[14], [457], [17705], [12801], [25005]]}
user: In this kata, you will write a function that returns the positions and the values of the "peaks" (or local maxima) of a numeric array.

For example, the array `arr = [0, 1, 2, 5, 1, 0]` has a peak at position `3` with a value of `5` (since `arr[3]` equals `5`).

~~~if-not:php,cpp,java,csharp
The output will be returned as an object with two properties: pos and peaks. Both of these properties should be arrays. If there is no peak in the given array, then the output should be `{pos: [], peaks: []}`.
~~~
~~~if:php
The output will be returned as an associative array with two key-value pairs: `'pos'` and `'peaks'`.  Both of them should be (non-associative) arrays.  If there is no peak in the given array, simply return `['pos' => [], 'peaks' => []]`.
~~~
~~~if:cpp
The output will be returned as an object of type `PeakData` which has two members: `pos` and `peaks`.  Both of these members should be `vector`s.  If there is no peak in the given array then the output should be a `PeakData` with an empty vector for both the `pos` and `peaks` members.

`PeakData` is defined in Preloaded as follows:

~~~
~~~if:java
The output will be returned as a ``Map>` with two key-value pairs: `"pos"` and `"peaks"`. If there is no peak in the given array, simply return `{"pos" => [], "peaks" => []}`.
~~~
~~~if:csharp
The output will be returned as a `Dictionary>` with two key-value pairs: `"pos"` and `"peaks"`. 
If there is no peak in the given array, simply return `{"pos" => new List(), "peaks" => new List()}`.
~~~

Example: `pickPeaks([3, 2, 3, 6, 4, 1, 2, 3, 2, 1, 2, 3])` should return `{pos: [3, 7], peaks: [6, 3]}` (or equivalent in other languages)

All input arrays will be valid integer arrays (although it could still be empty), so you won't need to validate the input.

The first and last elements of the array will not be considered as peaks (in the context of a mathematical function, we don't know what is after and before and therefore, we don't know if it is a peak or not).

Also, beware of plateaus !!! `[1, 2, 2, 2, 1]` has a peak while `[1, 2, 2, 2, 3]` does not. In case of a plateau-peak, please only return the position and value of the beginning of the plateau. For example: 
`pickPeaks([1, 2, 2, 2, 1])` returns `{pos: [1], peaks: [2]}` (or equivalent in other languages)

Have fun!

Answer: {"fn_name": "pick_peaks", "inputs": [[[1, 2, 3, 6, 4, 1, 2, 3, 2, 1]], [[3, 2, 3, 6, 4, 1, 2, 3, 2, 1, 2, 3]], [[3, 2, 3, 6, 4, 1, 2, 3, 2, 1, 2, 2, 2, 1]], [[2, 1, 3, 1, 2, 2, 2, 2, 1]], [[2, 1, 3, 1, 2, 2, 2, 2]], [[2, 1, 3, 2, 2, 2, 2, 5, 6]], [[2, 1, 3, 2, 2, 2, 2, 1]], [[1, 2, 5, 4, 3, 2, 3, 6, 4, 1, 2, 3, 3, 4, 5, 3, 2, 1, 2, 3, 5, 5, 4, 3]], [[]], [[1, 1, 1, 1]]], "outputs": [[{"pos": [3, 7], "peaks": [6, 3]}], [{"pos": [3, 7], "peaks": [6, 3]}], [{"pos": [3, 7, 10], "peaks": [6, 3, 2]}], [{"pos": [2, 4], "peaks": [3, 2]}], [{"pos": [2], "peaks": [3]}], [{"pos": [2], "peaks": [3]}], [{"pos": [2], "peaks": [3]}], [{"pos": [2, 7, 14, 20], "peaks": [5, 6, 5, 5]}], [{"pos": [], "peaks": []}], [{"pos": [], "peaks": []}]]}
user: Your company, [Congo Pizza](http://interesting-africa-facts.com/Africa-Landforms/Congo-Rainforest-Facts.html), is the second-largest online frozen pizza retailer. You own a number of international warehouses that you use to store your frozen pizzas, and you need to figure out how many crates of pizzas you can store at each location.

Congo recently standardized its storage containers: all pizzas fit inside a *cubic crate, 16-inchs on a side*. The crates are super tough so you can stack them as high as you want.

Write a function `box_capacity()` that figures out how many crates you can store in a given warehouse. The function should take three arguments: the length, width, and height of your warehouse (in feet) and should return an integer representing the number of boxes you can store in that space.

For example: a warehouse 32 feet long, 64 feet wide, and 16 feet high can hold 13,824 boxes because you can fit 24 boxes across, 48 boxes deep, and 12 boxes high, so `box_capacity(32, 64, 16)` should return `13824`.

Answer: {"fn_name": "box_capacity", "inputs": [[32, 64, 16], [20, 20, 20], [80, 40, 20], [70, 60, 15], [90, 7, 5], [53, 21, 13]], "outputs": [[13824], [3375], [27000], [25740], [1005], [5265]]}
user: # Task
 In ChessLand there is a small but proud chess bishop with a recurring dream. 
 
 In the dream the bishop finds itself on an `n × m` chessboard with mirrors along each edge, and it is not a bishop but a ray of light. This ray of light moves only along diagonals (the bishop can't imagine any other types of moves even in its dreams), it never stops, and once it reaches an edge or a corner of the chessboard it reflects from it and moves on.

 Given the initial position and the direction of the ray, find its position after `k` steps where a step means either moving from one cell to the neighboring one or reflecting from a corner of the board.

# Example

 For `boardSize = [3, 7], initPosition = [1, 2], initDirection = [-1, 1] and k = 13,` the output should be `[0, 1]`.

 Here is the bishop's path:
```
[1, 2] -> [0, 3] -(reflection from the top edge)
         -> [0, 4] -> [1, 5] -> [2, 6] -(reflection from the bottom right corner)
         -> [2, 6] ->[1, 5] -> [0, 4] -(reflection from the top edge)
         -> [0, 3] ->[1, 2] -> [2, 1] -(reflection from the bottom edge)
         -> [2, 0] -(reflection from the left edge)
         -> [1, 0] -> [0, 1]```

 ![](https://codefightsuserpics.s3.amazonaws.com/tasks/chessBishopDream/img/example.png?_tm=1472324389202)

# Input/Output


 - `[input]` integer array `boardSize`

    An array of two integers, the number of `rows` and `columns`, respectively. Rows are numbered by integers from `0 to boardSize[0] - 1`, columns are numbered by integers from `0 to boardSize[1] - 1` (both inclusive).

    Constraints: `1 ≤ boardSize[i] ≤ 20.`


 - `[input]` integer array `initPosition`

    An array of two integers, indices of the `row` and the `column` where the bishop initially stands, respectively.

    Constraints:  `0 ≤ initPosition[i] < boardSize[i]`.


 - `[input]` integer array `initDirection`

    An array of two integers representing the initial direction of the bishop. 
    
    If it stands in `(a, b)`, the next cell he'll move to is `(a + initDirection[0], b + initDirection[1])` or whichever it'll reflect to in case it runs into a mirror immediately.

    Constraints: `initDirection[i] ∈ {-1, 1}`.


 - `[input]` integer `k`

    Constraints: `1 ≤ k ≤ 1000000000`.


 - `[output]` an integer array

    The position of the bishop after `k` steps.

Answer: {"fn_name": "chess_bishop_dream", "inputs": [[[3, 7], [1, 2], [-1, 1], 13], [[1, 2], [0, 0], [1, 1], 6], [[2, 2], [1, 0], [1, 1], 12], [[1, 1], [0, 0], [1, -1], 1000000000], [[2, 3], [1, 2], [-1, -1], 41], [[17, 19], [14, 8], [1, -1], 239239], [[17, 19], [16, 18], [1, 1], 239239239]], "outputs": [[[0, 1]], [[0, 1]], [[1, 0]], [[0, 0]], [[0, 2]], [[4, 17]], [[10, 2]]]}
user: For all x in the range of integers [0, 2 ** n), let y[x] be the binary exclusive-or of x and x // 2. Find the sum of all numbers in y.

Write a function sum_them that, given n, will return the value of the above sum.

This can be implemented a simple loop as shown in the initial code. But once n starts getting to higher numbers, such as 2000 (which will be tested), the loop is too slow.

There is a simple solution that can quickly find the sum. Find it!

Assume that n is a nonnegative integer.

Hint: The complete solution can be written in two lines.

Answer: {"fn_name": "sum_them", "inputs": [[0], [1], [2], [3], [4]], "outputs": [[0], [1], [6], [28], [120]]}
user: # Do you speak retsec?
You and your friends want to play undercover agents. In order to exchange your *secret* messages, you've come up with the following system: you take the word, cut it in half, and place the first half behind the latter. If the word has an uneven number of characters, you leave the middle at its previous place:

![retsec examples](http://i.imgur.com/Ozy6p09.png)

That way, you'll be able to exchange your messages in private.

# Task
You're given a single word. Your task is to swap the halves. If the word has an uneven length, leave the character in the middle at that position and swap the chunks around it.

## Examples
```python
reverse_by_center("secret")  == "retsec" # no center character
reverse_by_center("agent")   == "nteag"  # center character is "e"
```

## Remarks
Don't use this to actually exchange messages in private.

Answer: {"fn_name": "reverse_by_center", "inputs": [["secret"], ["agent"], ["raw"], ["onion"]], "outputs": [["retsec"], ["nteag"], ["war"], ["onion"]]}
user: Lеt's create function to play cards. Our rules:

We have the preloaded `deck`:

```
deck = ['joker','2♣','3♣','4♣','5♣','6♣','7♣','8♣','9♣','10♣','J♣','Q♣','K♣','A♣',
                '2♦','3♦','4♦','5♦','6♦','7♦','8♦','9♦','10♦','J♦','Q♦','K♦','A♦',
                '2♥','3♥','4♥','5♥','6♥','7♥','8♥','9♥','10♥','J♥','Q♥','K♥','A♥',
                '2♠','3♠','4♠','5♠','6♠','7♠','8♠','9♠','10♠','J♠','Q♠','K♠','A♠']
```

We have 3 arguments:

`card1` and `card2` - any card of our deck.

`trump` - the main suit of four ('♣', '♦', '♥', '♠').

If both cards have the same suit, the big one wins.

If the cards have different suits (and no one has trump) return 'Let's play again.'

If one card has `trump` unlike another, wins the first one.

If both cards have `trump`, the big one wins.

If `card1` wins, return 'The first card won.' and vice versa.

If the cards are equal, return 'Someone cheats.'

A few games:

```
('3♣', 'Q♣', '♦') -> 'The second card won.'

('5♥', 'A♣', '♦') -> 'Let us play again.'

('8♠', '8♠', '♣') -> 'Someone cheats.'

('2♦', 'A♠', '♦') -> 'The first card won.'

('joker', 'joker', '♦') -> 'Someone cheats.'

```
P.S. As a card you can also get the string 'joker' - it means this card always wins.

Answer: {"fn_name": "card_game", "inputs": [["Q\u2663", "3\u2663", "\u2666"], ["3\u2663", "Q\u2663", "\u2666"], ["5\u2665", "A\u2663", "\u2666"], ["8\u2660", "8\u2660", "\u2663"], ["2\u2666", "A\u2660", "\u2666"], ["A\u2660", "2\u2666", "\u2666"], ["joker", "joker", "\u2666"], ["joker", "10\u2663", "\u2660"], ["10\u2663", "joker", "\u2660"]], "outputs": [["The first card won."], ["The second card won."], ["Let us play again."], ["Someone cheats."], ["The first card won."], ["The second card won."], ["Someone cheats."], ["The first card won."], ["The second card won."]]}
user: Write a function that takes two arguments, and returns a new array populated with the elements **that only appear once, in either one array or the other, taken only once**; display order should follow what appears in arr1 first, then arr2: 

```python
hot_singles([1, 2, 3, 3], [3, 2, 1, 4, 5]) # [4, 5]
hot_singles(["tartar", "blanket", "cinnamon"], ["cinnamon", "blanket", "domino"]) # ["tartar", "domino"]
hot_singles([77, "ciao"], [78, 42, "ciao"]) # [77, 78, 42]
hot_singles([1, 2, 3, 3], [3, 2, 1, 4, 5, 4]) # [4,5]
```

SPECIAL THANKS: @JulianKolbe !

Answer: {"fn_name": "hot_singles", "inputs": [[["tartar", "blanket", "domino"], ["blanket"]], [[77, "basketweave"], [78, 42, "basketweave"]], [[100, 45, "ciao"], [100, 2, 3, 45, 5]], [[10, 200, 30], [10, 20, 3, 4, 5, 5, 5, 200]], [[1, 2, 3, 3], [3, 2, 1, 4, 5, 4]]], "outputs": [[["tartar", "domino"]], [[77, 78, 42]], [["ciao", 2, 3, 5]], [[30, 20, 3, 4, 5]], [[4, 5]]]}
user: Gigi is a clever monkey, living in the zoo, his teacher (animal keeper) recently taught him some knowledge of "0".

In Gigi's eyes, "0" is a character contains some circle(maybe one, maybe two).

So, a is a "0",b is a "0",6 is also a "0"，and 8 have two "0" ,etc...

Now, write some code to count how many "0"s in the text.

Let us see who is smarter? You ? or monkey?

Input always be a string(including words numbers and symbols)，You don't need to verify it, but pay attention to the difference between uppercase and lowercase letters.

Here is a table of characters：

one zeroabdegopq069DOPQR         () <-- A pair of braces as a zerotwo zero%&B8

Output will be a number of "0".

Answer: {"fn_name": "countzero", "inputs": [[""], ["0"], ["0oO0oO"], ["1234567890"], ["abcdefghijklmnopqrstuvwxyz"], ["()"], ["E"], ["aA"], ["BRA"], ["%%"]], "outputs": [[0], [1], [6], [5], [8], [1], [0], [1], [3], [4]]}
user: Write a comparator for a list of phonetic words for the letters of the [greek alphabet](https://en.wikipedia.org/wiki/Greek_alphabet).

A comparator is:
> *a custom comparison function of two arguments (iterable elements) which should return a negative, zero or positive number depending on whether the first argument is considered smaller than, equal to, or larger than the second argument*

*(source: https://docs.python.org/2/library/functions.html#sorted)*

The greek alphabet is preloded for you as `greek_alphabet`:

```python
greek_alphabet = (
    'alpha', 'beta', 'gamma', 'delta', 'epsilon', 'zeta', 
    'eta', 'theta', 'iota', 'kappa', 'lambda', 'mu', 
    'nu', 'xi', 'omicron', 'pi', 'rho', 'sigma',
    'tau', 'upsilon', 'phi', 'chi', 'psi', 'omega')
```

## Examples

```python
greek_comparator('alpha', 'beta')   <  0
greek_comparator('psi', 'psi')      == 0
greek_comparator('upsilon', 'rho')  >  0
```

Answer: {"fn_name": "greek_comparator", "inputs": [["chi", "chi"]], "outputs": [[0]]}
user: You are the Dungeon Master for a public DnD game at your local comic shop and recently you've had some trouble keeping your players' info neat and organized so you've decided to write a bit of code to help keep them sorted!

The goal of this code is to create an array of objects that stores a player's name and contact number from a given string.

The method should return an empty array if the argument passed is an empty string or `nil`/`None`/`null`.

## Examples

```ruby 
player_manager("John Doe, 8167238327, Jane Doe, 8163723827") returns [{player: "John Doe", contact: 8167238327}, {player: "Jane Doe", contact: 8163723827}]
player_manager(nil) returns []
player_manager("") returns []
```
```python
player_manager("John Doe, 8167238327, Jane Doe, 8163723827") returns [{"player": "John Doe", "contact": 8167238327}, {"player": "Jane Doe", "contact": 8163723827}]
player_manager(None) returns []
player_manager("")   returns []
```
```
playerManager("John Doe, 8167238327, Jane Doe, 8163723827") returns [{player: "John Doe", contact: 8167238327}, {player: "Jane Doe", contact: 8163723827}]
playerManager(null) returns []
playerManager("")   returns []
```

Have at thee!

Answer: {"fn_name": "player_manager", "inputs": [["a, 5"], ["jane, 801, dave, 123"], ["Amelia, 8165254325, Jessie, 9187162345, Marcus Kaine, 8018273245"], [""], [null]], "outputs": [[[{"player": "a", "contact": 5}]], [[{"player": "jane", "contact": 801}, {"player": "dave", "contact": 123}]], [[{"player": "Amelia", "contact": 8165254325}, {"player": "Jessie", "contact": 9187162345}, {"player": "Marcus Kaine", "contact": 8018273245}]], [[]], [[]]]}
user: Chuck has lost count of how many asses he has kicked...

Chuck stopped counting at 100,000 because he prefers to kick things in the face instead of counting. That's just who he is.

To stop having to count like a mere mortal chuck developed his own special code using the hairs on his beard. You do not need to know the details of how it works, you simply need to know that the format is as follows: 'A8A8A8A8A8.-A%8.88.'

In Chuck's code, 'A' can be any capital letter and '8' can be any number 0-9 and any %, - or . symbols must not be changed.

Your task, to stop Chuck beating your ass with his little finger, is to use regex to verify if the number is a genuine Chuck score. If not it's probably some crap made up by his nemesis Bruce Lee. Return true if the provided count passes, and false if it does not.  

```Javascript
Example:
     'A8A8A8A8A8.-A%8.88.' <- don't forget final full stop :D\n
Tests:
     'A2B8T1Q9W4.-F%5.34.' == true;
     'a2B8T1Q9W4.-F%5.34.' == false; (small letter)
     'A2B8T1Q9W4.-F%5.3B.' == false; (last char should be number) 
     'A2B8T1Q9W4.£F&5.34.' == false; (symbol changed from - and %)
 ```

The pattern only needs to appear within the text. The full input can be longer, i.e. the pattern can be surrounded by other characters... Chuck loves to be surrounded!

Ready, steady, VERIFY!!

Answer: {"fn_name": "body_count", "inputs": [["A6C2E5Z9A4.-F%8.08."], ["PP P6A6T5F5S3.-Z%1.11.hgr"], ["A6A1E3A8M2.-Q%8.88."], ["d G8H1E2O9N3.-W%8.56. f"], ["B4A1D1I8B4.-E%8.76."], ["ffr65A C8K4D9U7V5.-Y%8.00."], [" 76     B2L4D0A8C6.-T%8.90.       lkd"], ["B2L4D0A8C6.-T%8.90"], ["B2L4D0AFC6.-T%8.90."], ["B4A1D1I8B4"], ["B4A6666..."], ["B4A1D1I000.-E%0.00.)"], [".-E%8.76."], ["B4A1t6I7.-E%8.76."], ["b4A1D1I8B4.-E%8.76."]], "outputs": [[true], [true], [true], [true], [true], [true], [true], [false], [false], [false], [false], [false], [false], [false], [false]]}
user: Implement a function which behaves like the uniq command in UNIX.

It takes as input a sequence and returns a sequence in which all duplicate elements following each other have been reduced to one instance.

Example:

```
["a", "a", "b", "b", "c", "a", "b", "c"]  =>  ["a", "b", "c", "a", "b", "c"]
```

Answer: {"fn_name": "uniq", "inputs": [[["a", "a", "b", "b", "c", "a", "b", "c", "c"]], [["a", "a", "a", "b", "b", "b", "c", "c", "c"]], [[]], [["foo"]], [["bar"]], [[""]], [[null, "a", "a"]]], "outputs": [[["a", "b", "c", "a", "b", "c"]], [["a", "b", "c"]], [[]], [["foo"]], [["bar"]], [[""]], [[null, "a"]]]}