जीत, हार और ड्रॉ की एक तालिका को देखते हुए, एक खेल टूर्नामेंट में प्रत्येक मैच का परिणाम

Question

यह सवाल रग्बी विश्व कप के "सज्जनों द्वारा खेले जाने वाले खेल" के चल रहे टूर्नामेंट से प्रेरित है , जिसने अभी पूल चरण को पूरा किया है। टूर्नामेंट में 20 टीमें हैं, और वे प्रत्येक 5 टीमों के 4 पूल में विभाजित हैं। पूल चरण के दौरान प्रत्येक टीम अपने पूल में सभी अन्य टीमों के खिलाफ खेलती है (प्रति पूल कुल 10 मैच), और प्रत्येक पूल की शीर्ष 2 टीमें नॉकआउट चरण में आगे बढ़ती हैं।

पूल चरण के अंत में प्रत्येक पूल के लिए एक टेबल होती है जिसमें प्रत्येक टीम के लिए जीत, हार और ड्रॉ की संख्या दर्शाई जाती है। इस प्रश्न के लिए चुनौती एक प्रोग्राम लिखना है जो प्रत्येक टीम के लिए एक पूल में जीत, हार और ड्रॉ की गिनती का इनपुट करता है, और उस जानकारी से 10 मैचों में से प्रत्येक के व्यक्तिगत परिणामों को आउटपुट करता है (जो जीता, हारा या ड्रॉ हुआ ) यदि संभव हो तो या त्रुटि संदेश को आउटपुट करता है यदि नहीं।

उदाहरण के लिए, यहां इस वर्ष के टूर्नामेंट के पूल डी के लिए तालिका है:

            Win    Loss    Draw
Canada        0       4       0
France        3       1       0
Ireland       4       0       0
Italy         2       2       0
Romania       1       3       0

इस जानकारी से, हम यह निष्कर्ष निकाल सकते हैं कि आयरलैंड ने कनाडा, फ्रांस, इटली और रोमानिया के खिलाफ जीत हासिल की, क्योंकि उन्होंने अपने सभी खेल जीते। फ्रांस कनाडा, इटली और रोमानिया के खिलाफ जीत गया होगा लेकिन आयरलैंड से हार गया, क्योंकि वे केवल एक हार गए थे और यह अपरिभाषित आयरलैंड के लिए रहा होगा। हमने अभी-अभी काम किया है कि इटली आयरलैंड और फ्रांस से हार गया, इसलिए वे कनाडा और रोमानिया के खिलाफ जीत गए होंगे। कनाडा ने अपने सभी खेल खो दिए, और इसलिए रोमानिया की जीत कनाडा के खिलाफ रही होगी।

         Canada  France Ireland   Italy Romania
Canada        -       L       L       L       L
France        W       -       L       W       W
Ireland       W       W       -       W       W
Italy         W       L       L       -       W
Romania       W       L       L       L       -

यहाँ एक और अधिक जटिल (काल्पनिक) उदाहरण है:

            Win    Loss    Draw
Canada        3       1       0
France        1       2       1
Ireland       0       3       1
Italy         0       2       2
Romania       4       0       0

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

         Canada  France Ireland   Italy Romania
Canada        -       W       W       W       L
France        L       -       W       D       L
Ireland       L       L       -       D       L
Italy         L       D       D       -       L
Romania       W       W       W       W       -

कुछ तालिकाएँ असाध्य हैं, उदाहरण के लिए इस साल के पूल बी, जिसमें 3 टीमों को एक ही डब्ल्यू / एल / डी योग मिला:

            Win    Loss    Draw
Japan         3       1       0
Samoa         1       3       0
Scotland      3       1       0
South Africa  3       1       0
United States 0       4       0

हालाँकि डुप्लीकेट पंक्तियों वाली कुछ सारणियाँ हल करने योग्य हैं, जैसे कि यह (काल्पनिक) एक:

            Win    Loss    Draw
Japan         4       0       0
Samoa         0       3       1
Scotland      2       2       0
South Africa  0       3       1
United States 3       1       0

इनपुट

आपके कार्यक्रम या फ़ंक्शन को 5 टीमों में से प्रत्येक के लिए जीत, नुकसान और ड्रॉ को निर्दिष्ट करने वाले 15 नंबर को स्वीकार करना चाहिए। आप अपनी इच्छानुसार किसी भी सीमांकक का उपयोग कर सकते हैं, संख्याओं को पंक्ति या स्तंभ प्रमुख क्रम में इनपुट कर सकते हैं, और संख्याओं को या तो स्टडिन के माध्यम से स्वीकार कर सकते हैं या किसी फ़ंक्शन के लिए एक सरणी से गुजर सकते हैं।

क्योंकि जीतता है + नुकसान + ड्रॉ = 4, आप एक मान को छोड़ सकते हैं और इसे दूसरों से बाहर कर सकते हैं यदि आप चाहें, तो इसका मतलब है कि आपको केवल 10 नंबर इनपुट करना होगा।

आपको किसी भी टीम के नाम इनपुट करने की आवश्यकता नहीं है।

नमूना इनपुट:

3 1 0
1 2 1
0 3 1
0 2 2
4 0 0

उत्पादन

