50 Python coding problems with solutions

for number in range(1, 21):
    if number % 15 == 0:
        print("FizzBuzz")
    elif number % 3 == 0:
        print("Fizz")
    elif number % 5 == 0:
        print("Buzz")
    else:
        print(number)

previous, current = 0, 1
values = []

for _ in range(10):
    values.append(previous)
    previous, current = current, previous + current

print(" ".join(map(str, values)))

def factorial(number):
    if number < 0:
        raise ValueError("number must be non-negative")

    result = 1
    for factor in range(2, number + 1):
        result *= factor
    return result


print(factorial(5))

def is_palindrome(text):
    left = 0
    right = len(text) - 1

    while left < right:
        if not text[left].isalnum():
            left += 1
            continue
        if not text[right].isalnum():
            right -= 1
            continue
        if text[left].lower() != text[right].lower():
            return False
        left += 1
        right -= 1
    return True


print(is_palindrome("Never odd or even"))

def is_prime(number):
    if number < 2:
        return False
    if number == 2:
        return True
    if number % 2 == 0:
        return False

    divisor = 3
    while divisor <= number // divisor:
        if number % divisor == 0:
            return False
        divisor += 2
    return True


print(is_prime(29))

def reverse(text):
    characters = list(text)
    left = 0
    right = len(characters) - 1

    while left < right:
        characters[left], characters[right] = characters[right], characters[left]
        left += 1
        right -= 1
    return "".join(characters)


print(reverse("BuildQuill"))

def are_anagrams(first, second):
    counts = {}

    for raw in first:
        if raw.isalnum():
            key = raw.lower()
            counts[key] = counts.get(key, 0) + 1

    for raw in second:
        if raw.isalnum():
            key = raw.lower()
            counts[key] = counts.get(key, 0) - 1

    return all(count == 0 for count in counts.values())


print(are_anagrams("Dormitory", "Dirty room"))

def find_largest(numbers):
    if not numbers:
        raise ValueError("List cannot be empty")

    largest = numbers[0]
    for number in numbers:
        if number > largest:
            largest = number
    return largest


print(find_largest([12, 7, 31, 18, 4]))

def binary_search(numbers, target):
    low = 0
    high = len(numbers) - 1

    while low <= high:
        middle = low + (high - low) // 2
        if numbers[middle] == target:
            return middle
        if numbers[middle] < target:
            low = middle + 1
        else:
            high = middle - 1
    return -1


print(binary_search([2, 5, 8, 12, 16, 23], 12))

def bubble_sort(numbers):
    for end in range(len(numbers) - 1, 0, -1):
        swapped = False
        for index in range(end):
            if numbers[index] > numbers[index + 1]:
                numbers[index], numbers[index + 1] = numbers[index + 1], numbers[index]
                swapped = True
        if not swapped:
            return


values = [5, 1, 4, 2, 8]
bubble_sort(values)
print(" ".join(map(str, values)))

def even_or_odd(number):
    return "Even" if number % 2 == 0 else "Odd"


print(even_or_odd(-7))

def sum_values(numbers):
    total = 0
    for number in numbers:
        total += number
    return total


print(sum_values([4, -2, 7, 1]))

def count_vowels(text):
    vowels = "aeiou"
    count = 0
    for symbol in text:
        if symbol.lower() in vowels:
            count += 1
    return count


print(count_vowels("Build useful tools"))

def sum_digits(number):
    remaining = abs(number)
    total = 0

    while remaining > 0:
        total += remaining % 10
        remaining //= 10
    return total


print(sum_digits(-4827))

number = 7

for multiplier in range(1, 11):
    print(f"{number} x {multiplier} = {number * multiplier}")

def is_leap_year(year):
    return year % 400 == 0 or (year % 4 == 0 and year % 100 != 0)


print("2024:", is_leap_year(2024))
print("1900:", is_leap_year(1900))

