CRDTs take a different position: design the data structure so that conflicts can never happen. Not “detect and resolve” – just structurally eliminate the problem.

The Core Idea

A CRDT is a data structure with a merge function that is commutative, associative, and idempotent. Those three properties together mean you can apply updates in any order, any number of times, from any subset of nodes, and always converge to the same state.

• Commutative: merge(A, B) = merge(B, A) – order doesn’t matter
• Associative: merge(A, merge(B, C)) = merge(merge(A, B), C) – grouping doesn’t matter
• Idempotent: merge(A, A) = A – applying the same update twice is harmless

If your data structure satisfies these, you can replicate it across nodes with no coordination. Each node applies updates locally and gossips state to peers. Eventually everyone has the same state.

The Simplest CRDT: G-Counter

A grow-only counter. Each node maintains a vector of counts, one slot per node. To increment, a node adds to its own slot. To read the total, sum all slots. To merge two replicas, take the element-wise max.

Node A: [3, 1, 0]   Node B: [2, 2, 0]
Merge:  [3, 2, 0]   -- take max per slot
Total:  5

Node A can never decrement B’s slot and Node B can never decrement A’s slot. Merges always move counters up, never down. Convergence is guaranteed.

Adding Decrements: PN-Counter

A grow-only counter can’t go down. If you need decrements, use two G-Counters – one for increments (P), one for decrements (N). The value is P - N.

Each node increments its P slot to add and its N slot to subtract. Merges take the element-wise max of both vectors. The final value is the sum of all P slots minus the sum of all N slots.

Sets: The Interesting Case

Sets are where CRDTs get non-obvious. The naive approach breaks immediately: if Node A removes an element at the same time Node B adds it, what’s the right answer?

G-Set (grow-only set) sidesteps this: elements can only be added, never removed. Merge is union. Works perfectly but is obviously limited.

2P-Set (two-phase set) adds a remove set R alongside the add set A. An element is in the set if it’s in A but not R. Once removed, it can never be re-added. Merge is union on both sets.

LWW-Element-Set (last-write-wins) attaches a timestamp to each add and remove. On conflict, the higher timestamp wins. Simple, but you’re back to trusting clocks.

OR-Set (observed-remove set) is the one that gets this right. Each add operation generates a unique tag. Remove only removes the specific tags that were observed at remove time. If Node A adds element X (tag: t1) and Node B concurrently adds X again (tag: t2), then Node A removing X (removing tag t1) leaves Node B’s addition (tag t2) intact. The element stays in the set.

This matches user intuition: you removed the copy you knew about, not the one that was being added concurrently somewhere else.

State-based vs. Operation-based

There are two families of CRDTs.

State-based (CvRDTs): nodes gossip their full state. Merge is applied on receipt. The merge function must be a join on a join-semilattice – a partial order where every pair of elements has a least upper bound. Simple to reason about, but shipping full state can be expensive for large structures.

Operation-based (CmRDTs): nodes broadcast operations instead of state. No merge function needed on state – instead, the transport layer must guarantee exactly-once delivery and causal ordering. More efficient, but the delivery guarantee is a real constraint.

In practice, libraries like Automerge and Yjs use operation-based CRDTs with a hybrid approach: operations for real-time sync, periodic state snapshots for catch-up after disconnection.

Where They’re Used

Collaborative editing is the obvious one. Google Docs uses OT (operational transformation), an older approach with similar goals. Figma uses CRDTs. Notion, Linear, and most newer collaborative tools have moved toward CRDTs because the math is cleaner and they handle offline edits naturally.

Distributed databases: Riak’s eventual consistency model was built around CRDTs. Redis has CRDT support in Redis Enterprise for multi-region deployments. Azure Cosmos DB uses them internally for its multi-master replication.

Shopping carts: Amazon’s Dynamo paper mentions the shopping cart as a canonical use case. Adds and removes to a cart from multiple devices or regions converge without a coordinator.

