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

सवाल

1. मुर्गियों
   

   एक किसान ने कुछ मुर्गियों को एक विशेष दिन में चार अलग-अलग ग्राहकों को बेच दिया। यह ऐसा था कि प्रत्येक ग्राहक शेष मुर्गियों का आधा और आधा चिकन अधिक खरीदता था।
   
   क्या आप पता लगा सकते हैं कि उस दिन किसान ने कितने चिकन बेचे थे अगर हम आपको बताएं कि चौथे ग्राहक ने एक ही चिकन खरीदा है?

   
   
   अनुवाद

   एक दिन में, किसान ने कई मुर्गियों को चार खरीदारों को बेच दिया। यह पता चला कि उनमें से प्रत्येक ने आधी बची मुर्गियों को खरीदा और दूसरी आधी फिल्म को।
   
   क्या आप मुझे बता सकते हैं कि उस दिन कितने मुर्गियां बेची गई थीं, अगर यह ज्ञात हो कि 4 वें खरीदार ने एक पूरा चिकन खरीदा है?
   
   
   
2. गोलियां और रिवॉल्वर
   

   एक रूसी गैंगस्टर आपका अपहरण कर लेता है। वह एक खाली छह-राउंड रिवॉल्वर में लगातार दो गोलियां डालता है, इसे घुमाता है, इसे अपने सिर पर रखता है और गोली मारता है। * क्लिक करें * आप अभी भी जीवित हैं। फिर वह आपसे पूछता है, "क्या आप चाहते हैं कि मैं इसे फिर से घुमाऊं और आग लगा दूं या ट्रिगर को फिर से खींच लूं?" प्रत्येक विकल्प के लिए, क्या संभावना है कि आपको गोली मार दी जाएगी?

   
   
   अनुवाद

   आपको एक रूसी डाकू ( ओह, इन स्टीरियोटाइप्स ) द्वारा अपहरण कर लिया गया था। उसने क्रमिक रूप से 2 गोलियों को छह-शॉट रिवाल्वर में डाला, ड्रम को स्क्रॉल किया, जिसका उद्देश्य आपके सिर पर था और ट्रिगर खींच दिया। * क्लिक करें *। तुम अभी भी जीवित हो। दस्यु ने आपसे पूछा - "क्या आप चाहते हैं कि मैं फिर से स्क्रॉल करूं और गोली मार दूं या तुरंत गोली मार दूं?" प्रत्येक मामले में गोली मारे जाने की संभावना क्या है?
   
   
   

कार्य

1. पुनरावृत्ति का उपयोग करके एक स्टैक को क्रमबद्ध करें
   

   एक स्टैक को देखते हुए, कार्य पुनरावृत्ति का उपयोग करके इसे सॉर्ट करना है। किसी भी लूप निर्माण का उपयोग करें, जबकि..etc की अनुमति नहीं है। हम केवल स्टैक S पर निम्न ADT फ़ंक्शंस का उपयोग कर सकते हैं:
   
   is_empty (S): टेस्ट कि स्टैक खाली है या नहीं।
   धक्का (एस): ढेर में नए तत्व जोड़ता है।
   पॉप (एस): स्टैक से शीर्ष तत्व निकालता है।
   शीर्ष (एस): शीर्ष तत्व का रिटर्न मान। ध्यान दें कि यह फ़ंक्शन स्टैक से तत्व को नहीं हटाता है।
   
   उदाहरण:
   
   इनपुट: -3 <- टॉप
   14
   18
   -5
   30
   
   आउटपुट: 30 <- शीर्ष
   18
   14
   -3
   -5

   
   
   अनुवाद

   एक स्टैक को देखते हुए, कार्य पुनरावृत्ति का उपयोग करके इसे सॉर्ट करना है। चक्रीय निर्माणों का उपयोग, जैसे कि, जबकि ... आदि के लिए निषिद्ध है। एस स्टैक पर केवल निम्नलिखित अमूर्त कमांड की अनुमति है:
   
   is_empty (S): यदि स्टैक खाली है तो चेक करता है।
   push (S): स्टैक में एक नया आइटम जोड़ता है।
   pop (S): स्टैक के शीर्ष तत्व को निकालता है।
   शीर्ष (एस): शीर्ष तत्व का मान लौटाता है। कृपया ध्यान दें कि आइटम उसी समय हटाया नहीं गया है।
   
   उदाहरण:
   
   इनपुट: -3 <- स्टैक के ऊपर
   14
   18
   -5
   30
   
   आउटपुट: 30 <- स्टैक के ऊपर
   18
   14
   -3
   -5
   
   