def greatest_common_divisor(first, second):
    a = abs(first)
    b = abs(second)

    while b != 0:
        a, b = b, a % b
    return a


print(greatest_common_divisor(84, 30))

def to_binary(number):
    if number < 0:
        raise ValueError("number must be non-negative")
    if number == 0:
        return "0"

    bits = []
    while number > 0:
        bits.append(str(number % 2))
        number //= 2
    return "".join(reversed(bits))


print(to_binary(42))

def linear_search(numbers, target):
    for index, number in enumerate(numbers):
        if number == target:
            return index
    return -1


print(linear_search([9, 3, 7, 1], 7))

def second_largest(numbers):
    largest = None
    second = None

    for number in numbers:
        if largest is None or number > largest:
            second = largest
            largest = number
        elif number != largest and (second is None or number > second):
            second = number

    if second is None:
        raise ValueError("Two distinct values are required")
    return second


print(second_largest([8, 3, 8, 6, 2]))

def selection_sort(numbers):
    for start in range(len(numbers) - 1):
        smallest = start
        for index in range(start + 1, len(numbers)):
            if numbers[index] < numbers[smallest]:
                smallest = index
        numbers[start], numbers[smallest] = numbers[smallest], numbers[start]


values = [9, 5, 1, 7, 3]
selection_sort(values)
print(" ".join(map(str, values)))

def insertion_sort(numbers):
    for index in range(1, len(numbers)):
        value = numbers[index]
        position = index - 1
        while position >= 0 and numbers[position] > value:
            numbers[position + 1] = numbers[position]
            position -= 1
        numbers[position + 1] = value


values = [5, 2, 4, 6, 1, 3]
insertion_sort(values)
print(" ".join(map(str, values)))

def celsius_to_fahrenheit(celsius):
    return celsius * 9.0 / 5.0 + 32.0


print(f"{celsius_to_fahrenheit(25):g}")

def count_occurrences(text, target):
    normalized_target = target.upper()
    count = 0
    for symbol in text:
        if symbol.upper() == normalized_target:
            count += 1
    return count


print(count_occurrences("Mississippi", "s"))

def remove_whitespace(text):
    return "".join(symbol for symbol in text if not symbol.isspace())


print(remove_whitespace(" C#\t is\n fun "))

def two_sum(numbers, target):
    seen = {}
    for index, number in enumerate(numbers):
        complement = target - number
        if complement in seen:
            return seen[complement], index
        seen[number] = index
    raise ValueError("No pair adds to the target")


print(two_sum([2, 7, 11, 15], 9))

def is_balanced(text):
    pairs = {"(": ")", "[": "]", "{": "}"}
    expected = []

    for symbol in text:
        if symbol in pairs:
            expected.append(pairs[symbol])
        elif symbol in ")]}" and (not expected or expected.pop() != symbol):
            return False
    return not expected


print(is_balanced("{[()]}"))

def merge(first, second):
    result = []
    i = j = 0

    while i < len(first) and j < len(second):
        if first[i] <= second[j]:
            result.append(first[i])
            i += 1
        else:
            result.append(second[j])
            j += 1
    result.extend(first[i:])
    result.extend(second[j:])
    return result


print(" ".join(map(str, merge([1, 4, 7], [2, 3, 8]))))

def distinct_in_order(numbers):
    seen = set()
    result = []
    for number in numbers:
        if number not in seen:
            seen.add(number)
            result.append(number)
    return result


print(" ".join(map(str, distinct_in_order([4, 2, 4, 1, 2, 3]))))

import re


def count_words(text):
    counts = {}
    for word in re.findall(r"[a-z0-9']+", text.lower()):
        counts[word] = counts.get(word, 0) + 1
    return counts


for word, count in count_words("Code, test, code, learn.").items():
    print(f"{word}: {count}")

def find_missing(numbers):
    missing = len(numbers)
    for index, number in enumerate(numbers):
        missing ^= index ^ number
    return missing


print(find_missing([3, 0, 1]))