The Tradeoff

CRDTs don’t work for everything. The merge semantics have to match what your application actually means.

A bank account is not a PN-Counter. If your account shows $500 and you withdraw $200 concurrently from two ATMs, merging the two PN-Counters would show $100 – which is correct math but incorrect banking. The constraint “balance must not go negative” requires coordination. You can’t avoid that with a CRDT.

The rule: CRDTs work when the merge semantics match application intent and when the application can tolerate the conflict-free resolution behavior. They’re not a universal replacement for coordination – they’re a way to avoid coordination in cases where the math lines up.

Vector clocks give you the diagnosis. CRDTs give you a structural guarantee that the diagnosis is never needed.

When N changes to N+1 or N-1, nearly every key remaps to a different node. You go from a warm cache to a cold one in an instant – a thundering herd of cache misses hitting your database all at once. For a large cluster, that’s enough to take down a service.

Consistent hashing fixes this. Add or remove a node, and only the keys that were assigned to that node need to move. Everything else stays put.

The Hash Ring

Instead of hash(key) % N, arrange all possible hash values on a ring from 0 to 2^32. Each node gets a position on the ring by hashing its name or ID. To find which node owns a key: hash the key, then walk clockwise around the ring until you hit a node.

          0
         / \
    Node C   Node A
       |         |
    Node B --- Node D

Key K hashes to a point on the ring. The first node clockwise from that point owns K.

Now add a new node between B and C. Only the keys that were between B and the new node’s position need to move – from C to the new node. Everything else is unaffected. In an N-node cluster, adding one node moves roughly 1/N of the keys instead of nearly all of them.

Virtual Nodes

Raw consistent hashing has a load distribution problem. With a small number of physical nodes, the gaps between them on the ring are uneven – one node might own 30% of the keyspace, another 10%. Remove a node and all its load lands on a single neighbor.

Virtual nodes fix this: each physical node gets multiple positions on the ring, typically by hashing it with different suffixes (node1-0, node1-1, node1-2, …). With enough virtual nodes per physical node, the load distributes evenly across the ring. Removing one node scatters its keys across many neighbors rather than dumping them all on one.

This is the production configuration in every serious deployment.

Where It’s Used

• Amazon DynamoDB – consistent hashing across storage nodes, virtual nodes for even distribution
• Apache Cassandra – the token ring is consistent hashing; each node owns a range of tokens
• Memcached – the ketama client implements consistent hashing for cache node assignment
• Basically every distributed cache or storage system that needs to scale nodes without full reshuffling

The pattern generalizes beyond caching. Any system that needs to assign work or data to nodes – and occasionally add or remove nodes – runs into the same problem. Consistent hashing is the standard solution.

The question is: can you still tell whether one event caused another?

Vector clocks answer that question. They don’t give you wall-clock time. They give you something more useful: a precise definition of “happened before.”

How They Work

Each node maintains a vector of counters, one slot per node in the system. Call them [A, B, C] for a three-node cluster.

Three rules:

1. Local event – increment your own counter
2. Send a message – attach the current vector to the message
3. Receive a message – merge by taking the element-wise max of your vector and the received vector, then increment your own counter

A concrete trace:

Node A starts:  [A:0, B:0, C:0]
Node A event:   [A:1, B:0, C:0]
Node A sends to B, attaches [A:1, B:0, C:0]

Node B receives, merges: max([A:0,B:0,C:0], [A:1,B:0,C:0]) = [A:1,B:0,C:0]
Node B increments own:   [A:1, B:1, C:0]
Node B event:            [A:1, B:2, C:0]

What You Can Determine

Given two events with vectors V1 and V2, exactly one of three things is true:

The concurrent case is the important one. When neither vector dominates, the events genuinely have no causal relationship – they happened independently on different nodes without either one knowing about the other. No ordering can be inferred because no ordering exists.

Why This Matters

