DeepSeek AI Chat

No. Start at 100:

• After +20%: (100 \times 1.20 = 120)
• After −20%: (120 \times 0.80 = 96)

So it ends at 96, not 100.

General rule: increasing by (p%) then decreasing by (p%) multiplies by:

[ (1+p)(1-p)=1-p^2 ]

So there is always a net loss of (p^2%). Here, (20^2% = 4%), so (100 - 4 = 96).

start = 100
after_rise = start * 1.20
end = after_rise * 0.80
print(end)  # 96.0

The order doesn’t matter either way: a fall then a rise also gives 96. Because percentages are applied to different bases, you don’t return to the starting value.

def first_non_repeating(s: str) -> str | None:
    """Return first character with count 1, or None if none."""
    from collections import Counter
    counts = Counter(s)  # O(n)
    for ch in s:         # O(n)
        if counts[ch] == 1:
            return ch
    return None

# Tests
print(first_non_repeating(""))          # None
print(first_non_repeating("aéa"))       # é
print(first_non_repeating("abca"))      # b
print(first_non_repeating("unicode😀🔁😀"))  # 🔁

Time complexity: O(n) – two passes over string, O(n) space for counting. Works with any Unicode characters.

Caching stores hot data in fast memory, so reads skip slow DB queries. But it trades freshness: the cached value can be stale until evicted.

Stock-count example: Cache says stock=10, but a sale just decremented the DB to 8. Until the cache updates or expires, customers see 10 and may oversell.

Invalidation strategy: Use write-through invalidation – update the DB, then delete/refresh the cache key atomically, with a short TTL as a safety net.

def sell(item_id, qty):
    with db.transaction():
        new_stock = db.decrement(item_id, qty)
        cache.set(f"stock:{item_id}", new_stock, ttl=60)  # refresh

This keeps cached counts nearly fresh, bounds staleness to the TTL if a cache update fails, and still reduces DB read load.