Automated update

Author: JakubDotPy

output/find_nearest_fibonacci_number.py

@@ -0,0 +1,20 @@
+"""Kata - Find Nearest Fibonacci Number
+
+completed at: 2024-09-10 10:51:31
+by: Jakub Červinka
+
+Given a positive integer (n) find the nearest fibonacci number to (n). 
+
+If there are more than one fibonacci with equal distance to the given number return the smallest one.
+
+Do it in a efficient way. 5000 tests with the input range 1 <= n <= 2^512 should not exceed 200 ms.
+
+"""
+
+def nearest_fibonacci(number):
+    a, b = 0, 1
+    while b < number:
+        a, b = b, a + b
+    a_num, num_b = number - a, b - number
+    return a if a_num <= num_b else b
+    

output/splitting_the_workload_part_i.py

@@ -0,0 +1,62 @@
+"""Kata - Splitting the Workload (part I)
+
+completed at: 2024-09-10 09:50:23
+by: Jakub Červinka
+
+Imagine you have a number of jobs to execute. Your workers are not permanently connected to your network, so you have to distribute all your jobs in the beginning. Luckily, you know exactly how long each job is going to take. 
+
+Let 
+```
+x = [2,3,4,6,8,2]
+```
+be the amount of time each of your jobs is going to take.
+
+Your task is to write a function ```splitlist(x)```, that will return two lists ```a``` and ```b```, such that ```abs(sum(a)-sum(b))``` is minimised.
+
+One possible solution to this example would be 
+```
+a=[2, 4, 6]
+b=[3, 8, 2]
+```
+with  ```abs(sum(a)-sum(b)) == 1```.
+
+The order of the elements is not tested, just make sure that you minimise ```abs(sum(a)-sum(b))``` and that ```sorted(a+b)==sorted(x)```.
+
+You may assume that ```len(x)<=15``` and ```0<=x[i]<=100```.
+
+When done, please continue with [part II](https://www.codewars.com/kata/586e6b54c66d18ff6c0015cd)!
+
+
+"""
+
+import itertools
+
+def split_list(x):
+    n = len(x)
+    
+    # edge case
+    if n == 1:
+        return x, []
+    
+    best_diff = float('inf')
+    best_a, best_b = [], []
+
+    for i in range(1, n // 2 + 1):  # only need to check half of the list length
+        for subset in itertools.combinations(x, i):
+            a = list(subset)
+            
+            b = x.copy()
+            for elem in a:
+                b.remove(elem)
+
+            diff = abs(sum(a) - sum(b))
+
+            if diff < best_diff:
+                best_diff = diff
+                best_a, best_b = a, b
+
+            if best_diff == 0:
+                return best_a, best_b
+    print(best_a, best_b)
+    return best_a, best_b
+

output/sum_of_intervals.py

@@ -0,0 +1,95 @@
+"""Kata - Sum of Intervals
+
+completed at: 2024-09-10 10:32:42
+by: Jakub Červinka
+
+Write a function called `sumIntervals`/`sum_intervals` that accepts an array of intervals, and returns the sum of all the interval lengths. Overlapping intervals should only be counted once.
+
+### Intervals
+
+Intervals are represented by a pair of integers in the form of an array. The first value of the interval will always be less than the second value. Interval example: `[1, 5]` is an interval from `1` to `5`. The length of this interval is `4`.
+
+### Overlapping Intervals
+
+List containing overlapping intervals:
+
+```c -- actual language id doesn't matter -- just want syntax highlighting
+[
+   [1, 4],
+   [7, 10],
+   [3, 5]
+]
+```
+
+The sum of the lengths of these intervals is `7`. Since `[1, 4]` and `[3, 5]` overlap, we can treat the interval as `[1, 5]`, which has a length of `4`.
+
+### Examples:
+
+```c -- idem
+sumIntervals( [
+   [1, 2],
+   [6, 10],
+   [11, 15]
+] ) => 9
+
+sumIntervals( [
+   [1, 4],
+   [7, 10],
+   [3, 5]
+] ) => 7
+
+sumIntervals( [
+   [1, 5],
+   [10, 20],
+   [1, 6],
+   [16, 19],
+   [5, 11]
+] ) => 19
+
+sumIntervals( [
+   [0, 20],
+   [-100000000, 10],
+   [30, 40]
+] ) => 100000030
+```
+
+### Tests with large intervals
+
+Your algorithm should be able to handle large intervals. All tested intervals are subsets of the range `[-1000000000, 1000000000]`.
+
+~~~if:lambdacalc
+### Encodings
+
+purity: `LetRec`  
+numEncoding: `ScottBinary` ( subsets are actually in range `[0, 2000]` )  
+export constructor `Pair` for your `Pair` encoding  
+export constructors `nil, cons` for your `List` encoding  
+~~~
+
+"""
+
+def sum_of_intervals(intervals):
+    intervals.sort(key=lambda x: x[0])
+    first = intervals[0]
+    if len(intervals) == 1:
+        return first[1] - first[0]
+
+    merged_intervals = [list(first), ]
+
+    for i_start, i_end in intervals[1:]:
+        for i, (ci_start, ci_end) in enumerate(merged_intervals):
+            starts_in = ci_start <= i_start <= ci_end
+            ends_in = ci_start <= i_end <= ci_end
+            if starts_in or ends_in:
+                ci_start = min(ci_start, i_start)
+                ci_end = max(ci_end, i_end)
+                merged_intervals[i] = [ci_start, ci_end]
+                break
+        else:
+            merged_intervals.append([i_start, i_end])
+
+    total = sum(
+        b - a
+        for a, b in merged_intervals
+    )
+    return total