Leetcode on ¬ just serendipity 🍀

LeetCode #355: Design Twitter

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 06 Apr 2026 00:54:49 +0200

My original solution:

from collections import defaultdict
from itertools import chain

class Twitter:

    def __init__(self):
        # [userId] -> {userId, ...}
        self.f = defaultdict(set)

        self.tweets = defaultdict(list)

        self.ts = 0


    def postTweet(self, userId: int, tweetId: int) -> None:
        self.tweets[userId].append((self.ts, tweetId))
        self.ts += 1

    def getNewsFeed(self, userId: int) -> List[int]:
        tweets_with_ts = []

        ## for followee in list(self.f[userId]) + [userId]:
        for followee in chain(self.f[userId], [userId]):
            tweets_with_ts.extend(self.tweets[followee][::-1])

        # [(1, 3), (0, 5)]
        tweets_with_ts.sort(reverse=True)

        tweets = [id for (_, id) in tweets_with_ts]

        return tweets[:10]

    def follow(self, followerId: int, followeeId: int) -> None:
        self.f[followerId].add(followeeId)


    def unfollow(self, followerId: int, followeeId: int) -> None:
        self.f[followerId].discard(followeeId)



# Your Twitter object will be instantiated and called as such:
# obj = Twitter()
# obj.postTweet(userId,tweetId)
# param_2 = obj.getNewsFeed(userId)
# obj.follow(followerId,followeeId)
# obj.unfollow(followerId,followeeId)

With deque (slow):

from collections import defaultdict, deque
from itertools import chain

class Twitter:

    def __init__(self):
        self.f = defaultdict(set)
        self.tweets = deque()

    def postTweet(self, userId: int, tweetId: int) -> None:
        self.tweets.appendleft((userId, tweetId))

    def getNewsFeed(self, userId: int) -> List[int]:
        return [tweetId for (user, tweetId) in self.tweets if user == userId or user in self.f[userId]][:10]

    def follow(self, followerId: int, followeeId: int) -> None:
        self.f[followerId].add(followeeId)


    def unfollow(self, followerId: int, followeeId: int) -> None:
        self.f[followerId].discard(followeeId)



# Your Twitter object will be instantiated and called as such:
# obj = Twitter()
# obj.postTweet(userId,tweetId)
# param_2 = obj.getNewsFeed(userId)
# obj.follow(followerId,followeeId)
# obj.unfollow(followerId,followeeId)

With heap:

from collections import defaultdict, deque
from itertools import chain
import heapq

class Twitter:

    def __init__(self):
        self.f = defaultdict(set)
        self.tweets = defaultdict(list)
        self.ts = 0

    def postTweet(self, userId: int, tweetId: int) -> None:
        self.tweets[userId].append((-self.ts, tweetId))
        self.ts += 1

    def getNewsFeed(self, userId: int) -> List[int]:
        tweets = []
        heap = []

        for followee in chain(self.f[userId], [userId]):
            heap.extend(self.tweets[followee])

        heapq.heapify(heap)

        for _ in range(min(10, len(heap))):
            tweets.append(heapq.heappop(heap)[1])

        return tweets

    def follow(self, followerId: int, followeeId: int) -> None:
        self.f[followerId].add(followeeId)


    def unfollow(self, followerId: int, followeeId: int) -> None:
        self.f[followerId].discard(followeeId)



# Your Twitter object will be instantiated and called as such:
# obj = Twitter()
# obj.postTweet(userId,tweetId)
# param_2 = obj.getNewsFeed(userId)
# obj.follow(followerId,followeeId)
# obj.unfollow(followerId,followeeId)

— § —

Reply via email

#dev #leetcode %coding

LeetCode #3822: Design Order Management System

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 01 Mar 2026 18:21:49 +0100

♠ LeetCode #3822: Design Order Management System:

from dataclasses import dataclass

@dataclass
class Entry():
    orderType: OrderType
    price: int

class OrderManagementSystem:

    def __init__(self):
        self.orders = {}

    def addOrder(self, orderId: int, orderType: str, price: int) -> None:
        assert orderType in ["buy", "sell"], f"invalid orderType: {orderType}"

        self.orders[orderId] = Entry(orderType, price)


    def modifyOrder(self, orderId: int, newPrice: int) -> None:
        assert orderId in self.orders

        orderType = self.orders[orderId].orderType
        self.orders[orderId] = Entry(orderType, newPrice)


    def cancelOrder(self, orderId: int) -> None:
        assert orderId in self.orders

        del self.orders[orderId]

    def getOrdersAtPrice(self, orderType: str, price: int) -> List[int]:
        return [orderId for (orderId, entry) in self.orders.items() if entry.orderType == orderType and entry.price == price]


# Your OrderManagementSystem object will be instantiated and called as such:
# obj = OrderManagementSystem()
# obj.addOrder(orderId,orderType,price)
# obj.modifyOrder(orderId,newPrice)
# obj.cancelOrder(orderId)
# param_4 = obj.getOrdersAtPrice(orderType,price)

— § —

Reply via email

#dev #leetcode %coding

LeetCode #146: LRU Cache

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 01 Mar 2026 18:09:17 +0100

♠ LeetCode #146: LRU Cache:

from collections import OrderedDict

class LRUCache:

    def __init__(self, capacity: int):
        self.m = OrderedDict()
        self.max_size = capacity


    def get(self, key: int) -> int:
        if key in self.m:
            self.m.move_to_end(key)
            return self.m[key]

        return -1


    def put(self, key: int, value: int) -> None:
        if key in self.m:
            self.m[key] = value
            self.m.move_to_end(key)
        else:
            if len(self.m) >= self.max_size:
                self.m.popitem(False)  # LRU / FIFO
            self.m[key] = value


# Your LRUCache object will be instantiated and called as such:
# obj = LRUCache(capacity)
# param_1 = obj.get(key)
# obj.put(key,value)

— § —

Reply via email

#dev #leetcode %coding

LeetCode #379: Design Phone Directory

serendipity@perrotta.dev (Thiago Perrotta) — Mon, 23 Feb 2026 01:25:36 +0100

♠ LeetCode #379: Design Phone Directory:

class PhoneDirectory:

    def __init__(self, maxNumbers: int):
        self.available = set(range(maxNumbers))

    def get(self) -> int:
        if not self.available:
            return -1

        return self.available.pop()


    def check(self, number: int) -> bool:
        return number in self.available


    def release(self, number: int) -> None:
        self.available.add(number)