The alternative is last-write-wins: when two writes conflict, pick the one with the later timestamp and discard the other. This is simple to implement and silently destroys data. If two users edit the same document concurrently, you lose one of their changes without telling anyone.

Vector clocks let you detect that conflict honestly. DynamoDB and Riak use them (or variants) to surface conflicting writes to the application rather than silently resolving them. The application – or the user – can then merge the two versions intelligently.

“Happened-before” is a relationship you earn through the causal structure of the system, not one you assume from timestamps.

The Tradeoff

Vector size grows O(N) with the number of nodes. In a cluster with hundreds of nodes, attaching a full vector to every message gets expensive.

Dotted version vectors are a modern fix: they compress the vector by pruning entries that are causally dominated. Same core semantics, better space efficiency for large clusters.

Lamport clocks are the scalar predecessor – a single counter instead of a vector. They give you a consistent ordering (if A happened-before B, A’s timestamp is lower), but they don’t detect concurrency. Two events with different Lamport timestamps might still be concurrent. Vector clocks are strictly more informative.

Intuition

The problem is asking us to generate the gray code for a given number n.

Gray code is a binary numeral system where two successive values differ in only one bit. This is similar to bit strings problem. But instead of printing the binary representation of the number, we need to print the gray code.

The formula to generate the gray code for a given number n is:

Solution

1def main():
2    n = int(input())
3    for i in range(2**n):   
4        num = i^(i>>1)
5        num_str = bin(num)[2:].zfill(n)
6        print(num_str, end="\n")
7
8if __name__ == "__main__":
9    main()

Other possible solutions

Bit-by-Bit Approach

This approach constructs the Gray code by calculating each bit position individually using the property that the i-th bit of the Gray code is the XOR of the i-th and (i+1)-th bits of the binary representation.

Dry Run for n = 2

For n = 2, we need to generate 4 Gray codes (2² = 4). Let’s walk through each iteration:

Iteration 1: i = 0

• Binary representation: 00
• Bit position 0 (rightmost):
  • Current bit: (0 » 0) & 1 = 0 & 1 = 0
  • Next bit: (0 » 1) & 1 = 0 & 1 = 0 (since bit position 1 < n=2)
  • Gray bit: 0 ⊕ 0 = 0
  • Set bit: gray = 0 | (0 « 0) = 0
• Bit position 1:
  • Current bit: (0 » 1) & 1 = 0 & 1 = 0
  • Next bit: 0 (since bit position 2 >= n=2)
  • Gray bit: 0 ⊕ 0 = 0
  • Set bit: gray = 0 | (0 « 1) = 0
• Result: 00

Iteration 2: i = 1

• Binary representation: 01
• Bit position 0:
  • Current bit: (1 » 0) & 1 = 1 & 1 = 1
  • Next bit: (1 » 1) & 1 = 0 & 1 = 0
  • Gray bit: 1 ⊕ 0 = 1
  • Set bit: gray = 0 | (1 « 0) = 1
• Bit position 1:
  • Current bit: (1 » 1) & 1 = 0 & 1 = 0
  • Next bit: 0 (since bit position 2 >= n=2)
  • Gray bit: 0 ⊕ 0 = 0
  • Set bit: gray = 1 | (0 « 1) = 1
• Result: 01

Iteration 3: i = 2

• Binary representation: 10
• Bit position 0:
  • Current bit: (2 » 0) & 1 = 2 & 1 = 0 (2 in binary is 10, rightmost bit is 0)
  • Next bit: (2 » 1) & 1 = 1 & 1 = 1
  • Gray bit: 0 ⊕ 1 = 1
  • Set bit: gray = 0 | (1 « 0) = 1
• Bit position 1:
  • Current bit: (2 » 1) & 1 = 1 & 1 = 1
  • Next bit: 0 (since bit position 2 >= n=2)
  • Gray bit: 1 ⊕ 0 = 1
  • Set bit: gray = 1 | (1 « 1) = 1 | 2 = 3
