total = 0
for s in spells:
    total += s
print(total)

Time: O(n) Space: O(1)

ok = True
for b in bravery:
    if b < 7:
        ok = False
        break
print(ok)

seen = {}
count = 0
for b in balloons:
    if b not in seen:
        seen[b] = True
        count += 1
print(count)

seen = set()
for s in spells:
    if s in seen:
        print(s)
        break
    seen.add(s)

window = power[0] + power[1] + power[2]

for i in range(3, len(power)):
    if window > 150:
        print(True)
        break
    window += power[i] - power[i-3]
else:
    print(window > 150)

n = 5
a, b = 1, 1
for _ in range(n):
    a, b = b, a + b
print(a)

Time: O(n) Space: O(1)

count = 0
for i in range(1, len(land)-1):
    if land[i] > land[i-1] and land[i] > land[i+1]:
        count += 1
print(count)

total = 0
for b in balls:
    total += b

left = 0
possible = False
for b in balls:
    left += b
    if left * 2 == total:
        possible = True
        break

print(possible)

n = 29
prime = n > 1

i = 2
while i * i <= n:
    if n % i == 0:
        prime = False
        break
    i += 1

print(prime)

best = 0
for i in range(1, len(nums)):
    best = max(best, nums[i] - nums[i-1])
print(best)

pos = 0
for p in path:
    pos += -1 if p == "L" else 1
print(pos == 0)

reach = 0
for i, s in enumerate(stones):
    if i > reach:
        print(False)
        break
    reach = max(reach, i + s)
else:
    print(True)

total = sum(force)
if total % 2 != 0:
    print(False)
else:
    target = total // 2
    dp = {0}
    for f in force:
        dp |= {x + f for x in dp}
    print(target in dp)

classes.sort()
time = 0

for c in classes:
    time += c
    if time > 90:
        print(False)
        break
else:
    print(True)

💡 Idea

If numbers from 1..n were complete, their sum would be:

$$ \frac{n(n+1)}{2} $$

Since one number is missing, subtract the actual sum from the expected sum.

🧠 Why it works

The difference between the two sums is exactly the missing number.

nums = [1, 2, 4, 5]

n = len(nums) + 1
expected = n * (n + 1) // 2
actual = sum(nums)

print(expected - actual)

⏱ Time: O(n) 📦 Space: O(1)

💡 Idea (Plain English)

XOR (^) checks whether two values are the same or different.

• Same → 0
• Different → 1

You only need to remember these two rules:

a ^ a = 0   # same values cancel out
a ^ 0 = a   # XOR with 0 keeps the value

🧠 Why it works (Step by Step)

We XOR together:

• all numbers from 1..n
• all numbers in the array

What happens?

• Numbers that exist in the array appear twice → they cancel out (a ^ a = 0)
• The missing number appears only once → it does NOT cancel out and remains

That remaining value is the missing number.

🔍 Simple Example

1 ^ 1 = 0
2 ^ 2 = 0
4 ^ 4 = 0
5 ^ 5 = 0

The number 3 has no pair, so it survives.

🧪 Code

nums = [1, 2, 4, 5]

n = len(nums) + 1
xor_all = 0

for i in range(1, n + 1):
    xor_all ^= i

for x in nums:
    xor_all ^= x

print(xor_all)

⏱ Time: O(n) 📦 Space: O(1) 😎 Bonus: No math formula required

💡 Idea

Store all numbers in a set, then scan from 1..n to find what’s missing.

🧠 Why it works

Set lookup is O(1), making the solution simple and readable.

nums = [1, 2, 4, 5]

num_set = set(nums)
n = len(nums) + 1

for i in range(1, n + 1):
    if i not in num_set:
        print(i)
        break

⏱ Time: O(n) 📦 Space: O(n) 👍 Best for beginners / clarity

💡 Idea

Assume the largest number in the array is n, then apply the sum formula.

nums = [1, 2, 4, 5]

n = max(nums)
expected = n * (n + 1) // 2
actual = sum(nums)

print(expected - actual)

❌ Why this can fail

This approach assumes the missing number is NOT n.

Example where it breaks:

nums = [1, 2, 3, 4]  # missing 5

• max(nums) = 4
• Expected sum = 1 + 2 + 3 + 4 = 10
• Actual sum = 10
• Result = 0 ❌ (wrong)

✅ When it works

• Numbers start from 1
• Missing number is not the last one
• Array is guaranteed to contain n

📌 Verdict

This solution is clever but dangerous Use only if the problem explicitly guarantees that n exists in the array.

seen = {}
for i, n in enumerate(nums):
    if target - n in seen:
        print(seen[target - n], i)
        break
    seen[n] = i

l, r = 0, len(s)-1
ok = True

while l < r:
    if s[l] != s[r]:
        ok = False
        break
    l += 1
    r -= 1

print(ok)

k = 2
for _ in range(k):
    last = times[-1]
    i = len(times) - 1
    while i > 0:
        times[i] = times[i-1]
        i -= 1
    times[0] = last

print(times)

same = True
for i in range(1, len(nums)):
    if nums[i] != nums[0]:
        same = False
        break
print(same)

i = j = 0
res = []

while i < len(a) and j < len(b):
    if a[i] < b[j]:
        res.append(a[i]); i += 1
    else:
        res.append(b[j]); j += 1

res += a[i:] + b[j:]
print(res)