इनपुट स्ट्रिंग और शब्दों के शब्दकोश को देखते हुए, पता करें कि क्या इनपुट स्ट्रिंग को शब्दों के अंतरिक्ष-पृथक अनुक्रम में विभाजित किया जा सकता है। अधिक जानकारी के लिए निम्न उदाहरण देखें।

निम्नलिखित शब्दकोश पर विचार करें
{, जैसे, सम, गाया, सैमसंग, मोबाइल, बर्फ,
क्रीम, आइसक्रीम, मैन, गो, मैंगो}

इनपुट: ilike
आउटपुट: हाँ
स्ट्रिंग को "आई लाइक" के रूप में विभाजित किया जा सकता है।

इनपुट: ilikesamsung
आउटपुट: हाँ
स्ट्रिंग को "I like samsung" के रूप में विभाजित किया जा सकता है
या "मुझे सैम गाया पसंद है"।

ऊँचाई n का एक स्थिर टॉवर एक टॉवर है जिसमें इकाई ऊँचाई की बिल्कुल टाइलें खड़ी होती हैं जो इस तरह से खड़ी होती हैं कि कोई बड़ी टाइल छोटी टाइल पर नहीं रखी जाती है। एक उदाहरण नीचे दिखाया गया है:

           [1]
        [2]
     [3]
 [4]

हमारे पास आकार 1, 2, ..., मी की टाइलों की अनंत संख्या है। कार्य की गणना ऊँचाई के विभिन्न स्थिर टॉवरों की संख्या से की जाती है, जिसे इन टाइलों से बनाया जा सकता है, इस प्रतिबंध के साथ कि आप टॉवर में प्रत्येक आकार के अधिकांश k टाइल्स पर उपयोग कर सकते हैं।

नोट: ऊँचाई के दो टॉवर n भिन्न होते हैं यदि और केवल तभी वहाँ ऊँचाई h (1 <= h <= n) मौजूद हो, जैसे कि टावरों में ऊँचाई h पर विभिन्न आकारों की टाइलें होती हैं।

उदाहरण:

इनपुट: n = 3, m = 3, k = 1
आउटपुट: १
संभव अनुक्रम: {1, 2, 3}।
इसलिए उत्तर 1 है।

इनपुट: n = 3, m = 3, k = 2
आउटपुट: 7
{, 1, 2,}, 1, 1, 3}, {1, 2, 2}, {1, 2, 3}, {1, 3, 3}, {2, 2, 3}, {2 , 3, 3}।

           [1]
        [2]
     [3]
 [4]

समाधान

1. प्रश्न 1

   उत्तर: 15. यहां उन्होंने बताया कि क्यों।
   
   
2. प्रश्न २

   टिप्पणियों में इस प्रश्न का सही उत्तर दिया
   संभावना है कि ड्रम के अगले स्लॉट में एक कारतूस है - 1/4
   यदि आप ड्रम को स्क्रॉल करते हैं, तो यह संभावना है कि यह कारतूस पर बंद हो जाएगा 2/6 = 1/3
   
   
   