• Result: 11

Iteration 4: i = 3

• Binary representation: 11
• Bit position 0:
  • Current bit: (3 » 0) & 1 = 3 & 1 = 1 (3 in binary is 11, rightmost bit is 1)
  • Next bit: (3 » 1) & 1 = 1 & 1 = 1
  • Gray bit: 1 ⊕ 1 = 0
  • Set bit: gray = 0 | (0 « 0) = 0
• Bit position 1:
  • Current bit: (3 » 1) & 1 = 1 & 1 = 1
  • Next bit: 0 (since bit position 2 >= n=2)
  • Gray bit: 1 ⊕ 0 = 1
  • Set bit: gray = 0 | (1 « 1) = 2
• Result: 10

Final Gray Code Sequence: 00, 01, 11, 10

Notice how each consecutive Gray code differs by only one bit:

• 00 → 01 (bit 0 changes: 0→1)
• 01 → 11 (bit 1 changes: 0→1)
• 11 → 10 (bit 0 changes: 1→0)

 1def generate_gray_code_bitwise(n):
 2    result = []
 3    for i in range(2**n):
 4        gray = 0
 5        for bit in range(n):
 6            # Gray bit is XOR of current bit and next bit
 7            current_bit = (i >> bit) & 1 # this step get the current bit using bitwise shift and bitwise and
 8            next_bit = (i >> (bit + 1)) & 1 if bit + 1 < n else 0 # this step get the next bit using bitwise shift and bitwise and
 9            gray_bit = current_bit ^ next_bit # this step get the gray bit using bitwise xor
10            gray |= (gray_bit << bit) # this step set the gray bit using bitwise or
11        result.append(bin(gray)[2:].zfill(n))
12    return result
13
14def main():
15    n = int(input())
16    gray_codes = generate_gray_code_bitwise(n)
17    for code in gray_codes:
18        print(code)
19
20if __name__ == "__main__":
21    main()

Intuition

Problem is asking us to find the number of combinations of 0s and 1s of length n. Basically its 2^n combinations.

Solution

1def main():
2    n = int(input())
3    print(2**n % 1000000007)
4
5if __name__ == "__main__":
6    main()

In python it feels cheating to use the power operator **, but it is a valid way to solve the problem.

In lower level languages like C, C++, Java, we need to use a loop to calculate the power of 2 and each time we take modulo 1e9+7.

 1#include <stdio.h>
 2#include <stdlib.h>
 3
 4int main() {
 5    int n;
 6    scanf("%d", &n);
 7    long long result = 1;
 8    for(int i = 0; i < n; i++) {
 9        result = (result * 2) % 1000000007;
10    }
11    printf("%lld\n", result);
12    return 0;
13}

Intuition

The problem asking us to partition the given set of numbers into two sets such that the sum of the numbers in the two sets are equal.

For the sum of two sets to be equal the total sum of the numbers must be even. That means sum(numbers) % 2 == 0. by the forumla for the sum of the first n natural numbers, sum(numbers) = n * (n + 1) / 2. So that means sum of each set must be n * (n + 1) / 4.

Hence we got that n mod 4 is 0 or (n+1) mod 4 is 0, combining both we get n mod 4 must be 0 or 3 to be able to partition the numbers into two sets. So this becomes a necessary condition for the problem to be solvable.

but this is not a sufficient condition.

When n mod 4 = 0: Total sum is even, partition is possible. The set can be split so both subsets have the same number of elements (equal size).

Example: n=8

Pairs: (8,1), (7,2), (6,3), (5,4)

Assign two pairs to one set, the other two pairs to the other set—both sum to 18.

When n mod 4 = 3: Total sum is even, partition is possible.

The sets will have different sizes (one will have one more element). Example: n=7

Pairs: (7,1,6) sums to 14, rest (2,3,4,5) sum to 14.

The sum of each smallest–largest pair is always n+1.

