अंक # 26: आईटी प्रशिक्षण - वर्तमान मुद्दों और प्रमुख कंपनियों से चुनौतियां

सवाल

एक चोर को प्राचीन खजाने की एक जोड़ी मिली है। गुफाओं में से एक अविश्वसनीय खजाने से भरा है और दूसरे में एक अग्नि श्वास राक्षस है जो उस गुफा को खोलने वाले को खा जाएगा।
एक गुफा में एक काले रंग का दरवाजा है जिसे हीरे से सजाया गया है और दूसरी गुफा में भूरे रंग से सजाया गया है।
प्रत्येक दरवाजे के ऊपर एक उत्कीर्ण विवरण है। वर्णन कहता है:

ब्लैक डोर: मॉन्स्टर यहाँ है।
ब्राउन डोर: केवल एक डोर सच बोलती है।

चोर किस दरवाजे को खोलना चाहिए?

आलोक की तीन बेटियां हैं। उनके दोस्त श्याम अपनी बेटियों की उम्र जानना चाहते हैं। आलोक उसे पहले संकेत देता है।

1. उनकी उम्र का उत्पाद 72 है। श्याम का कहना है कि यह पर्याप्त जानकारी नहीं है, आलोक उसे दूसरा संकेत देता है।
2. उनकी उम्र का योग मेरे घर की संख्या के बराबर है। श्याम बाहर जाते हैं और घर का नंबर देखते हैं और कहते हैं कि "मेरे पास अभी भी उम्र निर्धारित करने के लिए पर्याप्त जानकारी नहीं है"। आलोक स्वीकार करता है कि श्याम अनुमान नहीं लगा सकता है और उसे तीसरा संकेत देता है
3. सबसे पुरानी लड़कियों को स्ट्रॉबेरी आइसक्रीम पसंद है। श्याम तीसरे संकेत के बाद अनुमान लगाने में सक्षम है।

क्या आप अनुमान लगा सकते हैं कि तीन बेटियों की उम्र क्या है?

कार्य

बहुत लंबे समय से टॉम एंड जेरी एक दूसरे के साथ पनीर के टुकड़े के लिए लड़ रहे हैं। तो आखिरकार आप बचाव करने आए और तय किया कि लड़ाई का परिणाम एक गणितीय गेम द्वारा तय किया जाएगा, जिसमें आप एक नंबर लिखेंगे N (1 <= N <= 10^6) । टॉम और जेरी वैकल्पिक रूप से खेल खेलेंगे और उनमें से प्रत्येक नंबर n [n < N] घटाएगा जैसे कि N % n = 0 ।
खेल को तब तक बारी-बारी से दोहराया जाता है, जो अब एक और कदम नहीं बढ़ा सकता है।
खेल टॉम के पहले कदम के साथ शुरू होता है। यह अच्छी तरह से समझा जाता है कि दोनों इष्टतम तरीके से कदम बढ़ाएंगे। आप यह निर्धारित करते हैं कि कौन खेल को जीतता है।

इनपुट: प्रत्येक परीक्षण मामले की पहली पंक्ति में एन संख्या होती है।
आउटपुट: प्रिंट 1 यदि टॉम जीतता है और 0 प्रिंट करता है अगर जैरी एक अलग लाइन में जीतता है।

प्रतिबंध:
1 <= N <= 10^6

नमूना:
इनपुट: 2 / आउटपुट: 1
इनपुट: 4 / आउटपुट: 1

एक फर्म में एक बैठक कक्ष है। (S[i], F[i]) के रूप में N बैठकें होती हैं (S[i], F[i]) जहां S [i] बैठक के समय का प्रारंभ होता है और F [i] मिलने का समय समाप्त होता है।
बैठक कक्ष में अधिकतम कितनी बैठकें आयोजित की जा सकती हैं?

इनपुट:
इनपुट की पहली पंक्ति में परीक्षण मामलों की संख्या होती है। टी परीक्षण मामलों का वर्णन इस प्रकार है:
पहली पंक्ति में सरणी का आकार होता है, दूसरी पंक्ति में वह सरणी होती है जिसमें प्रत्येक मीटिंग के शुरुआती समय में प्रत्येक स्थान से अलग होता है, अर्थात, S [i]। और तीसरी पंक्ति में सरणी होती है, जिसमें प्रत्येक बैठक का स्थान, यानी F [i] द्वारा अलग-अलग पूरा होने का समय होता है।
आउटपुट:
प्रत्येक अलग पंक्ति में उस क्रम को प्रिंट करें जिसमें बैठकें एक स्थान से अलग होती हैं।

