meetforever/GRPO_CL huggingface dataset:
user: Create a function that takes any sentence and redistributes the spaces (and adds additional spaces if needed) so that each word starts with a vowel. The letters should all be in the same order but every vowel in the sentence should be the start of a new word. The first word in the new sentence may start without a vowel. It should return a string in all lowercase with no punctuation (only alphanumeric characters).



EXAMPLES
'It is beautiful weather today!' becomes 'it isb e a ut if ulw e ath ert od ay'
'Coding is great' becomes 'c od ing isgr e at'
'my number is 0208-533-2325' becomes 'myn umb er is02085332325'

Answer: {"fn_name": "vowel_start", "inputs": [["It is beautiful weather today!"], ["Coding is great"], ["my number is 0208-533-2325"], ["oranges, apples, melon, pineapple"], ["under_score"]], "outputs": [["it isb e a ut if ulw e ath ert od ay"], ["c od ing isgr e at"], ["myn umb er is02085332325"], ["or ang es appl esm el onp in e appl e"], ["und ersc or e"]]}
user: Calculate the trace of a square matrix. A square matrix has `n` rows and `n` columns, where `n` is any integer > 0. The entries of the matrix can contain any number of integers. The function should return the calculated trace of the matrix, or `nil/None` if the array is empty or not square; you can otherwise assume the input will be valid (of the form described below).

The trace of an n-by-n square matrix **A** is defined to be the sum of the elements on the main diagonal (the diagonal from the upper left to the lower right) of **A**.

A matrix will be defined as an array of arrays, where the 1st entry represents the 1st row, the 2nd entry the 2nd row, and so on.

For example, the following code...
```ruby,python
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
```
represents the matrix
```
|1 2 3|
|4 5 6|
|7 8 9|
```
which has a trace of `1 + 5 + 9 = 15`.

You can read more about the trace of a matrix at these sources:

 * http://en.wikipedia.org/wiki/Trace_(linear_algebra)
 * http://mathworld.wolfram.com/MatrixTrace.html

~~~if:ruby
Note: The `Matrix` class is disabled.
~~~
~~~if:python
Note: `Numpy` is disabled.
~~~

Answer: {"fn_name": "trace", "inputs": [[[[1, 2, 3], [4, 5, 6], [7, 8, 9]]], [[[0, 0], [0, 0]]], [[[0, 0, 0], [0, 0, 0], [0, 0, 0]]], [[[1, 0, 0], [0, 1, 0], [0, 0, -2]]], [[[0]]], [[[1]]], [[[-300]]], [[]], [[[]]], [[[1, 2], [1, 2], [1, 2]]], [[[1, 2, 3], [1, 2, 3]]]], "outputs": [[15], [0], [0], [0], [0], [1], [-300], [null], [null], [null], [null]]}
user: Given some positive integers, I wish to print the integers such that all take up the same width by adding a minimum number of leading zeroes. No leading zeroes shall be added to the largest integer.

For example, given `1, 23, 2, 17, 102`, I wish to print out these numbers as follows:

```python
001
023
002
017
102
```

Write a function `print_nums(n1, n2, n3, ...)` that takes a variable number of arguments and returns the string to be printed out.

Answer: {"fn_name": "print_nums", "inputs": [[2], [1, 12, 34], [1009, 2], [1, 1, 13], [2, 5, 8], [1, 8, 27]], "outputs": [["2"], ["01\n12\n34"], ["1009\n0002"], ["01\n01\n13"], ["2\n5\n8"], ["01\n08\n27"]]}
user: In this Kata, you will be given a string and your task is to determine if that string can be a palindrome if we rotate one or more characters to the left.

```Haskell
solve("4455") = true, because after 1 rotation, we get "5445" which is a palindrome
solve("zazcbaabc") = true, because after 3 rotations, we get "abczazcba", a palindrome
```

More examples in test cases. Input will be strings of lowercase letters or numbers only.

Good luck!

Answer: {"fn_name": "solve", "inputs": [["aaab"], ["abcabc"], ["4455"], ["zazcbaabc"], ["223456776543"], ["432612345665"], ["qponmlkjihgfeeiefghijklmnopqrsttsr"]], "outputs": [[false], [false], [true], [true], [true], [false], [false]]}
user: Given 2 elevators (named "left" and "right") in a building with 3 floors (numbered `0` to `2`), write a function `elevator` accepting 3 arguments (in order):

- `left` - The current floor of the left elevator
- `right` - The current floor of the right elevator
- `call` -  The floor that called an elevator