def move_disks(count, source, spare, destination):
    if count == 0:
        return
    move_disks(count - 1, source, destination, spare)
    print(f"Move disk {count} from {source} to {destination}")
    move_disks(count - 1, spare, source, destination)


move_disks(3, "A", "B", "C")

class Node:
    def __init__(self, value, next_node=None):
        self.value = value
        self.next = next_node


def reverse(current):
    previous = None
    while current is not None:
        next_node = current.next
        current.next = previous
        previous = current
        current = next_node
    return previous


head = Node(1, Node(2, Node(3)))
values = []
node = reverse(head)
while node is not None:
    values.append(node.value)
    node = node.next
print(" ".join(map(str, values)))

from collections import deque


def shortest_distance(graph, start, target):
    queue = deque([start])
    distances = {start: 0}

    while queue:
        current = queue.popleft()
        if current == target:
            return distances[current]
        for neighbor in graph[current]:
            if neighbor not in distances:
                distances[neighbor] = distances[current] + 1
                queue.append(neighbor)
    return -1


graph = {
    1: [2, 3], 2: [1, 4], 3: [1, 4],
    4: [2, 3, 5], 5: [4]
}
print(shortest_distance(graph, 1, 5))

def minimum_coins(coins, amount):
    best = [amount + 1] * (amount + 1)
    best[0] = 0

    for value in range(1, amount + 1):
        for coin in coins:
            if coin <= value:
                best[value] = min(best[value], best[value - coin] + 1)
    return -1 if best[amount] > amount else best[amount]


print(minimum_coins([1, 2, 5], 11))

def reverse(numbers, left, right):
    while left < right:
        numbers[left], numbers[right] = numbers[right], numbers[left]
        left += 1
        right -= 1


def rotate_right(numbers, positions):
    if not numbers:
        return
    positions %= len(numbers)
    if positions == 0:
        return
    reverse(numbers, 0, len(numbers) - 1)
    reverse(numbers, 0, positions - 1)
    reverse(numbers, positions, len(numbers) - 1)


values = [1, 2, 3, 4, 5]
rotate_right(values, 2)
print(" ".join(map(str, values)))

def transpose(matrix):
    rows = len(matrix)
    columns = len(matrix[0])
    result = [[0] * rows for _ in range(columns)]

    for row in range(rows):
        for column in range(columns):
            result[column][row] = matrix[row][column]
    return result


for row in transpose([[1, 2, 3], [4, 5, 6]]):
    print(" ".join(map(str, row)))

def encode(text):
    if not text:
        return ""

    encoded = []
    run_length = 1
    for index in range(1, len(text) + 1):
        if index < len(text) and text[index] == text[index - 1]:
            run_length += 1
            continue
        encoded.append(text[index - 1] + str(run_length))
        run_length = 1
    return "".join(encoded)


print(encode("aaabbccccdaa"))

def first_unique(text):
    counts = {}
    for symbol in text:
        counts[symbol] = counts.get(symbol, 0) + 1

    for symbol in text:
        if counts[symbol] == 1:
            return symbol
    return ""


print(first_unique("swiss"))

def longest_distinct_substring(text):
    last_seen = {}
    start = 0
    best = 0

    for end, symbol in enumerate(text):
        if symbol in last_seen and last_seen[symbol] >= start:
            start = last_seen[symbol] + 1
        last_seen[symbol] = end
        best = max(best, end - start + 1)
    return best


print(longest_distinct_substring("abcabcbb"))

def maximum_subarray_sum(numbers):
    if not numbers:
        raise ValueError("List cannot be empty")

    ending_here = numbers[0]
    best = numbers[0]
    for number in numbers[1:]:
        ending_here = max(number, ending_here + number)
        best = max(best, ending_here)
    return best


print(maximum_subarray_sum([-2, 1, -3, 4, -1, 2, 1, -5, 4]))

