Repository: Aditya-Mishra19/TCS-NQT-2024-Coding-Solutions Branch: main Commit: a3795782cfee Files: 99 Total size: 83.1 KB Directory structure: gitextract_1jnw95xb/ ├── .vscode/ │ └── settings.json ├── 06 MAY SHIFT 1/ │ ├── MAJORITY ELEMENT/ │ │ ├── code.cpp │ │ ├── code.java │ │ └── code.py │ └── SORT NUMBERS/ │ ├── code.cpp │ ├── code.java │ └── code.py ├── 06 MAY SHIFT 2/ │ ├── Missing number/ │ │ ├── code.cpp │ │ ├── code.java │ │ └── code.py │ └── Prime number/ │ ├── code.cpp │ ├── code.java │ └── code.py ├── 08 MAY SHIFT 2/ │ ├── SequenceQuestion/ │ │ ├── code.cpp │ │ ├── code.java │ │ └── code.py │ └── fiveThree Program/ │ ├── code.cpp │ ├── code.java │ └── code.py ├── 09 MAY 2024 SHIFT - 1/ │ ├── Armstrong Number/ │ │ ├── code.cpp │ │ ├── code.java │ │ └── code.py │ └── print top K students/ │ ├── code.cpp │ ├── code.java │ └── code.py ├── 14 May Shift 1/ │ ├── Maximum Sum of Subarray/ │ │ ├── codeCpp.cpp │ │ ├── codeJava.java │ │ └── codePy.py │ └── Sum of unique elements/ │ ├── codeCpp.cpp │ ├── codeJava.java │ └── codePy.py ├── 14 May Shift 2/ │ ├── Cost of shipping/ │ │ ├── codeCpp.cpp │ │ ├── codeJava.java │ │ └── codePy.py │ └── Number of Subarray of sum of K/ │ ├── codeCpp.cpp │ ├── codeJava.java │ └── codePy.py ├── 26 APRIL 2024 SHIFT - 1/ │ ├── Find subarray equals to target/ │ │ ├── codeCpp.cpp │ │ ├── codeJava.java │ │ └── subArraySum.py │ └── Unique Paths/ │ ├── codeCpp.cpp │ ├── codeJava.java │ └── uniquePaths.py ├── 26 APRIL 2024 SHIFT - 2/ │ ├── Cube sum/ │ │ ├── code.cpp │ │ ├── code.java │ │ └── cubeSum.py │ └── Find Most sell item-avg-totalsell/ │ ├── code.cpp │ ├── code.java │ └── code.py ├── 29 APRIL 2024 Shift - 1/ │ ├── Maximum element of subarray/ │ │ ├── code.cpp │ │ ├── code.java │ │ ├── code.py │ │ └── tempCodeRunnerFile.py │ └── Multiplication table/ │ ├── code.cpp │ ├── code.java │ └── code.py ├── 29 APRIL SHIFT 2/ │ ├── Bit OR Sum/ │ │ ├── code.cpp │ │ ├── code.java │ │ └── code.py │ └── FIbonacci/ │ ├── code.cpp │ ├── code.java │ └── code.py ├── 3 May SHIFT 2/ │ ├── Maximum Efficiency/ │ │ ├── code.cpp │ │ ├── code.java │ │ └── code.py │ └── Pairs of shoes/ │ ├── code.cpp │ ├── code.java │ └── code.py ├── 3 May Shift 1/ │ ├── Number Divisible/ │ │ ├── code.cpp │ │ ├── code.java │ │ └── code.py │ └── maximum difference between smallest and largest/ │ ├── code.cpp │ ├── code.java │ └── code.py ├── 30 APRIL SHIFT 1/ │ ├── GRADE Problem/ │ │ ├── code.cpp │ │ ├── code.java │ │ ├── code.py │ │ └── tempCodeRunnerFile.py │ └── MAJORITY ELEMENT/ │ ├── code.cpp │ ├── code.java │ └── code.py ├── 8 MAY SHIFT 1/ │ ├── Nearest divisible/ │ │ ├── code.cpp │ │ ├── code.java │ │ └── code.py │ └── Password creations/ │ ├── code.cpp │ ├── code.java │ └── code.py ├── 9 May 2024 Shift - 2/ │ ├── Print All combinations/ │ │ ├── code.cpp │ │ ├── code.java │ │ └── code.py │ └── Sort the given array asc and desc/ │ ├── code.cpp │ ├── code.java │ └── code.py └── TCS NQT ALL INPUT scenario/ ├── Arrays 1D/ │ ├── code.cpp │ ├── code.java │ └── code.py └── Strings/ ├── code.cpp ├── code.java └── code.py ================================================ FILE CONTENTS ================================================ ================================================ FILE: .vscode/settings.json ================================================ { "files.associations": { "ostream": "cpp", "array": "cpp", "atomic": "cpp", "*.tcc": "cpp", "bitset": "cpp", "cctype": "cpp", "cfenv": "cpp", "charconv": "cpp", "chrono": "cpp", "cinttypes": "cpp", "clocale": "cpp", "cmath": "cpp", "codecvt": "cpp", "complex": "cpp", "condition_variable": "cpp", "csetjmp": "cpp", "csignal": "cpp", "cstdarg": "cpp", "cstddef": "cpp", "cstdint": "cpp", "cstdio": "cpp", "cstdlib": "cpp", "cstring": "cpp", "ctime": "cpp", "cuchar": "cpp", "cwchar": "cpp", "cwctype": "cpp", "deque": "cpp", "forward_list": "cpp", "list": "cpp", "unordered_map": "cpp", "unordered_set": "cpp", "vector": "cpp", "exception": "cpp", "algorithm": "cpp", "functional": "cpp", "iterator": "cpp", "map": "cpp", "memory": "cpp", "memory_resource": "cpp", "numeric": "cpp", "optional": "cpp", "random": "cpp", "ratio": "cpp", "regex": "cpp", "set": "cpp", "string": "cpp", "string_view": "cpp", "system_error": "cpp", "tuple": "cpp", "type_traits": "cpp", "utility": "cpp", "fstream": "cpp", "future": "cpp", "initializer_list": "cpp", "iomanip": "cpp", "iosfwd": "cpp", "iostream": "cpp", "istream": "cpp", "limits": "cpp", "mutex": "cpp", "new": "cpp", "scoped_allocator": "cpp", "shared_mutex": "cpp", "sstream": "cpp", "stdexcept": "cpp", "streambuf": "cpp", "thread": "cpp", "typeindex": "cpp", "typeinfo": "cpp", "valarray": "cpp" } } ================================================ FILE: 06 MAY SHIFT 1/MAJORITY ELEMENT/code.cpp ================================================ #include #include #include #include using namespace std; void findMajorityElement(vector& arr, int N) { unordered_map freq; for (string& n : arr) { if (freq.find(n) != freq.end()) { freq[n]++; } else { freq[n] = 1; } } for (auto& it : freq) { if (it.second >= N / 3) { cout << it.first << " "; } } } void findMajorityElementInt(vector& arr, int N) { unordered_map freq; for (int& num : arr) { if (freq.find(num) != freq.end()) { freq[num]++; } else { freq[num] = 1; } } for (auto& it : freq) { if (it.second >= N / 3) { cout << it.first << " "; } } } void input_array_format() { cout << "\nEnter elements in format [e1,e2,e3]: "; string input; getline(cin, input); stringstream ss(input); string token; vector arr; while (getline(ss, token, ',')) { arr.push_back(token); } findMajorityElement(arr, arr.size()); } void input_space_separated() { cout << "\nCase 2: Enter space-separated elements: "; string input; getline(cin, input); stringstream ss(input); int num; vector arr; while (ss >> num) { arr.push_back(num); } findMajorityElementInt(arr, arr.size()); } int main() { input_array_format(); input_space_separated(); return 0; } ================================================ FILE: 06 MAY SHIFT 1/MAJORITY ELEMENT/code.java ================================================ import java.util.HashMap; import java.util.Scanner; public class MajorityElement { public static void findMajorityElement(String[] arr, int N) { HashMap freq = new HashMap<>(); for (String n : arr) { if (freq.containsKey(n)) { freq.put(n, freq.get(n) + 1); } else { freq.put(n, 1); } } for (String key : freq.keySet()) { if (freq.get(key) >= N / 3) { System.out.print(key + " "); } } } public static void findMajorityElementInt(int[] arr, int N) { HashMap freq = new HashMap<>(); for (int num : arr) { if (freq.containsKey(num)) { freq.put(num, freq.get(num) + 1); } else { freq.put(num, 1); } } for (int key : freq.keySet()) { if (freq.get(key) >= N / 3) { System.out.print(key + " "); } } } public static void inputArrayFormat() { Scanner scanner = new Scanner(System.in); System.out.print("\nEnter elements in format [e1,e2,e3]: "); String input = scanner.nextLine().replaceAll("[\\[\\]]", ""); String[] arr = input.split(","); findMajorityElement(arr, arr.length); } public static void inputSpaceSeparated() { Scanner scanner = new Scanner(System.in); System.out.print("\nCase 2: Enter space-separated elements: "); String input = scanner.nextLine(); String[] strArr = input.split("\\s+"); int[] arr = new int[strArr.length]; for (int i = 0; i < strArr.length; i++) { arr[i] = Integer.parseInt(strArr[i]); } findMajorityElementInt(arr, arr.length); } public static void main(String[] args) { inputArrayFormat(); inputSpaceSeparated(); } } ================================================ FILE: 06 MAY SHIFT 1/MAJORITY ELEMENT/code.py ================================================ def findMajorityElement(arr, N): freq = {} for n in arr: num = int(n) if num in freq: freq[num] += 1 else: freq[num] = 1 for key, val in freq.items(): if val >= N // 3: print(key, end=" ") def findMajorityElementInt(arr, N): freq = {} for num in arr: if num in freq: freq[num] += 1 else: freq[num] = 1 for key, val in freq.items(): if val >= N // 3: print(key, end=" ") def input_array_format(): print("\n[e1,e2,e3]") arr = list(map(str, input().strip("[]").split(','))) findMajorityElement(arr, len(arr)) def input_space_separated(): print("\nCase 2: space separated") arr = list(map(int, input().split())) findMajorityElementInt(arr, len(arr)) input_array_format() input_space_separated() ================================================ FILE: 06 MAY SHIFT 1/SORT NUMBERS/code.cpp ================================================ #include #include using namespace std; vector sortBySwap(vector& arr, int N) { int left = 0; int mid = 0; int right = N - 1; while (mid <= right) { if (arr[mid] == '3') { swap(arr[left], arr[mid]); left++; mid++; } else if (arr[mid] == '6') { mid++; } else if (arr[mid] == '7') { swap(arr[right], arr[mid]); right--; } } return arr; } int main() { cout << "\nEnter space-separated elements: "; vector arr; char c; while (cin >> c) { arr.push_back(c); } arr = sortBySwap(arr, arr.size()); for (char c : arr) { cout << c << " "; } return 0; } ================================================ FILE: 06 MAY SHIFT 1/SORT NUMBERS/code.java ================================================ import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class SortBySwap { public static List sortBySwap(char[] arr, int N) { int left = 0; int mid = 0; int right = N - 1; while (mid <= right) { if (arr[mid] == '3') { char temp = arr[left]; arr[left] = arr[mid]; arr[mid] = temp; left++; mid++; } else if (arr[mid] == '6') { mid++; } else if (arr[mid] == '7') { char temp = arr[right]; arr[right] = arr[mid]; arr[mid] = temp; right--; } } List result = new ArrayList<>(); for (char c : arr) { result.add(c); } return result; } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.print("\nEnter space-separated elements: "); String input = scanner.nextLine(); char[] arr = input.toCharArray(); List sortedArr = sortBySwap(arr, arr.length); for (char c : sortedArr) { System.out.print(c + " "); } } } ================================================ FILE: 06 MAY SHIFT 1/SORT NUMBERS/code.py ================================================ def sortBySwap(arr, N): left = 0 mid = 0 right = N - 1 while mid <= right: if arr[mid] == '3': arr[left], arr[mid] = arr[mid], arr[left] left += 1 mid += 1 elif arr[mid] == '6': mid += 1 elif arr[mid] == '7': arr[right], arr[mid] = arr[mid], arr[right] right -= 1 return arr print("\nSpace separated") arr = list(map(str, input().split())) print(*sortBySwap(arr, len(arr))) ================================================ FILE: 06 MAY SHIFT 2/Missing number/code.cpp ================================================ #include #include #include using namespace std; int getMissingNumIntFormat(vector& arr, int size) { int totalSum = 0; int n = size + 1; for (int num : arr) { totalSum += num; } int actualSum = (n * (n + 1)) / 2; return actualSum - totalSum; } int getMissingNumStrFormat(vector& arr, int size) { int totalSum = 0; int n = size + 1; for (auto str : arr) { int num = stoi(str); // Convert string to integer using stoi totalSum += num; } int actualSum = (n * (n + 1)) / 2; return actualSum - totalSum; } void input_space_separated() { cout << "\nEnter space-separated elements: "; int N; cin >> N; cin.ignore(); string input; getline(cin, input); stringstream ss(input); int num; vector arr; while (ss >> num) { arr.push_back(num); } cout << "Missing number: " << getMissingNumIntFormat(arr, N) << endl; } void input_array_format() { cout << "\nEnter elements in format e1,e2,e3: "; string input; int N; cin >> N; cin.ignore(); getline(cin, input); stringstream ss(input); string token; vector arr; while (getline(ss, token, ',')) { arr.push_back(token); } cout << "Missing number: " << getMissingNumStrFormat(arr, N) << endl; } int main() { input_space_separated(); input_array_format(); return 0; } ================================================ FILE: 06 MAY SHIFT 2/Missing number/code.java ================================================ import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class Main { public static int getMissingNumIntFormat(List arr, int size) { int totalSum = 0; int n = size + 1; for (int num : arr) { totalSum += num; } int actualSum = (n * (n + 1)) / 2; return actualSum - totalSum; } public static int getMissingNumStrFormat(List arr, int size) { int totalSum = 0; int n = size + 1; for (String str : arr) { int num = Integer.parseInt(str); totalSum += num; } int actualSum = (n * (n + 1)) / 2; return actualSum - totalSum; } public static void input_space_separated() { Scanner scanner = new Scanner(System.in); System.out.print("\nEnter space-separated elements: "); int N = scanner.nextInt(); scanner.nextLine(); // Consume the newline character left in the input buffer String input = scanner.nextLine(); Scanner ss = new Scanner(input); List arr = new ArrayList<>(); while (ss.hasNextInt()) { arr.add(ss.nextInt()); } System.out.println("Missing number: " + getMissingNumIntFormat(arr, N)); } public static void input_array_format() { Scanner scanner = new Scanner(System.in); System.out.print("\nEnter elements in format e1,e2,e3: "); int N = scanner.nextInt(); scanner.nextLine(); String input = scanner.nextLine(); String[] tokens = input.split(","); List arr = new ArrayList<>(); for (String token : tokens) { arr.add(token); } System.out.println("Missing number: " + getMissingNumStrFormat(arr, N)); } public static void main(String[] args) { input_space_separated(); input_array_format(); } } ================================================ FILE: 06 MAY SHIFT 2/Missing number/code.py ================================================ def getMissingNumIntFormat(arr, size): totalSum = 0 n = size + 1 for num in arr: totalSum += num actualSum = int((n * (n + 1) )/ 2) return actualSum - totalSum def intFormat(): N = int(input()) arr = list(map(int, input().split())) print(getMissingNumIntFormat(arr, N)) def getMissingNumStrFormat(arr, size): totalSum = 0 for num_str in arr: num = int(num_str) totalSum += num n = size + 1 actualSum = int((n * (n + 1)) / 2) return actualSum - totalSum def strFormat(): N = int(input()) arr = list(map(str, input().split(','))) print(getMissingNumStrFormat(arr, N)) intFormat() strFormat() ================================================ FILE: 06 MAY SHIFT 2/Prime number/code.cpp ================================================ #include using namespace std; bool isPrime(int number) { if (number <= 1) { // 1 and below are not prime return false; } if (number <= 3) { // 2 and 3 are prime return true; } if (number % 2 == 0 || number % 3 == 0) { // Eliminate multiples of 2 and 3 return false; } // Check divisibility by numbers of the form 6k ± 1, up to sqrt(n) int i = 5; while (i * i <= number) { if (number % i == 0 || number % (i + 2) == 0) { return false; } i += 6; } return true; } bool calculateSum(int n) { int sum = 0; while (n > 0) { int num = n % 10; sum += num; n /= 10; } return isPrime(sum); } int main() { int n, m; cin >> n >> m; for (int i = n; i <= m; i++) { if (isPrime(i) && calculateSum(i)) { cout << i << endl; } } return 0; } ================================================ FILE: 06 MAY SHIFT 2/Prime number/code.java ================================================ import java.util.Scanner; public class Main { public static boolean isPrime(int number) { if (number <= 1) { // 1 and below are not prime return false; } if (number <= 3) { // 2 and 3 are prime return true; } if (number % 2 == 0 || number % 3 == 0) { // Eliminate multiples of 2 and 3 return false; } // Check divisibility by numbers of the form 6k ± 1, up to sqrt(n) int i = 5; while (i * i <= number) { if (number % i == 0 || number % (i + 2) == 0) { return false; } i += 6; } return true; } public static boolean calculateSum(int n) { int sum = 0; while (n > 0) { int num = n % 10; sum += num; n /= 10; } return isPrime(sum); } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); int m = scanner.nextInt(); for (int i = n; i <= m; i++) {S if (isPrime(i) && calculateSum(i)) { System.out.println(i); } } } } ================================================ FILE: 06 MAY SHIFT 2/Prime number/code.py ================================================ def isPrime(number): if number <= 1: return False if number <= 3: return True if number % 2 == 0 or number % 3 == 0: return False i = 5 while i * i <= number: if number % i == 0 or number % (i + 2) == 0: return False i += 6 return True def calculateSum(n): sum = 0 while n > 0: num = n % 10 sum += num n /= 10 if isPrime(sum): return True else: return False n, m = map(int, input().split()) for i in range(n, m+1): if isPrime(i) and calculateSum(i): print(i) ================================================ FILE: 08 MAY SHIFT 2/SequenceQuestion/code.cpp ================================================ #include using namespace std; bool is_positive_integer(const string& str) { for (char c : str) { if (!isdigit(c)) { return false; } } return !str.empty() && stoi(str) > 0; } vector generate_sequence(int n) { vector sequence; sequence.push_back(n); while (n != 1) { if (n % 2 == 0) n /= 2; else n = 3 * n + 1; sequence.push_back(n); } return sequence; } pair max_length_of_sequence_and_k(int n) { int maxLen = 0, kValue = 0; for (int i = 1; i <= n; ++i) { vector sequence = generate_sequence(i); int currLen = sequence.size(); if (currLen > maxLen) { maxLen = currLen; kValue = i; } } return make_pair(maxLen, kValue); } pair max_sequence_value_and_k(int n) { int max_k = 0, max_val = 0; for (int k = 1; k <= n; ++k) { vector sequence = generate_sequence(k); int max_val_k = *max_element(sequence.begin(), sequence.end()); if (max_val_k > max_val) { max_val = max_val_k; max_k = k; } } return make_pair(max_val, max_k); } int main() { string n_str; cin >> n_str; if (is_positive_integer(n_str)) { int n = stoi(n_str); vector sequence = generate_sequence(n); auto max_val_k = max_sequence_value_and_k(n); auto maxLen_kValue = max_length_of_sequence_and_k(n); cout << "Sequence: ["; for (size_t i = 0; i < sequence.size(); ++i) { cout << sequence[i]; if (i != sequence.size() - 1) { cout << ", "; } } cout << "]" << endl; cout << maxLen_kValue.first << " " << maxLen_kValue.second << endl; cout << max_val_k.first << " " << max_val_k.second << endl; } else { cout << "Error!" << endl; } return 0; } ================================================ FILE: 08 MAY SHIFT 2/SequenceQuestion/code.java ================================================ import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class Main { public static boolean isPositiveInteger(String str) { for (char c : str.toCharArray()) { if (!Character.isDigit(c)) { return false; } } return !str.isEmpty() && Integer.parseInt(str) > 0; } public static List generateSequence(int n) { List sequence = new ArrayList<>(); sequence.add(n); while (n != 1) { if (n % 2 == 0) n /= 2; else n = 3 * n + 1; sequence.add(n); } return sequence; } public static int[] maxLengthOfSequenceAndK(int n) { int maxLen = 0, kValue = 0; for (int i = 1; i <= n; i++) { List sequence = generateSequence(i); int currLen = sequence.size(); if (currLen > maxLen) { maxLen = currLen; kValue = i; } } return new int[]{maxLen, kValue}; } public static int[] maxSequenceValueAndK(int n) { int max_k = 0, max_val = 0; for (int k = 1; k <= n; k++) { List sequence = generateSequence(k); int max_val_k = sequence.stream().mapToInt(Integer::intValue).max().orElse(Integer.MIN_VALUE); if (max_val_k > max_val) { max_val = max_val_k; max_k = k; } } return new int[]{max_val, max_k}; } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String n_str = scanner.nextLine(); scanner.close(); if (isPositiveInteger(n_str)) { int n = Integer.parseInt(n_str); List sequence = generateSequence(n); int[] max_val_k = maxSequenceValueAndK(n); int[] maxLen_kValue = maxLengthOfSequenceAndK(n); System.out.print("Sequence: ["); for (int i = 0; i < sequence.size(); i++) { System.out.print(sequence.get(i)); if (i != sequence.size() - 1) { System.out.print(", "); } } System.out.println("]"); System.out.println(maxLen_kValue[0] + " " + maxLen_kValue[1]); System.out.println(max_val_k[0] + " " + max_val_k[1]); } else { System.out.println("Error!"); } } } ================================================ FILE: 08 MAY SHIFT 2/SequenceQuestion/code.py ================================================ def generate_sequence(n): sequence = [n] while n != 1: if n % 2 == 0: n //= 2 else: n = 3 * n + 1 sequence.append(n) return sequence def max_length_of_sequence_and_k(n): maxLen = 0 kValue = 0 for i in range(1, n+1): sequence = generate_sequence(i) currLen = len(sequence) if currLen > maxLen: maxLen = currLen kValue = i return maxLen, kValue def max_sequence_value_and_k(n): max_k = 0 max_val = 0 for k in range(1, n + 1): sequence = generate_sequence(k) max_val_k = max(sequence) if max_val_k > max_val: max_val = max_val_k max_k = k return max_val, max_k num = input() if num.isdigit() and int(num) > 0: n = int(num) sequence = generate_sequence(n) max_val, max_k = max_sequence_value_and_k(n) max_length_of_sequence, k_value = max_length_of_sequence_and_k(n) print(sequence) print(max_length_of_sequence, k_value) print(max_val, max_k) else: print("Error!") ================================================ FILE: 08 MAY SHIFT 2/fiveThree Program/code.cpp ================================================ #include using namespace std; void solve(vector& arr) { stringstream result; for (auto n : arr) { int num = stoi(n); if (num % 3 == 0 && num % 5 == 0) { cout << "ThreeFive " << " "; } else if (num % 5 == 0) { cout << "Five "<< " "; } else if (num % 3 == 0) { cout << "Three "<< " "; } else { cout << num << " "; } } } void input_array_format1() { int n; cin >> n; cin.ignore(); string input; getline(cin, input); input.erase(remove(input.begin(), input.end(), '['), input.end()); // Remove '[' input.erase(remove(input.begin(), input.end(), ']'), input.end()); // Remove ']' stringstream ss(input); vector arr1; string element; while (ss >> element) { // Read elements separated by space arr1.push_back(element); } solve(arr1); // Print the result } int main() { input_array_format1(); return 0; } ================================================ FILE: 08 MAY SHIFT 2/fiveThree Program/code.java ================================================ import java.util.ArrayList; import java.util.List; import java.util.Scanner; import java.util.StringJoiner; public class Main { public static String solve(List arr) { StringBuilder result = new StringBuilder(); for (String n : arr) { int num = Integer.parseInt(n); if (num % 3 == 0 && num % 5 == 0) { result.append("ThreeFive "); } else if (num % 5 == 0) { result.append("Five "); } else if (num % 3 == 0) { result.append("Three "); } else { result.append(num).append(" "); } } return result.toString(); } public static void inputArrayFormat1() { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); scanner.nextLine(); // Consume the newline character String input = scanner.nextLine(); input = input.replaceAll("[\\[\\]]", ""); // Remove '[' and ']' String[] elements = input.split("\\s+"); List arr = new ArrayList<>(); for (String element : elements) { arr.add(element); } System.out.println(solve(arr)); // Print the result scanner.close(); } public static void main(String[] args) { inputArrayFormat1(); } } ================================================ FILE: 08 MAY SHIFT 2/fiveThree Program/code.py ================================================ def solve(arr, N): result = [] for num in arr: if num % 3 == 0 and num % 5 == 0: print("ThreeFive", end = " ") elif num % 5 == 0: print("Five", end = " ") elif num % 3 == 0: print("Three", end = " ") else: print(num, end = " ") def input_array_format1(): N = int(input()) arr = list(map(int, input().strip('[]').split())) solve(arr,N) input_array_format1() ================================================ FILE: 09 MAY 2024 SHIFT - 1/Armstrong Number/code.cpp ================================================ #include #include #include #include using namespace std; bool isArmStrongNumber(int n, int k) { int sum = 0; int originalNum = n; while (originalNum > 0) { int digit = originalNum % 10; sum += pow(digit, k); originalNum /= 10; } return sum == n; } int main() { string input; cout << "Enter numbers separated by commas: "; getline(cin, input); vector arr; size_t pos = 0; while ((pos = input.find(',')) != string::npos) { arr.push_back(input.substr(0, pos)); input.erase(0, pos + 1); } arr.push_back(input); int flag = 0; for (string num_str : arr) { int num = stoi(num_str); int n = num_str.length(); if (isArmStrongNumber(num, n)) { cout << num << " "; flag = 1; } } if (flag == 0) { cout << "No Armstrong numbers present"; } return 0; } ================================================ FILE: 09 MAY 2024 SHIFT - 1/Armstrong Number/code.java ================================================ import java.util.Scanner; import java.util.ArrayList; public class ArmstrongNumber { static boolean isArmStrongNumber(int n, int k) { int sum = 0; int originalNum = n; while (originalNum > 0) { int digit = originalNum % 10; sum += Math.pow(digit, k); originalNum /= 10; } return sum == n; } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.print("Enter numbers separated by commas: "); String input = scanner.nextLine(); String[] arr = input.split(","); ArrayList numbers = new ArrayList<>(); for (String num : arr) { numbers.add(num); } int flag = 0; for (String num_str : numbers) { int num = Integer.parseInt(num_str); int n = num_str.length(); if (isArmStrongNumber(num, n)) { System.out.print(num + " "); flag = 1; } } if (flag == 0) { System.out.print("No Armstrong numbers present"); } scanner.close(); } } ================================================ FILE: 09 MAY 2024 SHIFT - 1/Armstrong Number/code.py ================================================ def isArmStrongNumber(n, k): sum = 0 originalNum = n while originalNum > 0: digit = originalNum % 10 sum += digit ** k originalNum //= 10 if sum == n: return True return False arr = input("Enter numbers separated by commas: ").strip('[]').split(',') flag = 0 for num_str in arr: num = int(num_str) n = len(str(num)) if isArmStrongNumber(num, n): print(num, end=" ") flag = 1 if flag == 0: print("No Armstrong numbers present") ================================================ FILE: 09 MAY 2024 SHIFT - 1/print top K students/code.cpp ================================================ #include using namespace std; int main() { string s; getline(cin, s); vector l; string token; istringstream iss(s); while (iss >> token) { l.push_back(token); } int k = stoi(l[0]); int N = stoi(l[1]); vector> arr; for (int i = 2; i < l.size(); i += 2) { int marks = stoi(l[i]); string name = l[i + 1]; arr.push_back(make_pair(marks, name)); } sort(arr.begin(), arr.end(), greater>()); for (int top = 0; top < k && top < arr.size(); top++) { cout << arr[top].second << ": " << arr[top].first << endl; } return 0; } ================================================ FILE: 09 MAY 2024 SHIFT - 1/print top K students/code.java ================================================ import java.util.*; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String s = scanner.nextLine(); String[] l = s.split(" "); int k = Integer.parseInt(l[0]); int N = Integer.parseInt(l[1]); List> arr = new ArrayList<>(); for (int i = 2; i < l.length; i += 2) { int marks = Integer.parseInt(l[i]); String name = l[i + 1]; arr.add(new Pair<>(marks, name)); } Collections.sort(arr, new Comparator>() { @Override public int compare(Pair o1, Pair o2) { return Integer.compare(o2.getKey(), o1.getKey()); } }); for (int top = 0; top < k && top < arr.size(); top++) { Pair pair = arr.get(top); System.out.println(pair.getValue() + ": " + pair.getKey()); } } } ================================================ FILE: 09 MAY 2024 SHIFT - 1/print top K students/code.py ================================================ s = input() l = s.split() k, N = int(l[0]), int(l[1]) arr = [] for i in range(2, len(l), 2): marks, name = int(l[i]), l[i+1] arr.append((marks, name)) sorted_array = sorted(arr, key=lambda x: x[0], reverse=True) for top in range(k): marks, name = sorted_array[top] print("{}: {}".format(name, marks)) ================================================ FILE: 14 May Shift 1/Maximum Sum of Subarray/codeCpp.cpp ================================================ #include #include #include #include using namespace std; int main() { string input; getline(cin, input); stringstream ss(input); vector nums; int num; while (ss >> num) { nums.push_back(num); } int maxSum = nums[0]; int currentSum = 0; for (int i = 0; i < nums.size(); ++i) { currentSum += nums[i]; if (currentSum > maxSum) { maxSum = max(currentSum, maxSum); } if (currentSum < 0) { currentSum = 0; } } cout << maxSum << endl; return 0; } ================================================ FILE: 14 May Shift 1/Maximum Sum of Subarray/codeJava.java ================================================ import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String[] strNums = scanner.nextLine().split(" "); int[] nums = new int[strNums.length]; for (int i = 0; i < nums.length; i++) { nums[i] = Integer.parseInt(strNums[i]); } int maxSum = nums[0]; int currentSum = 0; for (int i = 0; i < nums.length; i++) { currentSum += nums[i]; if (currentSum > maxSum) { maxSum = Math.max(currentSum, maxSum); } if (currentSum < 0) { currentSum = 0; } } System.out.println(maxSum); } } ================================================ FILE: 14 May Shift 1/Maximum Sum of Subarray/codePy.py ================================================ nums = list(map(int, input().split())) maxSum = nums[0] currentSum = 0 for i in range(len(nums)): currentSum += nums[i] if currentSum > maxSum: maxSum = max(currentSum, maxSum) if currentSum < 0: currentSum = 0 print(maxSum) ================================================ FILE: 14 May Shift 1/Sum of unique elements/codeCpp.cpp ================================================ #include #include #include #include using namespace std; int main() { string input; getline(cin, input); stringstream ss(input); vector nums; int num; while (ss >> num) { nums.push_back(num); } unordered_map d; for (int i = 0; i < nums.size(); ++i) { if (d.find(nums[i]) == d.end()) { d[nums[i]] = 1; } else { d[nums[i]]++; } } int ans = 0; for (auto it: d) { if (it.second == 1) { ans += it.first; } } cout << ans << endl; return 0; } ================================================ FILE: 14 May Shift 1/Sum of unique elements/codeJava.java ================================================ import java.util.*; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String[] strNums = scanner.nextLine().split(" "); int[] nums = new int[strNums.length]; for (int i = 0; i < nums.length; i++) { nums[i] = Integer.parseInt(strNums[i]); } Map d = new HashMap<>(); for (int num : nums) { if (!d.containsKey(num)) { d.put(num, 1); } else { d.put(num, d.get(num) + 1); } } int ans = 0; for (int key : d.keySet()) { if (d.get(key) == 1) { ans += key; } } System.out.print(ans); } } ================================================ FILE: 14 May Shift 1/Sum of unique elements/codePy.py ================================================ nums = list(map(int, input().split())) d = {} for i in range(len(nums)): if nums[i] not in d: d[nums[i]] = 1 else: d[nums[i]] += 1 ans = 0 for i in d.keys(): if d[i] == 1: ans+=i print(ans) ================================================ FILE: 14 May Shift 2/Cost of shipping/codeCpp.cpp ================================================ #include double calculate_total_cost(int weight, int distance) { double base_money = 5.00; double cost_per_kg = 2.00; double cost_per_10_km = 0.50; double weight_cost = weight * cost_per_kg; double distance_cost = (distance / 10) * cost_per_10_km; double total_cost = base_money + weight_cost + distance_cost; return total_cost; } int main() { int weight, distance; std::cin >> weight; std::cin >> distance; double total_cost = calculate_total_cost(weight, distance); char output[50]; sprintf(output, "$%.2f", total_cost); std::cout << output << std::endl; return 0; } ================================================ FILE: 14 May Shift 2/Cost of shipping/codeJava.java ================================================ import java.util.Scanner; public class Main { public static double calculateTotalCost(int weight, int distance) { double baseMoney = 5.00; double costPerKg = 2.00; double costPer10Km = 0.50; double weightCost = weight * costPerKg; double distanceCost = (distance / 10) * costPer10Km; double totalCost = baseMoney + weightCost + distanceCost; return totalCost; } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int weight = scanner.nextInt(); int distance = scanner.nextInt(); double totalCost = calculateTotalCost(weight, distance); System.out.printf("$%.2f%n", totalCost); scanner.close(); } } ================================================ FILE: 14 May Shift 2/Cost of shipping/codePy.py ================================================ def calculate_total_cost(weight, distance): base_money = 5.00 cost_per_kg = 2.00 cost_per_10_km = 0.50 weight_cost = weight * cost_per_kg distance_cost = (distance // 10) * cost_per_10_km total_cost = base_money + weight_cost + distance_cost return total_cost weight = int(input()) distance = int(input()) total_cost = calculate_total_cost(weight, distance) print(f"${total_cost:.2f}") ================================================ FILE: 14 May Shift 2/Number of Subarray of sum of K/codeCpp.cpp ================================================ #include using namespace std; int subarraySum(vector& arr, int k) { unordered_map mpp; mpp[0] = 1; int preSum = 0, cnt = 0; for (int i = 0; i < arr.size(); ++i) { preSum += arr[i]; int rest = preSum - k; cnt += mpp[rest]; mpp[preSum] += 1; } return cnt; } int main() { string inputLine; getline(cin, inputLine); istringstream iss(inputLine); vector arr; int number; while (iss >> number) { arr.push_back(number); } int k; cin >> k; int result = subarraySum(arr, k); cout << result << endl; return 0; } ================================================ FILE: 14 May Shift 2/Number of Subarray of sum of K/codeJava.java ================================================ import java.util.*; public class Main { public static int subarraySum(int[] arr, int k) { Map mpp = new HashMap<>(); mpp.put(0, 1); int preSum = 0, cnt = 0; for (int num : arr) { preSum += num; int remove = preSum - k; cnt += mpp.getOrDefault(remove, 0); mpp.put(preSum, mpp.getOrDefault(preSum, 0) + 1); } return cnt; } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String inputLine = scanner.nextLine(); String[] inputStrings = inputLine.split(" "); int[] arr = new int[inputStrings.length]; for (int i = 0; i < inputStrings.length; i++) { arr[i] = Integer.parseInt(inputStrings[i]); } int k = scanner.nextInt(); int result = subarraySum(arr, k); System.out.println(result); scanner.close(); } } ================================================ FILE: 14 May Shift 2/Number of Subarray of sum of K/codePy.py ================================================ def subarray_sum(arr, k): mpp = {0: 1} pre_sum = 0 cnt = 0 for num in arr: pre_sum += num rest = pre_sum - k cnt += mpp.get(rest, 0) mpp[pre_sum] = mpp.get(pre_sum, 0) + 1 return cnt arr = list(map(int, input().split())) k = int(input()) result = subarray_sum(arr, k) print(result) ================================================ FILE: 26 APRIL 2024 SHIFT - 1/Find subarray equals to target/codeCpp.cpp ================================================ #include #include #include using namespace std; void bruteForce(vector& arr, int n, int target) { for (int i = 0; i < n; i++) { int curSum = 0; for (int j = i; j < n; j++) { curSum += arr[j]; if (curSum == target) { for (int k = i; k <= j; k++) { cout << arr[k] << " "; } cout << endl; } } } } void optimalApproach(vector& arr, int n, int target) { unordered_map sumMap; int curSum = 0; for (int i = 0; i < n; i++) { curSum += arr[i]; if (curSum == target) { for (int j = 0; j <= i; j++) { cout << arr[j] << " "; } cout << endl; } if (sumMap.find(curSum - target) != sumMap.end()) { int startIndex = sumMap[curSum - target] + 1; for (int k = startIndex; k <= i; k++) { cout << arr[k] << " "; } cout << endl; } sumMap[curSum] = i; } } int main() { vector arr = {3, 4, -7, 1, 3, 3, 1, -4}; int N = arr.size(); int target = 7; optimalApproach(arr, N, target); return 0; } ================================================ FILE: 26 APRIL 2024 SHIFT - 1/Find subarray equals to target/codeJava.java ================================================ import java.util.HashMap; public class Main { static void bruteForce(int[] arr, int n, int target) { for (int i = 0; i < n; i++) { int curSum = 0; for (int j = i; j < n; j++) { curSum += arr[j]; if (curSum == target) { for (int k = i; k <= j; k++) { System.out.print(arr[k] + " "); } System.out.println(); } } } } static void optimalApproach(int[] arr, int n, int target) { HashMap sumMap = new HashMap<>(); int curSum = 0; for (int i = 0; i < n; i++) { curSum += arr[i]; if (curSum == target) { for (int j = 0; j <= i; j++) { System.out.print(arr[j] + " "); } System.out.println(); } if (sumMap.containsKey(curSum - target)) { int startIndex = sumMap.get(curSum - target) + 1; for (int k = startIndex; k <= i; k++) { System.out.print(arr[k] + " "); } System.out.println(); } sumMap.put(curSum, i); } } public static void main(String[] args) { int[] arr = {3, 4, -7, 1, 3, 3, 1, -4}; int N = arr.length; int target = 7; optimalApproach(arr, N, target); } } ================================================ FILE: 26 APRIL 2024 SHIFT - 1/Find subarray equals to target/subArraySum.py ================================================ def bruteFroce(arr, n, target): for i in range(n): curSum = 0 for j in range(i, n): curSum += arr[j] if curSum == target: print(arr[i:j+1]) def optimalApp (arr, n, target): sumMap = {} curSum = 0 for i in range(n): curSum += arr[i] if curSum == target: print(arr[:i+1]) if curSum - target in sumMap: startIndex = sumMap[curSum - target]+1 print(arr[startIndex : i+1]) sumMap[curSum] = i arr = list(map(int, input().split())) # 3 4 -7 1 3 3 1 -4 N = len(arr) target = int(input()) # bruteFroce(arr, N, target) optimalApp(arr, N, target) ================================================ FILE: 26 APRIL 2024 SHIFT - 1/Unique Paths/codeCpp.cpp ================================================ #include using namespace std; class Solution { private: int f(int i, int j, vector> &dp){ if(i == 0 && j == 0) return 1; if(i < 0 || j < 0) return 0; if(dp[i][j] != -1) return dp[i][j]; int up = f(i-1, j, dp); int left = f(i, j-1, dp); return dp[i][j] = up + left; } public: int uniquePaths(int m, int n) { vector> dp (m, vector(n, -1)); return f(m-1, n-1, dp); } }; ================================================ FILE: 26 APRIL 2024 SHIFT - 1/Unique Paths/codeJava.java ================================================ public class Solution { public int f(int i, int j, int[][] dp) { if (i == 0 && j == 0) return 1; if (i < 0 || j < 0) return 0; if (dp[i][j] != -1) return dp[i][j]; int up = f(i - 1, j, dp); int left = f(i, j - 1, dp); dp[i][j] = up + left; return dp[i][j]; } public int uniquePaths(int m, int n) { int[][] dp = new int[m][n]; for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { dp[i][j] = -1; } } return f(m - 1, n - 1, dp); } } ================================================ FILE: 26 APRIL 2024 SHIFT - 1/Unique Paths/uniquePaths.py ================================================ class Solution: def __init__(self): pass def f(self, i, j, dp): if i == 0 and j == 0: return 1 if i < 0 or j < 0: return 0 if dp[i][j] != -1: return dp[i][j] up = self.f(i - 1, j, dp) left = self.f(i, j - 1, dp) dp[i][j] = up + left return dp[i][j] def uniquePaths(self, m, n): dp = [[-1] * n for _ in range(m)] return self.f(m - 1, n - 1, dp) ================================================ FILE: 26 APRIL 2024 SHIFT - 2/Cube sum/code.cpp ================================================ #include using namespace std; void findCubeSum(int start, int end) { int cubeSum = 0; for (int i = start; i <= end; i++) { cubeSum += i * i * i; } cout << cubeSum << endl; } int main() { int start, end; cin >> start >> end; findCubeSum(start, end); return 0; } ================================================ FILE: 26 APRIL 2024 SHIFT - 2/Cube sum/code.java ================================================ import java.util.Scanner; public class Main { public static void findCubeSum(int start, int end) { int cubeSum = 0; for (int i = start; i <= end; i++) { cubeSum += Math.pow(i, 3); } System.out.println(cubeSum); } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int start = scanner.nextInt(); int end = scanner.nextInt(); findCubeSum(start, end); scanner.close(); } } ================================================ FILE: 26 APRIL 2024 SHIFT - 2/Cube sum/cubeSum.py ================================================ def findCubeSum(start, end): cubeSum = 0 for i in range(start, end+1): cubeSum += i ** 3 # i * i * i print(cubeSum) start, end = map(int, input().split()) # start = int(input()) # end = int(input()) findCubeSum(start, end) ================================================ FILE: 26 APRIL 2024 SHIFT - 2/Find Most sell item-avg-totalsell/code.cpp ================================================ #include #include #include using namespace std; int main() { int n; cin >> n; // Method 1 int maxCost = 0; string maxCostItem = ""; double totalPrice = 0; double avg = 0; for (int i = 0; i < n; i++) { string item; int quantity, price; cin >> item >> quantity >> price; totalPrice += quantity * price; if (totalPrice > maxCost) { maxCostItem = item; } avg = totalPrice / (i + 1); } cout << "Task 1 - Item: " << maxCostItem << "\nTotal price: " << fixed << totalPrice << "\nAverage Price: " << avg << endl; // Method 2 map store; maxCost = 0; maxCostItem = ""; totalPrice = 0; for (int i = 0; i < n; i++) { string item; int quantity, price; cin >> item >> quantity >> price; totalPrice = quantity * price; store[item] += totalPrice; if (maxCost < store[item]) { maxCostItem = item; maxCost = store[item]; } } double total = 0; for (auto& pair : store) { total += pair.second; } avg = total / n; cout << "\nTask 2 - Item: " << maxCostItem << "\nTotal price: " << fixed << total << "\nAverage Price: " << avg << endl; return 0; } ================================================ FILE: 26 APRIL 2024 SHIFT - 2/Find Most sell item-avg-totalsell/code.java ================================================ import java.util.HashMap; import java.util.Map; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); // Method 1 int maxCost = 0; String maxCostItem = ""; double totalPrice = 0; double avg = 0; for (int i = 0; i < n; i++) { String item = scanner.next(); int quantity = scanner.nextInt(); int price = scanner.nextInt(); totalPrice += quantity * price; if (totalPrice > maxCost) { maxCostItem = item; } avg = totalPrice / (i + 1); } System.out.printf("Task 1 - Item: %s\nTotal price: %.2f\nAverage Price: %.2f\n", maxCostItem, totalPrice, avg); // Method 2 Map store = new HashMap<>(); maxCost = 0; maxCostItem = ""; totalPrice = 0; for (int i = 0; i < n; i++) { String item = scanner.next(); int quantity = scanner.nextInt(); int price = scanner.nextInt(); totalPrice = quantity * price; store.put(item, store.getOrDefault(item, 0.0) + totalPrice); if (maxCost < store.get(item)) { maxCostItem = item; maxCost = store.get(item).intValue(); } } double total = store.values().stream().mapToDouble(Double::doubleValue).sum(); avg = total / n; System.out.printf("\nTask 2 - Item: %s\nTotal price: %.2f\nAverage Price: %.2f\n", maxCostItem, total, avg); scanner.close(); } } ================================================ FILE: 26 APRIL 2024 SHIFT - 2/Find Most sell item-avg-totalsell/code.py ================================================ n = int(input()) maxCost = 0 maxCostItem = "" totalPrice = 0 avg = 0 for i in range(n): item = input() quantity = int(input()) price = int(input()) totalPrice += quantity * price if totalPrice > maxCost: maxCostItem = item avg = totalPrice / (i+1) print("Item: {} \nTotal price: {:.2f}\n Average Price: {:.2f}".format(maxCostItem, totalPrice, avg)) store = {} for i in range(n): item = input() quantity = int(input()) price = int(input()) totalPrice = quantity * price store[item] = store.get(item, 0) + totalPrice total = 0 for key, val in store.items(): if maxCost < val: maxCostItem = key maxCost = val total += val average = total / n print("Item: {} \nTotal price: {:.2f}\n Average Price: {:.2f}".format(maxCostItem, total, average)) ================================================ FILE: 29 APRIL 2024 Shift - 1/Maximum element of subarray/code.cpp ================================================ #include #include #include using namespace std; void solve(vector& arr, int k) { vector ans; for (int i = 0; i < arr.size() - k + 1; i++) { priority_queue maxHeap; for (int j = i; j < i + k; j++) { maxHeap.push(arr[j]); } ans.push_back(maxHeap.top()); } for (int num : ans) { cout << num << " "; } cout << endl; } void optimalSolution(vector& arr, int k) { priority_queue> maxHeap; vector ans; for (int i = 0; i < k; i++) { maxHeap.push({arr[i], i}); } ans.push_back(maxHeap.top().first); for (int i = k; i < arr.size(); i++) { maxHeap.push({arr[i], i}); while (maxHeap.top().second <= i - k) { maxHeap.pop(); } ans.push_back(maxHeap.top().first); } for (int num : ans) { cout << num << " "; } cout << endl; } int main() { vector arr; int num; while (cin >> num) { arr.push_back(num); if (cin.get() == '\n') break; } int k; cin >> k; solve(arr, k); optimalSolution(arr, k); return 0; } ================================================ FILE: 29 APRIL 2024 Shift - 1/Maximum element of subarray/code.java ================================================ import java.util.*; public class Main { public static void solve(ArrayList arr, int k) { ArrayList ans = new ArrayList<>(); for (int i = 0; i < arr.size() - k + 1; i++) { PriorityQueue maxHeap = new PriorityQueue<>(Collections.reverseOrder()); for (int j = i; j < i + k; j++) { maxHeap.offer(arr.get(j)); } ans.add(maxHeap.peek()); } for (int num : ans) { System.out.print(num + " "); } System.out.println(); } public static void optimalSolution(ArrayList arr, int k) { PriorityQueue maxHeap = new PriorityQueue<>((a, b) -> b[0] - a[0]); ArrayList ans = new ArrayList<>(); for (int i = 0; i < k; i++) { maxHeap.offer(new int[]{arr.get(i), i}); } ans.add(maxHeap.peek()[0]); for (int i = k; i < arr.size(); i++) { maxHeap.offer(new int[]{arr.get(i), i}); while (maxHeap.peek()[1] <= i - k) { maxHeap.poll(); } ans.add(maxHeap.peek()[0]); } for (int num : ans) { System.out.print(num + " "); } System.out.println(); } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); ArrayList arr = new ArrayList<>(); while (scanner.hasNextInt()) { arr.add(scanner.nextInt()); if (scanner.hasNextLine()) { String nextLine = scanner.nextLine(); if (nextLine.isEmpty()) break; } } int k = scanner.nextInt(); solve(arr, k); optimalSolution(arr, k); } } ================================================ FILE: 29 APRIL 2024 Shift - 1/Maximum element of subarray/code.py ================================================ import heapq def solve(arr, k): ans = [] for i in range(len(arr) - k + 1): maxi = arr[i] for j in range(i, i+k): maxi = max(maxi, arr[j]) ans.append(maxi) print(*ans) def optimalSolution(arr, k): heap = [] ans = [] for i in range(k): heapq.heappush(heap, (-arr[i], i)) ans.append(-heap[0][0]) for i in range(k, len(arr)): heapq.heappush(heap, (-arr[i], i)) while heap[0][1] <= i - k: heapq.heappop(heap) ans.append(-heap[0][0]) print(*ans) arr = list(map(int, input().split())) k = int(input()) solve(arr, k) optimalSolution(arr, k) ================================================ FILE: 29 APRIL 2024 Shift - 1/Maximum element of subarray/tempCodeRunnerFile.py ================================================ ================================================ FILE: 29 APRIL 2024 Shift - 1/Multiplication table/code.cpp ================================================ #include using namespace std; int main() { int n; cin >> n; int mSum = 0; for (int i = 1; i <= n; i++) { mSum += n * i; } cout << mSum << endl; return 0; } ================================================ FILE: 29 APRIL 2024 Shift - 1/Multiplication table/code.java ================================================ import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); int mSum = 0; for (int i = 1; i <= n; i++) { mSum += n * i; } System.out.println(mSum); } } ================================================ FILE: 29 APRIL 2024 Shift - 1/Multiplication table/code.py ================================================ n = int(input()) mSum = 0 for i in range(1, n+1): mSum += n * i print(mSum) ================================================ FILE: 29 APRIL SHIFT 2/Bit OR Sum/code.cpp ================================================ #include #include #include using namespace std; int subarrayBitwiseORs(vector& arr) { vector res; int left = 0; for (int num : arr) { int right = res.size(); res.push_back(num); for (int i = left; i < right; ++i) { int value = res[i] | num; if (res.back() != value) { res.push_back(value); } } left = right; } return unordered_set(res.begin(), res.end()).size(); } int main() { int n; cin >> n; vector arr(n); for (int i = 0; i < n; ++i) { cin >> arr[i]; } cout << subarrayBitwiseORs(arr) << endl; return 0; } ================================================ FILE: 29 APRIL SHIFT 2/Bit OR Sum/code.java ================================================ import java.util.*; public class SubarrayBitwiseORs { public static int subarrayBitwiseORs(int[] arr) { List res = new ArrayList<>(); int left = 0; for (int num : arr) { int right = res.size(); res.add(num); for (int i = left; i < right; ++i) { int value = res.get(i) | num; if (res.get(res.size() - 1) != value) { res.add(value); } } left = right; } Set resultSet = new HashSet<>(res); return resultSet.size(); } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); int[] arr = new int[n]; for (int i = 0; i < n; ++i) { arr[i] = scanner.nextInt(); } System.out.println(subarrayBitwiseORs(arr)); scanner.close(); } } ================================================ FILE: 29 APRIL SHIFT 2/Bit OR Sum/code.py ================================================ def subarrayBitwiseORs(arr): res = [] left = 0 for num in arr: right = len(res) res.append(num) for i in range(left, right): value = res[i] | num if (res[-1] != value): res.append(value) left = right return len(set(res)) arr = list(map(int, input().split())) print(subarrayBitwiseORs(arr)) ================================================ FILE: 29 APRIL SHIFT 2/FIbonacci/code.cpp ================================================ #include using namespace std; int fibonacci(int n) { int a = 0, b = 1, sum=1; if (n < 0) { cout << "Incorrect input" << endl; return -1; // or any error code you prefer } else if (n == 0) { return a; } else if (n == 1) { return b; } else { for (int i = 2; i < n; ++i) { int c = a + b; sum += c; a = b; b = c; } return sum; } } int main() { int n; cin >> n; cout << fibonacci(n) << endl; return 0; } ================================================ FILE: 29 APRIL SHIFT 2/FIbonacci/code.java ================================================ import java.util.Scanner; public class Fibonacci { public static int fibonacci(int n) { int a = 0, b = 1; if (n < 0) { System.out.println("Incorrect input"); return -1; // or any error code you prefer } else if (n == 0) { return a; } else if (n == 1) { return b; } else { for (int i = 2; i <= n; ++i) { int c = a + b; a = b; b = c; } return b; } } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); System.out.println(fibonacci(n)); scanner.close(); } } ================================================ FILE: 29 APRIL SHIFT 2/FIbonacci/code.py ================================================ def fibonacci(n): prev2, prev = 0, 1 if n == 0: return prev2 if n == 1: return prev fibSum = 1 for i in range(2, n): cur = prev2 + prev fibSum += cur print("FibSum: ", fibSum) prev2, prev = prev, cur return fibSum n = int(input()) print(fibonacci(n)) ================================================ FILE: 3 May SHIFT 2/Maximum Efficiency/code.cpp ================================================ #include #include #include using namespace std; int main() { int N; cin >> N; vector arr(N); for (int i = 0; i < N; ++i) { cin >> arr[i]; } sort(arr.begin(), arr.end()); // Max values int emp1 = arr[N - 1]; int emp2 = arr[N - 2]; int emp3 = arr[N - 3]; // Negative case int neg1 = arr[0]; int neg2 = arr[1]; cout << max(emp1 * emp2 * emp3, neg1 * neg2 * emp1) << endl; return 0; } ================================================ FILE: 3 May SHIFT 2/Maximum Efficiency/code.java ================================================ import java.util.*; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int N = scanner.nextInt(); int[] arr = new int[N]; for (int i = 0; i < N; ++i) { arr[i] = scanner.nextInt(); } Arrays.sort(arr); // Max values int emp1 = arr[N - 1]; int emp2 = arr[N - 2]; int emp3 = arr[N - 3]; // Negative case int neg1 = arr[0]; int neg2 = arr[1]; System.out.println(Math.max(emp1 * emp2 * emp3, neg1 * neg2 * emp1)); } } ================================================ FILE: 3 May SHIFT 2/Maximum Efficiency/code.py ================================================ N = int(input()) arr = list(map(int, input().split())) arr.sort() #Max values emp1 = arr[N-1] emp2 = arr[N-2] emp3 = arr[N-3] #negative case neg1 = arr[0] neg2 = arr[1] print(max(emp1 * emp2 * emp3, neg1 * neg2 * emp1)) ================================================ FILE: 3 May SHIFT 2/Pairs of shoes/code.cpp ================================================ #include #include #include using namespace std; int main() { int N; cin >> N; unordered_map store; for (int i = 0; i < N; ++i) { string shoeSize; cin >> shoeSize; if (store.find(shoeSize) != store.end()) { store[shoeSize]++; } else { store[shoeSize] = 1; } } int pairs = 0; for (auto& it : store) { string key = it.first; int val = it.second; string opposite; if (key[key.size() - 1] == 'L') { opposite = key.substr(0, key.size() - 1) + 'R'; } else { opposite = key.substr(0, key.size() - 1) + 'L'; } if (store.find(opposite) != store.end()) { pairs += min(val, store[opposite]); } } cout << pairs / 2 << endl; return 0; } ================================================ FILE: 3 May SHIFT 2/Pairs of shoes/code.java ================================================ import java.util.*; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int N = scanner.nextInt(); Map store = new HashMap<>(); for (int i = 0; i < N; i++) { String shoeSize = scanner.next(); store.put(shoeSize, store.getOrDefault(shoeSize, 0) + 1); } int pairs = 0; for (Map.Entry entry : store.entrySet()) { String key = entry.getKey(); int val = entry.getValue(); String opposite; if (key.charAt(key.length() - 1) == 'L') { opposite = key.substring(0, key.length() - 1) + 'R'; } else { opposite = key.substring(0, key.length() - 1) + 'L'; } if (store.containsKey(opposite)) { pairs += Math.min(val, store.get(opposite)); } } System.out.println(pairs / 2); // Dividing by 2 as we are counting pairs } } ================================================ FILE: 3 May SHIFT 2/Pairs of shoes/code.py ================================================ N = int(input()) l = list(map(str, input().split())) store = {} for shoeSize in l: if shoeSize in store: store[shoeSize] += 1 else: store[shoeSize] = 1 pairs = 0 for key, val in store.items(): if key[-1] == 'L': val = key[:-1] + 'R' if val in store: pairs += min(store[key], store[val]) else: val = key[:-1] + 'L' if val in store: pairs += min(store[key], store[val]) print(pairs // 2) ================================================ FILE: 3 May Shift 1/Number Divisible/code.cpp ================================================ #include bool isDivisibleByNine(int number) { return number % 9 == 0; } int main() { int number; std::cin >> number; if (number >= 100 && number <= 999) { if (isDivisibleByNine(number)) { std::cout << "Number " << number << " is divisible by 9" << std::endl; } else { std::cout << "Number " << number << " is not divisible by 9" << std::endl; } } return 0; } ================================================ FILE: 3 May Shift 1/Number Divisible/code.java ================================================ import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int number = scanner.nextInt(); if (number >= 100 && number <= 999) { if (number % 9 == 0) { System.out.println("Number " + number + " is divisible by 9"); } else { System.out.println("Number " + number + " is not divisible by 9"); } } } } ================================================ FILE: 3 May Shift 1/Number Divisible/code.py ================================================ def check_divisibility(number): if 100 <= number <= 999: if number % 9 == 0: print(f"Number {number} is divisible by 9") else: print(f"Number {number} is not divisible by 9") # Input a three-digit integer number = int(input()) check_divisibility(number) ================================================ FILE: 3 May Shift 1/maximum difference between smallest and largest/code.cpp ================================================ #include using namespace std; int solve(vector& arr) { int largest = INT_MIN; int maxDiff = INT_MIN; for (int i = arr.size() - 1; i >= 0; --i) { try { int num = stoi(arr[i]); largest = max(largest, num); maxDiff = max(maxDiff, largest - num); } catch (const std::invalid_argument& e) { // Handle invalid input std::cerr << "Invalid input: " << arr[i] << std::endl; } } return maxDiff; } int solveInt(vector& arr) { int largest = INT_MIN; int maxDiff = INT_MIN; for (int i = arr.size() - 1; i >= 0; --i) { int num = arr[i]; largest = max(largest, num); maxDiff = max(maxDiff, largest - num); } return maxDiff; } int main() { // Input array format cout << "Enter elements separated by commas within square brackets like [element1,element2,...]: "; string input; getline(cin, input); input.erase(remove(input.begin(), input.end(), '['), input.end()); // Remove '[' input.erase(remove(input.begin(), input.end(), ']'), input.end()); // Remove ']' stringstream ss(input); vector arr1; string element; while (getline(ss, element, ',')) { arr1.push_back(element); } cout << "Case 1 - [-3,-5,1,6,-7,8,11], maxdiff: " << solve(arr1) << endl; // Input space separated cout << "Enter elements separated by spaces: "; string spaceSeparatedInput; getline(cin, spaceSeparatedInput); vector arr2; int num; stringstream ss2(spaceSeparatedInput); while (ss2 >> num) { arr2.push_back(num); } cout << "Case 2: -3 -5 1 6 -7 8 11, maxdiff: " << solveInt(arr2) << endl; return 0; } ================================================ FILE: 3 May Shift 1/maximum difference between smallest and largest/code.java ================================================ import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class Main { public static int solve(List arr) { int largest = Integer.MIN_VALUE; int maxDiff = Integer.MIN_VALUE; for (int i = arr.size() - 1; i >= 0; i--) { try { int num = Integer.parseInt(arr.get(i)); largest = Math.max(largest, num); maxDiff = Math.max(maxDiff, largest - num); } catch (NumberFormatException e) { // Handle invalid input System.err.println("Invalid input: " + arr.get(i)); } } return maxDiff; } public static int solveInt(List arr) { int largest = Integer.MIN_VALUE; int maxDiff = Integer.MIN_VALUE; for (int i = arr.size() - 1; i >= 0; i--) { int num = arr.get(i); largest = Math.max(largest, num); maxDiff = Math.max(maxDiff, largest - num); } return maxDiff; } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); // Input array format System.out.print("Enter elements separated by commas within square brackets like [element1,element2,...]: "); String input = scanner.nextLine().trim(); input = input.substring(1, input.length() - 1); // Remove square brackets String[] arr1 = input.split(","); List list1 = new ArrayList<>(); for (String s : arr1) { list1.add(s.trim()); } System.out.println("Case 1 - [-3,-5,1,6,-7,8,11], maxdiff: " + solve(list1)); // Input space separated System.out.print("Enter elements separated by spaces: "); String spaceSeparatedInput = scanner.nextLine().trim(); String[] arr2 = spaceSeparatedInput.split(" "); List list2 = new ArrayList<>(); for (String s : arr2) { list2.add(Integer.parseInt(s)); } System.out.println("Case 2: -3 -5 1 6 -7 8 11, maxdiff: SS" + solveInt(list2)); scanner.close(); } } ================================================ FILE: 3 May Shift 1/maximum difference between smallest and largest/code.py ================================================ def solve(arr): largest, maxDiff = float('-inf'), float('-inf') for i in range(len(arr) - 1, -1, -1): num = int(arr[i]) largest = max(largest, num) maxDiff = max(maxDiff, largest - num) return maxDiff def solveInt(arr): largest, maxDiff = float('-inf'), float('-inf') for i in range(len(arr) - 1, -1, -1): num = arr[i] largest = max(largest, num) maxDiff = max(maxDiff, largest - num) return maxDiff def input_array_format(): arr = list(map(str, input().strip("[]").split(','))) print("\nCase 1 - [-3,-5,1,6,-7,8,11], maxdiff: ", solve(arr)) def input_space_separated(): arr = list(map(int, input().split())) print("\nCase 2: -3 -5 1 6 -7 8 11, maxdiff: ", solveInt(arr)) input_array_format() input_space_separated() ================================================ FILE: 30 APRIL SHIFT 1/GRADE Problem/code.cpp ================================================ #include using namespace std; int main() { int n; vector ans; int totalFemale = 0, totalGrade = 0; while(n--) { string name, gender; char grade; int age; cin >> name >> age >> grade >> gender; if(age > 20) cout << name << endl; if (gender == "Female") { totalFemale++; totalGrade += grade; } } double avg = (double) (totalGrade / totalFemale); cout << avg << endl; } ================================================ FILE: 30 APRIL SHIFT 1/GRADE Problem/code.java ================================================ import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); scanner.nextLine(); // Consume newline character List ans = new ArrayList<>(); int totalFemale = 0; int totalGrade = 0; while (n-- > 0) { String name, gender; char grade; int age; name = scanner.next(); age = scanner.nextInt(); grade = scanner.next().charAt(0); gender = scanner.next(); if (age > 20) { ans.add(name); } if (gender.equals("Female")) { totalFemale++; totalGrade += grade; } } for (String name : ans) { System.out.println(name); } double avg = totalFemale == 0 ? 0 : (double) totalGrade / totalFemale; System.out.println(avg); } } ================================================ FILE: 30 APRIL SHIFT 1/GRADE Problem/code.py ================================================ gradeTotal, totalFemale = 0, 0 ans = [] for _ in range(int(input())): # name = input() # age = int(input()) # grade = input() # gender = input() s = input() l = s.split(" ") name, age, grade, gender = l[0], int(l[1]), l[2], l[3] if age > 20: ans.append(name) if gender == "Female": gradeTotal += ord(grade) totalFemale += 1 avg = gradeTotal / totalFemale print(*ans) print(avg) ================================================ FILE: 30 APRIL SHIFT 1/GRADE Problem/tempCodeRunnerFile.py ================================================ 3 AAA 21 A Female BBB 24 B Male CCC 26 C Female ================================================ FILE: 30 APRIL SHIFT 1/MAJORITY ELEMENT/code.cpp ================================================ #include using namespace std; void findMajorityElement(vector& arr, int N) { unordered_map freq; for (int num : arr) { freq[num]++; } for (auto& pair : freq) { if (pair.second >= N / 2) { cout << pair.first << " "; } } } int main() { int N; cin >> N; vector array(N); for (int i = 0; i < N; ++i) { cin >> array[i]; } findMajorityElement(array, N); return 0; } ================================================ FILE: 30 APRIL SHIFT 1/MAJORITY ELEMENT/code.java ================================================ import java.util.HashMap; import java.util.Scanner; public class Main { public static void findMajorityElement(int[] arr, int N) { HashMap freq = new HashMap<>(); for (int num : arr) { freq.put(num, freq.getOrDefault(num, 0) + 1); } for (int key : freq.keySet()) { if (freq.get(key) >= N / 2) { System.out.print(key + " "); } } } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int N = scanner.nextInt(); int[] array = new int[N]; for (int i = 0; i < N; ++i) { array[i] = scanner.nextInt(); } findMajorityElement(array, N); } } ================================================ FILE: 30 APRIL SHIFT 1/MAJORITY ELEMENT/code.py ================================================ def findMajorityElement(arr, N): freq = {} for num in arr: if num in freq: freq[num] += 1 else: freq[num] = 1 for key, val in freq.items(): if val >= N // 2: print(key, end = " ") N = int(input()) array = list(map(int, input().split())) findMajorityElement(array, N) ================================================ FILE: 8 MAY SHIFT 1/Nearest divisible/code.cpp ================================================ #include using namespace std; int customRound(double number) { int integerPart = (int) number; double decimalPart = number - integerPart; if (decimalPart >= 0.5) { return integerPart + 1; } else { return integerPart; } } int main() { int x, y; cin >> x; cin >> y; double nearest = (double) x / y; int roundedNumber = customRound(nearest); cout << roundedNumber * y << endl; return 0; } ================================================ FILE: 8 MAY SHIFT 1/Nearest divisible/code.java ================================================ import java.util.Scanner; public class CustomRound { public static int customRound(double number) { int integerPart = (int) number; double decimalPart = number - integerPart; if (decimalPart >= 0.5) { return integerPart + 1; } else { return integerPart; } } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int x = scanner.nextInt(); int y = scanner.nextInt(); double nearest = (double) x / y; int roundedNumber = customRound(nearest); System.out.println(roundedNumber * y); } } ================================================ FILE: 8 MAY SHIFT 1/Nearest divisible/code.py ================================================ def custom_round(number): integer_part = int(number) decimal_part = number - integer_part if decimal_part >= 0.5: return integer_part + 1 else: return integer_part x = int(input()) y = int(input()) nearest = x / y rounded_number = custom_round(nearest) print(rounded_number * y) ================================================ FILE: 8 MAY SHIFT 1/Password creations/code.cpp ================================================ #include using namespace std; string addValueToChars(string inputStr, int value) { string result = ""; for (char ch : inputStr) { if (isalpha(ch)) { if (islower(ch)) { result += ((ch - 'a' + value) % 26) + 'a'; } else { result += ((ch - 'A' + value) % 26) + 'A'; } } else if (isdigit(ch)) { result += ((ch - '0' + value) % 10) + '0'; } else { if (ch == '@') { result += '#'; } else { result += '@'; } } } return result; } int main() { string inputStr; int value; cout << "Enter input string: "; cin >> inputStr; cout << "Enter value: "; cin >> value; string outputStr = addValueToChars(inputStr, value); cout << "Output: " << outputStr << endl; return 0; } ================================================ FILE: 8 MAY SHIFT 1/Password creations/code.java ================================================ import java.util.Scanner; public class Main { public static String addValueToChars(String inputStr, int value) { StringBuilder result = new StringBuilder(); for (char ch : inputStr.toCharArray()) { if (Character.isLetter(ch)) { if (Character.isLowerCase(ch)) { result.append((char) (((ch - 'a' + value) % 26) + 'a')); } else { result.append((char) (((ch - 'A' + value) % 26) + 'A')); } } else if (Character.isDigit(ch)) { result.append((char) (((ch - '0' + value) % 10) + '0')); } else { if (ch == '@') { result.append('#'); } else { result.append('@'); } } } return result.toString(); } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.print("Enter input string: "); String inputStr = scanner.next(); System.out.print("Enter value: "); int value = scanner.nextInt(); String outputStr = addValueToChars(inputStr, value); System.out.println("Output: " + outputStr); } } ================================================ FILE: 8 MAY SHIFT 1/Password creations/code.py ================================================ def add_value_to_chars(input_str, value): result = "" for char in input_str: if char.isalpha(): if char.islower(): result += chr(((ord(char) - ord('a') + value) % 26) + ord('a')) else: result += chr(((ord(char) - ord('A') + value) % 26) + ord('A')) elif char.isdigit(): result += str((int(char) + value) % 10) else: if char == '@': result += '#' else: result += '@' return result input_str = input() value = int(input()) output_str = add_value_to_chars(input_str, value) print("Output:", output_str) ================================================ FILE: 9 May 2024 Shift - 2/Print All combinations/code.cpp ================================================ #include #include #include int main() { std::string input; std::getline(std::cin, input); std::istringstream iss(input); int n; iss >> n; std::vector arr; int temp; while (iss >> temp) { arr.push_back(temp); } for (int i = 0; i < n; ++i) { for (int j = i; j < n; ++j) { for (int q = i; q <= j; ++q) { std::cout << arr[q]; if (q != j) std::cout << " "; } if (i != n - 1) std::cout << ","; } } return 0; } ================================================ FILE: 9 May 2024 Shift - 2/Print All combinations/code.java ================================================ import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); String in = sc.nextLine(); String[] arr = in.split(" "); int n = Integer.parseInt(arr[0]); StringBuilder sb = new StringBuilder(); for (int i = 1; i < arr.length; i++) { sb.append(arr[i]); } for (int i = 0; i < n; i++) { for (int j = i; j < n; j++) { for (int q = i; q <= j; q++) { if (q != j) { System.out.print(sb.charAt(q) + " "); } else { System.out.print(sb.charAt(q)); } } if (i != n - 1) System.out.print(","); } } } } ================================================ FILE: 9 May 2024 Shift - 2/Print All combinations/code.py ================================================ def main(): in_str = input() arr = in_str.split(" ") n = int(arr[0]) sb = "".join(arr[1:]) for i in range(n): for j in range(i, n): for q in range(i, j + 1): if q != j: print(sb[q], end=" ") else: print(sb[q], end="") if i != n - 1: print(",", end="") print() if __name__ == "__main__": main() ================================================ FILE: 9 May 2024 Shift - 2/Sort the given array asc and desc/code.cpp ================================================ #include using namespace std; void printDictSorted(const map& mydict, bool reverse = false) { vector sorted_keys; for (const auto& entry : mydict) { sorted_keys.push_back(entry.first); } if (reverse) { sort(sorted_keys.rbegin(), sorted_keys.rend()); } else { sort(sorted_keys.begin(), sorted_keys.end()); } for (const string& key : sorted_keys) { cout << key << " "; } cout << endl; } int main() { string input; getline(cin, input); istringstream iss(input); vector arr{istream_iterator{iss}, istream_iterator{}}; map d; for (const string& fruit : arr) { d[fruit]++; } printDictSorted(d); printDictSorted(d, true); return 0; } ================================================ FILE: 9 May 2024 Shift - 2/Sort the given array asc and desc/code.java ================================================ import java.util.Scanner; import java.util.HashMap; import java.util.Map; import java.util.ArrayList; import java.util.Collections; public class Main { public static void printDictSorted(Map mydict, boolean reverse) { ArrayList sortedKeys = new ArrayList<>(mydict.keySet()); if (reverse) { Collections.sort(sortedKeys, Collections.reverseOrder()); } else { Collections.sort(sortedKeys); } for (String key : sortedKeys) { System.out.print(key + " "); } System.out.println(); } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String input = scanner.nextLine(); String[] arr = input.split("\\s+"); Map d = new HashMap<>(); for (String fruit : arr) { d.put(fruit, d.getOrDefault(fruit, 0) + 1); } printDictSorted(d, false); printDictSorted(d, true); } } ================================================ FILE: 9 May 2024 Shift - 2/Sort the given array asc and desc/code.py ================================================ from collections import defaultdict def printDictSorted(mydict, reverse=False): sorted_keys = sorted(mydict.keys(), reverse=reverse) for key in sorted_keys: print(key, end=" ") print() arr = input().split() d = defaultdict(int) for fruit in arr: d[fruit] += 1 printDictSorted(d) printDictSorted(d, reverse=True) ================================================ FILE: TCS NQT ALL INPUT scenario/Arrays 1D/code.cpp ================================================ #include #include #include using namespace std; vector input_array_format() { vector arr; string input; getline(cin, input); stringstream ss(input); char c; while (ss >> c) { if (c != ',' || c != '[' or c != ']') { int num; ss >> num; arr.push_back(num); } } return arr; } vector input_space_separated() { vector arr; string input; getline(cin, input); stringstream ss(input); int num; while (ss >> num) { arr.push_back(num); } return arr; } vector input_comma_separated() { vector arr; string input; getline(cin, input); stringstream ss(input); int num; char c; while (ss >> num) { arr.push_back(num); ss >> c; // Skip the comma } return arr; } vector input_array_size_not_given() { vector arr; string input; getline(cin, input); stringstream ss(input); int num; while (ss >> num) { arr.push_back(num); } return arr; } int main() { // Case 1: [1,2,3,4,5] vector arr1 = input_array_format(); cout << "Case 1: [1,2,3,4,5]" << endl; for (int num : arr1) { cout << num << " "; } cout << endl; // Case 2: 1 2 3 4 5 vector arr2 = input_space_separated(); cout << "Case 2: 1 2 3 4 5" << endl; for (int num : arr2) { cout << num << " "; } cout << endl; // Case 3: 1,2,3,4,5 vector arr3 = input_comma_separated(); cout << "Case 3: 1,2,3,4,5" << endl; for (int num : arr3) { cout << num << " "; } cout << endl; // Case with size not given vector arr4 = input_array_size_not_given(); cout << "Case with size not given" << endl; for (int num : arr4) { cout << num << " "; } cout << endl; return 0; } ================================================ FILE: TCS NQT ALL INPUT scenario/Arrays 1D/code.java ================================================ import java.util.ArrayList; import java.util.Scanner; public class InputExample { public static ArrayList inputArrayFormat() { ArrayList arr = new ArrayList<>(); Scanner scanner = new Scanner(System.in); String input = scanner.nextLine(); for (char c : input.toCharArray()) { if (Character.isDigit(c)) { int num = Character.getNumericValue(c); arr.add(num); } } return arr; } public static ArrayList inputSpaceSeparated() { ArrayList arr = new ArrayList<>(); Scanner scanner = new Scanner(System.in); String input = scanner.nextLine(); Scanner ss = new Scanner(input); while (ss.hasNextInt()) { arr.add(ss.nextInt()); } return arr; } public static ArrayList inputCommaSeparated() { ArrayList arr = new ArrayList<>(); Scanner scanner = new Scanner(System.in); String input = scanner.nextLine(); Scanner ss = new Scanner(input).useDelimiter(","); while (ss.hasNextInt()) { arr.add(ss.nextInt()); } return arr; } public static ArrayList inputArraySizeNotGiven() { ArrayList arr = new ArrayList<>(); Scanner scanner = new Scanner(System.in); String input = scanner.nextLine(); Scanner ss = new Scanner(input); while (ss.hasNextInt()) { arr.add(ss.nextInt()); } return arr; } public static void main(String[] args) { // Case 1: [1,2,3,4,5] ArrayList arr1 = inputArrayFormat(); System.out.println("Case 1: [1,2,3,4,5]"); for (int num : arr1) { System.out.print(num + " "); } System.out.println(); // Case 2: 1 2 3 4 5 ArrayList arr2 = inputSpaceSeparated(); System.out.println("Case 2: 1 2 3 4 5"); for (int num : arr2) { System.out.print(num + " "); } System.out.println(); // Case 3: 1,2,3,4,5 ArrayList arr3 = inputCommaSeparated(); System.out.println("Case 3: 1,2,3,4,5"); for (int num : arr3) { System.out.print(num + " "); } System.out.println(); // Case with size not given ArrayList arr4 = inputArraySizeNotGiven(); System.out.println("Case with size not given"); for (int num : arr4) { System.out.print(num + " "); } System.out.println(); } } ================================================ FILE: TCS NQT ALL INPUT scenario/Arrays 1D/code.py ================================================ # Case 1: [1,2,3,4,5] def input_array_format(): arr = list(map(int, input().strip("[]").split(','))) return arr # Case 2: 1 2 3 4 5 def input_space_separated(): arr = list(map(int, input().split())) return arr # Case 3: 1,2,3,4,5 def input_comma_separated(): arr = list(map(int, input().split(','))) return arr # Case with size not given def input_array_size_not_given(): arr = [] while True: try: num = input().strip() if num == "": break arr.extend(map(int, num.split())) except ValueError: print("Please enter valid integers separated by space.") return arr def input_array_size_not_given2(): arr = list(map(int, input().split())) return arr print(input_array_format()) print(input_space_separated()) print(input_comma_separated()) print(input_array_size_not_given2()) ================================================ FILE: TCS NQT ALL INPUT scenario/Strings/code.cpp ================================================ #include #include #include using namespace std; vector input_array_format() { vector arr; string input; getline(cin, input); stringstream ss(input); char c; while (ss >> c) { if (isalpha(c)) { string element; ss >> element; arr.push_back(element); } } return arr; } vector input_space_separated() { vector arr; string input; getline(cin, input); stringstream ss(input); string element; while (ss >> element) { arr.push_back(element); } return arr; } vector input_array_size_not_given() { vector arr; string input; cout << "Enter array elements (press Enter after each element, press Enter twice to stop):" << endl; while (true) { string element; getline(cin, element); if (element.empty()) { break; } arr.push_back(element); } return arr; } int main() { // Case 1: ['A', 'B', 'C', 'D'] cout << "Case 1: ['A', 'B', 'C', 'D']" << endl; vector arr1 = input_array_format(); for (const string& element : arr1) { cout << element << " "; } cout << endl; // Case 2: A B C D cout << "Case 2: A B C D" << endl; vector arr2 = input_space_separated(); for (const string& element : arr2) { cout << element << " "; } cout << endl; // Case with size not given cout << "Case with size not given" << endl; vector arr3 = input_array_size_not_given(); for (const string& element : arr3) { cout << element << " "; } cout << endl; return 0; } ================================================ FILE: TCS NQT ALL INPUT scenario/Strings/code.java ================================================ import java.util.ArrayList; import java.util.Scanner; public class InputExample { public static ArrayList inputArrayFormat() { ArrayList arr = new ArrayList<>(); Scanner scanner = new Scanner(System.in); String input = scanner.nextLine(); for (char c : input.toCharArray()) { if (Character.isLetter(c)) { arr.add(Character.toString(c)); } } return arr; } public static ArrayList inputSpaceSeparated() { ArrayList arr = new ArrayList<>(); Scanner scanner = new Scanner(System.in); String input = scanner.nextLine(); Scanner ss = new Scanner(input); while (ss.hasNext()) { arr.add(ss.next()); } return arr; } public static ArrayList inputArraySizeNotGiven() { ArrayList arr = new ArrayList<>(); Scanner scanner = new Scanner(System.in); System.out.println("Enter array elements (press Enter after each element, press Enter twice to stop):"); while (true) { String element = scanner.nextLine().trim(); if (element.isEmpty()) { break; } arr.add(element); } return arr; } public static void main(String[] args) { // Case 1: ['A', 'B', 'C', 'D'] System.out.println("Case 1: ['A', 'B', 'C', 'D']"); System.out.println(inputArrayFormat()); // Case 2: A B C D System.out.println("Case 2: A B C D"); System.out.println(inputSpaceSeparated()); // Case with size not given System.out.println("Case with size not given"); System.out.println(inputArraySizeNotGiven()); } } ================================================ FILE: TCS NQT ALL INPUT scenario/Strings/code.py ================================================ def input_array_format(): arr = list(map(str, input().strip("[]").split(','))) return arr def input_space_separated(): arr = list(map(str, input().split())) return arr def input_array_size_not_given(): arr = [] while True: element = input().strip() if not element: break arr.append(element) return arr def main(): # Case 1: ['A', 'B', 'C', 'D'] print("Case 1: ['A', 'B', 'C', 'D']") print(input_array_format()) # Case 2: A B C D, Case with size not given print("Case 2: A B C D, Case with size not given") print(input_space_separated()) if __name__ == "__main__": main()