# Your PhoneDirectory object will be instantiated and called as such:
# obj = PhoneDirectory(maxNumbers)
# param_1 = obj.get()
# param_2 = obj.check(number)
# obj.release(number)

— § —

Reply via email

#dev #leetcode %coding

LeetCode #2166: Design Bitset

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 20 Jan 2026 22:20:59 +0100

♠ LeetCode #2166: Design Bitset:

Time limit exceeded:

class Bitset:

    def __init__(self, size: int):
        self.bits = [False] * size


    def fix(self, idx: int) -> None:
        self.bits[idx] = 1


    def unfix(self, idx: int) -> None:
        self.bits[idx] = 0


    def flip(self) -> None:
        self.bits = [not bit for bit in self.bits]


    def all(self) -> bool:
        return all(self.bits)


    def one(self) -> bool:
        return any(self.bits)


    def count(self) -> int:
        return len([bit for bit in self.bits if bit])


    def toString(self) -> str:
        return ''.join('1' if bit else '0' for bit in self.bits)



# Your Bitset object will be instantiated and called as such:
# obj = Bitset(size)
# obj.fix(idx)
# obj.unfix(idx)
# obj.flip()
# param_4 = obj.all()
# param_5 = obj.one()
# param_6 = obj.count()
# param_7 = obj.toString()

Optimized:

class Bitset:

    def __init__(self, size: int):
        self.bits = [False] * size
        self.ones = 0
        self.flipped = False


    def fix(self, idx: int) -> None:
        if self.flipped:
            # When flipped, fixing means setting underlying bit to 0
            if self.bits[idx]:
                self.bits[idx] = False
                self.ones -= 1
        else:
            # Normal case: set to 1
            if not self.bits[idx]:
                self.bits[idx] = True
                self.ones += 1


    def unfix(self, idx: int) -> None:
        if self.flipped:
            # When flipped, unfixing means setting underlying bit to 1
            if not self.bits[idx]:
                self.bits[idx] = True
                self.ones += 1
        else:
            # Normal case: set to 0
            if self.bits[idx]:
                self.bits[idx] = False
                self.ones -= 1


    def flip(self) -> None:
        self.flipped = not self.flipped


    def all(self) -> bool:
        if self.flipped:
            return self.ones == 0
        else:
            return self.ones == len(self.bits)


    def one(self) -> bool:
        if self.flipped:
            # When flipped, we need at least one 0 in underlying array (which becomes 1)
            return self.ones < len(self.bits)
        else:
            return self.ones > 0


    def count(self) -> int:
        if self.flipped:
            return len(self.bits) - self.ones
        else:
            return self.ones


    def toString(self) -> str:
        if self.flipped:
            return ''.join('0' if bit else '1' for bit in self.bits)
        else:
            return ''.join('1' if bit else '0' for bit in self.bits)

— § —

Reply via email

#dev #leetcode %coding

LeetCode #1047: Remove All Adjacent Duplicates In String

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 18 Jan 2026 13:37:46 -0300

♠ LeetCode #1047: Remove All Adjacent Duplicates In String:

Initial:

class Solution:
    def removeDuplicates(self, s: str) -> str:
        stack = []
        ans = []

        for c in s:
            if not stack:
                stack.append(c)
                ans.append(c)
            else:
                if stack[-1] != c:
                    stack.append(c)
                    ans.append(c)
                else:
                    stack.pop()
                    ans.pop()

        return ''.join(ans)

Optimized:

class Solution:
    def removeDuplicates(self, s: str) -> str:
        stack = []
        ans = []

        for c in s:
            if not stack or stack[-1] != c:
                stack.append(c)
                ans.append(c)
            else:
                stack.pop()
                ans.pop()

        return ''.join(ans)

— § —

Reply via email

#dev #leetcode %coding

LeetCode #380: Insert Delete GetRandom O(1)

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 18 Jan 2026 02:54:25 -0300

♠ LeetCode #380: Insert Delete GetRandom O(1):

Initial solution:

import random

class RandomizedSet:

    def __init__(self):
        self.l = []

        self.d = {}
        ## self.d = dict()

    def insert(self, val: int) -> bool:
        if val not in self.d:
            self.d[val] = len(self.l)
            self.l.append(val)
            return True

        return False


    def remove(self, val: int) -> bool:
        if val in self.d:
            del self.d[val]
            ## self.l: do not touch. Removal is O(n)
            return True

        return False


    def getRandom(self) -> int:
        return random.choice(list(self.d.keys()))


# Your RandomizedSet object will be instantiated and called as such:
# obj = RandomizedSet()
# param_1 = obj.insert(val)
# param_2 = obj.remove(val)
# param_3 = obj.getRandom()

However, getRandom() is O(n).

Better solution:

import random

class RandomizedSet:

    def __init__(self):
        self.l = []

        self.d = {}
        ## self.d = dict()

    def insert(self, val: int) -> bool:
        if val not in self.d:
            self.d[val] = len(self.l)
            self.l.append(val)
            return True

        return False


    def remove(self, val: int) -> bool:
        if val in self.d:
            i = self.d[val]
            del self.d[val]

            del self.l[i]
            return True

        return False


    def getRandom(self) -> int:
        return random.choice(self.l)


# Your RandomizedSet object will be instantiated and called as such:
# obj = RandomizedSet()
# param_1 = obj.insert(val)
# param_2 = obj.remove(val)
# param_3 = obj.getRandom()

But it’s still O(n) because of the list deletion.

Even better:

import random

class RandomizedSet:

    def __init__(self):
        self.l = []

        self.d = {}
        ## self.d = dict()

    def insert(self, val: int) -> bool:
        if val not in self.d:
            self.d[val] = len(self.l)
            self.l.append(val)
            return True

        return False


    def remove(self, val: int) -> bool:
        if val in self.d:
            i = self.d[val]
            del self.d[val]

            last_val = self.l[-1]

            # Swap with the last element
            self.l[i] = last_val
            self.l.pop()

            # Update the dictionary for the swapped element only if it's not the same as removed valA
            # i.e. not the last element
            if i < len(self.l):
            ## if i != len(self.l):
                self.d[last_val] = i

            return True

        return False


    def getRandom(self) -> int:
        return random.choice(self.l)


# Your RandomizedSet object will be instantiated and called as such:
# obj = RandomizedSet()
# param_1 = obj.insert(val)
# param_2 = obj.remove(val)
# param_3 = obj.getRandom()

— § —

Reply via email

#dev #leetcode %coding

LeetCode #288: Unique Word Abbreviation

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 17 Jan 2026 03:00:13 -0300

