Automated update

Author: JakubDotPy

output/binary_contiguous_array.py

@@ -0,0 +1,58 @@
+"""Kata - Binary Contiguous Array
+
+completed at: 2024-04-25 19:53:56
+by: Jakub Červinka
+
+An array consisting of `0`s and `1`s, also called a binary array, is given as an input.
+
+### Task
+
+Find the length of the longest contiguous subarray which consists of **equal** number of `0`s and `1`s.
+
+### Example
+
+```
+s = [1,1,0,1,1,0,1,1]
+         |_____|
+            |
+         [0,1,1,0]
+
+         length = 4
+```
+
+### Note
+
+<!-- this should show the first block for every language except LC -->
+```c
+0 <= length(array) < 120 000
+```
+```lambdacalc
+0 <= length list <= 25
+```
+
+~~~if:lambdacalc
+### Encodings
+
+purity: `LetRec`  
+numEncoding: `BinaryScott`  
+export constructors `nil, cons` for your `List` encoding  
+~~~
+"""
+
+def binarray(arr):
+    count = 0
+    map = {0: -1}
+    max_length = 0
+
+    arr = [1 if x else -1 for x in arr]
+
+    for i, number in enumerate(arr):
+        count += number
+
+        if count in map:
+            max_length = max(max_length, (i - map[count]))
+        else:
+            map[count] = i
+
+    return max_length
+

output/calculate_the_function_f_x_for_a_simple_linear_sequence_medium.py

@@ -0,0 +1,59 @@
+"""Kata - Calculate the function f(x) for a simple linear sequence (Medium)
+
+completed at: 2024-04-25 18:09:00
+by: Jakub Červinka
+
+This is a follow-up from my previous Kata which can be found here: http://www.codewars.com/kata/5476f4ca03810c0fc0000098
+
+This time, for any given linear sequence, calculate the function [f(x)] and return it as a function in Javascript or Lambda/Block in Ruby.
+
+For example:
+
+```javascript
+getFunction([0, 1, 2, 3, 4])(5) => 5
+getFunction([0, 3, 6, 9, 12])(10) => 30
+getFunction([1, 4, 7, 10, 13])(20) => 61
+```
+
+```ruby
+get_function([0, 1, 2, 3, 4]).call(5) => 5
+get_function([0, 3, 6, 9, 12]).call(10) => 30
+get_function([1, 4, 7, 10, 13]).call(20) => 61
+```
+
+```python
+get_function([0, 1, 2, 3, 4])(5) => 5
+get_function([0, 3, 6, 9, 12])(10) => 30
+get_function([1, 4, 7, 10, 13])(20) => 61
+```
+
+```csharp
+GetFunction(new[] { 0, 1, 2, 3, 4 })(5) => 5
+GetFunction(new[] { 0, 3, 6, 9, 12 })(10) => 30
+GetFunction(new[] { 1, 4, 7, 10, 13 })(20) => 61
+```
+
+```php
+get_function([0, 1, 2, 3, 4])(5) // => 5
+get_function([0, 3, 6, 9, 12])(10) // => 30
+get_function([1, 4, 7, 10, 13])(20) // => 61
+```
+
+Assumptions for this kata are:
+```
+The sequence argument will always contain 5 values equal to f(0) - f(4).
+The function will always be in the format "nx +/- m", 'x +/- m', 'nx', 'x' or 'm'
+If a non-linear sequence simply return 'Non-linear sequence' for javascript, ruby, and python. For C#, throw an ArgumentException.
+```
+"""
+
+from itertools import pairwise
+
+def get_function(seq):
+    dif = seq[1] - seq[0]
+    for a, b in pairwise(seq):
+        if b - a != dif:
+            return "Non-linear sequence"
+    return lambda x: seq[0] + dif * x
+    
+    

output/element_equals_its_index.py

@@ -0,0 +1,77 @@
+"""Kata - Element  equals its index
+
+completed at: 2024-04-25 19:08:20
+by: Jakub Červinka
+
+```if:python
+Given a sorted array of distinct integers, write a function `index_equals_value` that returns the lowest index for which `array[index] == index`.  
+Return `-1` if there is no such index.
+```
+```if:haskell,javascript
+Given a sorted array of distinct integers, write a function `indexEqualsValue` that returns the lowest index for which `array[index] == index`.  
+Return `-1` if there is no such index.
+```
+```if:rust
+Given a sorted slice of distinct integers, write a function `index_equals_value` that returns the lowest index for which `slice[index] == index`.  
+Return `-1` if there is no such index.
+```
+
+Your algorithm should be very performant.
+
+[input] array of integers ( with `0`-based nonnegative indexing )  
+[output] integer
+
+### Examples:
+
+<!-- no need to add more languages really. but leave "python" in or words get coloured -->
+```python
+input: [-8,0,2,5]
+output: 2 # since array[2] == 2
+
+input: [-1,0,3,6]
+output: -1 # since no index in array satisfies array[index] == index
+```
+### Random Tests Constraints:
+
+```if:python,javascript
+Array length: 200 000
+```
+```if:rust
+Slice length: 200 000
+```
+```if:haskell
+Array length: 10 000
+```
+
+Amount of tests: 1 000
+
+```if:python
+Time limit: 1.5 s
+```
+```if:haskell,javascript,rust
+Time limit: 150 ms
+```
+___
+
+If you liked this Kata check out my more complex creations:
+
+Find the neighbourhood in big dimensions. [Neighbourhood collection](https://www.codewars.com/collections/5b2f4db591c746349d0000ce)
+
+The [Rubik's cube](https://www.codewars.com/kata/5b3bec086be5d8893000002e)
+"""
+
+def index_equals_value(arr):
+    left, right = 0, len(arr) - 1
+    smallest_match = float('inf')
+
+    while left <= right:
+        mid = left + (right - left) // 2
+        if arr[mid] == mid:
+            smallest_match = min(smallest_match, mid)
+            right = mid - 1
+        elif arr[mid] > mid:
+            right = mid - 1
+        else:
+            left = mid + 1
+
+    return smallest_match if smallest_match != float('inf') else -1

output/simple_sum_with_restrictions.py

@@ -0,0 +1,37 @@
+"""Kata - Simple Sum (with restrictions)
+
+completed at: 2024-04-25 19:20:50
+by: Jakub Červinka
+
+## Task
+
+You're given two non-negative numbers `(0 <= x,y)`. The goal is to create a function named `simple_sum` which return their sum.
+
+## Restrictions
+
+The restrictions can be summurized as 'bit and logical operations are allowed'.
+
+Here comphrensive description. You're code __mustn't__ contain:
+
+```
+1. `import`, `getattr`, `exec`, `eval`, `sum`  # with next point produce short solutions,
+2. `int` class methods names                   # but here is another idea.
+3. `__loader__`, `vars`, `__dict__`            # even more of them.
+4. `if`, `in`, `is`                            # they start with `i` :)
+5. `+`, `-`, `*`, `/`, `//`, `%`               # arithmetic operations
+6. `==`, `!=`, `<`, `>`, `<=`, `>=`            # comparisions
+```
+
+## Note
+
+**Inspired by [suic](https://www.codewars.com/users/553bfb4e8234ef15340000b9)'s katas**
+
+**Please  assess the difficulty  of the kata when you finish it :)**
+"""
+
+def simple_sum(a, b):
+    while b:
+        swc = a ^ b
+        carry = (a & b) << 1
+        a, b = swc, carry
+    return a