It should return the name of the elevator closest to the called floor (`"left"`/`"right"`).

In the case where both elevators are equally distant from the called floor, choose the elevator to the right.

You can assume that the inputs will always be valid integers between 0-2.

Examples:

```python
elevator(0, 1, 0) # => "left"
elevator(0, 1, 1) # => "right"
elevator(0, 1, 2) # => "right"
elevator(0, 0, 0) # => "right"
elevator(0, 2, 1) # => "right"
```

Answer: {"fn_name": "elevator", "inputs": [[0, 1, 0], [0, 1, 1], [0, 1, 2], [0, 0, 0], [0, 2, 1], [0, 0, 1], [0, 0, 2], [0, 2, 0], [0, 2, 2], [1, 0, 0], [1, 0, 1], [1, 0, 2], [1, 1, 0], [1, 1, 1], [1, 1, 2], [1, 2, 0], [1, 2, 1], [1, 2, 2], [2, 0, 0], [2, 0, 1], [2, 0, 2], [2, 1, 0], [2, 1, 1], [2, 1, 2], [2, 2, 0], [2, 2, 1], [2, 2, 2]], "outputs": [["left"], ["right"], ["right"], ["right"], ["right"], ["right"], ["right"], ["left"], ["right"], ["right"], ["left"], ["left"], ["right"], ["right"], ["right"], ["left"], ["left"], ["right"], ["right"], ["right"], ["left"], ["right"], ["right"], ["left"], ["right"], ["right"], ["right"]]}
user: Given a positive integer `n`, return first n dgits of Thue-Morse sequence, as a string (see examples).

Thue-Morse sequence is a binary sequence with 0 as the first element. The rest of the sequece is obtained by adding the Boolean (binary) complement of a group obtained so far.

```
For example:

0
01
0110
01101001
and so on...
```