आपका प्रोग्राम या फ़ंक्शन का आउटपुट stdout में मुद्रित 5 x 5 ग्रिड के रूप में होना चाहिए, या किसी फ़ंक्शन से लौटा एक सरणी। प्रत्येक तत्व को निर्दिष्ट करना चाहिए कि पंक्ति स्थिति में दी गई टीम कॉलम स्थिति में टीम के खिलाफ जीती, हारी या आकर्षित हुई। आउटपुट के लिए आदेश देने वाली पंक्ति इनपुट से मेल खाना चाहिए। आप परिभाषित कर सकते हैं कि एक जीत, हानि या ड्रा को क्या दर्शाता है, इसलिए W, L, D या अंक 0 1 2 या जो कुछ भी आप चाहते हैं उनका उपयोग तब तक किया जा सकता है जब तक कि वे स्पष्ट रूप से परिभाषित हो और एक दूसरे से अलग हो सकते हैं। विकर्ण तत्व अपरिभाषित हैं, आप कुछ भी आउटपुट कर सकते हैं, लेकिन यह प्रत्येक मामले में समान होना चाहिए। मानों को अल्पविराम, रिक्त स्थान या जो भी चरित्र आपको पसंद है, या चरित्र से अलग किया जा सकता है। यदि वांछित है तो इनपुट और आउटपुट दोनों को एक लाइन पर सभी मानों के साथ स्वरूपित किया जा सकता है।

यदि एक तालिका में एक अनूठा समाधान नहीं है, तो आपको अपनी पसंद का एक सरल त्रुटि संदेश आउटपुट करना होगा।

नमूना उत्पादन:

- W W W L
L - W D L
L L - D L
L D D - L
W W W W -

अनमोल तालिका के लिए नमूना उत्पादन:

dunno mate

यह कोड गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा कार्यक्रम है।

Pic संबंधित (जापान बनाम दक्षिण अफ्रीका):

Answer 1

CJam, 57 49 47 45 बाइट्स

{JZb:af{.*e_1+e!}:m*:e_5f/{_z2\ff-=},_,(0@?~}

यह एक अनाम फ़ंक्शन है जो स्टैक से दो-आयामी सरणी पॉप करता है और बदले में एक छोड़ देता है। इसमें 2जीत के लिए, 1ड्रॉ के लिए और 0नुकसान के लिए होता है। इसमें 1विकर्ण तत्वों के लिए भी शामिल है , जिसके लिए आप कुछ भी आउटपुट कर सकते हैं । यदि समस्या हल नहीं है, तो फ़ंक्शन वापस आ जाता है -1।

कोड ऑनलाइन काम करेगा, लेकिन इसमें कुछ समय लगेगा। CJam दुभाषिया में यह कोशिश करो ।

परीक्षण चालन

$ cat input
3 1 0
1 2 1
0 3 1
0 2 2
4 0 0
$ time cjam results.cjam < input
[1 2 2 2 0]
[0 1 2 1 0]
[0 0 1 1 0]
[0 1 1 1 0]
[2 2 2 2 1]

real    0m1.584s
user    0m4.020s
sys     0m0.146s

यह काम किस प्रकार करता है

JZb:a e# Push 19 in base 3; wrap each digit in an array. Pushes [[2] [0] [1]].
f{    e# For each row of the input, push it and [[2] [0] [1]]; then:
  .*  e# Repeat 2, 0 and 1 (win, loss, draw) the specified number of times.
  e_  e# Flatten the resulting array.
  1+  e# Append a 1 for the diagonal.
  e!  e# Push all possible permutations.
}     e#
:m*   e# Cartesian product; push all possible combinations of permutations.
:e_   e# Flatten the results.
5f/   e# Split into rows of length 5.
{     e# Filter:
  _z  e#   Push a transposed copy of the array.
  2\  e#   Swap the result with 2.
  ff- e#   Subtract all elements from 2.
  =   e#   Check for equality.
},    e# Keep the element if `=' pushed 1.
_,(   e# Get the length of the array of solutions and subtract 1.
0@?   e# Keep the array for length 1, push 0 otherwise.
~     e# Either dump the singleton array or turn 0 into -1.

Answer 2

हास्केल, 180 177 बाइट्स

import Data.List
z=zipWith
m=map
a#b|(c,d)<-splitAt a b=c++[0]++d
f t=take 1[x|x<-m(z(#)[0..])$sequence$m(permutations.concat.z(flip replicate)[1,-1,0])t,transpose x==m(m(0-))x]

एक जीत के रूप में 1, एक हार के रूप में -1और एक ड्रा के रूप में दिखाया गया है 0। विकर्ण तत्व भी हैं 0। अयोग्य टेबल खाली सूची हैं, अर्थात []।

प्रयोग उदाहरण: f [[3,1,0],[1,2,1],[0,3,1],[0,2,2],[4,0,0]]-> [[[0,1,1,1,-1],[-1,0,1,0,-1],[-1,-1,0,0,-1],[-1,0,0,0,-1],[1,1,1,1,0]]]।

यह कैसे काम करता है: क्रूर बल! इनपुट के अनुसार जीत / नुकसान / ड्रॉ की सूची बनाएं, जैसे [3,1,0]-> [1,1,1,-1], अनुमति दें, सभी संयोजनों का निर्माण करें, विकर्ण डालें और उन सभी तालिकाओं को रखें जो सभी तत्वों के साथ उनके स्थानांतरण के बराबर हैं। पहले वाला ले लो।