contest-solutions

Author: gautamankoji

.gitignore

@@ -0,0 +1,14 @@
+*.exe
+*.bin
+.cph/
+*personel-notes.md
+*test.c
+*test.py
+*test.cpp
+*test1.c
+*test1.c
+*test1.py
+*test2.py
+*test1.cpp
+*test2.cpp
+vignan-contest-solutions-draft/

ECP-week-3/01multiply_with_shift.py

@@ -0,0 +1,22 @@
+def max_value_no_consecutive_bits(n):
+    # Convert n to binary string
+    binary_str = bin(n)[2:]
+    
+    # Convert binary string to list of integers
+    bits = list(map(int, binary_str))
+    
+    # Iterate through bits to make sure no three consecutive bits are set
+    for i in range(2, len(bits)):
+        if bits[i] == 1 and bits[i-1] == 1 and bits[i-2] == 1:
+            bits[i] = 0  # Change the third consecutive bit to 0
+    
+    # Convert modified list of bits back to integer
+    new_value = int(''.join(map(str, bits)), 2)
+    
+    return new_value
+
+# Test cases
+test_cases = int(input("Enter the number of test cases: "))
+for _ in range(test_cases):
+    n = int(input())
+    print(max_value_no_consecutive_bits(n))

ECP-week-3/02_no_consecutive_bits.py

@@ -0,0 +1,10 @@
+for _ in range(int(input())):
+    s = input()
+    a, b, c, d = int(s[0]), int(s[1]), int(s[2]), int(s[3])
+    and1 = a & b
+    not1 = ~c & 1
+    or1 = and1 | not1
+    and2 = or1 & d
+    not2 = ~and2 & 1
+    print(bool(not2))
+    

ECP-week-3/03_fruit_pile_combinations.py

@@ -0,0 +1,23 @@
+def can_distribute_equally(n, m):
+    total_chocolates = n + m
+    # If the total number of chocolates is odd, it's impossible to distribute equally
+    if total_chocolates % 2 != 0:
+        return False
+    # If both have the same number of chocolates, return True
+    if n == m:
+        return True
+    # Otherwise, it's only possible if the total number of chocolates is divisible by 2
+    return total_chocolates % 2 == 0
+
+# Read the number of test cases
+T = int(input("Enter the number of test cases: "))
+results = []
+
+# Iterate over each test case
+for _ in range(T):
+    n, m = map(int, input().split())
+    results.append(can_distribute_equally(n, m))
+
+# Print the results
+for result in results:
+    print("True" if result else "False")

ECP-week-3/04_circultrix.py

@@ -0,0 +1,24 @@
+def find_duplicate_and_replace(N, arr):
+    frequency = {}
+    for num in arr:
+        if num in frequency:
+            duplicate = num
+        else:
+            frequency[num] = True
+    
+    # Find a replacement roll number
+    replacement = 1
+    while replacement in frequency:
+        replacement += 1
+    
+    return duplicate, replacement
+
+# Input
+N = int(input())
+arr = list(map(int, input().split()))
+
+# Find duplicate and replacement
+duplicate, replacement = find_duplicate_and_replace(N, arr)
+
+# Output
+print(duplicate, replacement)

ECP-week-3/05_matching_bits.py

@@ -0,0 +1,23 @@
+def min_flips_to_or(a, b, c):
+    flips = 0
+    for i in range(31, -1, -1):  # Considering 32-bit integers
+        bit_a = (a >> i) & 1
+        bit_b = (b >> i) & 1
+        bit_c = (c >> i) & 1
+        
+        if (bit_a | bit_b) != bit_c:
+            if bit_c == 1:  # If bit_c is 1, we need to flip a or b to make it 1
+                if bit_a == 0 and bit_b == 0:  # If both a and b are 0, flip any one
+                    flips += 1
+                elif bit_a == 1 and bit_b == 1:  # If both a and b are 1, flip any one
+                    flips += 1
+            else:  # If bit_c is 0, we need to ensure both a and b are 0
+                flips += (bit_a + bit_b)
+                
+    return flips
+
+# Input
+t = int(input("Enter the number of test cases: "))
+for _ in range(t):
+    a, b, c = map(int, input().split())
+    print(min_flips_to_or(a, b, c))

ECP-week-3/06_chocolates_equality_check.py