For n mod 4 = 0: you can split pairs alternately between the two sets.

For n mod 4 = 3: this is a tricky case Consider some integer k such that we have n = 4k+3. that means n mod 4 = 3. Now sum of n numbers is n * (n + 1) / 2 = (4k+3) * (4k+4) / 2 = (4k+3) * (2k+2)

Mathematical Derivation

For n = 4k + 3, we assign:

• Set 1: numbers where i ≡ 1 or 2 (mod 4)
• Set 2: numbers where i ≡ 0 or 3 (mod 4)

Count of numbers in each residue class:

• ≡ 0 mod 4: k numbers (4, 8, …, 4k)
• ≡ 1 mod 4: k+1 numbers (1, 5, …, 4k+1)
• ≡ 2 mod 4: k+1 numbers (2, 6, …, 4k+2)
• ≡ 3 mod 4: k+1 numbers (3, 7, …, 4k+3)

Sum of each residue class:

≡ 0 mod 4:

4 + 8 + ... + 4k = 4(1 + 2 + ... + k) = 4 × k(k+1)/2 = 2k(k+1)

≡ 1 mod 4:

1 + 5 + 9 + ... + (4k+1)

Arithmetic series: first term = 1, last term = 4k+1, common difference = 4, terms = k+1

Sum = (k+1) × (1 + 4k+1)/2 = (k+1) × (4k+2)/2 = (k+1) × 2(k+1) = 2(k+1)²

≡ 2 mod 4:

2 + 6 + 10 + ... + (4k+2)

Arithmetic series: first term = 2, last term = 4k+2, common difference = 4, terms = k+1

Sum = (k+1) × (2 + 4k+2)/2 = (k+1) × (4k+4)/2 = (k+1) × 2(k+2) = 2(k+1)(k+2)

≡ 3 mod 4:

3 + 7 + 11 + ... + (4k+3)

Arithmetic series: first term = 3, last term = 4k+3, common difference = 4, terms = k+1

Sum = (k+1) × (3 + 4k+3)/2 = (k+1) × (4k+6)/2 = (k+1) × 2(k+3) = 2(k+1)(k+3)

Total sum verification:

Total sum = 2k(k+1) + 2(k+1)² + 2(k+1)(k+2) + 2(k+1)(k+3)
         = 2(k+1) × [k + (k+1) + (k+2) + (k+3)]
         = 2(k+1) × (4k + 6)
         = 2(k+1) × 2(2k + 3)
         = 4(k+1)(2k + 3)

Each set should sum to: 2(k+1)(2k + 3)

Sum of each set:

Set 1 (≡1 or ≡2 mod 4):

Sum = 2(k+1)² + 2(k+1)(k+2) = 2(k+1) × [(k+1) + (k+2)] = 2(k+1) × (2k + 3)

Set 2 (≡0 or ≡3 mod 4):

Sum = 2k(k+1) + 2(k+1)(k+3) = 2(k+1) × [k + (k+3)] = 2(k+1) × (2k + 3)

Both sets sum to 2(k+1)(2k + 3), which is exactly half the total sum.

Solution

 1def main():
 2    n = int(input())
 3    if n % 4 not in (0, 3):
 4        print("NO")
 5        return
 6    
 7    set1 = []
 8    set2 = []
 9    toggle = True
10    
11    if n % 4 == 0:
12        low = 1
13        high = n
14        while low <= high:
15            if toggle:
16                set1.append(low)
17                set1.append(high)
18            else:
19                set2.append(low)
20                set2.append(high)
21            low += 1
22            high -= 1
23            toggle = not toggle
24    else:
25        for i in range(1, n+1):
26            if i % 4 == 1 or i % 4 == 2: # 
27                set1.append(i)
28            else:
29                set2.append(i)
30    
31    # Output the result
32    print("YES")
33    print(len(set1))
34    print(" ".join(map(str, set1)))
35    print(len(set2))
36    print(" ".join(map(str, set2)))
37
38if __name__ == "__main__":
39    main()

