Python Notes on Dan Stefan Oprean

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

print("Hello, world!")

Run the script:

python main.py

This prints a line in Python with the built-in print function. It is the normal first script example.

Variables

Python variables are dynamically typed and can be annotated when the expected type matters.

name = "Dan"
age: int = 30
is_active = True

Python lets you bind values without declaring a type first. Add annotations when you want the expected shape to be clearer.

Add

Mon, 01 Jan 0001 00:00:00 +0000

Python Add

def add(param1: int, param2: int) -> int:
    return param1 + param2

This just adds the two input numbers with the language’s normal arithmetic and returns the sum.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

Python Add Border

def add_border(picture: list[str]) -> list[str]:
    width = len(picture[0]) + 2
    border = "*" * width
    return [border] + [f"*{row}*" for row in picture] + [border]

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

Python Adjacent Elements Product

def adjacent_elements_product(input_array: list[int]) -> int:
    return max(
        input_array[i] * input_array[i + 1] for i in range(len(input_array) - 1)
    )

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

Python Almost Magic Square

def almost_magic_square(a: list[int]) -> list[int]:
    grid = [a[i:i + 3] for i in range(0, 9, 3)]
    row_sum = [0, 0, 0]
    col_sum = [0, 0, 0]

    for i in range(3):
        for j in range(3):
            row_sum[i] += grid[i][j]
            col_sum[i] += grid[j][i]

    max_sum = 0
    for k in range(3):
        max_sum = max(max_sum, row_sum[k])
        max_sum = max(max_sum, col_sum[k])

    i = j = 0
    while i < 3 and j < 3:
        diff = min(max_sum - row_sum[i], max_sum - col_sum[j])
        grid[i][j] += diff
        row_sum[i] += diff
        col_sum[j] += diff

        if row_sum[i] == max_sum:
            i += 1
        if col_sum[j] == max_sum:
            j += 1

    return [v for row in grid for v in row]

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

Python Are Equally Strong

def are_equally_strong(
    your_left: int, your_right: int, friends_left: int, friends_right: int
) -> bool:
    return max(your_right, your_left) == max(friends_left, friends_right) and min(
        your_left, your_right
    ) == min(friends_right, friends_left)

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

Python Array Change

def array_change(a: list[int]) -> int:
    moves = 0
    for k in range(len(a) - 1):
        if a[k] >= a[k + 1]:
            diff = a[k] - a[k + 1] + 1
            a[k + 1] += diff
            moves += diff
    return moves

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

Python Array Maximal Adjacement Difference

def array_maximal_adjacent_difference(a: list[int]) -> int:
    diff = 0
    for i in range(1, len(a) - 1):
        diff = max(diff, abs(a[i] - a[i - 1]), abs(a[i] - a[i + 1]))
    return diff

This checks the gap between each pair of neighbors and returns the largest difference.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

Python Binary Gap

def binary_gap(n: int) -> int:
    zeroes = bin(n)[2:].strip("0").split("1")
    return max((len(z) for z in zeroes), default=0)

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

Python Bracket

def bracket(s: str) -> int:
    closers = {")": "(", "]": "[", "}": "{"}
    stack: list[str] = []

    for ch in s:
        if ch in closers:
            if not stack or stack.pop() != closers[ch]:
                return 0
        elif ch:
            stack.append(ch)

    return 1 if not stack else 0

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

Python Century From Year

import math


def century_from_year(year: int) -> int:
    return math.ceil(year / 100)

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

Python Check Palindrome

def check_palindrome(input_string: str) -> bool:
    return input_string[::-1] == input_string

This compares the string with its reverse. If they match, it is a palindrome.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

Python Chocolates By Numbers

from math import gcd


def chocolates_by_numbers(n: int, m: int) -> int:
    return (n * m) // gcd(n, m) // m

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

Python Common Prime Divisors

from math import gcd


def common_prime_divisors(a: list[int], b: list[int]) -> int:
    def remove_common_prime_divisors(n: int, m: int) -> int:
        while n != 1:
            d = gcd(n, m)
            if d == 1:
                break
            n //= d
        return n

    counter = 0
    for x, y in zip(a, b):
        d = gcd(x, y)

        x = remove_common_prime_divisors(x, d)
        if x != 1:
            continue

        y = remove_common_prime_divisors(y, d)
        if y == 1:
            counter += 1

    return counter

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

Python Count Div

def count_div(a: int, b: int, k: int) -> int:
    first_div = a if a % k == 0 else a + (k - a % k)
    last_div = b - b % k

    return (last_div - first_div) // k + 1

