LEVEL 1

EASY MODE
CODES
 1.1.1 Armstrong (Java)

package q3341;
public class CTJ3341 {
public static String checkArmstrong(int num) {
String numStr = Integer.toString(num);
int numDigits = numStr.length();
int armstrongSum = 0;
for (char digit : numStr.toCharArray()) {
armstrongSum += Math.pow(Character.getNumericValue(digit), numDigits);
}
if (armstrongSum == num) {
return "yes";
} else {
return "no";
}
}
public static void main(String[] args) {
int num = Integer.parseInt(args[0]);
System.out.println(checkArmstrong(num));
}
}
 1.1.2 Series Sum (C)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
float geometricSum(int k) {
if (k == 0) {
return 1.0;
}
return 1.0 / pow(2, k) + geometricSum(k - 1);
}
int main(int argc, char *argv[]) {
int k = atoi(argv[1]);
printf("%1.6e\n", geometricSum(k));
return 0;
}
 1.1.3 ith factor (Python)

import sys
n = int(sys.argv[1])
i = int(sys.argv[2])
def ithFactor(n, i):
factors = []
for j in range(1, int(n**0.5) + 1):
if n % j == 0:
factors.append(j)
if j != n // j:
factors.append(n // j)
factors.sort()
if i <= len(factors):
return factors[i - 1]
else:
return 0
print(ithFactor(n, i))
 1.1.4 Palindrome (C)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int isPalindrome(long n) {
long original = n;
long reversed = 0;
while (n > 0) {
reversed = reversed * 10 + n % 10;
n /= 10;
}
return (original == reversed) ? 1 : 0;
}
int main(int argc, char *argv[]) {
long n = atol(argv[1]);
printf(isPalindrome(n) ? "true\n" : "false\n");
return 0;
}
 1.1.5 LCM (Java)

package q23415;
public class CTJ23415 {
public static int gcd(int a, int b) {
while (b != 0) {
int temp = b;
b = a % b;
a = temp;
}
return a;
}
public static int lcm(int a, int b){
return (a / gcd(a,b)) * b;
}
public static int findLCM(int n1, int n2, int n3) {
return lcm(lcm(n1, n2), n3);
}
public static void main(String[] args) {
int n1 = Integer.parseInt(args[0]);
int n2 = Integer.parseInt(args[1]);
int n3 = Integer.parseInt(args[2]);
System.out.println(findLCM(n1, n2, n3));
}
}
 1.1.6 Prime (Java)

package q23503;
public class CTJ23503 {
public static int prime(int n) {
int count = 0;
int currentNumber = 1;
while (count < n) {
currentNumber++;
if (isPrime(currentNumber)) {
count++;
}
}
return currentNumber;
}
private static boolean isPrime(int num) {
if (num <= 1) return false;
for (int i = 2; i * i <= num; i++) {
if (num % i == 0) {
return false;
}
}
return true;
}
public static void main(String[] args) {
int n = Integer.parseInt(args[0]);
System.out.println(prime(n));
}
}
 1.1.7 Sum of all factors (C)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int sumOfFactors(int n) {
int sum = 0;
for (int i = 1; i <= n; i++){
if (n % i == 0) {
sum += i;
}
}
return sum;
}
int main(int argc, char *argv[]) {
int n = atoi(argv[1]);
printf("%d\n", sumOfFactors(n));
return 0;
}
 1.1.8 Five Digit Sum (C)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int reverseFiveDigitNum(int fiveDigitNum) {
int reversedNum = 0;
for (int i = 0; i < 5; i++) {
reversedNum = reversedNum * 10 + (fiveDigitNum % 10);
fiveDigitNum /= 10;
}
return reversedNum;
}
int main(int argc, char *argv[]) {
int fiveDigitNum = atoi(argv[1]);
printf("%d\n", reverseFiveDigitNum(fiveDigitNum));
return 0;
}
 1.1.10 Trailing Zeros (C)

#include <stdio.h>
int count_trailing_zeroes(int n) {
int count = 0;
while (n >= 5) {
n /= 5;
count += n;
}
return count;
}
int main() {
int n;
scanf("%d", &n);
printf("%d\n", count_trailing_zeroes(n));
return 0;
}
 1.1.11 Sum of Squares (Python)

def sum_of_squares_of_digits(n):
return sum(int(digit) ** 2 for digit in str(n))
def is_favouite_number(n):
seen = set()
while n != 1:
if n in {89, 145,42, 20, 4, 16, 37, 58}:
return False
if n in seen:
return False
seen.add(n)
n = sum_of_squares_of_digits(n)
return True
n = int(input())
if is_favouite_number(n):
print("Yes")
else:
print("No")
 1.1.12 Best Primes (Python)

def count_primes_less_than_n(N):
if N <= 2:
return 0
is_prime = [True] * N
is_prime[0] = is_prime[1] = False
for i in range(2, int(N**0.5) + 1):
if is_prime[i]:
for j in range(i * i, N, i):
is_prime[j] = False
return sum(is_prime)
N = int(input())
print(count_primes_less_than_n(N))
 1.1.13 Prime Count (Python)

def count_primes_in_range(L, U):

if U < 2:
return 0
L = max(L, 2)
sieve = [True] * (U + 1)
sieve[0] = sieve[1] = False
for start in range(2, int(U**0.5) + 1):
if sieve[start]:
for multiple in range(start*start, U + 1, start):
sieve[multiple] = False
prime_count = sum(1 for number in range(L, U + 1) if sieve[number])
return prime_count
input_data = input().strip()
L, U = map(int, input_data.split())
result = count_primes_in_range(L, U)
print(result)
 1.1.14 power of 2 (Python)

def nearest_power_of_two(n):
if n <= 0:
return 1
power = 1
while power < n:
power *= 2
lower_power = power // 2
if n - lower_power < power - n:
return lower_power
else:
return power
n = int(input().strip())
result = nearest_power_of_two(n)
print(result)
 1.2.1 String reverse (C)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char * stringReverse(char *str) {
if (str == NULL) return NULL;
int len = strlen(str);
char *reversed = (char *)malloc((len + 1) * sizeof(char));
if (reversed == NULL) return NULL;
for (int i = 0; i < len; i++) {
reversed[i] = str[len - 1 - i];
}
reversed[len] = '\0';
return reversed;
}
int main(int argc, char *argv[]) {
char *str = argv[1];
printf("%s\n", stringReverse(str));
return 0;
}
 1.2.2 CodeTantra Analytical Team (C)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int MagicString(char *S) {
int count_m = 0, count_n = 0, count_o = 0, count_p = 0;
for (int i = 0; S[i] != '\0'; i++) {
if (S[i] == 'm') count_m++;
else if (S[i] == 'n') count_n++;
else if (S[i] == 'o') count_o++;
else if (S[i] == 'p') count_p++;
}
int sum_mo = count_m + count_o;
int sum_np = count_n + count_p;
return (sum_mo % 2 == 0 && sum_np % 2 == 0) ? 1 : 0;
}
int main(int argc, char *argv[]) {
char *S = argv[1];
printf("%d\n", MagicString(S));
return 0;
}
 1.2.3 Remove consecutive characters (Java)

package q3340;
public class CTJ3340 {
public static String removeConsecutiveCharacters(String str) {
char a[] = str.toCharArray();
int l = a.length;
String res = "";
res+=a[0];
for(int i = 1;i<l;i++){
if(a[i]!=a[i-1]){
res+=a[i];
}
}
return res;
}
public static void main(String[] args) {
String str = args[0];
System.out.println(removeConsecutiveCharacters(str));
}
}
 1.2.4 Unique characters (Java)

package q1631;
import java.util.*;
public class CTJ1631 {
public static String uniqueCharacters(String str) {
// Write your code here
List<Character> l = new ArrayList<>();
char a[] = str.toCharArray();
for(char n:a){
if(!l.contains(n)) l.add(n);
}
String ans = "";
for(char nn:l){
ans +=nn;
}
return ans;
}
public static void main(String[] args) {
String str = args[0];
System.out.println(uniqueCharacters(str));
}
}
 1.2.5 Anagram (Java)

package q1075;
import java.util.Arrays;
public class CTJ1075 {
public static String AnagramCheck (String Str1, String Str2) {
char a[] = Str1.toCharArray();
char b[] = Str2.toCharArray();
int l = a.length;
int r = b.length;
if(l!=r) return "Not Anagram";
Arrays.sort(a);
Arrays.sort(b);
if(Arrays.equals(a,b)){
return "Anagram";
}
else return "Not Anagram";
}
public static void main(String[] args) {
String Str1 = args[0];
String Str2 = args[1];
System.out.println(AnagramCheck (Str1, Str2));
}
}
 1.2.6 Not a Palindrome (Java)

package q1557;
public class CTJ1557 {
public static String palindrome(String str) {
int len = str.length();
int l = 0;
int r = len-1;
while(l<r){
if(str.charAt(l)!= str.charAt(r)) return "Not a palindrome";
l++;
r--;
}
return "Palindrome";
}
public static void main(String[] args) {
String str = args[0];
System.out.println(palindrome(str));
}
}
 1.2.7 Strange Language (Python)

def largest_lexicographical_rotation(word):
doubled_word = word * 2
max_rotation = word
for i in range(1, len(word)):
rotation = doubled_word[i:i + len(word)]
if rotation > max_rotation:
max_rotation = rotation
return max_rotation
N = int(input())
results = []
for _ in range(N):
word = input().strip()
results.append(largest_lexicographical_rotation(word))
for result in results:
print(result)
 1.3.1 Reverse the Array (Java)

package q1555;
import java.util.*;
import java.util.stream.*;
public class CTJ1555 {
public static List<Integer> reverseArray(List<Integer> Arr) {
// Write your code here
int len = Arr.size();
int r = len-1;
int l = 0;
while(l<=r){
int temp = Arr.get(l);
Arr.set(l,Arr.get(r));
Arr.set(r,temp);
l++;
r--;
}
return Arr;
}
public static void main(String[] args) {
List<Integer> Arr = Arrays.stream(args[0].split(",")).map(s -> Integer.parseInt(s)).collect(Collectors.toList());
System.out.println(reverseArray(Arr).stream().map(String::valueOf).collect(Collectors.joining(",")));
}
}
 1.3.2 Count duplicates (Java)

package q27;
import java.util.*;
import java.util.stream.*;
public class CTJ27 {
public static int countDuplicates(List<Integer> Arr) {
int a[] = new int[1000];
for(int n:Arr){
a[n]++;
}
int c = 0;
for(int k:a){
if(k>=2) c++;
}
return c;
}
public static void main(String[] args) {
List<Integer> Arr = Arrays.stream(args[0].split(",")).map(s -> Integer.parseInt(s)).collect(Collectors.toList());
System.out.println(countDuplicates(Arr));
}
}
 1.3.3 Total painting Cost (Java)

package q12;
import java.util.*;
import java.util.stream.*;
public class CTJ12 {
public static float TotalPaintingCost (int M, int N, List<Float> SurfaceAreaOfWalls) {
float ans = 0;
for(int i =0;i<M+N;i++){
if(i<M){
ans += SurfaceAreaOfWalls.get(i)*20;
}
else{
ans += SurfaceAreaOfWalls.get(i)*15;
}
}
return ans;
}
public static void main(String[] args) {
int M = Integer.parseInt(args[0]);
int N = Integer.parseInt(args[1]);
List<Float> SurfaceAreaOfWalls = Arrays.stream(args[2].split(",")).map(s ->
Float.parseFloat(s)).collect(Collectors.toList());
System.out.println(String.format("%1.6e", TotalPaintingCost (M, N, SurfaceAreaOfWalls)));
}
}
 1.3.4 Count trips (Java)

package q29;
import java.util.*;
import java.util.stream.*;
public class CTJ29 {
public static int CountTrips(List<Float> weight) {
if(weight.size()==1) return 1;
Collections.sort(weight);
int l = 0;
int r = weight.size()-1;
int c= 0;
int sum =0;
while(l<=r){
if(weight.get(l)+weight.get(r) <=3.00){
l++;
}
r--;
c++;
}
return c;
}
public static void main(String[] args) {
List<Float> weight = Arrays.stream(args[0].split(",")).map(s ->
Float.parseFloat(s)).collect(Collectors.toList());
System.out.println(CountTrips(weight));
}
}
 1.3.5 Zero One Two (0,1,2) Sort (Java)

package q1600;
import java.util.*;
import java.util.stream.*;
public class CTJ1600 {
public static List<Short> zeroTwoSort(List<Short> Arr) {
short arr[] = new short[3];
boolean check = false;
for(short n: Arr){
if(n>2 || n<0){
check = true;
break;
}
arr[n]++;
}
if(check){
List<Short> i = new ArrayList<>();
short k = -1;
i.add(k);
return i;
}

List<Short> res = new ArrayList<>();

for(short i = 0;i<3;i++){
for(short j = 0;j<arr[i];j++){
res.add(i);
}
}
return res;
}
public static void main(String[] args) {
List<Short> Arr = Arrays.stream(args[0].split(",")).map(s -> Short.parseShort(s)).collect(Collectors.toList());
System.out.println(zeroTwoSort(Arr).stream().map(String::valueOf).collect(Collectors.joining(",")));
}
}
 1.3.7 Absolute difference (Python)
import sys
import math
from functools import reduce
def gcd(a, b):
while b:
a, b = b, a % b
return a
def gcd_of_list(numbers):
return reduce(gcd, numbers)
def distinct_elements_count(numbers):
if not numbers:
return 0
array_gcd = gcd_of_list(numbers)
max_value = max(numbers)
return (max_value // array_gcd)
if __name__ == "__main__":
n = int(sys.stdin.readline().strip())
numbers = list(map(int, sys.stdin.readline().strip().split()))
print(distinct_elements_count(numbers))
 1.3.8 Queries on Array (Java)

package q14112;
class CTJ14112{
public static void main(String arg[]){
java.util.Scanner sc = new java.util.Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
long diff [] = new long [n+1];
for(int i=0;i<m;i++){
int a = sc.nextInt()-1;
int b = sc.nextInt();
int v = sc.nextInt();
diff[a] +=v;
if(b<n){
diff [b]-=v;
}
}
long maxVal = Long.MIN_VALUE;
long currVal = 0;
for(int i=0;i<n;i++){
currVal += diff[i];
maxVal = Math.max(maxVal, currVal);
}
System.out.println(maxVal);
}
}
 1.3.9 Reverse the Array (Java)

package q14129;
import java.util.*;
class CTJ14129{
public static void main(String arg []) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int a[] = new int [n];
for(int i=0;i<n;i++) {
a[i] = sc.nextInt();
}
int l = 0;
int r = n-1;
while(l<=r) {
int temp = a[l];
a[l] = a[r];
a[r] = temp;
l++;
r--;
}
for(int i:a) {
System.out.print(i+" ");
}
return;
}
}
 1.3.10 Xoring (Java)

package q13212;
class CTJ13212{
public static void main(String arg []){
java.util.Scanner sc = new java.util.Scanner(System.in);
int n = sc.nextInt();
int a[] = new int[n];
for(int i=0;i<n;i++) {
a[i] = sc.nextInt();
}
int totalSubset = 1<<n;
int max= 0;
for(int i = 0; i<totalSubset; i++) {
int temp = 1;
for(int j = 0; j<n;j++) {
if((i&(1<<j))!=0) {
temp^= a[j];
max = Math.max(temp,max);
}
}
}
System.out.println(max);
}
}
 1.4.1 Mth Smallest (Python)

import sys
Arr = [int(x) for x in sys.argv[1].split(',')]
M = int(sys.argv[2])
Arr.sort()
return Arr[M-1]
print(MthSmallestElement(Arr, M))
 1.4.2 Search the element (Java)

package q3342;
import java.util.*;
import java.util.stream.*;
public class CTJ3342 {
public static List<Integer> searchTheElement(List<Integer> Arr, List<Integer> e) {
List<Integer> result = new ArrayList<>();
for (int element : e) {
int index = binarySearch(Arr, element);
result.add(index);
}
return result;
}
private static int binarySearch(List<Integer> Arr, int target) {
int left = 0, right = Arr.size() - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (Arr.get(mid) == target) {
return mid;
} else if (Arr.get(mid) < target) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return -1;
}
public static void main(String[] args) {
List<Integer> Arr = Arrays.stream(args[0].split(",")).map(s -> Integer.parseInt(s)).collect(Collectors.toList());
List<Integer> e = Arrays.stream(args[1].split(",")).map(s -> Integer.parseInt(s)).collect(Collectors.toList());
System.out.println(searchTheElement(Arr,
e).stream().map(String::valueOf).collect(Collectors.joining(",")));
}
}
 1.4.3 Shift 0’s (Java)

package q1076;
import java.util.*;
import java.util.stream.*;
public class CTJ1076 {
public static List<Short> ShiftZeros(List<Integer> A) {
int zerocount = 0;
for (int num : A) {
if (num == 0) {
zerocount++;
}
}
List<Short> result = new ArrayList<>();

for (int i = 0; i < zerocount; i++) {

result.add((short) 0);
}
for (int i = zerocount; i < A.size(); i++) {
result.add((short) 1);
}
return result;
}
public static void main(String[] args) {
List<Integer> A = Arrays.stream(args[0].split(",")).map(s -> Integer.parseInt(s)).collect(Collectors.toList());
System.out.println(ShiftZeros(A).stream().map(String::valueOf).collect(Collectors.joining(",")));
}
}
 1.4.4 Highest Frequency (Java)

package q3666;
import java.util.LinkedHashMap;
import java.util.Map;
public class CTJ3666 {
public static String highestFrequency (String str) {
Map<Character, Integer> freq = new LinkedHashMap<>();
for (char ch : str.toCharArray()) {
freq.put(ch, freq.getOrDefault(ch, 0) + 1);
}
int maxFreq = 0;
for (int count : freq.values()) {
maxFreq = Math.max(maxFreq, count);
}
StringBuilder result = new StringBuilder();
for (Map.Entry<Character, Integer> entry : freq.entrySet()) {
if (entry.getValue() == maxFreq) {
result.append(entry.getKey());
}
}
return result.toString();
}
public static void main(String[] args) {
String str = args[0];
System.out.println( highestFrequency (str));
}
}
 1.4.8 Perfect squares (Java)

package q9783;
public class CTJ9783 {
public static int findTheIndices(int n) {
return (int) Math.sqrt(n - 1);
}
public static void main(String[] args) {
int n = Integer.parseInt(args[0]);
System.out.println(findTheIndices(n));
}
}
 1.4.9 Majority Find (Python)

import sys
Arr = [int(x) for x in sys.argv[1].split(',')]
def majorityFind(Arr):
N = len(Arr)
majority_count = (N + 1) // 2
frequency = {}
for num in Arr:
if num in frequency:
frequency[num] += 1
else:
frequency[num] = 1
for num, count in frequency.items():
if count >= majority_count:
return num
return -1
print(majorityFind(Arr))
 1.4.10 Domino’s Pizza (Python)

import sys
m = int(sys.argv[1])
ranks = [int(x) for x in sys.argv[2].split(',')]
def minimumTimeToCompleteTheOrder(m, ranks):
def can_make_pizzas_in_time(t):
total_pizzas = 0
for r in ranks:
k=0
time_spent = 0
while True:
k += 1
time_spent += k * r
if time_spent > t:
break
total_pizzas += 1
if total_pizzas >= m:
return True
return total_pizzas >= m
left, right = 0, max(ranks) * (m * (m + 1)) // 2
while left < right:
mid = (left + right) // 2
if can_make_pizzas_in_time(mid):
right = mid
else:
left = mid + 1
return left
print(minimumTimeToCompleteTheOrder(m, ranks))
 1.4.11 Binary Search (Java)

package q29601;
import java.util.*;
import java.util.stream.*;
public class CTJ29601 {
public static int binSearch(List<Integer> arr, int ele) {
int left = 0;
int right = arr.size() - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (arr.get(mid) == ele) {
return mid;
} else if (arr.get(mid) < ele) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return-1;
}
public static void main(String[] args) {
List<Integer> arr = Arrays.stream(args[0].split(",")).map(s -> Integer.parseInt(s)).collect(Collectors.toList());
int ele = Integer.parseInt(args[1]);
System.out.println(binSearch(arr, ele));
}
}
 1.5.1 Self Loop (Python)

class Node:
def __init__(self, data):
self.data = data
self.next = None
def create_linked_list(sizes, loop_position):
head = Node(sizes[0])
current = head
nodes_list = [head]
for size in sizes[1:]:
new_node = Node(size)
current.next = new_node
current = new_node
nodes_list.append(new_node)
if loop_position > 0 and loop_position <= len(nodes_list):
current.next = nodes_list[loop_position - 1]
elif loop_position == 0:
current.next = None
return head
def has_loop(head):
slow = head
fast = head
while fast and fast.next:
slow = slow.next
fast = fast.next.next
if slow == fast:
return True
return False
def check_loop_in_memory_allocation(N, sizes, loop_position):
if loop_position < 0 or loop_position > N:
return "Invalid"
head = create_linked_list(sizes, loop_position)
if has_loop(head):
return True
else:
return False
N = int(input())
sizes = list(map(int, input().split()))
loop_position = int(input())
result = check_loop_in_memory_allocation(N, sizes, loop_position)
print(result)
 1.5.2 Merging (Python)

class Node:
def __init__(self, data):
self.data = data
self.next = None
def create_linked_list(values):
if not values:
return None
head = Node(values[0])
current = head
for value in values[1:]:
current.next = Node(value)
current = current.next
return head
def merge_sorted_lists(headA, headB):
dummy = Node(0)
tail = dummy
while headA and headB:
if headA.data < headB.data:
tail.next = headA
headA = headA.next
else:
tail.next = headB
headB = headB.next
tail = tail.next
if headA:
tail.next = headA
elif headB:
tail.next = headB
return dummy.next
def linked_list_to_list(head):
result = []
while head:
result.append(head.data)
head = head.next
return result
def main():
N1, N2 = map(int, input().split())
valuesA = list(map(int, input().split())) if N1 > 0 else []
valuesB = list(map(int, input().split())) if N2 > 0 else []
headA = create_linked_list(valuesA)
headB = create_linked_list(valuesB)
merged_head = merge_sorted_lists(headA, headB)
merged_list = linked_list_to_list(merged_head)
print(" ".join(map(str, merged_list)),"")
main()
 1.6.1 Reverse the Queue (Python)

class Queue:
def __init__(self, size):
self.size = size
self.queue = []
self.front = -1
self.rear = -1
def enqueue(self, element):
if len(self.queue) < self.size:
if self.front == -1:
self.front = 0
self.rear += 1
self.queue.append(element)
else:
print("Queue is full")
def reverse(self):
i, j = self.front, self.rear
while i < j:
self.queue[i], self.queue[j] = self.queue[j], self.queue[i]
i += 1
j -= 1
def display(self):
return self.queue[self.front:self.rear + 1]
size = int(input())
elements = list(map(int, input().split()))
queue = Queue(size)
for element in elements:
queue.enqueue(element)
print(" ".join(map(str, queue.display())),"")
queue.reverse()
print(" ".join(map(str, queue.display())),"")
 1.6.2 Dequeue (Python)

def max_sum_k_corners(arr, N, K):

max_sum = 0
for i in range(K + 1):
if i <= N:
sum_start = sum(arr[:i])
sum_end = sum(arr[N - (K - i):])
max_sum = max(max_sum, sum_start + sum_end)
return max_sum
input_data = input().strip()
N, K = map(int, input_data.split())
arr = list(map(int, input().strip().split()))
result = max_sum_k_corners(arr, N, K)
print(result)
 1.6.3 Longest Valid Parentheses (Python)

def longest_valid_parentheses(A):
stack = []
max_length = 0
stack.append(-1)
for i in range(len(A)):
if A[i] == '(':
stack.append(i)
else:
if stack:
stack.pop()
if not stack:
stack.append(i)
else:
max_length = max(max_length, i - stack[-1])
return max_length
A = input().strip()
result = longest_valid_parentheses(A)
print(result)
 1.6.3 Longest Valid Parentheses (Python)

def longest_valid_parentheses(A):
stack = []
max_length = 0
stack.append(-1)
for i in range(len(A)):
if A[i] == '(':
stack.append(i)
else:
if stack:
stack.pop()
if not stack:
stack.append(i)
else:
max_length = max(max_length, i - stack[-1])
return max_length
A = input().strip()
result = longest_valid_parentheses(A)
print(result)
YOU’RE
WELCOME
Please Subscribe My YouTube Channel

Direct YT link: “@IY_YT”

AppOpener link: “@IY_YT”