♠ LeetCode #288: Unique Word Abbreviation:

from collections import Counter

def abbrev(word):
    if len(word) < 3:
        return word

    return f'{word[0]}{len(word) - 2}{word[-1]}'

assert abbrev("dg") == "dg"
assert abbrev("dog") == "d1g"
assert abbrev("a") == "a"


class ValidWordAbbr:

    def __init__(self, words: List[str]):
        self.words = words

        ## self.mappings = Counter()  # abbrev -> word
        ## for word in set(words):
        ##     self.mappings[abbrev(word)] += 1

        self.mappings = Counter(abbrev(word) for word in set(words))

    def isUnique(self, word: str) -> bool:
        ab = abbrev(word)

        return self.mappings[ab] < 1 or (self.mappings[ab] == 1 and word in self.words)


# Your ValidWordAbbr object will be instantiated and called as such:
# obj = ValidWordAbbr(dictionary)
# param_1 = obj.isUnique(word)

— § —

Reply via email

#dev #leetcode %coding

LeetCode #23: Merge k Sorted Lists

serendipity@perrotta.dev (Thiago Perrotta) — Thu, 15 Jan 2026 23:20:52 -0300

♠ LeetCode #23: Merge k Sorted Lists:

Heap of ListNodes:

import heapq

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class HeapNode:
    def __init__(self, node: ListNode):
        self.node = node

    def __lt__(self, other: HeapNode):
        return self.node.val < other.node.val

class Solution:
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        prehead = ListNode(None)

        curr = prehead
        heap = []

        for lst in lists:
            if lst:
                heapq.heappush(heap, HeapNode(lst))

        while heap:
            # find next element: val
            next_heap_node = heapq.heappop(heap)
            next_node = next_heap_node.node

            curr.next = ListNode(next_node.val)
            curr = curr.next

            next_node = next_node.next
            if next_node:
                heapq.heappush(heap, HeapNode(next_node))


        head = prehead.next
        return head

— § —

Reply via email

#dev #leetcode %coding

LeetCode #362: Design Hit Counter

serendipity@perrotta.dev (Thiago Perrotta) — Thu, 15 Jan 2026 23:10:19 -0300

♠ LeetCode #362: Design Hit Counter:

With Counter:

import bisect
from collections import Counter

class HitCounter:

    def __init__(self):
        self.hits = Counter()
        ## timestamp -> hits

    def hit(self, timestamp: int) -> None:
        self.hits[timestamp] += 1

    def getHits(self, timestamp: int) -> int:
        ## 3 * 60 -> 2
        ## 4 * 60 -> 1
        ## getHits(8 * 60) -> 3

        ## (exclusive, inclusive)
        ## (self.hits[timestamp - 300], self.hits[timestamp])

        items = list(sorted(self.hits.items()))
        ## (timestamp, counter)

        ## inclusive
        ts_left = bisect.bisect_right(items, timestamp - 300, key=lambda item: item[0])
        ts_right = bisect.bisect_left(items, timestamp, key=lambda item: item[0])

        ans = 0

        for (timestamp, hits) in items[ts_left:]:
            ans += hits

        return ans


# Your HitCounter object will be instantiated and called as such:
# obj = HitCounter()
# obj.hit(timestamp)
# param_2 = obj.getHits(timestamp)

Alternatively, maintain our own sorted list of tuple:

import bisect

class HitCounter:

    def __init__(self):
        self.hits = []
        ## (timestamp, hits)

    def hit(self, timestamp: int) -> None:
        i = bisect.bisect_left(self.hits, timestamp, key=lambda item: item[0])
        if i < len(self.hits) and self.hits[i][0] == timestamp:
            self.hits[i] = (timestamp, self.hits[i][1] + 1)
        else:
            self.hits.insert(i, (timestamp, 1))

    def getHits(self, timestamp: int) -> int:
        ## 3 * 60 -> 2
        ## 4 * 60 -> 1
        ## getHits(8 * 60) -> 3

        ## (exclusive, inclusive)
        ## (self.hits[timestamp - 300], self.hits[timestamp])

        ## (timestamp, counter)

        ## inclusive
        ts_left = bisect.bisect_right(self.hits, timestamp - 300, key=lambda item: item[0])
        ts_right = bisect.bisect_left(self.hits, timestamp, key=lambda item: item[0])

        ans = 0

        for (timestamp, hits) in self.hits[ts_left:]:
            ans += hits

        return ans


# Your HitCounter object will be instantiated and called as such:
# obj = HitCounter()
# obj.hit(timestamp)
# param_2 = obj.getHits(timestamp)

— § —

Reply via email

#dev #leetcode %coding

LeetCode #692: Top K Frequent Words

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 11 Jan 2026 10:26:15 -0300

♠ LeetCode #692: Top K Frequent Words:

from collections import Counter, defaultdict

class Solution:
    def topKFrequent(self, words: List[str], k: int) -> List[str]:
        ## return [word for (word, freq) in Counter(words).most_common()][:k]

        by_freq = defaultdict(list)

        for (word, freq) in Counter(words).most_common():
            by_freq[freq].append(word)

        ans = []

        for (freq, words) in sorted(by_freq.items(), reverse=True):
            ans.extend(sorted(words))
            if len(ans) >= k:
                break

        return ans[:k]

— § —

Reply via email

#dev #leetcode %coding

LeetCode #170: Two Sum III - Data structure design

serendipity@perrotta.dev (Thiago Perrotta) — Sun, 11 Jan 2026 08:08:13 -0300

♠ LeetCode #170: Two Sum III — Data structure design:

from collections import Counter

class TwoSum:

    def __init__(self):
        self.s = Counter()


    def add(self, number: int) -> None:
        self.s[number] += 1


    def find(self, value: int) -> bool:
        for num in self.s:
            if (value - num) == num:
                if self.s[num] > 1:
                    return True
            elif value - num in self.s:
                return True

        return False


# Your TwoSum object will be instantiated and called as such:
# obj = TwoSum()
# obj.add(number)
# param_2 = obj.find(value)

— § —

Reply via email

#dev #leetcode %coding

LeetCode #347: Top K Frequent Elements

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 10 Jan 2026 02:09:59 -0300

♠ LeetCode #347: Top K Frequent Elements:

With Counter:

from collections import Counter

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        return [k for (k, v) in Counter(nums).most_common()[:k]]

With defaultdict(int):

from collections import defaultdict

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        c = defaultdict(int)
        for num in nums:
            c[num] += 1

        return [k for (k, v) in (sorted(c.items(), key=lambda item: item[1], reverse=True))[:k]]