3. टास्क 1

   समाधान विकल्प, डायनामिक प्रोग्रामिंग:
   

   #include <iostream> #include <string.h> using namespace std; /* A utility function to check whether a word is present in dictionary or not. An array of strings is used for dictionary. Using array of strings for dictionary is definitely not a good idea. We have used for simplicity of the program*/ int dictionaryContains(string word) { string dictionary[] = {"mobile","samsung","sam","sung","man","mango", "icecream","and","go","i","like","ice","cream"}; int size = sizeof(dictionary)/sizeof(dictionary[0]); for (int i = 0; i < size; i++) if (dictionary[i].compare(word) == 0) return true; return false; } // Returns true if string can be segmented into space separated // words, otherwise returns false bool wordBreak(string str) { int size = str.size(); if (size == 0) return true; // Create the DP table to store results of subroblems. The value wb[i] // will be true if str[0..i-1] can be segmented into dictionary words, // otherwise false. bool wb[size+1]; memset(wb, 0, sizeof(wb)); // Initialize all values as false. for (int i=1; i<=size; i++) { // if wb[i] is false, then check if current prefix can make it true. // Current prefix is "str.substr(0, i)" if (wb[i] == false && dictionaryContains( str.substr(0, i) )) wb[i] = true; // wb[i] is true, then check for all substrings starting from // (i+1)th character and store their results. if (wb[i] == true) { // If we reached the last prefix if (i == size) return true; for (int j = i+1; j <= size; j++) { // Update wb[j] if it is false and can be updated // Note the parameter passed to dictionaryContains() is // substring starting from index 'i' and length 'ji' if (wb[j] == false && dictionaryContains( str.substr(i, ji) )) wb[j] = true; // If we reached the last character if (j == size && wb[j] == true) return true; } } } /* Uncomment these lines to print DP table "wb[]" for (int i = 1; i <= size; i++) cout << " " << wb[i]; */ // If we have tried all prefixes and none of them worked return false; } // Driver program to test above functions int main() { wordBreak("ilikesamsung")? cout <<"Yesn": cout << "Non"; wordBreak("iiiiiiii")? cout <<"Yesn": cout << "Non"; wordBreak("")? cout <<"Yesn": cout << "Non"; wordBreak("ilikelikeimangoiii")? cout <<"Yesn": cout << "Non"; wordBreak("samsungandmango")? cout <<"Yesn": cout << "Non"; wordBreak("samsungandmangok")? cout <<"Yesn": cout << "Non"; return 0; } 

   
   
   
   
4. टास्क २

   जावा में घोल:
   

    import java.util.ListIterator; import java.util.Stack; class Test { // Recursive Method to insert an item x in sorted way static void sortedInsert(Stack<Integer> s, int x) { // Base case: Either stack is empty or newly inserted // item is greater than top (more than all existing) if (s.isEmpty() || x > s.peek()) { s.push(x); return; } // If top is greater, remove the top item and recur int temp = s.pop(); sortedInsert(s, x); // Put back the top item removed earlier s.push(temp); } // Method to sort stack static void sortStack(Stack<Integer> s) { // If stack is not empty if (!s.isEmpty()) { // Remove the top item int x = s.pop(); // Sort remaining stack sortStack(s); // Push the top item back in sorted stack sortedInsert(s, x); } } // Utility Method to print contents of stack static void printStack(Stack<Integer> s) { ListIterator<Integer> lt = s.listIterator(); // forwarding while(lt.hasNext()) lt.next(); // printing from top to bottom while(lt.hasPrevious()) System.out.print(lt.previous()+" "); } // Driver method public static void main(String[] args) { Stack<Integer> s = new Stack<>(); s.push(30); s.push(-5); s.push(18); s.push(14); s.push(-3); System.out.println("Stack elements before sorting: "); printStack(s); sortStack(s); System.out.println(" \n\nStack elements after sorting:"); printStack(s); } } 

   
   
   
   
5. टास्क 3

   समाधान विकल्प:
   

    #include <bits/stdc++.h> using namespace std; #define N 100 int possibleWays(int n, int m, int k) { int dp[N][N]; int presum[N][N]; memset(dp, 0, sizeof dp); memset(presum, 0, sizeof presum); // Initialing 0th row to 0. for (int i = 1; i < n + 1; i++) { dp[0][i] = 0; presum[0][i] = 1; } // Initialing 0th column to 0. for (int i = 0; i < m + 1; i++) presum[i][0] = dp[i][0] = 1; // For each row from 1 to m for (int i = 1; i < m + 1; i++) { // For each column from 1 to n. for (int j = 1; j < n + 1; j++) { // Initialing dp[i][j] to presum of (i - 1, j). dp[i][j] = presum[i - 1][j]; if (j > k) { dp[i][j] -= presum[i - 1][j - k - 1]; } } // Calculating presum for each i, 1 <= i <= n. for (int j = 1; j < n + 1; j++) presum[i][j] = dp[i][j] + presum[i][j - 1]; } return dp[m][n]; } // Driver Program int main() { int n = 3, m = 3, k = 2; cout << possibleWays(n, m, k) << endl; return 0; }