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