With max heap:

from collections import Counter
import heapq

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        # c = defaultdict(int)
        # for num in nums:
        #     c[num] += 1

        # return [k for (k, v) in (sorted(c.items(), key=lambda item: item[1], reverse=True))[:k]]

        counter = Counter(nums)

        class Pair:
            def __init__(self, num, freq):
                self.num = num
                self.freq = freq

            def __lt__(self, other):
                if not isinstance(other, Pair):
                    raise ValueError
                # note: > instead of < because we want the TOP elements – max heap
                return self.freq > other.freq

        pq = []

        for (num, freq) in counter.items():
            pq.append(Pair(num, freq))

        heapq.heapify(pq)

        ans = []

        for _ in range(k):
            pair = heapq.heappop(pq)
            ans.append(pair.num)

        return ans

Simpler:

from collections import Counter
import heapq

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        # c = defaultdict(int)
        # for num in nums:
        #     c[num] += 1

        # return [k for (k, v) in (sorted(c.items(), key=lambda item: item[1], reverse=True))[:k]]

        counter = Counter(nums)

        class Pair:
            def __init__(self, num, freq):
                self.num = num
                self.freq = freq

            def __lt__(self, other):
                if not isinstance(other, Pair):
                    raise ValueError
                return self.freq < other.freq

        pq = []

        for (num, freq) in counter.items():
            pq.append(Pair(num, freq))

        heapq.heapify(pq)

        ans = []

        return [pair.num for pair in heapq.nlargest(k, pq)]

— § —

Reply via email

#dev #leetcode %coding

LeetCode #694: Number of Distinct Islands

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 10 Jan 2026 01:50:25 -0300

♠ LeetCode #694: Number of Distinct Islands:

Wrong answer: 696 / 760 testcases passed. Directions do not uniquely identify shapes. Counterexample:

1 1   1 1
1 0   0 1

These produce the same directions.

from collections import deque

class Solution:
    def numDistinctIslands(self, grid: List[List[int]]) -> int:
        m = len(grid)
        n = len(grid[0])

        ans: set[str] = set()

        def within_bounds(a, b):
            return 0 <= a < m and 0 <= b < n

        def bfs(x, y):
            queue = deque([(x, y)])
            h = [str((0, 0))] # hash

            while queue:
                (x, y) = queue.popleft()

                # if not within_bounds(x, y):
                #     continue

                ## if grid[x][y] == -1:
                ##    continue

                grid[x][y] = -1

                for dir in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
                    neighbor = (
                        x + dir[0],
                        y + dir[1],
                    )

                    if within_bounds(neighbor[0], neighbor[1]) and grid[neighbor[0]][neighbor[1]] == 1:
                        queue.append((neighbor[0], neighbor[1]))
                        h.append(str(dir))

            ans.add(''.join(h))


        for x, row in enumerate(grid):
            for y, cell in enumerate(row):
                if cell == 1:
                    bfs(x, y)

        return len(ans)

Instead, store relative positions. Memory limit exceeded: 714 / 760 testcases passed.

from collections import deque

class Solution:
    def numDistinctIslands(self, grid: List[List[int]]) -> int:
        m = len(grid)
        n = len(grid[0])

        ans: set[str] = set()

        def within_bounds(a, b):
            return 0 <= a < m and 0 <= b < n

        def bfs(initial_x, initial_y):
            queue = deque([(initial_x, initial_y)])
            h = [str((0, 0))] # hash

            while queue:
                (x, y) = queue.popleft()

                # if not within_bounds(x, y):
                #     continue

                ## if grid[x][y] == -1:
                ##    continue

                grid[x][y] = -1

                for dir in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
                    neighbor = (
                        x + dir[0],
                        y + dir[1],
                    )

                    if within_bounds(neighbor[0], neighbor[1]) and grid[neighbor[0]][neighbor[1]] == 1:
                        queue.append((neighbor[0], neighbor[1]))
                        h.append(str((neighbor[0] - initial_x, neighbor[1] - initial_y)))

            ans.add(''.join(h))


        for x, row in enumerate(grid):
            for y, cell in enumerate(row):
                if cell == 1:
                    bfs(x, y)

        return len(ans)

We need to mark cells as visited right away, before queueing them:

from collections import deque

class Solution:
    def numDistinctIslands(self, grid: List[List[int]]) -> int:
        m = len(grid)
        n = len(grid[0])

        ans: set[str] = set()

        def within_bounds(a, b):
            return 0 <= a < m and 0 <= b < n

        def bfs(initial_x, initial_y):
            queue = deque([(initial_x, initial_y)])
            h = [(0, 0)] # hash
            grid[initial_x][initial_y] = -1

            while queue:
                (x, y) = queue.popleft()

                # if not within_bounds(x, y):
                #     continue

                ## if grid[x][y] == -1:
                ##    continue

                ## grid[x][y] = -1

                for dir in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
                    neighbor = (
                        x + dir[0],
                        y + dir[1],
                    )

                    if within_bounds(neighbor[0], neighbor[1]) and grid[neighbor[0]][neighbor[1]] == 1:
                        queue.append((neighbor[0], neighbor[1]))
                        grid[neighbor[0]][neighbor[1]] = -1
                        h.append((neighbor[0] - initial_x, neighbor[1] - initial_y))

            ## ans.add(frozenset(h))
            ans.add(tuple(sorted(h))) # supposedly faster


        for x, row in enumerate(grid):
            for y, cell in enumerate(row):
                if cell == 1:
                    bfs(x, y)

        return len(ans)

— § —

Reply via email

#dev #leetcode %coding

LeetCode #1254: Number of Closed Islands

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 10 Jan 2026 01:23:06 -0300

♠ LeetCode #1254: Number of Closed Islands:

Recursive:

class Solution:
    def closedIsland(self, grid: List[List[int]]) -> int:
        m = len(grid)
        n = len(grid[0])

        def within_bounds(a, b):
            return 0 <= a < m and 0 <= b < n

        def dfs(x, y, poisoned=False):
            if not within_bounds(x, y):
                return True

            if grid[x][y] in [-1, 1]:
                return False

            grid[x][y] = -1

            for dir in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
                neighbor = (
                    x + dir[0],
                    y + dir[1],
                )
                if dfs(neighbor[0], neighbor[1]):
                    poisoned = True

            return poisoned

        ans = 0

        for x, row in enumerate(grid):
            for y, cell in enumerate(row):
                if grid[x][y] == 0:
                    if not dfs(x, y):
                        ans += 1

        return ans