def merge_intervals(intervals):
    intervals.sort(key=lambda interval: interval[0])
    merged = []

    for start, end in intervals:
        if not merged or merged[-1][1] < start:
            merged.append([start, end])
        else:
            merged[-1][1] = max(merged[-1][1], end)
    return merged


intervals = [[1, 3], [2, 6], [8, 10], [15, 18]]
labels = [f"{start}-{end}" for start, end in merge_intervals(intervals)]
print(", ".join(labels))

def group_anagrams(words):
    by_signature = {}
    groups = []

    for word in words:
        signature = "".join(sorted(word))
        if signature not in by_signature:
            by_signature[signature] = []
            groups.append(by_signature[signature])
        by_signature[signature].append(word)
    return groups


for group in group_anagrams(["eat", "tea", "tan", "ate", "nat", "bat"]):
    print(",".join(group))

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None


def has_cycle(head):
    slow = head
    fast = head
    while fast is not None and fast.next is not None:
        slow = slow.next
        fast = fast.next.next
        if slow is fast:
            return True
    return False


first = Node(1)
second = Node(2)
third = Node(3)
first.next = second
second.next = third
third.next = second
print(has_cycle(first))

class Node:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None


def height(node):
    if node is None:
        return 0
    return 1 + max(height(node.left), height(node.right))


root = Node(8)
root.left = Node(4)
root.right = Node(12)
root.left.left = Node(2)
print(height(root))

class Node:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None


def traverse(node, values):
    if node is None:
        return
    traverse(node.left, values)
    values.append(node.value)
    traverse(node.right, values)


root = Node(4)
root.left = Node(2)
root.right = Node(5)
root.left.left = Node(1)
root.left.right = Node(3)
values = []
traverse(root, values)
print(" ".join(map(str, values)))

def fill(image, row, column, original, replacement):
    if (row < 0 or row >= len(image) or column < 0 or
            column >= len(image[0]) or image[row][column] != original):
        return

    image[row][column] = replacement
    fill(image, row - 1, column, original, replacement)
    fill(image, row + 1, column, original, replacement)
    fill(image, row, column - 1, original, replacement)
    fill(image, row, column + 1, original, replacement)


def flood_fill(image, row, column, replacement):
    original = image[row][column]
    if original != replacement:
        fill(image, row, column, original, replacement)


image = [[1, 1, 1], [1, 1, 0], [1, 0, 1]]
flood_fill(image, 1, 1, 2)
for row in image:
    print(" ".join(map(str, row)))

def generate(characters, position, results):
    if position == len(characters):
        results.append("".join(characters))
        return

    for index in range(position, len(characters)):
        characters[position], characters[index] = characters[index], characters[position]
        generate(characters, position + 1, results)
        characters[position], characters[index] = characters[index], characters[position]


results = []
generate(list("ABC"), 0, results)
print(" ".join(results))

def edit_distance(first, second):
    edits = [[0] * (len(second) + 1) for _ in range(len(first) + 1)]
    for index in range(len(first) + 1):
        edits[index][0] = index
    for index in range(len(second) + 1):
        edits[0][index] = index

    for i in range(1, len(first) + 1):
        for j in range(1, len(second) + 1):
            if first[i - 1] == second[j - 1]:
                edits[i][j] = edits[i - 1][j - 1]
            else:
                edits[i][j] = 1 + min(
                    edits[i - 1][j - 1], edits[i - 1][j], edits[i][j - 1]
                )
    return edits[-1][-1]


print(edit_distance("kitten", "sitting"))

def maximum_value(weights, values, capacity):
    if len(weights) != len(values):
        raise ValueError("Weights and values must have equal lengths")

    best = [0] * (capacity + 1)
    for weight, value in zip(weights, values):
        for limit in range(capacity, weight - 1, -1):
            best[limit] = max(best[limit], best[limit - weight] + value)
    return best[capacity]


print(maximum_value([2, 3, 4, 5], [3, 4, 5, 8], 5))