This counts how many numbers in a range are divisible by K without looping through every value.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

Python Count Factors

def count_factors(n: int) -> int:
    count = 0
    i = 1
    while i * i < n:
        if n % i == 0:
            count += 2
        i += 1
    if i * i == n:
        count += 1

    return count

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

Python Count Non Divisible

def count_non_divisible(a: list[int]) -> list[int]:
    size = len(a)
    occurrences = [0] * (max(a) + 1)
    for v in a:
        occurrences[v] += 1

    nondivisor = [0] * size
    for k, v in enumerate(a):
        count = 0
        i = 1
        while i * i <= v:
            if v % i == 0:
                count += occurrences[i]
                if v // i != i:
                    count += occurrences[v // i]
            i += 1
        nondivisor[k] = size - count

    return nondivisor

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

Python Count Semi Primes

def count_semi_primes(n: int, p: list[int], q: list[int]) -> list[int]:
    primes = [True] * (n + 1)
    semi_primes = [0] * (n + 1)

    i = 2
    while i * i <= n:
        if primes[i]:
            for k in range(i * i, n + 1, i):
                primes[k] = False
        i += 1

    k = 2
    while k * k <= n:
        if primes[k]:
            i = 2
            while i * k <= n:
                if primes[i]:
                    semi_primes[k * i] = 1
                i += 1
        k += 1

    for i in range(1, n + 1):
        semi_primes[i] += semi_primes[i - 1]

    return [semi_primes[q[idx]] - semi_primes[p[idx] - 1] for idx in range(len(p))]

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

Python Cyclic Rotation

from collections import deque


def cyclic_rotation(a: list[int], k: int) -> list[int]:
    if not a:
        return a

    d = deque(a)
    d.rotate(k)
    return list(d)

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

Python Distinct

def distinct(a: list[int]) -> int:
    return len(set(a))

This counts unique values by tracking what has already been seen.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

Python Dominator

def dominator(a: list[int]) -> int:
    size = value = index = 0
    for k, v in enumerate(a):
        if size == 0:
            size += 1
            value = v
            index = k
        elif value != v:
            size -= 1
        else:
            size += 1
    candidate = value if size > 0 else -1

    count = sum(1 for v in a if v == candidate)
    if count <= len(a) / 2:
        index = -1

    return index

This finds a value that appears in more than half of the array, then returns one valid index for it.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

Python Equi Leader

def equi_leader(a: list[int]) -> int:
    leader_size = value = 0
    for v in a:
        if leader_size == 0:
            leader_size += 1
            value = v
        elif value != v:
            leader_size -= 1
        else:
            leader_size += 1
    candidate = value if leader_size > 0 else -1

    count = len(a)
    leader_count = sum(1 for v in a if v == candidate)
    leader = candidate if leader_count > count / 2 else -1

    l_leader_count = 0
    equi_leaders = 0
    for k, v in enumerate(a):
        left_half = (k + 1) // 2
        right_half = (count - k - 1) // 2
        if v == leader:
            l_leader_count += 1

        r_leader_count = leader_count - l_leader_count
        if l_leader_count > left_half and r_leader_count > right_half:
            equi_leaders += 1

    return equi_leaders

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

Python Fib Frog

from collections import deque


def fib_frog(a: list[int]) -> int:
    size = len(a)

    fib = [0, 1]
    i = 1
    while fib[i] <= size:
        i += 1
        fib.append(fib[i - 1] + fib[i - 2])

    queue = deque([(-1, 0)])
    visited = [False] * size

    while queue:
        idx, jumps = queue.popleft()
        for f in range(len(fib) - 1, 1, -1):
            new_idx = idx + fib[f]
            if new_idx == size:
                return jumps + 1
            if new_idx > size or visited[new_idx] or a[new_idx] == 0:
                continue
            if a[new_idx] == 1:
                visited[new_idx] = True
                queue.append((new_idx, jumps + 1))

    return -1

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

Python Fish

def fish(a: list[int], b: list[int]) -> int:
    size = len(a)
    dead = 0
    downstream: list[int] = []

    for i in range(size):
        if b[i] == 1:
            downstream.append(a[i])
        else:
            while downstream:
                dead += 1
                if a[i] > downstream[-1]:
                    downstream.pop()
                else:
                    break

    return size - dead

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

Python Flags

def flags(a: list[int]) -> int:
    size = len(a)
    if size == 0:
        return 0

    peaks = [False] * size
    for i in range(1, size):
        next_val = a[i + 1] if i + 1 < size else 0
        peaks[i] = a[i - 1] < a[i] and a[i] > next_val

    next_peak = [0] * size
    next_peak[size - 1] = -1
    for i in range(size - 2, -1, -1):
        next_peak[i] = i if peaks[i] else next_peak[i + 1]

    i = 1
    result = 0
    while i * (i - 1) <= size:
        pos = 0
        num = 0
        while pos < size and num < i:
            pos = next_peak[pos]
            if pos == -1:
                break
            num += 1
            pos += i
        i += 1
        result = max(result, num)

    return result

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

Python Frog Jmp

import math


def frog_jmp(x: int, y: int, d: int) -> int:
    return math.ceil((y - x) / d)

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

Python Frog River One

def frog_river_one(x: int, a: list[int]) -> int:
    existing: set[int] = set()
    for k, i in enumerate(a):
        if i not in existing and i <= x:
            existing.add(i)
            if len(existing) == x:
                return k

    return -1

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

Python Genomic Range Query

def genomic_range_query(s: str, p: list[int], q: list[int]) -> list[int]:
    result = []
    for pi, qi in zip(p, q):
        sub = s[pi:qi + 1]
        if "A" in sub:
            result.append(1)
        elif "C" in sub:
            result.append(2)
        elif "G" in sub:
            result.append(3)
        else:
            result.append(4)

    return result

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

Python Is Ipv 4 Adress

def is_ipv4_address(input_string: str) -> bool:
    parts = input_string.split(".")
    if len(parts) != 4:
        return False

    for v in parts:
        try:
            n = int(v)
        except ValueError:
            return False
        if n > 255 or v == "" or v != str(n):
            return False

    return True

This splits the string by dots and validates each part as a normal IPv4 octet.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

Python Ladder

def ladder(a: list[int], b: list[int]) -> list[int]:
    size = len(a)
    mod = (1 << max(b)) - 1

    fib = [0, 1]
    for i in range(2, max(a) + 2):
        fib.append((fib[i - 1] + fib[i - 2]) & mod)

    result = [0] * size
    for i in range(size):
        result[i] = fib[a[i] + 1] & ((1 << b[i]) - 1)

    return result

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

Python Largest String

def largest_string(s: str) -> str:
    chars = list(s)
    length = len(chars)

    # instead of raising; this helper preserves that read behavior so the
    # lookahead checks below can't index past the end of the list.
    def char_at(idx: int) -> str:
        return chars[idx] if 0 <= idx < length else ""

    cur = ""
    i = length - 1
    while i >= 0:
        cur = char_at(i) + cur

        if len(cur) == 3:
            if cur == "abb":
                chars[i] = "b"
                chars[i + 1] = "a"
                chars[i + 2] = "a"
                if char_at(i + 4) == "b":
                    i += 4 + 1
                elif char_at(i + 3) == "b":
                    i += 3 + 1
                elif chars[i + 2] == "b":
                    i += 2 + 1
            if char_at(i + 1) == "b":
                i += 1 + 1
            else:
                i += 1
            cur = ""
        i -= 1

    return "".join(chars)

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

Python Max Counters

def max_counters(n: int, a: list[int]) -> list[int]:
    counters = [0] * n
    max_counter = 0
    last_update = 0
    condition = n + 1

    for v in a:
        if v <= n:
            index = v - 1
            if counters[index] < last_update:
                counters[index] = last_update
            counters[index] += 1
            max_counter = max(counters[index], max_counter)
        if v == condition:
            last_update = max_counter

    for k, v in enumerate(counters):
        if v < last_update:
            counters[k] = last_update

    return counters

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Python Max Double Slice Sum

def max_double_slice_sum(a: list[int]) -> int:
    size = len(a)
    if size < 3:
        return 0

    p1 = {1: 0}
    p2 = {size - 2: 0}

    for i in range(2, size - 1):
        p1[i] = max(0, p1[i - 1] + a[i - 1])
        p2[size - i - 1] = max(0, p2[size - i] + a[size - i])

    total = p1[1] + p2[1]
    for i in range(1, size - 1):
        total = max(total, p1[i] + p2[i])

    return total

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

Python Max Product Of Three

def max_product_of_three(a: list[int]) -> int:
    a = sorted(a)
    c = len(a)

    return max(a[c - 1] * a[c - 2] * a[c - 3], a[0] * a[1] * a[c - 1])

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

Python Max Profit

def max_profit(a: list[int]) -> int:
    price = a[0]
    profit = 0
    for v in a:
        price = min(price, v)
        profit = max(profit, v - price)

    return profit

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Python Max Slice Sum

def max_slice_sum(a: list[int]) -> int:
    tmp = max_sum = float("-inf")
    for v in a:
        tmp = max(tmp + v, v)
        max_sum = max(max_sum, tmp)

    return int(max_sum)

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

Python Min Avg Two Slice

def min_avg_two_slice(a: list[int]) -> int:
    idx = 0
    min_avg = (a[0] + a[1]) / 2
    for i in range(len(a) - 1):
        cur = (a[i] + a[i + 1]) / 2
        if i + 2 < len(a):
            three = (a[i] + a[i + 1] + a[i + 2]) / 3
            cur = min(cur, three)
        if cur < min_avg:
            min_avg = cur
            idx = i

    return idx

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.

Min Perimeter Rectangle

Mon, 01 Jan 0001 00:00:00 +0000

Python Min Perimeter Rectangle

def min_perimeter_rectangle(n: int) -> int:
    i = 1
    min_perimeter = float("inf")
    while i * i < n:
        if n % i == 0:
            min_perimeter = min(min_perimeter, 2 * (i + n // i))
        i += 1

    return int(min_perimeter)

This searches factor pairs up to the square root and picks the pair with the smallest perimeter.

Missing Integer

Mon, 01 Jan 0001 00:00:00 +0000

Python Missing Integer

def missing_integer(a: list[int]) -> int:
    min_val = 1
    for v in sorted(set(a)):
        if v > 0:
            if min_val != v:
                break
            min_val += 1

    return min_val

This records the positive numbers that exist, then returns the smallest positive value that is still missing.

Nesting

Mon, 01 Jan 0001 00:00:00 +0000

Python Nesting

def nesting(s: str) -> int:
    if not s:
        return 1

    stack: list[str] = []
    for ch in s:
        if ch == ")":
            if not stack or stack.pop() != "(":
                return 0
        elif ch:
            stack.append(ch)

    return 1 if not stack else 0

This treats the string like a balance counter: open parentheses add one, closing ones remove one.

Number Of Disc Intersections

Mon, 01 Jan 0001 00:00:00 +0000

Python Number Of Disc Intersections

def number_of_disc_intersections(a: list[int]) -> int:
    c = len(a)
    start = [0] * c
    end = [0] * c

    for k, v in enumerate(a):
        key = 0 if k < v else k - v
        start[key] += 1

        key = c - 1 if k + v >= c else k + v
        end[key] += 1

    total = 0
    active = 0
    for k in range(c):
        total += active * start[k] + (start[k] * (start[k] - 1)) // 2
        active += start[k] - end[k]
        if total > 10000000:
            return -1

    return total

This sorts disc start and end points and counts active overlaps without comparing every pair directly.

Odd Occurrences In Array

Mon, 01 Jan 0001 00:00:00 +0000

Python Odd Occurrences In Array

def odd_occurrences_in_array(a: list[int]) -> int | None:
    count: dict[int, int] = {}
    for value in a:
        if value not in count:
            count[value] = 1
        else:
            del count[value]

    return next(iter(count), None)

This uses XOR to cancel out pairs, leaving only the value that appears an odd number of times.

Palindrome Rearranging

Mon, 01 Jan 0001 00:00:00 +0000

Python Palindrome Rearranging

from collections import Counter


def palindrome_rearranging(input_string: str) -> bool:
    counts = Counter(input_string)
    odd = sum(1 for v in counts.values() if v % 2 != 0)

    return odd <= 1

This counts character frequency and checks whether the string has the right number of odd counts to form a palindrome.

Passing Cars

Mon, 01 Jan 0001 00:00:00 +0000

Python Passing Cars

def passing_cars(a: list[int]) -> int:
    passing = 0
    multiply = 0
    for i in a:
        if i == 0:
            multiply += 1
        elif multiply > 0:
            passing += multiply
            if passing > 1000000000:
                return -1

    return passing

This counts eastbound cars as it scans, then adds them whenever a westbound car appears.

Peaks

Mon, 01 Jan 0001 00:00:00 +0000

Python Peaks

def peaks(a: list[int]) -> int:
    n = len(a)
    if n <= 2:
        return 0

    total = [0] * n
    last = -1
    dist = 0
    for i in range(1, n - 1):
        total[i] = total[i - 1]
        if a[i] > a[i - 1] and a[i] > a[i + 1]:
            dist = max(dist, i - last)
            last = i
            total[i] += 1

    total[n - 1] = total[n - 2]
    if total[n - 1] == 0:
        return 0

    dist = max(dist, n - last)

    for i in range(dist // 2 + 1, dist):
        if n % i == 0:
            last = 0
            j = i
            while j <= n:
                if total[j - 1] <= last:
                    break
                last = total[j - 1]
                j += i
            if j > n:
                return n // i

    last = dist
    while n % last:
        last += 1

    return n // last

This finds the peak positions, then tests how many equal blocks can each contain at least one peak.

Perm Check

Mon, 01 Jan 0001 00:00:00 +0000

Python Perm Check

def perm_check(a: list[int]) -> int:
    a = sorted(a)
    for k, v in enumerate(a):
        if k + 1 < len(a) and v != k + 1:
            return 0

    return 1

This validates that every value from 1 to N appears exactly once.

Perm Missing Element

Mon, 01 Jan 0001 00:00:00 +0000

Python Perm Missing Element

def perm_missing_element(a: list[int]) -> int:
    a = sorted(a)
    for k, v in enumerate(a):
        if v != k + 1:
            return k + 1

    return len(a) + 1

This uses the expected sum of 1..N+1 and subtracts the actual sum to find the missing value.

Plagiarism Check

Mon, 01 Jan 0001 00:00:00 +0000

Python Plagiarism Check

import re


def plagiarism_check(code1: list[str], code2: list[str]) -> bool:
    c1 = " ".join(code1)
    c2 = " ".join(code2)
    if c1 == c2:
        return False

    d1 = re.findall(r"\w+", c1)
    d2 = re.findall(r"\w+", c2)

    r_cand: dict[str, str] = {}
    for v, w in zip(d1, d2):
        if v != w and not v.isdigit():
            r_cand[v] = w

    for orig, _repl in r_cand.items():
        c1 = re.sub(r"(\W)" + re.escape(orig) + r"(\W*)", r"\1PLACEHOLDER" + orig + r"\2", c1)
        c1 = re.sub(r"(\W)" + re.escape(orig), r"\1PLACEHOLDER" + orig, c1)

    for orig, repl in r_cand.items():
        c1 = re.sub(r"(\W)PLACEHOLDER" + re.escape(orig) + r"(\W)", r"\1" + repl + r"\2", c1)
        c1 = re.sub(r"(\W)PLACEHOLDER" + re.escape(orig), r"\1" + repl, c1)

    return c1 == c2

This flattens both snippets, tries consistent identifier replacements, and checks whether the rewritten code matches.

Shape Area

Mon, 01 Jan 0001 00:00:00 +0000

Python Shape Area

def shape_area(n: int) -> int:
    return shape_area(n - 1) + 4 * (n - 1) if n > 1 else 1

This returns the area of the growing n-interesting polygon using the direct formula instead of building the shape.

Stone Blocks

Mon, 01 Jan 0001 00:00:00 +0000

Python Stone Blocks

def stone_blocks(h: list[int]) -> int:
    height: list[int] = []
    index = 0
    blocks = 0

    for i in h:
        while index > 0 and height[index - 1] > i:
            index -= 1
        if index > 0 and height[index - 1] == i:
            continue

        if index < len(height):
            height[index] = i
        else:
            height.append(i)
        blocks += 1
        index += 1

    return blocks

This uses a stack of active heights and only counts a new block when the wall needs a new height segment.

Tape Equilibrium

Mon, 01 Jan 0001 00:00:00 +0000

Python Tape Equilibrium

def tape_equilibrium(a: list[int]) -> int:
    first_part = 0
    second_part = sum(a)
    min_diff = float("inf")
    for i in range(len(a) - 1):
        first_part += i
        second_part -= i
        diff = abs(first_part - second_part)
        min_diff = min(min_diff, diff)

    return int(min_diff)

This keeps left and right running sums and updates the smallest difference at each split point.

Triangle

Mon, 01 Jan 0001 00:00:00 +0000

Python Triangle

def triangle(a: list[int]) -> int:
    a = sorted(a)
    c = len(a)
    if c < 3:
        return 0

    for i in range(c - 2):
        if a[i] > 0 and a[i] > (a[i + 2] - a[i + 1]):
            return 1

    return 0

This sorts the values and checks nearby triples, because a valid triangle only needs one local match after sorting.