![alt](https://upload.wikimedia.org/wikipedia/commons/f/f1/Morse-Thue_sequence.gif)

Ex.:
```python
thue_morse(1);  #"0"
thue_morse(2);  #"01"
thue_morse(5);  #"01101"
thue_morse(10): #"0110100110"
```

- You don't need to test if n is valid - it will always be a positive integer.
- `n` will be between 1 and 10000

[Thue-Morse on Wikipedia](https://en.wikipedia.org/wiki/Thue%E2%80%93Morse_sequence)

[Another kata on Thue-Morse](https://www.codewars.com/kata/simple-fun-number-106-is-thue-morse) by @myjinxin2015

Answer: {"fn_name": "thue_morse", "inputs": [[1], [2], [5], [10], [100]], "outputs": [["0"], ["01"], ["01101"], ["0110100110"], ["0110100110010110100101100110100110010110011010010110100110010110100101100110100101101001100101100110"]]}
user: Write
```python
function repeating_fractions(numerator, denominator)
```
that given two numbers representing the numerator and denominator of a fraction, return the fraction in string format. If the fractional part has repeated digits, replace those digits with a single digit in parentheses. 

For example:
```python
repeating_fractions(1,1) === '1'
repeating_fractions(1,3) === '0.(3)'
repeating_fractions(2,888) === '0.(0)(2)5(2)5(2)5(2)5(2)5(2)'
```

Answer: {"fn_name": "repeating_fractions", "inputs": [[0, 1], [18018018, 80000000000], [1, 1], [1, 2], [1, 3], [1554, 70]], "outputs": [["0.0"], ["0.(0)(2)5(2)5(2)5"], ["1.0"], ["0.5"], ["0.(3)"], ["22.2"]]}
user: Write function alternateCase which switch every letter in string from upper to lower and from lower to upper.
E.g: Hello World -> hELLO wORLD

Answer: {"fn_name": "alternateCase", "inputs": [["ABC"], [""], [" "], ["Hello World"], ["cODEwARS"], ["i LIKE MAKING KATAS VERY MUCH"], ["HuMpTy DuMpTy SaT On A WaLl"], ["aBracaDabRa"], ["Hickory DICKORY dock"], ["Jack JUMPED over THE CaNdLeStIcK"]], "outputs": [["abc"], [""], [" "], ["hELLO wORLD"], ["CodeWars"], ["I like making katas very much"], ["hUmPtY dUmPtY sAt oN a wAlL"], ["AbRACAdABrA"], ["hICKORY dickory DOCK"], ["jACK jumped OVER the cAnDlEsTiCk"]]}
user: Write a function that replaces 'two', 'too' and 'to' with the number '2'. Even if the sound is found mid word (like in octopus) or not in lowercase grandma still thinks that should be replaced with a 2. Bless her.

```text
'I love to text' becomes 'I love 2 text'
'see you tomorrow' becomes 'see you 2morrow'
'look at that octopus' becomes 'look at that oc2pus'
```

Note that 'too' should become '2', not '2o'

Answer: {"fn_name": "textin", "inputs": [["I love to text"], ["see you tomorrow"], ["look at that octopus"], ["BECAUSE I WANT TO"]], "outputs": [["I love 2 text"], ["see you 2morrow"], ["look at that oc2pus"], ["BECAUSE I WANT 2"]]}
user: Write a function called `LCS` that accepts two sequences and returns the longest subsequence common to the passed in sequences.

### Subsequence
A subsequence is different from a substring. The terms of a subsequence need not be consecutive terms of the original sequence.

### Example subsequence
Subsequences of `"abc"` = `"a"`, `"b"`, `"c"`, `"ab"`, `"ac"`, `"bc"` and `"abc"`.

### LCS examples
```python
lcs( "abcdef" , "abc" ) => returns "abc"
lcs( "abcdef" , "acf" ) => returns "acf"
lcs( "132535365" , "123456789" ) => returns "12356"
```

### Notes
* Both arguments will be strings
* Return value must be a string
* Return an empty string if there exists no common subsequence
* Both arguments will have one or more characters (in JavaScript)
* All tests will only have a single longest common subsequence. Don't worry about cases such as `LCS( "1234", "3412" )`, which would have two possible longest common subsequences: `"12"` and `"34"`.

Note that the Haskell variant will use randomized testing, but any longest common subsequence will be valid.

Note that the OCaml variant is using generic lists instead of strings, and will also have randomized tests (any longest common subsequence will be valid).

### Tips

Wikipedia has an explanation of the two properties that can be used to solve the problem:

- [First property](http://en.wikipedia.org/wiki/Longest_common_subsequence_problem#First_property)
- [Second property](http://en.wikipedia.org/wiki/Longest_common_subsequence_problem#Second_property)

Answer: {"fn_name": "lcs", "inputs": [["a", "b"], ["a", "a"], ["abc", "ac"], ["abcdef", "abc"], ["abcdef", "acf"], ["anothertest", "notatest"], ["132535365", "123456789"], ["finaltest", "zzzfinallyzzz"]], "outputs": [[""], ["a"], ["ac"], ["abc"], ["acf"], ["nottest"], ["12356"], ["final"]]}
user: The idea for this Kata came from 9gag today.[here](http://9gag.com/gag/amrb4r9)

[screen]:("http://img-9gag-fun.9cache.com/photo/amrb4r9_700b.jpg")

You'll have to translate a string to Pilot's alphabet (NATO phonetic alphabet) [wiki](https://en.wikipedia.org/wiki/NATO_phonetic_alphabet).

Like this:

**Input:**

`If, you can read?`

**Output:**

`India Foxtrot , Yankee Oscar Uniform Charlie Alfa November Romeo Echo Alfa Delta ?`

**Notes**

* The set of used punctuation is `.!?`.
* Punctuation should be kept in your return string, but spaces should not.
* __Xray__ should not have a dash within.
* Every word and punctuation mark should be seperated by a space ' '.
* There should be no trailing whitespace


~~~if:php
Although the proper alphabet for j is `Juliett` you have to use `Juliet` here
~~~

Answer: {"fn_name": "to_nato", "inputs": [["If you can read"], ["Did not see that coming"]], "outputs": [["India Foxtrot Yankee Oscar Uniform Charlie Alfa November Romeo Echo Alfa Delta"], ["Delta India Delta November Oscar Tango Sierra Echo Echo Tango Hotel Alfa Tango Charlie Oscar Mike India November Golf"]]}
user: ### Description:

 Remove all exclamation marks from sentence except at the end.

### Examples

```
remove("Hi!") == "Hi!"
remove("Hi!!!") == "Hi!!!"
remove("!Hi") == "Hi"
remove("!Hi!") == "Hi!"
remove("Hi! Hi!") == "Hi Hi!"
remove("Hi") == "Hi"
```

Answer: {"fn_name": "remove", "inputs": [["Hi!"], ["Hi!!!"], ["!Hi"], ["!Hi!"], ["Hi! Hi!"], ["Hi"]], "outputs": [["Hi!"], ["Hi!!!"], ["Hi"], ["Hi!"], ["Hi Hi!"], ["Hi"]]}
user: Create a function `close_compare` that accepts 3 parameters: `a`, `b`, and an optional `margin`. The function should return whether `a` is lower than, close to, or higher than `b`. `a` is "close to" `b` if `margin` is higher than or equal to the difference between `a` and `b`.

When `a` is lower than `b`, return `-1`.

When `a` is higher than `b`, return `1`.

When `a` is close to `b`, return `0`.

If `margin` is not given, treat it as zero.

Example: if `a = 3`, `b = 5` and the `margin = 3`, since `a` and `b` are no more than 3 apart, `close_compare` should return `0`. Otherwise, if instead `margin = 0`, `a` is lower than `b` and `close_compare` should return `-1`.

Assume: `margin >= 0`

Tip: Some languages have a way to make arguments optional.

Answer: {"fn_name": "close_compare", "inputs": [[4, 5], [5, 5], [6, 5], [2, 5, 3], [5, 5, 3], [8, 5, 3], [8.1, 5, 3], [1.99, 5, 3]], "outputs": [[-1], [0], [1], [0], [0], [0], [1], [-1]]}
user: A [sequence or a series](http://world.mathigon.org/Sequences), in mathematics, is a string of objects, like numbers, that follow a particular pattern. The individual elements in a sequence are called terms. A simple example is `3, 6, 9, 12, 15, 18, 21, ...`, where the pattern is: _"add 3 to the previous term"_.

In this kata, we will be using a more complicated sequence:   `0, 1, 3, 6, 10, 15, 21, 28, ...`
This sequence is generated with the pattern: _"the nth term is the sum of numbers from 0 to n, inclusive"_.

```
[ 0,  1,    3,      6,   ...]
  0  0+1  0+1+2  0+1+2+3
```

## Your Task

Complete the function that takes an integer `n` and returns a list/array of length `abs(n) + 1` of the arithmetic series explained above. When`n < 0` return the sequence with negative terms.

## Examples 

```
 5  -->  [0,  1,  3,  6,  10,  15]
-5  -->  [0, -1, -3, -6, -10, -15]
 7  -->  [0,  1,  3,  6,  10,  15,  21,  28]
```

Answer: {"fn_name": "sum_of_n", "inputs": [[3], [-4], [1], [0], [10]], "outputs": [[[0, 1, 3, 6]], [[0, -1, -3, -6, -10]], [[0, 1]], [[0]], [[0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55]]]}
user: Create a function that takes 2 positive integers in form of a string as an input, and outputs the sum (also as a string):

If either input is an empty string, consider it as zero.

Answer: {"fn_name": "sum_str", "inputs": [["4", "5"], ["34", "5"], ["9", ""], ["", "9"]], "outputs": [["9"], ["39"], ["9"], ["9"]]}
user: A palindrome is a word, phrase, number, or other sequence of characters which reads the same backward as forward. Examples of numerical palindromes are:

2332 
110011 
54322345

You'll be given 2 numbers as arguments: ```(num,s)```.  Write a function which returns an array of ```s``` number of numerical palindromes that come after ```num```. If ```num``` is a palindrome itself, it should be included in the count. 

Return "Not valid" instead if any one of the inputs is not an integer or is less than 0.

For this kata, single digit numbers will NOT be considered numerical palindromes. 

```
palindrome(6,4) => [11,22,33,44]
palindrome(59,3) => [66,77,88]
palindrome(101,2) => [101,111]
palindrome("15651",5) => "Not valid" 
palindrome(1221,"8") => "Not valid" 
```

```Haskell

In Haskell, the return type is a Maybe which returns Nothing if either of the inputs is negative."
```


Other Kata in this Series:
Numerical Palindrome #1
Numerical Palindrome #1.5 
Numerical Palindrome #2
Numerical Palindrome #3
Numerical Palindrome #3.5
Numerical Palindrome #4
Numerical Palindrome #5

Answer: {"fn_name": "palindrome", "inputs": [[6, 4], [75, 1], [19, 3], [101, 2], ["ACCDDCCA", 3], [773, "1551"], [-4505, 15]], "outputs": [[[11, 22, 33, 44]], [[77]], [[22, 33, 44]], [[101, 111]], ["Not valid"], ["Not valid"], ["Not valid"]]}
user: A **bouncy number** is a positive integer whose digits neither increase nor decrease. For example, `1235` is an increasing number, `5321` is a decreasing number, and `2351` is a bouncy number. By definition, all numbers under `100` are non-bouncy, and `101` is the first bouncy number. To complete this kata, you must write a function that takes a number and determines if it is bouncy.

Input numbers will always be positive integers, but it never hurts to throw in some error handling : )

For clarification, the bouncy numbers between `100` and `125` are: `101, 102, 103, 104, 105, 106, 107, 108, 109, 120, and 121`.

Answer: {"fn_name": "is_bouncy", "inputs": [[0], [99], [101], [120], [122], [221], [2379], [29340], [234689], [98874], [92722983], [129347924210]], "outputs": [[false], [false], [true], [true], [false], [false], [false], [true], [false], [false], [true], [true]]}
user: In recreational mathematics, a magic square is an arrangement of distinct numbers (i.e., each number is used once), usually integers, in a square grid, where the numbers in each row, and in each column, and the numbers in the main and secondary diagonals, all add up to the same number, called the "magic constant."

For example, the following "square":

      4    9    2 -> 15
      3    5    7 -> 15
      8    1    6 -> 15
     /v    v    v \
    15 15   15   15  15
    
A 3x3 magic square will have its sums always resulting to 15, this number is called the "magic constant" and changes according to the square size.

In this problem you will have to create a function that receives a 3x3 'square' and returns True if it is magic and False otherwise.
The sum of rows, columns or diagonals should **always** equal **15**.

For example, the above square will be passed like: `[4, 9, 2, 3, 5, 7, 8, 1, 6]` and the output should be True

`[9, 4, 7, 3, 5, 2, 8, 6, 1]` should return False

### Note:
This kata is very easy. If you want to try some more "difficult" ones you may try these :
* [Magic Square - Verify 3x3](https://www.codewars.com/kata/magic-square-verify-3x3)
* [Double Even Magic Square](https://www.codewars.com/kata/double-even-magic-square)
* [Odd Magic Square](https://www.codewars.com/kata/odd-magic-square)

Answer: {"fn_name": "is_magical", "inputs": [[[4, 9, 2, 3, 5, 7, 8, 1, 6]], [[4, 9, 2, 3, 5, 7, 8, 6, 1]], [[1, 2, 3, 4, 5, 6, 7, 8, 9]], [[9, 4, 7, 3, 5, 2, 8, 6, 1]], [[8, 1, 6, 3, 5, 7, 4, 9, 2]]], "outputs": [[true], [false], [false], [false], [true]]}
user: You have an award-winning garden and everyday the plants need exactly 40mm of water. You created a great piece of JavaScript to calculate the amount of water your plants will need when you have taken into consideration the amount of rain water that is forecast for the day. Your jealous neighbour hacked your computer and filled your code with bugs. 

Your task is to debug the code before your plants die!

Answer: {"fn_name": "rain_amount", "inputs": [[100], [40], [39], [5], [0]], "outputs": [["Your plant has had more than enough water for today!"], ["Your plant has had more than enough water for today!"], ["You need to give your plant 1mm of water"], ["You need to give your plant 35mm of water"], ["You need to give your plant 40mm of water"]]}
user: Complete the function to find the count of the most frequent item of an array. You can assume that input is an array of integers. For an empty array return `0`

## Example
```python
input array: [3, -1, -1, -1, 2, 3, -1, 3, -1, 2, 4, 9, 3]
ouptut: 5 
```
The most frequent number in the array is `-1` and it occurs `5` times.

Answer: {"fn_name": "most_frequent_item_count", "inputs": [[[3, -1, -1]], [[3, -1, -1, -1, 2, 3, -1, 3, -1, 2, 4, 9, 3]], [[]], [[9]]], "outputs": [[2], [5], [0], [1]]}
user: A palindrome is a word, phrase, number, or other sequence of characters which reads the same backward as forward. Examples of numerical palindromes are:

2332  
110011  
54322345  

For a given number `num`, write a function to test if it's a numerical palindrome or not and return a boolean (true if it is and false if not).

```if-not:haskell
Return "Not valid" if the input is not an integer or less than `0`.
```
```if:haskell
Return `Nothing` if the input is less than `0` and `Just True` or `Just False` otherwise.
```

Other Kata in this Series:
Numerical Palindrome #1
Numerical Palindrome #1.5
Numerical Palindrome #2
Numerical Palindrome #3
Numerical Palindrome #3.5
Numerical Palindrome #4
Numerical Palindrome #5

Answer: {"fn_name": "palindrome", "inputs": [[1221], [110011], [1456009006541], [123322], [1], [152], [9999], ["ACCDDCCA"], ["@14AbC"], ["1221"], [-450]], "outputs": [[true], [true], [true], [false], [true], [false], [true], ["Not valid"], ["Not valid"], ["Not valid"], ["Not valid"]]}
user: Story
Jumbo Juice makes a fresh juice out of fruits of your choice.Jumbo Juice charges $5 for regular fruits and $7 for special ones. Regular fruits are Banana, Orange, Apple, Lemon and Grapes. Special ones are Avocado, Strawberry and Mango. Others fruits that are not listed are also available upon request. Those extra special fruits cost $9 per each. There is no limit on how many fruits she/he picks.The price of a cup of juice is the mean of price of chosen fruits. In case of decimal number (ex. $5.99), output should be the nearest integer (use the standard rounding function of your language of choice). 

Input
The function will receive an array of strings, each with the name of a fruit. The recognition of names should be case insensitive. There is no case of an enmpty array input.  


Example

```
['Mango', 'Banana', 'Avocado'] //the price of this juice bottle is (7+5+7)/3 = $6($6.333333...)
```

Answer: {"fn_name": "mix_fruit", "inputs": [[["banana", "mango", "avocado"]], [["melon", "Mango", "kiwi"]], [["watermelon", "cherry", "avocado"]], [["watermelon", "lime", "tomato"]], [["blackBerry", "coconut", "avocado"]], [["waterMelon", "mango"]], [["watermelon", "pEach"]], [["watermelon", "Orange", "grapes"]], [["watermelon"]], [["BlACKbeRrY", "cOcONuT", "avoCaDo"]]], "outputs": [[6], [8], [8], [9], [8], [8], [9], [6], [9], [8]]}
user: Transpose means is to interchange rows and columns of a two-dimensional array matrix.

[A^(T)]ij=[A]ji

ie:
Formally, the i th row, j th column element of AT is the j th row, i th column element of A:



Example :

```
[[1,2,3],[4,5,6]].transpose() //should return [[1,4],[2,5],[3,6]]
```

Write a prototype transpose to array in JS or add a .transpose method in Ruby or create a transpose function in Python so that any matrix of order ixj 2-D array returns transposed Matrix of jxi .

Link:  To understand array prototype

Answer: {"fn_name": "transpose", "inputs": [[[]], [[[1]]], [[[0, 1]]], [[[1, 2, 3], [4, 5, 6]]], [[[1, 2, 3, 4, 5, 6]]], [[[1], [2], [3], [4], [5], [6]]], [[["a", "b", "c"], ["d", "e", "f"]]], [[[true, false, true], [false, true, false]]], [[[]]], [[[], [], [], [], [], []]]], "outputs": [[[]], [[[1]]], [[[0], [1]]], [[[1, 4], [2, 5], [3, 6]]], [[[1], [2], [3], [4], [5], [6]]], [[[1, 2, 3, 4, 5, 6]]], [[["a", "d"], ["b", "e"], ["c", "f"]]], [[[true, false], [false, true], [true, false]]], [[[]]], [[[]]]]}
user: We like parsed SQL or PL/SQL blocks...

You need to write function that return list of literals indices from source block, excluding "in" comments, OR return empty list if no literals found.

input:
some fragment of sql or pl/sql code

output:
list of literals indices [(start, end), ...] OR empty list

Sample:
```
get_textliterals("'this' is sample") -> [(0,6)]
get_textliterals("'this' is sample 'too'") -> [(0, 6), (15, 20)]
```

Text literal: any text between single quotes
Sample:
```
  s := 'i am literal'
```
Single-line comment: any text started with "--" 
Sample:
```
  a := 1;
  -- this is single-line comment
```
Multy-line comment: any text between /* */
```
  a := 1;
  /*
  this is long multy-line comment
  */
```

Note: 
1) handle single quote inside literal
```
  s := 'we can use quote '' in literal'
```  
2) multy-line literal
```
 s := '
 this is literal too
 ';
```
3) skip literal inside comment
```
s := 'test'; --when comment started - this is not 'literal'
```
4) any unclosed literal should be closed with last symbol of the source fragment
```
s := 'test
```
There is one literal in this code: "'test"

Answer: {"fn_name": "get_textliterals", "inputs": [["select 'text' into row from table where a = 'value'"], ["if a>'data'and b<'nnn' then c:='test'; end if;"], ["select aaa, bbb, ccc, /*'ddd'?*/ into row from table;"], ["a:='data''s';"]], "outputs": [[[[7, 13], [44, 51]]], [[[5, 11], [17, 22], [31, 37]]], [[]], [[[3, 12]]]]}