1a. sortowanie kubelkowe ziomo wpisuje

def bucket_sort(arr):
    max_num = max(arr)
    buckets = [[] for _ in range(max_num)]
    for num in arr:
        buckets[num-1].append(num)
    result = []
    for bucket in buckets:
        for num in bucket:
            result.append(num)
    return result

input_str = input("Podaj liczby do posortowania, oddzielone spacjami: ")
arr = []
for s in input_str.split():
    arr.append(int(s))
sorted_arr = bucket_sort(arr)
print("Posortowane liczby:", sorted_arr)


1b. sorotwanie kubelkowe ziomo nie wpisuje

def bucket_sort(arr):
    max_num = max(arr)
    buckets = [[] for _ in range(max_num)]
    for num in arr:
        buckets[num-1].append(num)
    result = []
    for bucket in buckets:
        for num in bucket:
            result.append(num)
    return result


arr = [3, 5, 1, 9, 8, 6, 7, 2, 4]
sorted_arr = bucket_sort(arr)
print("Posortowane liczby:", sorted_arr)


2a. sortowanie wybor ziomek wpisuje
def selection_sort(arr):
    for i in range(len(arr)):
        min_idx = i
        for j in range(i+1, len(arr)):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr

input_str = input("Podaj liczby do posortowania, oddzielone spacjami: ")
arr = []
for s in input_str.split():
    arr.append(int(s))
sorted_arr = selection_sort(arr)
print("Posortowane liczby:", sorted_arr)

2b sortowanie wybor ziomek nie wpisuje

def selection_sort(arr):
    for i in range(len(arr)):
        min_idx = i
        for j in range(i+1, len(arr)):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr

arr = [1, 5, 3, 2, 4, 7]
sorted_arr = selection_sort(arr)
print("Posortowane liczby:", sorted_arr)

3a. sortowanie babelkowe  ziomo wpsiuje
def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

input_str = input("Podaj liczby do posortowania, oddzielone spacjami: ")
arr = []
for num in input_str.split():
    arr.append(int(num))
sorted_arr = bubble_sort(arr)
print("Posortowana lista:", sorted_arr)


3b. sorotwanie babelkowe ziomo nie wpisuje

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr


arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = bubble_sort(arr)
print("Posortowana lista:", sorted_arr)


4a. sortowanie wstawianie ziomo wpisuje

def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and key < arr[j]:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
    return arr

input_str = input("Podaj liczby do posortowania, oddzielone spacjami: ")
arr = []
for num in input_str.split():
    arr.append(int(num))
sorted_arr = insertion_sort(arr)
print("Posortowana lista:", sorted_arr)


4b. sortowanie wstawianie ziomo nie wpisuje

def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and key < arr[j]:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
    return arr

arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = insertion_sort(arr)
print("Posortowane liczby:", sorted_arr)


5a. sorotwanie zliczanie ziomo wspisuje

def counting_sort(arr):
    max_val = max(arr)
    counts = [0] * (max_val + 1)
    for num in arr:
        counts[num] += 1
    sorted_arr = []
    for i in range(max_val + 1):
        for j in range(counts[i]):
            sorted_arr.append(i)

    return sorted_arr

input_str = input("Podaj liczby do posortowania, oddzielone spacjami: ")
arr = []
for num in input_str.split():
    arr.append(int(num))
sorted_arr = counting_sort(arr)
print("Posortowana lista:", sorted_arr)



5b. sorotwanie zliczanie ziomo nie wpisuje

def counting_sort(arr):
    max_val = max(arr)
    counts = [0] * (max_val + 1)
    for num in arr:
        counts[num] += 1
    sorted_arr = []
    for i in range(max_val + 1):
        for j in range(counts[i]):
            sorted_arr.append(i)

    return sorted_arr

arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = counting_sort(arr)
print("Posortowane liczby:", sorted_arr)


6a. sortowanie scalanie ziomo wpisuje 

def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        left_arr = []
        i = 0
        while i < mid and i < len(arr):
            left_arr.append(arr[i])
            i += 1
        right_arr = []
        j = mid
        while j < len(arr) and j < len(arr):
            right_arr.append(arr[j])
            j += 1
        merge_sort(left_arr)
        merge_sort(right_arr)
        i = j = k = 0
        while i < len(left_arr) and j < len(right_arr):
            if left_arr[i] < right_arr[j]:
                arr[k] = left_arr[i]
                i += 1
            else:
                arr[k] = right_arr[j]
                j += 1
            k += 1
        while i < len(left_arr):
            arr[k] = left_arr[i]
            i += 1
            k += 1
        while j < len(right_arr):
            arr[k] = right_arr[j]
            j += 1
            k += 1

    return arr

input_str = input("Podaj liczby do posortowania, oddzielone spacjami: ")
arr = []
for num in input_str.split():
    arr.append(int(num))
sorted_arr = merge_sort(arr)
print("Posortowana lista:", sorted_arr)



6b. sortowanie scalanie ziomo nie wpsiuje

def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        left_arr = []
        i = 0
        while i < mid and i < len(arr):
            left_arr.append(arr[i])
            i += 1
        right_arr = []
        j = mid
        while j < len(arr) and j < len(arr):
            right_arr.append(arr[j])
            j += 1
        merge_sort(left_arr)
        merge_sort(right_arr)
        i = j = k = 0
        while i < len(left_arr) and j < len(right_arr):
            if left_arr[i] < right_arr[j]:
                arr[k] = left_arr[i]
                i += 1
            else:
                arr[k] = right_arr[j]
                j += 1
            k += 1
        while i < len(left_arr):
            arr[k] = left_arr[i]
            i += 1
            k += 1
        while j < len(right_arr):
            arr[k] = right_arr[j]
            j += 1
            k += 1

    return arr

arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = merge_sort(arr)
print("Posortowane liczby:", sorted_arr)