जादूगर से पूछो #357

[स्पॉइलर=समाधान]

उत्तर खोजने के लिए permut(9,3)*permut(6,3)*permut(3,3)/fact(3) = 60,480 संभावित क्रमपरिवर्तनों को छाँटना होगा। मुझे स्वीकार करना होगा कि मैंने कम से कम एक घंटे तक कोशिश की और कोई हल नहीं मिला।

इसलिए, मैंने नौ अंकों को क्रमबद्ध करने के सभी 362,880 तरीकों से एक प्रोग्राम बनाया और उन सभी का परीक्षण किया। सबसे मुश्किल काम नौ संख्याओं को क्रमबद्ध करने के हर संभव तरीके से क्रमबद्ध करना था। लेक्सोग्राफ़िक सॉर्टिंग का उपयोग करके इसे कैसे किया जाता है, यहाँ बताया गया है।

1. सभी नौ तत्वों को एक सारणी में रखें, निम्नतम से उच्चतम तक व्यवस्थित करें।
2. सारणी में वह अंतिम तत्व ढूँढें जिससे अगला तत्व बड़ा हो। यदि कोई तत्व न मिले, तो प्रोग्राम से बाहर निकलें।
3. चरण 2 के बाद वाले तत्व से शुरू करते हुए, सरणी में वह अंतिम तत्व ढूंढें जो चरण 2 से बड़ा हो।
4. चरण 2 और 3 से सरणी में तत्वों को बदलें।
5. चरण 2 से अंत तक सरणी में तत्वों को उलट दें।
6. चरण 2 पर वापस जाएँ

इस प्रक्रिया का पालन करने पर, आपको छह बार सही उत्तर मिलेगा, तीनों भिन्नों को क्रमबद्ध करने के सभी छह तरीकों के लिए एक बार। [/spoiler]

[स्पॉइलर=कोड]

मैंने निम्नलिखित कोड लिखा, 1 से 9 तक प्रत्येक अंक को लेक्सोग्राफिक क्रम में क्रमबद्ध करने के लिए तथा प्रत्येक का परीक्षण करने के लिए कि क्या यह एक हल है।

शून्य तीन_अंश(शून्य)
{
 int i, x_max, y_max, temp_array[100], होल्ड, pt;
 int lex_array[] = { 1,2,3,4,5,6,7,8,9 };
 int num_elements = sizeof(lex_array) / sizeof(lex_array[0]);
 int गिनती = 0;
 बूल स्टॉप = झूठ;
 डबल टोट3;
 cerr << "तत्वों की संख्या =\t" << num_elements << "\n";
 करना
 {
  गिनती++;
  tot3 = (डबल)lex_array[0] / (डबल)(10 * lex_array[1] + lex_array[2]);
  tot3 += (डबल)lex_array[3] / (डबल)(10 * lex_array[4] + lex_array[5]);
  tot3 += (डबल)lex_array[6] / (डबल)(10 * lex_array[7] + lex_array[8]); 
  यदि (tot3 == 1.0)
  {
   cerr << गिनती << "\t";
   cerr << lex_array[0] << "/" << lex_array[1] << lex_array[2] << " + ";
   cerr << lex_array[3] << "/" << lex_array[4] << lex_array[5] << " + ";
   cerr << lex_array[6] << "/" << lex_array[7] << lex_array[8] << "\n";
  } 
  x_मैक्स = -1;
  के लिए (i = 0; i < (num_elements - 1); i++)
  {
   यदि (lex_array[i] < lex_array[i + 1])
    x_मैक्स = i;
  }
  यदि (x_max >= 0)
  {
   y_मैक्स = 0;
   (i = x_max + 1; i < num_elements; i++) के लिए
   {
    यदि (lex_array[x_max] < lex_array[i])
     y_मैक्स = i;
   }
   होल्ड = lex_array[x_max];
   लेक्स_एरे[x_मैक्स] = लेक्स_एरे[y_मैक्स];
   lex_array[y_max] = होल्ड;
   यदि (x_max + 1 < num_elements - 1) // उलटा
   {
    (i = x_max + 1; i < num_elements; i++) के लिए
    {
     अस्थायी_सरणी[i] = लेक्स_सरणी[i];
    }
    पीटी = 0;
    (i = x_max + 1; i < num_elements; i++) के लिए
    {
     lex_array[i] = temp_array[num_elements - 1 - pt];
     पीटी++;
    }
   }
  }
  अन्य
   रोक = सच;
 } जबकि (रोक == गलत);
}

यह प्रश्न मेरे फोरम विजार्ड ऑफ वेगास में पूछा गया है और इस पर चर्चा की गई है।

[स्पॉइलर=समाधान]

माना j = जग का आयतन.

पहली बार जग भरने के बाद, जग में 10-j गैलन वाइन बची थी। वाइन की जगह पानी डालने के बाद, पूरे केग में वाइन का अनुपात (10-j)/10 था।

जग से तनुकृत शराब निकालने के बाद, केग में 10 गैलन तनुकृत शराब बची थी। तनुकृत शराब में शुद्ध शराब की मात्रा इस प्रकार व्यक्त की जा सकती है:

(10-जे)*((10-जे)/10) = 5

(10-j)^2 = 50

j^2 - 20j + 100 = 50

जे^2 - 20जे + 50 = 0

j = (20 +/- sqrt(400-200))/2

j = (20 +/- 10*sqrt(2))/2

j = 10 +/- 5*sqrt(2)

जग, केग से बड़ा नहीं हो सकता, इसलिए हमें ऋणात्मक चिह्न का प्रयोग करना चाहिए:

j = 10 - 5*sqrt(2) =~ लगभग 2.92893218813452 गैलन.

यह प्रश्न मेरे फोरम विजार्ड ऑफ वेगास में पूछा गया है और इस पर चर्चा की गई है।

[स्पॉइलर=समाधान]

मुझे इसके लिए मार्कोव श्रृंखला का उपयोग करना पड़ा। नीचे दी गई तालिका बाएँ स्तंभ में दिए गए चलित योग के अनुसार प्रत्येक अंतिम योग की प्रायिकता दर्शाती है। 13 से 18 के योग के लिए स्पष्ट मामलों से शुरुआत करें। फिर, 0 से 12 के चलित योग के लिए, नीचे दिए गए छह कक्षों का औसत निकालें।

प्रारंभिक अवस्था की संभावनाएं पहली पंक्ति में 0 के योग के लिए पाई जा सकती हैं।

यह प्रश्न मेरे फोरम ' विजार्ड ऑफ वेगास' में पूछा गया और इस पर चर्चा की गई।