Iterative:

class Solution:
    def closedIsland(self, grid: List[List[int]]) -> int:
        m = len(grid)
        n = len(grid[0])

        def within_bounds(a, b):
            return 0 <= a < m and 0 <= b < n

        def dfs(x, y):
            valid = True

            stack = [(x, y)]

            while stack:
                (x, y) = stack.pop()

                if not within_bounds(x, y):
                    valid = False
                    continue

                if grid[x][y] in [-1, 1]:
                    continue

                ## assert grid[x][y] == 0
                grid[x][y] = -1

                for dir in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
                    neighbor = (
                        x + dir[0],
                        y + dir[1],
                    )
                    ## if not within_bounds(neighbor[0], neighbor[1]):
                    ##     return False
                    stack.append((neighbor[0], neighbor[1]))

            return valid

        ans = 0

        for x, row in enumerate(grid):
            for y, cell in enumerate(row):
                if grid[x][y] == 0:
                    ans += dfs(x, y)

        return ans

— § —

Reply via email

#dev #leetcode %coding

LeetCode #200: Number of Islands

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 10 Jan 2026 00:24:09 -0300

♠ LeetCode #200: Number of Islands:

class Solution:
    def numIslands(self, grid: List[List[str]]) -> int:
        m = len(grid)
        n = len(grid[0])

        def within_bounds(a, b):
            return 0 <= a < m and 0 <= b < n

        def dfs(x, y):
            if not within_bounds(x, y):
                return

            if grid[x][y] in ["-1", "0"]:
                return

            grid[x][y] = "-1"

            for dir in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
                neighbor = (
                    x + dir[0],
                    y + dir[1],
                )
                dfs(neighbor[0], neighbor[1])

        ans = 0

        for x, row in enumerate(grid):
            for y, cell in enumerate(row):
                if grid[x][y] == "1":
                    dfs(x, y)
                    ans += 1

        return ans

Pass tuples around:

class Solution:
    def numIslands(self, grid: List[List[str]]) -> int:
        m = len(grid)
        n = len(grid[0])

        def within_bounds(coords):
            (a, b) = coords
            return 0 <= a < m and 0 <= b < n

        def dfs(coords):
            (x, y) = coords
            if not within_bounds(coords):
                return

            if grid[x][y] in ["-1", "0"]:
                return

            grid[x][y] = "-1"

            for dir in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
                neighbor = (
                    x + dir[0],
                    y + dir[1],
                )
                dfs(neighbor)

        ans = 0

        for x, row in enumerate(grid):
            for y, cell in enumerate(row):
                if grid[x][y] == "1":
                    dfs((x, y))
                    ans += 1

        return ans

— § —

Reply via email

#dev #leetcode %coding

LeetCode #1244: Design A Leaderboard

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 10 Jan 2026 00:12:45 -0300

♠ LeetCode #1244: Design A Leaderboard:

With Counter:

from collections import Counter

class Leaderboard:

    def __init__(self):
        self.counter = Counter()

    def addScore(self, playerId: int, score: int) -> None:
        self.counter[playerId] += score

    def top(self, K: int) -> int:
        return sum(v for (k, v) in self.counter.most_common()[:K])

    def reset(self, playerId: int) -> None:
        del self.counter[playerId]
        ## self.counter[playerId] = 0


# Your Leaderboard object will be instantiated and called as such:
# obj = Leaderboard()
# obj.addScore(playerId,score)
# param_2 = obj.top(K)
# obj.reset(playerId)

With priority queue (heap):

from collections import defaultdict

class Leaderboard:

    def __init__(self):
        self.d = defaultdict(int)

    def addScore(self, playerId: int, score: int) -> None:
        self.d[playerId] += score

    def top(self, K: int) -> int:
        pq = []

        for score in self.d.values():
            heapq.heappush(pq, score)
            if len(pq) > K:
                heapq.heappop(pq)

        return sum(pq)

    def reset(self, playerId: int) -> None:
        del self.d[playerId]


# Your Leaderboard object will be instantiated and called as such:
# obj = Leaderboard()
# obj.addScore(playerId,score)
# param_2 = obj.top(K)
# obj.reset(playerId)

— § —

Reply via email

#dev #leetcode %coding

LeetCode #2490: Circular Sentence

serendipity@perrotta.dev (Thiago Perrotta) — Sat, 10 Jan 2026 00:05:44 -0300

♠ LeetCode #2490: Circular Sentence:

class Solution:
    def isCircularSentence(self, sentence: str) -> bool:
        # case sensitive

        words = sentence.strip().split(' ')

        for word1, word2 in zip(
            words,
            words[1:] + [words[0]]
        ):
            if word1[-1] != word2[0]:
                return False

        return True

— § —

Reply via email

#dev #leetcode %coding

LeetCode #286: Walls and Gates

serendipity@perrotta.dev (Thiago Perrotta) — Fri, 09 Jan 2026 23:57:56 -0300

♠ LeetCode #286: Walls and Gates:

Level order traversal:

from collections import deque

class Solution:
    def wallsAndGates(self, rooms: List[List[int]]) -> None:
        """
        Do not return anything, modify rooms in-place instead.
        """
        m = len(rooms)
        n = len(rooms[0])

        INF = 2 ** 31 - 1

        def bfs(x, y):
            queue = deque([(x, y)])

            dirs = [
                (0, 1),
                (1, 0),
                (0, -1),
                (-1, 0),
            ]

            def within_bounds(a, b):
                return 0 <= a < m and 0 <= b < n

            level = 0
            while queue:
                level += 1
                num_elements = len(queue)

                for _ in range(num_elements):
                    (x, y) = queue.popleft()

                    for dir in dirs:
                        neighbor = (
                            x + dir[0],
                            y + dir[1],
                        )

                        if within_bounds(neighbor[0], neighbor[1]):
                            value = rooms[neighbor[0]][neighbor[1]]

                            if value == 0 or value == -1:
                                continue

                            if level < value:
                                rooms[neighbor[0]][neighbor[1]] = level
                                queue.append((neighbor[0], neighbor[1]))



        for x, row in enumerate(rooms):
            for y, cell in enumerate(row):
                if cell == 0:
                    bfs(x, y)

— § —

Reply via email

#dev #leetcode %coding

LeetCode #1472: Design Browser History

serendipity@perrotta.dev (Thiago Perrotta) — Fri, 09 Jan 2026 22:07:44 -0300

♠ LeetCode #1472: Design Browser History:

class BrowserHistory:

    def __init__(self, homepage: str):
        self.history = [homepage]
        self.pos = 0

        # example.com <-
        #   example.org
        #     foo.example.com <=


    def visit(self, url: str) -> None:
        if self.pos == (len(self.history) - 1):
            self.history.append(url)
            self.pos += 1
        else:
            self.pos += 1
            self.history[self.pos] = url
            self.history = self.history[:self.pos + 1]


    def back(self, steps: int) -> str:
        steps = min(steps, self.pos)
        self.pos -= steps
        return self.history[self.pos]


    def forward(self, steps: int) -> str:
        steps = min(steps, len(self.history) - 1 - self.pos)
        self.pos += steps
        return self.history[self.pos]


# Your BrowserHistory object will be instantiated and called as such:
# obj = BrowserHistory(homepage)
# obj.visit(url)
# param_2 = obj.back(steps)
# param_3 = obj.forward(steps)

— § —

Reply via email

#dev #leetcode %coding

LeetCode #1188: Design Bounded Blocking Queue

serendipity@perrotta.dev (Thiago Perrotta) — Fri, 09 Jan 2026 21:58:29 -0300

♠ LeetCode #1188: Design Bounded Blocking Queue:

from collections import deque
from threading import Lock, Condition

class BoundedBlockingQueue(object):

    def __init__(self, capacity: int):
        self.q = deque()
        self.capacity = capacity
        self.lock = Lock()
        self.not_full = Condition(self.lock)
        self.not_empty = Condition(self.lock)


    def enqueue(self, element: int) -> None:
        self.not_full.acquire()

        while self.size() == self.capacity:
            self.not_full.wait()

        self.q.append(element)
        self.not_empty.notify()
        self.not_full.release()

    def dequeue(self) -> int:
        self.not_empty.acquire()

        while self.size() == 0:
            self.not_empty.wait()

        element = self.q.popleft()
        self.not_full.notify()
        self.not_empty.release()

        return element


    def size(self) -> int:
        return len(self.q)

— § —

Reply via email

#dev #leetcode %coding

LeetCode #1756: Design Most Recently Used Queue

serendipity@perrotta.dev (Thiago Perrotta) — Fri, 09 Jan 2026 21:53:51 -0300

♠ LeetCode #1756: Design Most Recently Used Queue:

class MRUQueue:

    def __init__(self, n: int):
        self.arr = list(range(1, n + 1))

    def fetch(self, k: int) -> int:
        # 0-indexed
        k -= 1

        assert 0 <= k < len(self.arr)

        el = self.arr[k]

        del self.arr[k]
        self.arr.append(el)

        return el

# Your MRUQueue object will be instantiated and called as such:
# obj = MRUQueue(n)
# param_1 = obj.fetch(k)

— § —

Reply via email

#dev #leetcode %coding

LeetCode #622: Design Circular Queue

serendipity@perrotta.dev (Thiago Perrotta) — Fri, 09 Jan 2026 04:35:00 -0300

♠ LeetCode #622: Design Circular Queue:

class MyCircularQueue:

    def __init__(self, k: int):
        self.q = [None] * k
        self.k = k

        self.start = 0
        self.end = 0
        self.count = 0

    ## -- queue

    ## .   .  .
    ## se

    ## 1   .  .
    ## s      e

    ## 1   .  2
    ## s   e

    ## --  dequeue

    ## 1 . 2
    ## s e

    ## . . 2
    ##   e s

    def enQueue(self, value: int) -> bool:
        if self.isFull():
            return False

        self.q[self.end] = value
        self.end = (self.end - 1) % self.k
        self.count += 1
        return True


    def deQueue(self) -> bool:
        if self.isEmpty():
            return False

        self.start = (self.start - 1) % self.k
        self.count -= 1
        return True


    def Front(self) -> int:
        if self.isEmpty():
            return -1

        return self.q[self.start]


    def Rear(self) -> int:
        if self.isEmpty():
            return -1

        return self.q[(self.end + 1) % self.k]


    def isEmpty(self) -> bool:
        return self.count == 0


    def isFull(self) -> bool:
        return self.count == self.k


# Your MyCircularQueue object will be instantiated and called as such:
# obj = MyCircularQueue(k)
# param_1 = obj.enQueue(value)
# param_2 = obj.deQueue()
# param_3 = obj.Front()
# param_4 = obj.Rear()
# param_5 = obj.isEmpty()
# param_6 = obj.isFull()

— § —

Reply via email

#dev #leetcode %coding

LeetCode #641: Design Circular Deque

serendipity@perrotta.dev (Thiago Perrotta) — Fri, 09 Jan 2026 04:20:38 -0300

♠ LeetCode #641: Design Circular Deque:

class MyCircularDeque:

    def __init__(self, k: int):
        self.q = [None] * k
        self.k = k

        self.start = 0
        self.end = 0
        self.count = 0

        ##  .  . . .
        ## se

        ## . 1 . .
        ## s   e

        ## . 2 3 .
        ## s     e

    def insertFront(self, value: int) -> bool:
        if self.isEmpty():
            self.q[self.start] = value
            self.start = (self.start - 1) % self.k
            self.end = (self.end + 1) % self.k
            self.count += 1
            return True

        if self.isFull():
            return False

        self.q[self.start] = value
        self.start = (self.start - 1) % self.k
        self.count += 1
        return True


    def insertLast(self, value: int) -> bool:
        if self.isEmpty():
            self.q[self.end] = value
            self.start = (self.start - 1) % self.k
            self.end = (self.end + 1) % self.k
            self.count += 1
            return True

        if self.isFull():
            return False

        self.q[self.end] = value
        self.end = (self.end + 1) % self.k
        self.count += 1
        return True


    def deleteFront(self) -> bool:
        if self.isEmpty():
            return False

        self.start = (self.start + 1) % self.k
        self.count -= 1
        ## self.q[self.start] = None

        if self.count == 0:
            self.end = self.start

        return True


    def deleteLast(self) -> bool:
        if self.isEmpty():
            return False

        self.end = (self.end - 1) % self.k
        self.count -= 1
        ## self.q[self.end] = None

        if self.count == 0:
            self.start = self.end

        return True

    def getFront(self) -> int:
        if self.isEmpty():
            return -1
        return self.q[(self.start + 1) % self.k]


    def getRear(self) -> int:
        if self.isEmpty():
            return -1
        return self.q[self.end - 1 % self.k]


    def isEmpty(self) -> bool:
        return self.count == 0


    def isFull(self) -> bool:
        return self.count == self.k



