Bytebytego on ¬ just serendipity 🍀

ByteByteGo: Product Array Without Current Element

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 02 Dec 2025 23:12:24 -0300

♠ ByteByteGo: Product Array Without Current Element:

from typing import List
from functools import reduce
import operator

def product_array_without_current_element(nums: List[int]) -> List[int]:
    total_no_zeroes = 1
    for num in nums:
        total_no_zeroes *= num if num != 0 else 1

    num_zeroes = len([num for num in nums if num == 0])

    if num_zeroes >= 2:
        return [0] * len(nums)

    if num_zeroes == 0:
        return [total_no_zeroes // num for num in nums]

    assert num_zeroes == 1
    return [0 if num != 0 else total_no_zeroes for num in nums]

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: K-Sum Subarrays

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 02 Dec 2025 22:56:27 -0300

♠ ByteByteGo: K-Sum Subarrays:

from typing import List
import itertools

def k_sum_subarrays(nums: List[int], k: int) -> int:
    acc = list(itertools.accumulate(nums))

    ans = 0

    for i in range(len(nums)):
        for j in range(i, len(nums)):
            mysum = acc[j] - (acc[i - 1] if i != 0 else 0)
            if mysum == k:
                ans += 1

    return ans

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Sum Between Range

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 02 Dec 2025 22:50:57 -0300

♠ ByteByteGo: Sum Between Range:

from typing import List

import itertools

class SumBetweenRange:
    def __init__(self, nums: List[int]):
        self.acc = list(itertools.accumulate(nums))

    def sum_range(self, i: int, j: int):
        return self.acc[j] - (self.acc[i - 1] if i != 0 else 0)

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: First and Last Occurrences of a Number

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 02 Dec 2025 16:37:49 -0300

♠ ByteByteGo: First and Last Occurrences of a Number:

import bisect
from typing import List

def first_and_last_occurrences_of_a_number(nums: List[int], target: int) -> int:
    if not nums:
        return [-1, -1]

    left = bisect.bisect_left(nums, target)
    right = bisect.bisect_right(nums, target)

    if (left < len(nums) and nums[left] == target) and (right > 0 and nums[right - 1] == target):
        return [left, right - 1]

    return [-1, -1]

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Happy Number

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 02 Dec 2025 16:32:31 -0300

♠ ByteByteGo: Happy Number:

def happy_number(n: int) -> bool:
    seen = (set([n]))

    def apply(n):
        ans = 0

        while n > 0:
            ans += (n % 10) ** 2
            n //= 10

        return ans

    assert apply(23) == 13

    while n != 1:
        n = apply(n)

        if n in seen:
            return False
        else:
            seen.add(n)

    return True

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Linked List Midpoint

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 02 Dec 2025 16:10:08 -0300

♠ ByteByteGo: Linked List Midpoint:

Slow and fast pointers.

from ds import ListNode

"""
Definition of ListNode:
class ListNode:
    def __init__(self, val=None, next=None):
        self.val = val
        self.next = next
"""

def linked_list_midpoint(head: ListNode) -> ListNode:
    if not head or not head.next:
        return head

    slow = head
    fast = head

    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next

    return slow

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Linked List Loop

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 02 Dec 2025 16:01:34 -0300

♠ ByteByteGo: Linked List Loop:

Slow and fast pointers.

from ds import ListNode

"""
Definition of ListNode:
class ListNode:
    def __init__(self, val=None, next=None):
        self.val = val
        self.next = next
"""

def linked_list_loop(head: ListNode) -> bool:
    if not head or not head.next:
        return False

    slow = head
    fast = head.next

    while slow != fast:
        slow = slow.next

        if not fast or not fast.next:
            return False

        fast = fast.next.next

    return True

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Remove the Kth Last Node From a Linked List

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 02 Dec 2025 03:58:25 -0300

♠ ByteByteGo: Remove the Kth Last Node From a Linked List:

from ds import ListNode

"""
Definition of ListNode:
class ListNode:
    def __init__(self, val=None, next=None):
        self.val = val
        self.next = next
"""

def remove_kth_last_node(head: ListNode, k: int) -> ListNode:
    pivot = head
    back = head

    for _ in range(k):
        if pivot:
            pivot = pivot.next
        else:
            return head

    if not pivot:
        return head.next

    while pivot.next:
        pivot = pivot.next
        back = back.next

    back.next = back.next.next

    return head

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Largest Square in a Matrix

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 30 Nov 2025 23:18:37 -0300

♠ ByteByteGo: Largest Square in a Matrix:

from typing import List
from functools import lru_cache

def largest_square_in_a_matrix(matrix: List[List[int]]) -> int:
    @lru_cache(maxsize=None)
    def solve(x: int, y: int) -> int:
        if x < 0 or y < 0:
            return 0
        if matrix[x][y] == 0 or x == 0 or y == 0:
            return matrix[x][y]
        return 1 + min(
            solve(x - 1, y),
            solve(x, y - 1),
            solve(x - 1, y - 1),
        )

    # stores the maximum side length
    ans = 0
    for i in range(len(matrix)):
        for j in range(len(matrix[0])):
            ans = max(ans, solve(i, j))

    # Return the area (side length squared)
    return ans * ans

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Longest Palindrome in a String

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 30 Nov 2025 22:16:55 -0300

♠ ByteByteGo: Longest Palindrome in a String:

def longest_palindrome_in_a_string(s: str) -> str:
    from functools import lru_cache

    ans = ""

    @lru_cache(maxsize=None)
    def is_palindrome(i, j):
        assert i >= 0
        assert j < len(s)

        if i >= j:  # out of bounds
            return True

        if s[i] != s[j]:
            return False

        return is_palindrome(i + 1, j - 1)

    if len(s) > 0:
        ans = s[0]

    for i in range(len(s)):
        for j in range(i + 1, len(s)):  # both inclusive
            if is_palindrome(i, j):
                curr_len = j - i + 1
                if curr_len > len(ans):
                    ans = s[i:j + 1]

    return ans

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: N Queens

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 30 Nov 2025 21:14:24 -0300

♠ ByteByteGo: N Queens:

def n_queens(n: int) -> int:
    ans = 0

    def backtrack(r, vset: set, d1set: set, d2set: set):
        nonlocal ans

        # r, c: row, col

        # d1 set: r + c
        # d2 set: r - c (or c - r, just be consistent)

        if r == n:
            ans += 1
            return

        for c in range(n):
            # place a queen in (r, c) position if possible
            if c not in vset and c + r not in d1set and c - r not in d2set:
                vset.add(c)
                d1set.add(c + r)
                d2set.add(c - r)

                backtrack(r + 1, vset, d1set, d2set)

                vset.remove(c)
                d1set.remove(c + r)
                d2set.remove(c - r)


    backtrack(0, set(), set(), set())

    return ans

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Josephus

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 30 Nov 2025 17:26:22 -0300

♠ ByteByteGo: Josephus:

With an array:

def josephus(n: int, k: int) -> int:
    circle = list(range(n))
    victim = 0
    # [0, 1, 2, 3, 4]
    #  ^
    #
    # clockwise: victim += 1
    #
    # next victim: victim + k - 1 (remember to mod)

    while len(circle) > 1:
        victim = (victim + (k - 1)) % len(circle)
        del circle[victim]

    return circle[0]

With a linked list (deque):

from collections import deque

def josephus(n: int, k: int) -> int:
    circle = deque(range(n))
    victim = 0
    # [0, 1, 2, 3, 4]
    #  ^
    #
    # clockwise: victim += 1
    #
    # next victim: victim + k - 1 (remember to mod)

    while len(circle) > 1:
        victim = (victim + (k - 1)) % len(circle)
        del circle[victim]

    return circle[0]

With a linked list, efficient removals from the end (beginning) of the list:

from collections import deque

def josephus(n: int, k: int) -> int:
    circle = deque(range(n))

    while len(circle) > 1:
        # rotate left so that the k‑th person becomes the leftmost element
        # deque.rotate moves elements to the right; negative rotates left
        circle.rotate(-(k - 1))

        # eliminate that person
        circle.popleft()

    return circle[0]

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Spiral Traversal

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 30 Nov 2025 16:49:27 -0300

♠ ByteByteGo: Spiral Traversal:

from typing import List

def spiral_matrix(matrix: List[List[int]]) -> List[int]:
    ans = []

    start = (0, 0)
    end = (len(matrix), len(matrix[0]))

    def debian_once(start, end):
        for j in range(start[1], end[1]):
            ans.append(matrix[start[0]][j])

        for i in range(start[0] + 1, end[0] - 1):
            ans.append(matrix[i][end[1] - 1])

        if end[0] - 1 > start[0]:
            for j in range(end[1] - 1, start[1] - 1, -1):
                ans.append(matrix[end[0] - 1][j])

        if end[1] - 1 > start[1]:
            for i in range(end[0] - 1 - 1, start[1], -1):
                ans.append(matrix[i][start[1]])

    # while start[0] < end[0] and start[1] < end[1]:
    # while all(start[i] < end[i] for i in range(len(start))):
    while all(x < y for (x, y) in zip(start, end)):
        debian_once(start, end)
        start = tuple(el + 1 for el in start)
        end = tuple(el - 1 for el in end)

    return ans

Beware of not doing <- (leftwards) and ^ (upwards) whenever there’s a single column or a single row!

Or, changing the meaning of end by shifting one cell diagonally inwards (inclusive):

from typing import List

def spiral_matrix(matrix: List[List[int]]) -> List[int]:
    ans = []

    start = (0, 0)
    end = (len(matrix) - 1, len(matrix[0]) - 1)

    def debian_once(start, end):
        for j in range(start[1], end[1] + 1):
            ans.append(matrix[start[0]][j])

        for i in range(start[0] + 1, end[0]):
            ans.append(matrix[i][end[1]])

        if start[0] < end[0]:
            for j in range(end[1], start[1] - 1, -1):
                ans.append(matrix[end[0]][j])

        if start[1] < end[1]:
            for i in range(end[0] - 1, start[1], -1):
                ans.append(matrix[i][start[1]])

    # while start[0] <= end[0] and start[1] <= end[1]:
    # while all(start[i] <= end[i] for i in range(len(start))):
    while all(x <= y for (x, y) in zip(start, end)):
        debian_once(start, end)
        start = tuple(el + 1 for el in start)
        end = tuple(el - 1 for el in end)

    return ans

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Combinations of a Sum

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 30 Nov 2025 14:58:14 -0300

♠ ByteByteGo: Combinations of a Sum:

Initial solution, wrong:

Input: nums = [1, 2, 3], target = 4
Output: [[1,1,1,1],[1,1,2],[1,2,1],[1,3],[2,1,1],[2,2],[3,1]]

from typing import List

def combinations_of_sum_k(nums: List[int], target: int) -> List[List[int]]:
    ans = []

    def backtrack(candidate = [], target = target):
        if target < 0:
            return

        if target == 0:
            ans.append(candidate[:])
            return

        for num in nums:
            # include num
            candidate.append(num)
            backtrack(candidate, target - num)
            candidate.pop()

            # do not include num
            continue

    backtrack()

    return ans

It is incorrect because it includes certain combinations multiple times e.g. [1,1,2], [1,2,1], [2,1,1].

The key insight is, upon moving to the next num in nums, not to include the entire nums list during the backtracking, but rather only from the index corresponding to num.

Final solution, correct:

Input: nums = [1, 2, 3], target = 4
Output: [[1, 1, 1, 1], [1, 1, 2], [1, 3], [2, 2]]

from typing import List

def combinations_of_sum_k(nums: List[int], target: int) -> List[List[int]]:
    ans = []

    def backtrack(nums = nums, candidate = [], target = target):
        if target < 0:
            return

        if target == 0:
            ans.append(candidate[:])
            return

        for i, num in enumerate(nums):
            # include num
            candidate.append(num)
            backtrack(nums[i:], candidate, target - num)
            candidate.pop()

            # do not include num
            continue

    backtrack()

    return ans

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Find All Subsets

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 30 Nov 2025 14:42:17 -0300

♠ ByteByteGo: Find All Subsets:

from typing import List

def find_all_subsets(nums: List[int]) -> List[List[int]]:
    ans = []

    def backtrack(nums = nums, candidate = []):
        if not nums:
            ans.append(candidate[:])
            return

        num = nums[0]

        # or do include num
        candidate.append(num)
        backtrack(nums[1:], candidate)
        candidate.pop()

        # either do not include num
        backtrack(nums[1:], candidate)


    backtrack()

    return ans

It’s also possible to do it with a single recursion:

from typing import List

def find_all_subsets(nums: List[int]) -> List[List[int]]:
    ans = []

    def backtrack(start, candidate):
        # Every point in the recursion represents a valid subset
        ans.append(candidate[:])

        for i in range(start, len(nums)):
            candidate.append(nums[i])    # include nums[i]
            backtrack(i + 1, candidate)  # recurse on the rest
            candidate.pop()              # backtrack

    backtrack(0, [])

    return ans

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Find All Permutations

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 30 Nov 2025 14:02:35 -0300

♠ ByteByteGo: Find All Permutations:

from typing import List

def find_all_permutations(nums: List[int]) -> List[List[int]]:
    ans = []

    def backtrack(candidate = [], visited = set()):
        if len(candidate) == len(nums):
            ans.append(candidate[:])
            return

        for num in nums:
            if num not in visited:
                candidate.append(num)
                visited.add(num)

                backtrack(candidate, visited)

                candidate.pop()
                visited.remove(num)


    backtrack()

    return ans

If we do not make a copy of candidate (candidate[:]), ans will be a mess.

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Hamming Weights of Integers

serendipity@perrotta.dev (Thiago Perrotta) — Thu, 27 Nov 2025 03:09:16 -0300

♠ ByteByteGo: Hamming Weights of Integers:

Did someone say something about variable scoping? Poor n is overworked.

from typing import List

def hamming_weights_of_integers(n: int) -> List[int]:
    def hammer(n):
        ans = 0
        while n > 0:
            ans += n & 1
            n >>= 1
        return ans

    return [hammer(n) for n in range(n + 1)]

With top-down dynamic programming, linear:

from typing import List

def hamming_weights_of_integers(n: int) -> List[int]:
    from functools import lru_cache

    @lru_cache(maxsize=None)
    def hammer(n):
        if n in [0, 1]:
            return n

        return hammer(n >> 1) + (n & 1)

    return [hammer(n) for n in range(n + 1)]

With bottom-up dynamic programming, linear:

from typing import List

def hamming_weights_of_integers(n: int) -> List[int]:
    from functools import lru_cache

    if n == 0:
        return [0]

    hammer = [0] * (n + 1)
    hammer[0] = 0
    hammer[1] = 1

    for x in range(2, n + 1):
        hammer[x] = hammer[x >> 1] + (x & 1)

    return hammer

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Swap Odd and Even Bits

serendipity@perrotta.dev (Thiago Perrotta) — Thu, 27 Nov 2025 03:06:15 -0300

♠ ByteByteGo: Swap Odd and Even Bits:

def swap_odd_and_even_bits(n: int) -> int:
    ans = 0
    shift = 0

    while n > 0:
        ans += ((n & 0b01) << 1) + ((n & 0b10) >> 1) << shift
        n >>= 2
        shift += 2

    return ans

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Lonely Integer

serendipity@perrotta.dev (Thiago Perrotta) — Thu, 27 Nov 2025 02:58:33 -0300

♠ ByteByteGo: Lonely Integer:

from typing import List
from functools import reduce

def lonely_integer(nums: List[int]) -> int:
    return reduce(lambda x, y: x ^ y, nums)

If you forget how to call reduce:

from typing import List
from functools import reduce

def lonely_integer(nums: List[int]) -> int:
    ans = 0
    for num in nums:
        ans ^= num
    return ans

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Maximum Subarray Sum

serendipity@perrotta.dev (Thiago Perrotta) — Thu, 27 Nov 2025 02:51:23 -0300

♠ ByteByteGo: Maximum Subarray Sum:

from typing import List

def maximum_subarray_sum(nums: List[int]) -> int:
    from functools import lru_cache

    @lru_cache(maxsize=None)
    def solve(i, must_take=False):
        if i < 0:
            return 0

        if i == 0:
            if must_take:
                return max(0, nums[i])
            else:
                return nums[i]

        take = nums[i] + solve(i - 1, True)
        if must_take:
            return max(0, take)

        skip = solve(i - 1)
        return max(take, skip)

    return solve(len(nums) - 1)

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: 0/1 Knapsack

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 26 Nov 2025 22:06:31 -0300

♠ ByteByteGo: 0/1 Knapsack:

from typing import List

def knapsack(k: int, weights: List[int], values: List[int]) -> int:
    from functools import lru_cache

    assert len(weights) == len(values)

    @lru_cache(maxsize=None)
    def solve(i, k):
        assert i >= 0

        if i == 0:
            if weights[i] <= k:
                return values[i]
            else:
                return 0

        if k <= 0:
            return 0

        skip = solve(i - 1, k)

        take = 0
        if weights[i] <= k:
            take = values[i] + solve(i - 1, k - weights[i])

        return max(skip, take)

    return solve(len(weights) - 1, k)

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Neighborhood Burglary

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 26 Nov 2025 21:17:39 -0300

♠ ByteByteGo: Neighborhood Burglary:

from typing import List

def neighborhood_burglary(houses: List[int]) -> int:
    from functools import lru_cache

    @lru_cache(maxsize=None)
    def solve(i):
        # 0 to n - 1
        assert i >= 0

        if i == 0:
            return houses[0]

        if i == 1:
            return max(houses[0], houses[1])

        return max(
            houses[i] + solve(i - 2),
            solve(i - 1),
        )

    return solve(len(houses) - 1)

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Matrix Pathways

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 26 Nov 2025 21:01:40 -0300

♠ ByteByteGo: Matrix Pathways:

def matrix_pathways(m: int, n: int) -> int:
    from functools import lru_cache

    @lru_cache(maxsize=None)
    def solve(m, n):
        # from 1 to m, from 1 to n
        assert (m, n) >= (0, 0)

        if m == 0 or n == 0:
            return 0

        if m == 1 and n == 1:
            return 1

        return solve(m - 1, n) + solve(m, n - 1)

    return solve(m, n)

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Kth Largest Integer

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 26 Nov 2025 18:11:54 -0300

♠ ByteByteGo: Kth Largest Integer:

Sort with reverse=True:

from typing import List

def kth_largest_integer(nums: List[int], k: int) -> int:
    s = sorted(set(nums), reverse=True)

    if len(s) == 1:
        return list(s)[0]

    return list(s)[k - 1 % len(nums)]

Sort with reversed:

from typing import List

def kth_largest_integer(nums: List[int], k: int) -> int:
    s = list(reversed(list(sorted(set(nums)))))

    if len(s) == 1:
        return list(s)[0]

    return list(s)[k - 1 % len(nums)]

Forego reversion, index from the end of the list instead:

from typing import List

def kth_largest_integer(nums: List[int], k: int) -> int:
    s = sorted(set(nums))

    if len(s) == 1:
        return list(s)[0]

    return list(s)[len(nums) - k]

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Reverse 32-Bit Integer

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 26 Nov 2025 15:06:17 -0300

♠ ByteByteGo: Reverse 32-Bit Integer:

Strings #

def reverse_32_bit_integer(n: int) -> int:
    ans = ""

    s = str(n)[::-1]

    # 420
    # 024

    # -15
    # 51-

    is_negative = n < 0
    is_beginning = True

    for i, c in enumerate(s):
        if i == (len(s) - 1) and is_negative:
            continue

        if c == '0' and is_beginning:
            continue

        ans += c

        is_beginning = False

    ans = int(ans) * (-1 if is_negative else 1)

    return ans if (-1 * 2**31 <= ans <= 2**31 - 1) else 0

Numbers #

def reverse_32_bit_integer(n: int) -> int:
    ans = 0
    is_negative = -1 if n < 0 else 1
    n = abs(n)

    while n != 0:
        digit = n % 10
        n //= 10

        # Check for overflow: positive
        if ans > (2**31 - 1) // 10:
            return 0

        ans = ans * 10 + digit

    return is_negative * ans

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Dutch National Flag

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 26 Nov 2025 14:03:26 -0300

♠ ByteByteGo: Dutch National Flag:

Cheat, O(n log n) time:

from typing import List
from collections import defaultdict

def dutch_national_flag(nums: List[int]) -> None:
    nums.sort()

O(n) time, O(1) storage:

from typing import List
from collections import defaultdict

def dutch_national_flag(nums: List[int]) -> None:
    c = defaultdict(int)

    for num in nums:
        c[num] += 1

    order = sorted(c.keys())

    for i in range(len(nums)):
        for ins in order:
            if c[ins] > 0:
                nums[i] = ins
                c[ins] -= 1
                break

Clean:

from typing import List

def dutch_national_flag(nums: List[int]) -> None:
    """
    In-place sort of array containing only 0,1,2 using the three-pointer method.
    Time: O(n), Space: O(1)
    """
    left = 0
    mid = 0
    right = len(nums) - 1

    while mid <= right:
        if nums[mid] == 0:
            nums[left], nums[mid] = nums[mid], nums[left]
            left += 1
            mid += 1
        elif nums[mid] == 1:
            mid += 1
        else:  # nums[mid] == 2
            nums[mid], nums[right] = nums[right], nums[mid]
            right -= 1

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Find the Insertion Index

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 26 Nov 2025 13:48:52 -0300

♠ ByteByteGo: Find the Insertion Index:

from typing import List

def find_the_insertion_index(nums: List[int], target: int) -> int:
    if len(nums) == 0:
        return 0

    left = 0
    right = len(nums) - 1
    assert right >= left

    while left < right:
        mid = left + ((right - left) // 2)

        if nums[mid] == target:
            return mid

        elif nums[mid] < target:
            left = mid + 1

        else:
            right = mid - 1

    if nums[left] < target:
        return left + 1
    else:
        return left

Elegant:

import bisect
from typing import List

def find_the_insertion_index(nums: List[int], target: int) -> int:
    return bisect.bisect_left(nums, target)

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Minimum Coin Combination

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 26 Nov 2025 13:28:33 -0300

♠ ByteByteGo: Minimum Coin Combination:

The -1 return requirement makes it a bit ugly.

from typing import List
from functools import lru_cache

def min_coin_combination(coins: List[int], target: int) -> int:
    @lru_cache(maxsize=None)
    def solve(i, target):
        if i < 0 or target < 0:
            if target == 0:
                return 0
            else:
                return -1

        q1 = solve(i, target - coins[i])
        q2 = solve(i - 1, target)

        if q1 != -1 and q2 != -1:
            return min(
                q1 + 1,
                q2,
            )
        if q1 != -1:
            return q1 + 1
        if q2 != -1:
            return q2

        return -1

    return solve(len(coins) - 1, target)

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Repeated Removal of Adjacent Duplicates

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 25 Nov 2025 21:45:48 -0300

♠ ByteByteGo: Repeated Removal of Adjacent Duplicates:

def repeated_removal_of_adjacent_duplicates(s: str) -> str:
    stack = []

    for c in s:
        if len(stack) == 0 or stack[-1] != c:
            stack.append(c)
        elif stack[-1] == c:
            stack.pop()

    return ''.join(stack)

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Valid Parenthesis Expression

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 25 Nov 2025 21:39:15 -0300

♠ ByteByteGo: Valid Parenthesis Expression:

def valid_parenthesis_expression(s: str) -> bool:
    stack = []

    for c in s:
        if c in '([{':
            stack.append(c)

        if len(stack) == 0:
            return False

        if c == ')':
            if stack.pop() != '(':
                return False

        if c == ']':
            if stack.pop() != '[':
                return False

        if c == '}':
            if stack.pop() != '{':
                return False

    return len(stack) == 0

Refinement:

def valid_parenthesis_expression(s: str) -> bool:
    stack = []

    ass = {
        ')': '(',
        ']': '[',
        '}': '{',
    }

    for c in s:
        if c in '([{':
            stack.append(c)

        if len(stack) == 0:
            return False

        if c in ')]}':
            if stack.pop() != ass[c]:
                return False

    return len(stack) == 0

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Linked List Reversal

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 25 Nov 2025 21:18:56 -0300

♠ ByteByteGo: Linked List Reversal:

Recursive #

from ds import ListNode

"""
Definition of ListNode:
class ListNode:
    def __init__(self, val=None, next=None):
        self.val = val
        self.next = next
"""

def linked_list_reversal(head: ListNode) -> ListNode:
    if head is None or head.next is None:
        return head

    new_head = linked_list_reversal(head.next)

    head.next.next = head
    head.next = None

    return new_head

Iterative #

from ds import ListNode

"""
Definition of ListNode:
class ListNode:
    def __init__(self, val=None, next=None):
        self.val = val
        self.next = next
"""

def linked_list_reversal(head: ListNode) -> ListNode:
    if head is None or head.next is None:
        return head

    prev = None

    while head is not None:
        next_node = head.next

        head.next = prev

        prev = head
        head = next_node

    return prev

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Invert Binary Tree

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 25 Nov 2025 00:36:17 -0300

♠ ByteByteGo: Invert Binary Tree:

from ds import TreeNode

"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None
"""

def invert_binary_tree(root: TreeNode) -> TreeNode:
    if root is None:
        return None

    root.left, root.right = root.right, root.left

    invert_binary_tree(root.left)
    invert_binary_tree(root.right)

    return root

The following DOES NOT work:

from ds import TreeNode

"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None
"""

def invert_binary_tree(root: TreeNode) -> TreeNode:
    if root is None:
        return None

    root.left = invert_binary_tree(root.right)
    root.right = invert_binary_tree(root.left)

    return root

The swap must happen simultaneously. The following works:

from ds import TreeNode

"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None
"""

def invert_binary_tree(root: TreeNode) -> TreeNode:
    if root is None:
        return None

    root.left, root.right = invert_binary_tree(root.right), invert_binary_tree(root.left)

    return root

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Climbing Stairs

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 25 Nov 2025 00:27:38 -0300

♠ ByteByteGo: Climbing Stairs:

Top-down DP:

def climbing_stairs(n: int) -> int:
    from functools import lru_cache

    @lru_cache(maxsize=None)
    def cs(n):
        """How many possibilities for n steps?"""
        assert n >= 0

        if n in [0, 1, 2]:
            return n

        return cs(n-1) + cs(n-2)

    return cs(n)

Their Python environment is quite old (3.8). Goodness.

We can only do from functools import cache from Python 3.9+.

Bottom-up DP:

def climbing_stairs(n: int) -> int:
    dp = [None] * n

    dp[0] = 1
    dp[1] = 2

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

    return dp[n - 1]

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Zero Striping

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 25 Nov 2025 00:13:43 -0300

♠ ByteByteGo: Zero Striping:

from typing import List

def zero_striping(matrix: List[List[int]]) -> None:
    row_set = set()
    col_set = set()

    for x in range(len(matrix)):
        for y in range(len(matrix[0])):
            c = matrix[x][y]

            if c == 0:
                row_set.add(x)
                col_set.add(y)

    for x in range(len(matrix)):
        for y in range(len(matrix[0])):
            if x in row_set or y in col_set:
                matrix[x][y] = 0

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Verify Sudoku Board

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 24 Nov 2025 22:09:17 -0300

♠ ByteByteGo: Verify Sudoku Board:

from typing import List

def verify_sudoku_board(board: List[List[int]]) -> bool:
    row_sets = [set() for _ in range(9)]
    col_sets = [set() for _ in range(9)]
    grid_sets = [[set() for _ in range(3)] for _ in range(3)]

    for x in range(len(board)):
        for y in range(len(board[0])):
            c = board[x][y]
            if c == 0:
                continue

            if c in row_sets[x]:
                return False
            else:
                row_sets[x].add(c)

            if c in col_sets[y]:
                return False
            else:
                col_sets[y].add(c)

            if c in grid_sets[x // 3][y // 3]:
                return False
            else:
                grid_sets[x // 3][y // 3].add(c)

    return True

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Longest Chain of Consecutive Numbers

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 24 Nov 2025 00:41:57 -0300

♠ ByteByteGo: Longest Chain of Consecutive Numbers:

from typing import List

def longest_chain_of_consecutive_numbers(nums: List[int]) -> int:
    nums.sort()

    ans = 0

    size = 0
    last = None

    for n in nums:
        if last is None:
            last = n
            size = 1
        elif n == last + 1:
            last = n
            size += 1
        elif n == last:  # alternatively: put nums in a set
            continue
        else:
            last = n
            size = 1
        ans = max(ans, size)

    return ans

Alternative:

from typing import List

def longest_chain_of_consecutive_numbers(nums: List[int]) -> int:
    ans = 0

    size = 0
    last = None

    for n in sorted(set(nums)):
        if last is None:
            last = n
            size = 1
        elif n == last + 1:
            last = n
            size += 1
        else:
            last = n
            size = 1
        ans = max(ans, size)

    return ans

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Shift Zeros to the End

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 23 Nov 2025 18:16:40 -0300

♠ Same as LeetCode #283.

ByteByteGo: Shift Zeros to the End:

from typing import List

def shift_zeros_to_the_end(nums: List[int]) -> None:
    j = None

    for i, num in enumerate(nums):
        if num != 0:
            if j is not None:
                assert j < i
                nums[i], nums[j] = nums[j], nums[i]
                j += 1
        else:
            if j is None:
                j = i

Simplified version:

from typing import List

def shift_zeros_to_the_end(nums: List[int]) -> None:
    j = 0

    for i, num in enumerate(nums):
        if num != 0:
            nums[i], nums[j] = nums[j], nums[i]
            j += 1

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Largest Container

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 23 Nov 2025 17:09:59 -0300

♠ ByteByteGo: Largest Container:

from typing import List

def largest_container(heights: List[int]) -> int:
    left = 0
    right = len(heights) - 1

    ans = 0

    def area(left, right):
        assert 0 <= left < len(heights)
        assert 0 <= right < len(heights)

        return (right - left) * min(heights[left], heights[right])

    while left < right:
        myarea = area(left, right)
        ans = max(ans, myarea)

        if heights[left] < heights[left + 1]:
            left += 1
        elif heights[right - 1] > heights[right]:
            right -= 1
        else:
            left += 1
            right -= 1

    return ans

Converge two pointers inwards. No mystery.

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Triplet Sum

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 23 Nov 2025 17:00:21 -0300

♠ ByteByteGo: Triplet Sum:

from typing import List

def triplet_sum(nums: List[int]) -> List[List[int]]:
    sequence = sorted(nums)

    ans = []

    for ia, a in enumerate(sequence):
        if a > 0:  # positive numbers cannot add up to zero
            break

        if ia > 0 and sequence[ia - 1] == sequence[ia]:  # prevent duplicates
            continue

        ib = ia + 1
        ic = len(sequence) - 1

        while ib < ic:
            b = sequence[ib]
            c = sequence[ic]

            target = -a
            if (b + c) == target:
                ans.append([a, b, c])
                ib += 1
                ic -= 1

                # keep going, preventing duplicates
                while ib < ic and sequence[ib - 1] == sequence[ib]:
                    ib += 1
                while ib < ic and sequence[ic + 1] == sequence[ic]:
                    ic -= 1
            elif (b + c) < target:
                ib += 1
            else:
                ic -=1

    return ans

Time complexity: O(n^2)

— § —

Reply via email

#bytebytego #dev %coding

ByteByteGo: Pair Sum - Unsorted

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 22 Nov 2025 19:28:06 -0300

♠ ByteByteGo: Pair Sum — Unsorted:

from typing import List

def pair_sum_unsorted(nums: List[int], target: int) -> List[int]:
    # Option 1: sort it and do two pointers.
    # Option 2: hash map.
    d = {}
    for i, num in enumerate(nums):
        d[num] = i

    for i, num in enumerate(nums):
        if (target - num) in d.keys():
            j = d[target - num]
            if i != j:
                return [i, j]

    return []

Be careful not to pick the same index twice.

Simpler way to construct the hash map: a dict comprehension:

d = {num: i for i, num in enumerate(nums)}

Fancier:

d = dict(zip(nums, range(len(nums))))

— § —

Reply via email

#bytebytego #dev %coding