meetforever/GRPO_CL huggingface dataset:
user: Our friendly friend Pete is really a nice person, but he tends to be rather... Inappropriate.

And possibly loud, if given enough ethanol and free rein, so we ask you to write a function that should take its not always "clean" speech and cover as much as possible of it, in order not to offend some more sensible spirits.

For example, given an input like
```
What the hell am I doing here? And where is my wallet? PETE SMASH!
```
You are expected to turn it into something like:
```
W**t t*e h**l am i d***g h**e? A*d w***e is my w****t? P**e s***h!
```
In case you didn't figure out the rules yet: any words longer than 2 characters need to have its "inside" (meaning every character which is not the first or the last) changed into `*`;  as we do not want Pete to scream too much, every uppercase letter which is not at the beginning of the string or coming after a punctuation mark among [".","!","?"] needs to be put to lowercase; spaces and other punctuation marks can be ignored.

Conversely, you need to be sure that the start of each sentence has a capitalized word at the beginning. Sentences are divided by the aforementioned punctuation marks.

Finally, the function will take an additional parameter consisting of an array/list of allowed words (upper or lower case) which are not to be replaced (the match has to be case insensitive).

Extra cookies if you can do it all in some efficient way and/or using our dear regexes ;)

**Note:** Absolutely not related to [a certain codewarrior I know](http://www.codewars.com/users/petegarvin1) :p

Answer: {"fn_name": "pete_talk", "inputs": [["I want to punch someone in the face"], ["uh!"], ["What the hell am I doing here? And where is my wallet? PETE SMASH!"], ["I want to punch someone in the face", ["someone", "face"]], ["I want to punch someone in the face", ["drink", "job", "girls"]]], "outputs": [["I w**t to p***h s*****e in t*e f**e"], ["Uh!"], ["W**t t*e h**l am i d***g h**e? A*d w***e is my w****t? P**e s***h!"], ["I w**t to p***h someone in t*e face"], ["I w**t to p***h s*****e in t*e f**e"]]}
user: # Task
 You are given three integers `l, d and x`. Your task is:
```
• determine the minimal integer n 
    such that l ≤ n ≤ d, and the sum of its digits equals x.
• determine the maximal integer m 
    such that l ≤ m ≤ d, and the sum of its digits equals x.
```
It is guaranteed that such numbers always exist.

# Input/Output


 - `[input]` integer `l`

 - `[input]` integer `d`

  `1 ≤ l ≤ d ≤ 10000.`


 - `[input]` integer `x`

  `1 ≤ x ≤ 36`


 - `[output]` an integer array

  Array of two elements, where the first element is `n`, and the second one is `m`.


# Example

 For `l = 500, d = 505, x = 10`, the output should be `[505, 505]`.
 
 For `l = 100, d = 200, x = 10`, the output should be `[109, 190]`.

Answer: {"fn_name": "min_and_max", "inputs": [[100, 200, 10], [123, 456, 5], [99, 501, 5], [99, 234, 1], [99, 234, 19], [99, 5001, 27], [99, 5001, 28], [2000, 7000, 3]], "outputs": [[[109, 190]], [[131, 410]], [[104, 500]], [[100, 100]], [[199, 199]], [[999, 4995]], [[1999, 4996]], [[2001, 3000]]]}
user: Bleatrix Trotter the sheep has devised a strategy that helps her fall asleep faster. First, she picks a number N. Then she starts naming N, 2 × N, 3 × N, and so on.
Whenever she names a number, she thinks about all of the digits in that number. She keeps track of which digits (0, 1, 2, 3, 4, 5, 6, 7, 8, and 9) she has seen at least once so far as part of any number she has named. Once she has seen each of the ten digits at least once, she will fall asleep.
Bleatrix must start with N and must always name (i + 1) × N directly after i × N.
For example, suppose that Bleatrix picks N = 1692. She would count as follows:

N = 1692. Now she has seen the digits 1, 2, 6, and 9.
2N = 3384. Now she has seen the digits 1, 2, 3, 4, 6, 8, and 9.
3N = 5076. Now she has seen all ten digits, and falls asleep.

The purpose of this kata is to return the last number Bleatrix Trotter sees before falling asleep.
Input
Will always be positive integer or zero

Output
The last number Bleatrix Trotter sees or "INSOMNIA" (-1 in Rust and C++) if she will count forever

Please note, this challenge is not my idea. It's from Google Code Jam 2016

Answer: {"fn_name": "trotter", "inputs": [[1692], [2], [7], [100], [1], [11], [163444], [206929], [459923], [691520], [0], [12500], [1250000]], "outputs": [[5076], [90], [70], [900], [10], [110], [653776], [620787], [4139307], [2074560], ["INSOMNIA"], [900000], [90000000]]}
user: ## If/else syntax debug

While making a game, your partner, Greg, decided to create a function to check if the user is still alive called `checkAlive`/`CheckAlive`/`check_alive`. Unfortunately, Greg made some errors while creating the function.

`checkAlive`/`CheckAlive`/`check_alive` should return true if the player's health is greater than 0 or false if it is 0 or below. 

```if-not:csharp
The function receives one parameter `health` which will always be a whole number between -10 and 10.
```

Answer: {"fn_name": "check_alive", "inputs": [[5], [0], [-5]], "outputs": [[true], [false], [false]]}
user: Looking at consecutive powers of `2`, starting with `2^1`:

`2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, ...`

Note that out of all the digits `0-9`, the last one ever to appear is `7`. It only shows up for the first time in the number `32768 (= 2^15)`.

So let us define LAST DIGIT TO APPEAR as the last digit to be written down when writing down all the powers of `n`, starting with `n^1`.


## Your task

You'll be given a positive integer ```1 =< n <= 10000```, and must return the last digit to appear, as an integer.

If for any reason there are digits which never appear in the sequence of powers, return `None`/`nil`.

Please note: The Last digit to appear can be in the same number as the penultimate one. For example for `n = 8`, the last digit to appear is `7`, although `3` appears slightly before it, in the same number:
`8, 64, 512, 4096, 32768, ...`

Answer: {"fn_name": "LDTA", "inputs": [[100], [2], [3], [8], [1111], [3000]], "outputs": [[null], [7], [0], [7], [9], [5]]}
user: Task
======

Make a custom esolang interpreter for the language [InfiniTick](https://esolangs.org/wiki/InfiniTick). InfiniTick is a descendant of [Tick](https://esolangs.org/wiki/tick) but also very different. Unlike Tick, InfiniTick has 8 commands instead of 4. It also runs infinitely, stopping the program only when an error occurs. You may choose to do the [Tick](https://www.codewars.com/kata/esolang-tick) kata first.

Syntax/Info
======

InfiniTick runs in an infinite loop. This makes it both harder and easier to program in. It has an infinite memory of bytes and an infinite output amount. The program only stops when an error is reached. The program is also supposed to ignore non-commands.

Commands
======

`>`: Move data selector right.

`<`: Move data selector left.

`+`: Increment amount of memory cell. Truncate overflow: 255+1=0.

`-`: Decrement amount of memory cell. Truncate overflow: 0-1=255.

`*`: Add ascii value of memory cell to the output tape.

`&`: Raise an error, ie stop the program.

`/`: Skip next command if cell value is zero.

`\`: Skip next command if cell value is nonzero.

Examples
======

**Hello world!**

The following is a valid hello world program in InfiniTick.

```
'++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++**>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*>++++++++++++++++++++++++++++++++*>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*<<*>>>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*<<<<*>>>>>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*>+++++++++++++++++++++++++++++++++*&'
```

Notes
======

* Please be wordy and post your likes/dislikes in the discourse area.
* If this kata is a duplicate or uses incorrect style, this is not an issue, this is a suggestion.
* Please don't edit this kata just to change the estimated rank. Thank you!

Answer: {"fn_name": "interpreter", "inputs": [["\\h*&"], ["+-*&"]], "outputs": [["\u0000"], ["\u0000"]]}
user: Sam has opened a new sushi train restaurant - a restaurant where sushi is served on plates that travel around the bar on a conveyor belt and customers take the plate that they like.

Sam is using Glamazon's new visual recognition technology that allows a computer to record the number of plates at a customer's table and the colour of those plates.  The number of plates is returned as a string.  For example, if a customer has eaten 3 plates of sushi on a red plate the computer will return the string 'rrr'.

Currently, Sam is only serving sushi on red plates as he's trying to attract customers to his restaurant.  There are also small plates on the conveyor belt for condiments such as ginger and wasabi - the computer notes these in the string that is returned as a space ('rrr r' //denotes 4 plates of red sushi and a plate of condiment).

Sam would like your help to write a program for the cashier's machine to read the string and return the total amount a customer has to pay when they ask for the bill.  The current price for the dishes are as follows:  

 * Red plates of sushi ('r') - $2 each, but if a customer eats 5 plates the 5th one is free.
 * Condiments (' ') - free.

```
Input: String
Output: Number

Examples:

Input: 'rr'  Output: 4
Input: 'rr rrr' Output: 8
Input: 'rrrrr rrrrr' Output: 16

```

Answer: {"fn_name": "total_bill", "inputs": [["rr"], ["rr rrr"], ["rr rrr rrr rr"], ["rrrrrrrrrrrrrrrrrr   rr r"], [""]], "outputs": [[4], [8], [16], [34], [0]]}
user: In this kata your mission is to rotate matrix counter - clockwise N-times.

So, you will have 2 inputs:

    1)matrix

    2)a number, how many times to turn it

And an output is turned matrix.  
Example:

    matrix = [[1, 2, 3, 4],
              [5, 6, 7, 8],
              [9, 10, 11, 12],
              [13, 14, 15, 16]]
          
    times_to_turn = 1

It should return this:

    [[4, 8, 12, 16],
     [3, 7, 11, 15],
     [2, 6, 10, 14],
     [1, 5, 9, 13]])

Note: all matrixes will be square. Also random tests will have big numbers in input (times to turn)

Happy coding!

Answer: {"fn_name": "rotate_against_clockwise", "inputs": [[[[1, 2], [3, 4]], 1], [[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]], 1], [[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]], 2], [[[1, 2, 3, 4, 5, 6, 7, 8], [9, 10, 11, 12, 13, 14, 15, 16], [17, 18, 19, 20, 21, 22, 23, 24], [25, 26, 27, 28, 29, 30, 31, 32], [33, 34, 35, 36, 37, 38, 39, 40], [41, 42, 43, 44, 45, 46, 47, 48], [49, 50, 51, 52, 53, 54, 55, 56], [57, 58, 59, 60, 61, 62, 63, 64]], 3]], "outputs": [[[[2, 4], [1, 3]]], [[[4, 8, 12, 16], [3, 7, 11, 15], [2, 6, 10, 14], [1, 5, 9, 13]]], [[[16, 15, 14, 13], [12, 11, 10, 9], [8, 7, 6, 5], [4, 3, 2, 1]]], [[[57, 49, 41, 33, 25, 17, 9, 1], [58, 50, 42, 34, 26, 18, 10, 2], [59, 51, 43, 35, 27, 19, 11, 3], [60, 52, 44, 36, 28, 20, 12, 4], [61, 53, 45, 37, 29, 21, 13, 5], [62, 54, 46, 38, 30, 22, 14, 6], [63, 55, 47, 39, 31, 23, 15, 7], [64, 56, 48, 40, 32, 24, 16, 8]]]]}
user: # Task
 Your task is to find the similarity of given sorted arrays `a` and `b`, which is defined as follows: 
 
 you take the number of elements which are present in both arrays and divide it by the number of elements which are present in at least one array.

 It also can be written as a formula `similarity(A, B) = #(A ∩ B) / #(A ∪ B)`, where `#(C)` is the number of elements in C, `∩` is intersection of arrays, `∪` is union of arrays.

 This is known as `Jaccard similarity`.

 The result is guaranteed to fit any floating-point type without rounding.

# Example

 For `a = [1, 2, 4, 6, 7]` and `b = [2, 3, 4, 7]`:
```
elements [2, 4, 7] are present in both arrays;
elements [1, 2, 3, 4, 6, 7] are present in at least one of the arrays.
So the similarity equals to 3 / 6 = 0.5.```

# Input/Output


 - `[input]` integer array `a`

  A `sorted` array of positive integers. 
  
  All elements are `different` and are `less than 100`.
  
  `1 ≤ a.length ≤ 100`


 - `[input]` integer array `b`

  An array in the same format as `a`.


 - `[output]` a float number

  The similarity of the arrays.
  
  ```Haskell
  
  In Haskell the two arrays are passed as a touple.
  ```

Answer: {"fn_name": "similarity", "inputs": [[[1, 2, 3], [1, 2, 3]], [[1, 2, 3], [4, 5, 6]], [[1, 2, 4, 6, 7], [2, 3, 4, 7]], [[1, 2, 6, 8, 9], [0, 1, 4, 5, 6, 8, 9]], [[0, 1, 3, 4, 5, 6, 9, 14, 15, 16, 17, 18, 19], [1, 4, 10, 12, 13, 14, 15, 16]]], "outputs": [[1], [0], [0.5], [0.5], [0.3125]]}
user: Implement a function to calculate the sum of the numerical values in a nested list. For example :

```python
sum_nested([1, [2, [3, [4]]]]) -> 10
```

Answer: {"fn_name": "sum_nested", "inputs": [[[1]], [[1, 2, 3, 4]], [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]], [[]], [[[1], []]], [[[1, 2, 3, 4]]], [[[], []]], [[1, [1], [[1]], [[[1]]]]], [[1, [1], [1, [1]], [1, [1], [1, [1]]]]], [[[[[], [], [[[[[[[[[[]]]]]]]]]]], [], [], [[[], [[]]]]], []]]], "outputs": [[1], [10], [55], [0], [1], [10], [0], [4], [8], [0]]}
user: # Base reduction

## Input

A positive integer:
```
0 < n < 1000000000
```

## Output

The end result of the base reduction.

If it cannot be fully reduced (reduced down to a single-digit number), return -1.

Assume that if 150 conversions from base 11 take place in a row, the number cannot be fully reduced.

## Description

Base reduction is a process where a number is inputted, repeatedly converted into another base, and then outputted if it cannot be reduced anymore. If it cannot be fully reduced, return -1.

During the base conversions, the number is converted from the lowest base it can be converted from into base 10. For example, 123 would be converted from base 4 to base 10, since base 4 is the lowest base that 123 can be in (123 base 3 is impossible; in base 3, there is no digit 3).

If the lowest possible base the number can be converted into is 10, convert the number from base 11 to base 10. For example, 53109 would be converted from base 11 to base 10, since base 10 is the lowest base it can be in.

In the end, you should get a number that cannot be reduced by this process (a single digit number).

## Example

Starting with 5312:
```
5312 base 6 = 1196 base 10
1196 base 11 = 1557 base 10
1557 base 8 = 879 base 10
879 base 11 = 1054 base 10
1054 base 6 = 250 base 10
250 base 6 = 102 base 10
102 base 3 = 11 base 10
11 base 2 = 3 base 10
```
The output would be 3.

Answer: {"fn_name": "basereduct", "inputs": [[10], [5], [7], [7], [15]], "outputs": [[2], [5], [7], [7], [3]]}
user: The Story:
Aliens from Kepler 27b have immigrated to Earth! They have learned English and go to our stores, eat our food, dress like us, ride Ubers, use Google, etc. However, they speak English a little differently. Can you write a program that converts our English to their Alien English?

Task:

Write a function converting their speech to ours. They tend to speak the letter `a` like `o` and `o` like a `u`.
```python
>>> convert('hello')
'hellu'
>>> convert('codewars')
'cudewors'
```

Answer: {"fn_name": "convert", "inputs": [["codewars"], ["hello"]], "outputs": [["cudewors"], ["hellu"]]}
user: Consider the number `1176` and its square (`1176 * 1176) = 1382976`. Notice that:

* the first two digits of `1176` form a prime.
* the first two digits of the square `1382976` also form a prime.
* the last two digits of `1176` and `1382976` are the same. 

Given two numbers representing a range (`a, b`), how many numbers satisfy this property within that range? (`a <= n < b`)


## Example

`solve(2, 1200) = 1`, because only `1176` satisfies this property within the range `2 <= n < 1200`. See test cases for more examples. The upper bound for the range will not exceed `1,000,000`. 

Good luck!

If you like this Kata, please try:

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

[Alphabet symmetry](https://www.codewars.com/kata/59d9ff9f7905dfeed50000b0)

[Upside down numbers](https://www.codewars.com/kata/59f7597716049833200001eb)

Answer: {"fn_name": "solve", "inputs": [[2, 1200], [1176, 1200], [2, 100000], [2, 1000000], [100000, 1000000]], "outputs": [[1], [1], [247], [2549], [2302]]}
user: # Introduction 

Digital Cypher assigns to each letter of the alphabet unique number. For example:

```
 a  b  c  d  e  f  g  h  i  j  k  l  m
 1  2  3  4  5  6  7  8  9 10 11 12 13
 n  o  p  q  r  s  t  u  v  w  x  y  z
14 15 16 17 18 19 20 21 22 23 24 25 26
```

Instead of letters in encrypted word we write the corresponding number, eg. The word scout:

```
 s  c  o  u  t
19  3 15 21 20
```
Then we add to each obtained digit consecutive digits from the key. For example. In case of key equal to `1939` :

```
   s  c  o  u  t
  19  3 15 21 20
 + 1  9  3  9  1
 ---------------
  20 12 18 30 21
  
   m  a  s  t  e  r  p  i  e  c  e
  13  1 19 20  5 18 16  9  5  3  5
+  1  9  3  9  1  9  3  9  1  9  3
  --------------------------------
  14 10 22 29  6 27 19 18  6  12 8
```

# Task

Write a function that accepts an array of integers `code` and a `key` number. As the result, it should return string containg a decoded message from the `code`.

# Input / Output

The `code` is a array of positive integers.
The `key` input is a positive integer.

# Example

``` javascript
decode([ 20, 12, 18, 30, 21],1939);  ==> "scout"
decode([ 14, 10, 22, 29, 6, 27, 19, 18, 6, 12, 8],1939);  ==>  "masterpiece"
```

# Digital cypher series
- [Digital cypher vol 1](https://www.codewars.com/kata/592e830e043b99888600002d)
- [Digital cypher vol 2](https://www.codewars.com/kata/592edfda5be407b9640000b2)
- [Digital cypher vol 3 - missing key](https://www.codewars.com/kata/5930d8a4b8c2d9e11500002a)

Answer: {"fn_name": "decode", "inputs": [[[20, 12, 18, 30, 21], 1939], [[14, 10, 22, 29, 6, 27, 19, 18, 6, 12, 8], 1939]], "outputs": [["scout"], ["masterpiece"]]}
user: Your friend has been out shopping for puppies (what a time to be alive!)... He arrives back with multiple dogs, and you simply do not know how to respond!

By repairing the function provided, you will find out exactly how you should respond, depending on the number of dogs he has.

The number of dogs will always be a number and there will always be at least 1 dog.

```r
The expected behaviour is as follows:
- Your friend has fewer than 10 dogs:                    "Hardly any"
- Your friend has at least 10 but fewer than 51 dogs:    "More than a handful!"
- Your friend has at least 51 but not exactly 101 dogs:  "Woah that's a lot of dogs!"
- Your friend has 101 dogs:                              "101 DALMATIANS!!!"

Your friend will always have between 1 and 101 dogs, inclusive.
```

Answer: {"fn_name": "how_many_dalmatians", "inputs": [[26], [8], [14], [80], [100], [50], [10], [101]], "outputs": [["More than a handful!"], ["Hardly any"], ["More than a handful!"], ["Woah that's a lot of dogs!"], ["Woah that's a lot of dogs!"], ["More than a handful!"], ["Hardly any"], ["101 DALMATIONS!!!"]]}
user: Raj was to move up through a pattern of stairs of a given number **(n)**. Help him to get to the    top using the function **stairs**.

##Keep in mind :
  * If **n<1** then return ' ' .
  * There are a lot of spaces before the stair starts except for **pattern(1)**


##Examples :
  pattern(1)

          1 1

  pattern(6)

                          1 1
                      1 2 2 1  
                  1 2 3 3 2 1
              1 2 3 4 4 3 2 1
          1 2 3 4 5 5 4 3 2 1
      1 2 3 4 5 6 6 5 4 3 2 1

pattern(12)

                                                  1 1
                                              1 2 2 1
                                          1 2 3 3 2 1
                                      1 2 3 4 4 3 2 1
                                  1 2 3 4 5 5 4 3 2 1
                              1 2 3 4 5 6 6 5 4 3 2 1
                          1 2 3 4 5 6 7 7 6 5 4 3 2 1
                      1 2 3 4 5 6 7 8 8 7 6 5 4 3 2 1
                  1 2 3 4 5 6 7 8 9 9 8 7 6 5 4 3 2 1
              1 2 3 4 5 6 7 8 9 0 0 9 8 7 6 5 4 3 2 1
          1 2 3 4 5 6 7 8 9 0 1 1 0 9 8 7 6 5 4 3 2 1
      1 2 3 4 5 6 7 8 9 0 1 2 2 1 0 9 8 7 6 5 4 3 2 1

Answer: {"fn_name": "stairs", "inputs": [[3], [7], [10], [16]], "outputs": [["        1 1\n    1 2 2 1\n1 2 3 3 2 1"], ["                        1 1\n                    1 2 2 1\n                1 2 3 3 2 1\n            1 2 3 4 4 3 2 1\n        1 2 3 4 5 5 4 3 2 1\n    1 2 3 4 5 6 6 5 4 3 2 1\n1 2 3 4 5 6 7 7 6 5 4 3 2 1"], ["                                    1 1\n                                1 2 2 1\n                            1 2 3 3 2 1\n                        1 2 3 4 4 3 2 1\n                    1 2 3 4 5 5 4 3 2 1\n                1 2 3 4 5 6 6 5 4 3 2 1\n            1 2 3 4 5 6 7 7 6 5 4 3 2 1\n        1 2 3 4 5 6 7 8 8 7 6 5 4 3 2 1\n    1 2 3 4 5 6 7 8 9 9 8 7 6 5 4 3 2 1\n1 2 3 4 5 6 7 8 9 0 0 9 8 7 6 5 4 3 2 1"], ["                                                            1 1\n                                                        1 2 2 1\n                                                    1 2 3 3 2 1\n                                                1 2 3 4 4 3 2 1\n                                            1 2 3 4 5 5 4 3 2 1\n                                        1 2 3 4 5 6 6 5 4 3 2 1\n                                    1 2 3 4 5 6 7 7 6 5 4 3 2 1\n                                1 2 3 4 5 6 7 8 8 7 6 5 4 3 2 1\n                            1 2 3 4 5 6 7 8 9 9 8 7 6 5 4 3 2 1\n                        1 2 3 4 5 6 7 8 9 0 0 9 8 7 6 5 4 3 2 1\n                    1 2 3 4 5 6 7 8 9 0 1 1 0 9 8 7 6 5 4 3 2 1\n                1 2 3 4 5 6 7 8 9 0 1 2 2 1 0 9 8 7 6 5 4 3 2 1\n            1 2 3 4 5 6 7 8 9 0 1 2 3 3 2 1 0 9 8 7 6 5 4 3 2 1\n        1 2 3 4 5 6 7 8 9 0 1 2 3 4 4 3 2 1 0 9 8 7 6 5 4 3 2 1\n    1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1\n1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1"]]}
user: Write a function that checks the braces status in a string, and return `True` if all braces are properly closed, or `False` otherwise. Available types of brackets: `()`, `[]`, `{}`.

**Please note, you need to write this function without using regex!**

## Examples
```python
'([[some](){text}here]...)'  =>  True
'{([])}'                     =>  True
'()[]{}()'                   =>  True
'(...[]...{(..())}[abc]())'  =>  True
'1239(df){'                  =>  False
'[()])'                      =>  False
')12[x]34('                  =>  False
```
Don't forget to rate this kata! Thanks :)

Answer: {"fn_name": "braces_status", "inputs": [["[()]"], ["{[]}"], ["{[()]}"], ["([)]"], ["([[some](){text}here]...)"], ["}"], ["[()]]"], ["[()]{("], ["()[]{}()"], ["[[[["]], "outputs": [[true], [true], [true], [false], [true], [false], [false], [false], [true], [false]]}
user: Triangular numbers count the number of objects that can form an equilateral triangle. The nth triangular number forms an equilateral triangle with n dots on each side (including the vertices).
Here is a graphic example for the triangular numbers of 1 to 5:
```
n=1: triangular number: 1
*

n=2: triangular number: 3
 *
* *

n=3: triangular number: 6
  *
 * *
* * *

n=4: triangular number: 10
    *
   * *
  * * *
 * * * *
 
 n=5: triangular number: 15
      *
     * *
    * * *
   * * * *
  * * * * *
```

Your task is to implement a function ```triangular_range(start, stop)``` that returns a dictionary of all numbers as keys and the belonging triangular numbers as values, where the triangular number is in the range start, stop (including start and stop).
For example, ```triangular_range(1, 3)``` should return ```{1: 1, 2: 3}``` and ```triangular_range(5, 16)``` should return ```{3: 6, 4: 10, 5: 15}```.

Answer: {"fn_name": "triangular_range", "inputs": [[1, 3], [5, 16]], "outputs": [[{"1": 1, "2": 3}], [{"3": 6, "4": 10, "5": 15}]]}