@@ -0,0 +1,20 @@
+def min_operations(n):
+    if n == 1:
+        return 0
+    elif n % 2 == 0:
+        return 1 + min_operations(n // 2)
+    else:
+        return 1 + min(min_operations(n + 1), min_operations(n - 1))
+
+# Input
+t = int(input("Enter number of test cases: "))
+test_cases = []
+for _ in range(t):
+    test_cases.append(int(input()))
+
+# Output
+for n in test_cases:
+    print(min_operations(n))
+
+
+# gives tle if removed recursion then 100

ECP-week-3/07_roll_numbers_assignment_error.py

@@ -0,0 +1,19 @@
+import math
+
+def min_operations(N):
+    count = 0
+    while N > 0:
+        max_power_of_2 = int(math.log2(N))
+        N -= 2**max_power_of_2
+        count += 1
+    return count
+
+# Input
+T = int(input("Enter number of test cases: "))
+test_cases = []
+for _ in range(T):
+    test_cases.append(int(input()))
+
+# Output
+for N in test_cases:
+    print(min_operations(N))

ECP-week-3/08_a_or_b.py

@@ -0,0 +1,20 @@
+def hamming_distance(num1, num2):
+    # XOR the two numbers to get the bits that differ
+    xor_result = num1 ^ num2
+    
+    # Count the number of set bits in the XOR result
+    # This is the Hamming distance
+    hamming_dist = 0
+    while xor_result:
+        hamming_dist += xor_result & 1
+        xor_result >>= 1
+    
+    return hamming_dist
+
+# Input
+t = int(input("Enter the number of test cases: "))
+for _ in range(t):
+    num1, num2 = map(int, input().split())
+    
+    # Output
+    print(hamming_distance(num1, num2))

ECP-week-3/09_shambala_nagram.py

@@ -0,0 +1,26 @@
+def binary_to_decimal(binary_string):
+    decimal_value = int(binary_string, 2)
+    return decimal_value
+
+def flip_even_indices(binary_input):
+    res = ''
+    for i in range(len(binary_input)):
+        if i % 2 != 0:
+            if binary_input[i] == '0':
+                res += '1'
+            else:
+                res += '0'
+        else:
+            res += binary_input[i]
+    return res
+
+
+n = int(input())
+binary_input = bin(n)[2:]
+
+flipped_binary_string = flip_even_indices(binary_input)
+decimal_value = binary_to_decimal(flipped_binary_string)
+
+print("Input Binary String:", binary_input)
+print("Flipped Binary String:", flipped_binary_string)
+print("Decimal Value:", decimal_value)

ECP-week-3/10_numeria_a_magical_land.py

@@ -0,0 +1,9 @@
+for _ in range(int(input())):
+    n = int(input())
+    l = list(map(int, input().split()))
+    res = [1]*n
+    for a in range(1, n):
+        for b in range(a):
+            if res[a] < res[b] + 1 and l[a] > l[b]:
+                res[a] = res[b] + 1
+    print(max(res))

ECP-week-3/11_ben_10.py

@@ -0,0 +1,34 @@
+## Problem Statement: Cricket Analyst of the year
+
+As a cricket analyst for a prestigious team preparing for the upcoming IPL season, you aim to impress team owners by presenting the analysis of a player's performance. You possess a series of scores for the player, and you seek to identify the longest strictly increasing sequence of these scores to showcase the player's consistency and potential. The sequence need not comprise consecutive match scores but must exhibit a strictly ascending trend. Your task is to determine the length of this longest increasing sequence for each test case.
+
+### Input
+
+- The first line contains an integer, T, denoting the number of test cases.
+- For each test case:
+  - The first line contains an integer, N, representing the number of scores for the player.
+  - The second line contains N space-separated integers representing the scores.
+
+### Output
+
+For each test case, output the length of the longest strictly increasing sequence of scores.
+
+### Constraints
+
+- 1 < T < 10
+- 1 < N < 10^3
+- 1 < scores < 300
+
+### Example
+
+Input:
+```
+1
+3
+2 1 5
+```
+
+Output:
+```
+2
+```

ECP-week-3/12_help_eswar.py

@@ -0,0 +1,11 @@
+for _ in range(int(input())):
+    n, k = map(int, input().split())
+    s = list(input().strip())
+    i = 0
+    while k > 0 and i < n:
+        if s[i] != 'a':
+            s[i] = chr((ord(s[i]) - 96) % 26 + 97)
+            k -= 1
+        else:
+            i += 1
+    print(''.join(s))

ECP-week-3/13_neel_cinematic_universe.py

@@ -0,0 +1,37 @@
+# Get The String
+
+**Problem Statement:**
+
+Given a string, Str, you can replace a character with its next character in the alphabet. You need to find a string such that it will become the first in dictionary order after performing K such operations.
+
+**Input format:**
+
+- The first line contains an integer, T, denoting the number of test cases.
+- For each test case:
+  - The first line contains two space-separated integers, N and K, denoting the length of string Str and the number of operations to be performed, respectively.
+  - The second line contains string Str consisting of lowercase letters.
+
+**Output Format:**
+
+Print a string such that it will become the first in dictionary order after performing K such operations.
+
+**Constraints:**
+
+- 1 ≤ T ≤ 100
+- 1 ≤ N ≤ 10^5
+- 0 ≤ K ≤ 10^5
+
+**Sample Input:**
+```
+2
+1 3
+x
+3 3
+zya
+```
+
+**Sample Output:**
+```
+a
+aaa
+```

ECP-week-3/14_dj_ravi.py

@@ -0,0 +1,43 @@
+## Problem Statement: Maximum XOR of Two Numbers
+
+In a world of magical numbers, a pair of numbers, `x` and `y`, was considered special if `|x - y|` was less than or equal to the smaller number. Your task is to find two numbers from this set that create the most powerful pair, where their XOR is the highest among all pairs meeting this rule.
+
+Return the maximum XOR value out of all possible strong pairs in the array `nums`.
+
+Note that you can pick the same integer twice to form a pair.
+
+### Input Format
+
+- The first line contains an integer `T`, the number of test cases.
+- For each test case:
+  - The first line contains an integer `N`, the number of elements in the array.
+  - The second line contains `N` space-separated integers, the elements of the array.
+
+### Output Format
+
+For each test case, print the maximum XOR value out of all possible strong pairs in the array `nums`.
+
+### Constraints
+
+- 1 <= nums.length <= 5 * 10^4
+- 1 <= nums[i] <= 2^20 - 1
+
+### Sample Input
+
+```terminal
+3
+5
+9 5 10 10 5
+4
+4 9 9 8
+5
+4 4 10 3 10
+```
+
+### Sample Output
+
+```terminal
+15
+12
+7
+```

ECP-week-3/15_inversion.py

@@ -0,0 +1,9 @@
+for _ in range(int(input())):
+    n = int(input())
+    l = list(map(int, input().split()))
+    res = 0
+    for a in range(n):
+        for b in range(a, n):
+            if min(l[a], l[b]) >= abs(l[a] - l[b]):
+                res = max(l[a] ^ l[b], res)
+    print(res)