प्रतिबंध:
1 ≤ T ≤ 70
1 ≤ N ≤ 100
1 ≤ S[ i ], F[ i ] ≤ 100000

उदाहरण:
इनपुट:
2
6
1 3 0 5 8 5
2 4 6 7 9 9
8
75250 50074 43659 8931 11273 27545 50879 77924
112960 114515 81825 93424 54316 35533 73383 160252
आउटपुट:
1 2 4 5
6 7 1

सकारात्मक पूर्णांक की एक सरणी को देखते हुए। कार्य सरणी के उलटा गिनती खोजने के लिए है।
उलटा गणना: एक सरणी के लिए, उलटा गणना इंगित करती है कि सरणी को कितने दूर (या करीब) से सॉर्ट किया जा रहा है। यदि सरणी को उल्टे क्रम में क्रमबद्ध किया जाता है तो उलटा गिनती अधिकतम होती है।
औपचारिक रूप से, दो तत्व [i] और [j] एक उलटा बनाते हैं यदि a[i] > a[j] और i < j ।

इनपुट: इनपुट की पहली पंक्ति में एक पूर्णांक T होता है जो परीक्षण मामलों की संख्या को दर्शाता है। प्रत्येक परीक्षण मामले की पहली पंक्ति एन, सरणी का आकार है। प्रत्येक परीक्षण मामले की दूसरी पंक्ति में एन तत्व होते हैं।
आउटपुट: सरणी का उलटा गिनती प्रिंट करें।

प्रतिबंध:
1 ≤ T ≤ 100
1 ≤ N ≤ 107
1 ≤ C ≤ 1018

उदाहरण:
इनपुट:
1
5
2 4 1 3 5
आउटपुट:
3

उत्तर

 using System; public class TomJerry { static public void Main () { Scanner sc = new Scanner(System.in); int n = sc.nextInt(); System.out.printIn((n - 1) % 2); } } 

 #include <bits/stdc++.h> using namespace std; struct Activity { int start, finish, index; }; bool activityCompare(Activity s1, Activity s2) { return s1.finish < s2.finish; } int main() { int t, n, i, j; cin >> t; while (t--) { cin >> n; Activity arr[n]; for (i = 0; i < n; i++) { cin >> arr[i].start; arr[i].index = i; } for (i = 0; i < n; i++) cin >> arr[i].finish; sort(arr, arr + n, activityCompare); i = 0; cout << arr[i].index + 1 << " "; for (int j = 1; j < n; j++) { if (arr[j].start >= arr[i].finish) { cout << arr[j].index + 1 << " "; i = j; } } cout << endl; } return 0; } 

 #include<iostream> using namespace std; int merge(int* arr, int* LArr, int* RArr, int m, int n) { int i = 0, j = 0, k = 0; int count = 0; while (i < m && j < n) { if (LArr[i] <= RArr[j]) arr[k++] = LArr[i++]; else { arr[k++] = RArr[j++]; count = count + m - i; } } while (i < m) arr[k++] = LArr[i++]; while (j < n) arr[k++] = RArr[j++]; return count; } int mergeSort(int* arr, int start, int end) { if (start > end) return 0; if (start == end) return 0; if (start == end - 1) { if (arr[start] <= arr[end]) return 0; else swap(arr[start], arr[end]); return 1; } int mid = (start + end) / 2; int* LArr = new int[mid + 1]; int* RArr = new int[end - mid]; int i; for (i = start; i <= mid; i++) LArr[i] = arr[i]; for (i = mid + 1; i <= end; i++) RArr[i - (mid + 1)] = arr[i]; int count = 0; count += mergeSort(LArr, 0, mid); count += mergeSort(RArr, 0, end - mid - 1); count += merge(arr, LArr, RArr, mid + 1, end - mid); delete[] LArr; delete[] RArr; return count; } int main() { int t, n,*arr; cin >> t; while (t--) { cin >> n; arr = new int[n]; for (int i = 0; i < n; i++) cin >> arr[i]; cout << mergeSort(arr, 0, n - 1) << endl; } }