Intuition

The idea is to generate a permutation of the numbers from 1 to n such that the difference between any two consecutive elements is at least greater than 1.

One way to do this is to first write all the even numbers between 1 and n in increasing order and then write all the odd numbers between 1 and n in increasing order.

This is only one such solution. There are other solutions as well.

Edge case:

• If n is 1, print 1. this is because there are no consecutive elements in the permutation, hence is a valid permutation.
• If n is less than 4, print “NO SOLUTION”. because for n < 4, any permutation will have a difference between any two consecutive elements less than 1. example 1 2 3 4, 1 3 2 4, 1 3 4 2, etc are not valid permutations.

Solution

 1def main():
 2    n = int(input())
 3    if n == 1:
 4        print(1)
 5        return
 6    if n < 4:
 7        print("NO SOLUTION")
 8        return
 9    for i in range(2,n+1,2):
10        print(i, end=" ")
11    for i in range(1,n+1,2):
12        print(i, end=" ")
13
14if __name__ == "__main__":
15    main()

Other possible solutions

• Write all the odd numbers between 1 and n in increasing order and then write all the even numbers between 1 and n in increasing order.
• Write all the odd numbers between 1 and n in decreasing order and then write all the even numbers between 1 and n in decreasing order.
• Write all the even numbers between 1 and n in increasing order and then write all the odd numbers between 1 and n in decreasing order.

Intuition

The idea is to make an array increasing by making the current element equal to or greater than the previous element. and in each step we can increase the value of a single element by 1.

That means for ith element which is less than the i-1th element, we need elem[i-1] - elem[i] steps to make it equal to or greater than the i-1th element.

So we can come up with the following algorithm:

• Loop through the array
• If the current element is less than the previous element, we need to increase the current element to the previous element.
• Increment the count by the difference between the previous element and the current element.
• Update the current element to the previous element.

At the end of the loop, we will have the minimum number of steps to make the array increasing.

Solution

 1def main():
 2    n = int(input())
 3    nums = list(map(int, input().split()))
 4    count = 0
 5    for i in range(0,n-1):
 6        if nums[i] > nums[i+1]:
 7            count += nums[i] - nums[i+1]
 8            nums[i+1] = nums[i]
 9    print(count)
10
11if __name__ == "__main__":
12    main()

Mathematical Proof

Theorem: The greedy algorithm that ensures each element is at least as large as its predecessor gives the minimum total cost to make the array non-decreasing.

Proof by Induction:

Base Cases:

• For an array of size 1: The cost is 0, which is trivially optimal.
• For an array of size 2: If nums[0] ≤ nums[1], cost is 0. If nums[0] > nums[1], we must increment nums[1] by nums[0] - nums[1] to make it ≥ nums[0]. This is optimal since we must satisfy nums[1] ≥ nums[0].

Inductive Hypothesis: Assume the greedy algorithm is optimal for arrays of size ≤ k.

Inductive Step: Consider an array of size k+1. Let the array be a[0], a[1], ..., a[k].

Apply the greedy algorithm:

1. Process the first k elements optimally (by inductive hypothesis)
2. For the last element a[k], if a[k-1] ≤ a[k], no change needed (cost 0)
3. If a[k-1] > a[k], increment a[k] to a[k-1], costing a[k-1] - a[k]

Why this is optimal: Any optimal solution must satisfy a'[i] ≥ a'[i-1] for all i, where a' is the final array.

For the prefix a'[0] ... a'[k-1], the inductive hypothesis says our greedy choices give the minimum cost.

For the last pair a'[k-1] and a'[k]:

• We must have a'[k] ≥ a'[k-1]
• The minimum cost to achieve this is exactly max(0, a'[k-1] - a'[k])
• Our greedy algorithm achieves exactly this minimum cost

Key insight: The greedy choice doesn’t affect the optimality of the prefix because:

1. The prefix constraints are already satisfied optimally
2. Setting a[k] = max(a[k], a[k-1]) only affects the relationship between a[k-1] and a[k]
3. This choice is independent of future elements since there are none

Proof by Contradiction : Suppose there exists an optimal solution with lower total cost than the greedy algorithm. Let the greedy algorithm produce array g with cost C_g. Let the optimal solution produce array o with cost C_o < C_g.

Since both g and o must satisfy g[i] ≥ g[i-1] and o[i] ≥ o[i-1] for all i:

• At the first position where g and o differ, the optimal solution must have made a different choice
• But making a different choice would either violate the non-decreasing constraint or require more operations later, contradicting optimality

Therefore, the greedy algorithm is optimal.

Intuition

This problem wants us to find the longest substring of a string that has only 1 type of character. input has A,G,C and T only.

Edge case: if the string is empty, return 0.

We need to keep track of the current length of the substring and the maximum length of the substring seen so far which satisfies the condition.

Loop through the string and check if the current character is the same as the previous character.

• If it is, increment the current length. Update the maximum length if the current length is greater than the maximum length.
• If it is not, reset the current length to 1.

Solution

 1def main():
 2    string = input().strip()
 3    if not string:
 4        print(0)
 5        return
 6    
 7    max_len = 1
 8    current_len = 1
 9    
10    for i in range(1, len(string)):
11        if string[i] == string[i-1]:
12            current_len += 1
13            max_len = max(max_len, current_len)
14        else:
15            current_len = 1
16    
17    print(max_len)
18
19if __name__ == "__main__":
20    main()

Time complexity

O(n)

Space complexity

O(1)

This is a greedy problem. A greedy approach is something that makes the best local choice at each step in the hope that this choice will lead to the global optimal solution.

here the best local choice is to increment the current length if the current character is the same as the previous character.

Intuition

This problem wants us to find the missing number in a sequence of numbers from 1 to n. The naive approach is to use a hash map to store the numbers and then find the missing number. But this is not efficient.

The idea is to use the formula for the sum of an arithmetic series. The sum of an arithmetic series is given by the formula:

where n is the number of terms, a is the first term, and l is the last term. In this problem, the first term is 1 and the last term is n. So the sum of the series is given by the formula:

now if we accumulate the sum of the numbers in the list, we can find the missing number by subtracting the sum of the numbers in the list from the sum of the series. Since only one number is missing, the sum of the numbers in the list will be less than the sum of the series and the difference will be the missing number.

Solution

 1def main():
 2    n = int(input())
 3    nums_list = input().strip()
 4    nums = nums_list.split()
 5    total = 0
 6    for num in nums:
 7        total += int(num)
 8    tot = n * (n + 1) // 2
 9    print(tot - total)
10
11
12if __name__ == "__main__":
13    main()

Some formulae for arithmetic series

nth term

where a is the first term, d is the common difference, and n is the number of terms.

sum of the first n terms

where n is the number of terms, a is the first term, and l is the last term.

sum of the first n terms

where n is the number of terms, a is the first term, and d is the common difference.

Intuition

This problem is a direct implementation of the algorithm described in the problem statement.

Given a number n, we need to apply the following algorithm:

1. If n is even, divide it by 2.
2. If n is odd, multiply it by 3 and add 1.
3. Repeat the process until n becomes 1.

Solution

1def weird_algorithm(n):
2    while n != 1:
3        print(n, end=" ")
4        if n % 2 == 0:
5            n = n // 2
6        else:
7            n = 3 * n + 1
8    print(n)

Geek fact

This is a famous problem in the field math called the Collatz conjecture.

Collatz conjecture is a conjecture in mathematics that states that for any positive integer n, the sequence of numbers generated by the following algorithm will eventually reach 1.

So far, the conjecture has been verified for all positive integers up to 2^68.

Wikipedia link: Collatz conjecture