# Your MyCircularDeque object will be instantiated and called as such:
# obj = MyCircularDeque(k)
# param_1 = obj.insertFront(value)
# param_2 = obj.insertLast(value)
# param_3 = obj.deleteFront()
# param_4 = obj.deleteLast()
# param_5 = obj.getFront()
# param_6 = obj.getRear()
# param_7 = obj.isEmpty()
# param_8 = obj.isFull()

— § —

Reply via email

#dev #leetcode %coding

LeetCode #211: Design Add and Search Words Data Structure

serendipity@perrotta.dev (Thiago Perrotta) — Thu, 08 Jan 2026 03:43:06 -0300

♠ LeetCode #211: Design Add and Search Words Data Structure:

from collections import defaultdict

class Node:
    def __init__(self):
        self.children = {}
        self.end = False

class WordDictionary:

    def __init__(self):
        self.root = Node()

    def addWord(self, word: str) -> None:
        node = self.root
        ## "hello"
        for c in word:
            if c not in node.children:
                node.children[c] = Node()
            node = node.children[c]
        node.end = True

    def search(self, word: str) -> bool:
        def node_search(node, word: str) -> bool:
            for i, c in enumerate(word):
                if c == '.':
                    for child in node.children.values():
                        if node_search(child, word[i + 1:]):
                            return True
                    return False

                if c not in node.children:
                    return False
                node = node.children[c]

            return node.end

        return node_search(self.root, word)


# Your WordDictionary object will be instantiated and called as such:
# obj = WordDictionary()
# obj.addWord(word)
# param_2 = obj.search(word)

— § —

Reply via email

#dev #leetcode %coding

LeetCode #2965: Find Missing and Repeated Values

serendipity@perrotta.dev (Thiago Perrotta) — Thu, 08 Jan 2026 00:24:02 -0300

♠ LeetCode #2965: Find Missing and Repeated Values:

Two sets:

class Solution:
    def findMissingAndRepeatedValues(self, grid: List[List[int]]) -> List[int]:
        seen = set()
        numbers = set(range(1, len(grid) ** 2 + 1))

        a = b = None

        for row in grid:
            for num in row:
                if num in seen:
                    a = num
                    continue
                seen.add(num)
                numbers.discard(num)

        assert len(numbers) == 1
        b = numbers.pop()

        return [a, b]

— § —

Reply via email

#dev #leetcode %coding

LeetCode #1033: Moving Stones Until Consecutive

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 07 Jan 2026 23:53:36 -0300

♠ LeetCode #1033: Moving Stones Until Consecutive:

Convoluted:

class Solution:
    def numMovesStones(self, a: int, b: int, c: int) -> List[int]:
        (a, b, c) = sorted([a, b, c])

        ans_max = ((c - b) - 1) + ((b - a) - 1)

        ans_min = 0
        while not ((b - a) == 1 and (c - b) == 1): ## 3 4 5
            ## 3 10 50

            if (b - a) == 1 or (c - b) == 1:
                ans_min += 1
                break

            # find smallest interval with a gap
            ## (3, 10)
            if (c - b == 1) or (b - a) <= (c - b): # left
                e1 = a
                e2 = b
                ms  = c
            else: ## right
                e1 = b
                e2 = c
                ms = a

            # move the other stone (ms) to the middle of (e1, e2)
            ms = (e1 + e2) // 2

            # update a, b, c; then keep going
            a, b, c = e1, ms, e2
            assert a < b
            assert b < c

            ans_min += 1
            if ans_min == 2:
                break

        return [ans_min, ans_max]

min_ans will be up to 2. That will significantly simplify everything!

class Solution:
    def numMovesStones(self, a: int, b: int, c: int) -> List[int]:
        (a, b, c) = sorted([a, b, c])

        ans_max = ((c - b) - 1) + ((b - a) - 1)

        ans_min = 0
        if ((b - a) == 1 and (c - b) == 1): ## 3 4 5
            ans_min = 0
        elif (b - a) in [1, 2] or (c - b) in [1, 2]: ## 3 4 6
            ans_min = 1
        else:
            ans_min = 2

        return [ans_min, ans_max]

— § —

Reply via email

#dev #leetcode %coding

LeetCode #771: Jewels and Stones

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 07 Jan 2026 01:18:30 -0300

♠ LeetCode #771: Jewels and Stones:

Cozy:

class Solution:
    def numJewelsInStones(self, jewels: str, stones: str) -> int:
        s = set(jewels)

        ans = 0

        for stone in stones:
            if stone in s:
                ans += 1

        return ans

One-liner:

class Solution:
    def numJewelsInStones(self, jewels: str, stones: str) -> int:
        s = set(jewels)
        return sum(stone in s for stone in stones)

— § —

Reply via email

#dev #leetcode %coding

LeetCode #652: Find Duplicate Subtrees

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 07 Jan 2026 00:49:44 -0300

♠ LeetCode #652: Find Duplicate Subtrees:

Original, 119 / 175 testcases passed:

from collections import defaultdict

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def findDuplicateSubtrees(self, root: Optional[TreeNode]) -> List[Optional[TreeNode]]:
        mappings = defaultdict(list)

        def dfs(node):
            if not node:
                return

            mappings[node.val].append(node)

            dfs(node.left)
            dfs(node.right)

        dfs(root)

        ans = set()

        def duplicate_subtree(node1, node2):
            if not node1 and not node2:
                return True

            if not node1 and node2:
                return False

            if node1 and not node2:
                return False

            return node1.val == node2.val and duplicate_subtree(node1.left, node2.left) and duplicate_subtree(node1.right, node2.right)

        for nodes in mappings.values():
            for i, node1 in enumerate(nodes[:-1]):
                for node2 in nodes[i + 1:]:
                    if duplicate_subtree(node1, node2):
                        ans.add(node1)

        return list(ans)

With proper serialization:

from collections import Counter

class Solution:
    def findDuplicateSubtrees(self, root: Optional[TreeNode]) -> List[Optional[TreeNode]]:
        # serial -> count
        seen = Counter()

        # serial -> node
        node_from_serial = {}

        def dfs(node) -> str:
            """Return the serialized representation of the node."""
            if not node:
                return "null"

            s = f"{node.val},{dfs(node.left)},{dfs(node.right)}"

            node_from_serial[s] = node

            seen[s] += 1

            return s

        dfs(root)

        ans = []

        for (serial, count) in seen.items():
            if count >= 2:
                ans.append(node_from_serial[serial])

        return ans

Optimized:

from collections import Counter

class Solution:
    def findDuplicateSubtrees(self, root: Optional[TreeNode]) -> List[Optional[TreeNode]]:
        # serial -> count
        seen = Counter()

        ans = []

        def dfs(node) -> str:
            """Return the serialized representation of the node."""
            if not node:
                return "null"

            s = f"{node.val},{dfs(node.left)},{dfs(node.right)}"

            seen[s] += 1

            if seen[s] == 2:
                ans.append(node)

            return s

        dfs(root)

        return ans

— § —

Reply via email

#dev #leetcode %coding

LeetCode #36: Valid Sudoku

serendipity@perrotta.dev (Thiago Perrotta) — Wed, 07 Jan 2026 00:10:01 -0300

♠ LeetCode #36: Valid Sudoku:

class Solution:
    def isValidSudoku(self, board: List[List[str]]) -> bool:
        m = len(board)
        n = len(board[0])

        def is_valid(a):
            a = [el for el in a if el != "."]
            ## [1, 2, 2] -> 3
            ## {1, 2}    -> 2
            ##
            ## [1, 2]
            ## {1, 2}
            return len(a) - len(set(a)) == 0

        for row in board:
            if not is_valid(row):
                return False

        for col in zip(*board):
            if not is_valid(col):
                return False

        subgrids_i = [
            [0, 0],
            [0, 3],
            [0, 6],
            [3, 0],
            [3, 3],
            [3, 6],
            [6, 0],
            [6, 3],
            [6, 6],
        ]

        for subgrid_i in subgrids_i:
            subgrid = []

            for x in range(3):
                for y in range(3):
                    ix = subgrid_i[0] + x
                    iy = subgrid_i[1] + y
                    subgrid.append(board[ix][iy])

            if not is_valid(subgrid):
                return False

        return True

— § —

Reply via email

#dev #leetcode %coding

LeetCode #49: Group Anagrams

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 06 Jan 2026 23:55:13 -0300

♠ LeetCode #49: Group Anagrams:

from collections import defaultdict
from collections.abc import Hashable

def is_hashable(obj) -> bool:
    return isinstance(obj, Hashable)

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        seen = defaultdict(list)

        for s in strs:
            cs = ''.join(sorted(s)) # canonical
            seen[cs].append(s)

        return list(seen.values())

— § —

Reply via email

#dev #leetcode %coding

LeetCode #359: Logger Rate Limiter

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 06 Jan 2026 23:45:02 -0300

♠ LeetCode #359: Logger Rate Limiter:

class Logger:

    def __init__(self):
        self.log = {}


    def shouldPrintMessage(self, timestamp: int, message: str) -> bool:
        if message not in self.log:
            self.log[message] = timestamp
            return True

        if timestamp - self.log[message] < 10:
            return False

        self.log[message] = timestamp
        return True



# Your Logger object will be instantiated and called as such:
# obj = Logger()
# param_1 = obj.shouldPrintMessage(timestamp,message)

— § —

Reply via email

#dev #leetcode %coding

LeetCode #2215: Find the Difference of Two Arrays

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 06 Jan 2026 23:30:46 -0300

♠ LeetCode #2215: Find the Difference of Two Arrays:

class Solution:
    def findDifference(self, nums1: List[int], nums2: List[int]) -> List[List[int]]:
        s1 = set(nums1)
        s2 = set(nums2)

        return [list(s1 - s2), list(s2 - s1)]

— § —

Reply via email

#dev #leetcode %coding

LeetCode #219: Contains Duplicate II

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 06 Jan 2026 21:10:50 -0300

♠ LeetCode #219: Contains Duplicate II:

from collections import defaultdict

class Solution:
    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
        d = defaultdict(list)
        for i, num in enumerate(nums):
            d[num].append(i)

        for values in d.values():
            values.sort()
            # 1 3 4
            for a, b in zip(values[:-1], values[1:]):
                if abs(a - b) <= k:
                    return True

        return False

— § —

Reply via email

#dev #leetcode %coding

LeetCode #350: Intersection of Two Arrays II

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 06 Jan 2026 21:03:03 -0300

♠ LeetCode #350: Intersection of Two Arrays II:

from collections import Counter

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        c1 = Counter(nums1)
        c2 = Counter(nums2)

        common = set(c1.keys()) & set(c2.keys())

        ans = []

        for n in common:
            ans.extend([n] * min(c1[n], c2[n]))

        return ans

— § —

Reply via email

#dev #leetcode %coding

LeetCode #387: First Unique Character in a String

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 06 Jan 2026 20:59:58 -0300

♠ LeetCode #387: First Unique Character in a String:

from collections import Counter

class Solution:
    def firstUniqChar(self, s: str) -> int:
        counter = Counter(s)
        for i, c in enumerate(s):
            if counter[c] == 1:
                return i

        return -1

— § —

Reply via email

#dev #leetcode %coding

LeetCode #136: Single Number

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 06 Jan 2026 20:55:38 -0300

♠ LeetCode #136: Single Number:

XOR everything:

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        ans = 0
        for num in nums:
            ans ^= num
        return ans

Or with reduce:

from functools import reduce

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        return reduce(lambda a, b: a ^ b, nums)

— § —

Reply via email

#dev #leetcode %coding

LeetCode #2154: Keep Multiplying Found Values by Two

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 06 Jan 2026 20:43:08 -0300

♠ LeetCode #2154: Keep Multiplying Found Values by Two:

class Solution:
    def findFinalValue(self, nums: List[int], original: int) -> int:
        s = set(nums)

        while True:
            if original in s:
                original <<= 1
            else:
                break

        return original

— § —

Reply via email

#dev #leetcode %coding

LeetCode #3667: Sort Array By Absolute Value

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 06 Jan 2026 20:42:00 -0300

♠ LeetCode #3667: Sort Array By Absolute Value:

class Solution:
    def sortByAbsoluteValue(self, nums: List[int]) -> List[int]:
        return list(sorted(nums, key=lambda x: abs(x)))

— § —

Reply via email

#dev #leetcode %coding

LeetCode #1018: Binary Prefix Divisible By 5

serendipity@perrotta.dev (Thiago Perrotta) — Tue, 06 Jan 2026 20:40:49 -0300

♠ LeetCode #1018: Binary Prefix Divisible By 5:

class Solution:
    def prefixesDivBy5(self, nums: List[int]) -> List[bool]:
        ans = []

        n = 0

        for i, num in enumerate(nums):
            n = n * 2 + num
            ans.append(n % 5 == 0)

        return ans

— § —

Reply via email

#dev #leetcode %coding