13

जैसा कि आप जानते हैं, विश्व कप ग्रुप चरण समाप्त हो गया है, और कल से सर्वश्रेष्ठ 16 टीमें नॉकआउट चरण शुरू करेंगी:

ब्राज़ील (ब्रा)
मेक्सिको (MEX)
नीदरलैंड (NED)
चिली (CHI)
कोलम्बिया (COL)
ग्रीस (GRE)
कोस्टा रिका (CRC)
उरुग्वे (URU)
फ्रांस (FRA)
स्विट्जरलैंड (SUI)
अर्जेंटीना (ARG)
नाइजीरिया (NGA)
जर्मनी (GER)
संयुक्त राज्य अमेरिका (यूएसए)
बेल्जियम (BEL)
अल्जीरिया (ALG)

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

आप एक नई सट्टेबाजी वेबसाइट golfbet.com द्वारा काम पर रखा गया है, क्योंकि आप प्रोग्रामिंग और खेल सट्टेबाजी दोनों में अच्छे होने के लिए जाने जाते हैं। आपका कार्य एक प्रोग्राम या फ़ंक्शन लिखना है जो एक मैच के विजेता का अनुमान लगा सकता है। बेशक, हर कोई अलग-अलग अनुमान लगाता है, यह तब तक कोई फर्क नहीं पड़ता जब तक कि आपके अनुमान सुसंगत न हों।

यदि आप अनुमान नहीं लगाना चाहते हैं, तो आप निम्नलिखित अनुमानों का उपयोग कर सकते हैं:

BRA
        BRA
CHI
                BRA
COL
        COL
URU
                        GER
FRA
        FRA
NGA
                GER
GER
        GER
ALG
                                        GER
NED
        NED
MEX
                NED
CRC
        CRC
GRE
                        ARG
ARG
        ARG
SUI
                ARG
BEL
        BEL
USA

टीमों के आदेश की परवाह किए बिना कार्यक्रम को उसी विजेता को आउटपुट करना होगा (BRA-CHI मैच के विजेता को CHI-BRA मैच के समान होना चाहिए)
यदि कोई टीम हार जाती है, तो वह कोई और मैच नहीं खेल सकती है। यह उन मैचों के लिए है जो जगह नहीं लेते हैं, आपको ऐसा संकेत देना होगा। उदाहरण के लिए यदि आपका कार्यक्रम ब्राजील को बीआर-सीएचआई मैच जीतने का अनुमान लगाता है, तो सीएचआई-जीईआर को "कोई परिणाम नहीं" लौटना होगा, क्योंकि चिली जर्मनी के खिलाफ नहीं खेलेगा। शेड्यूल के लिए ऊपर लिंक देखें।

सादगी के लिए आपको कांस्य मैच (लेकिन आप निश्चित रूप से कर सकते हैं) से निपटना नहीं है।

आपका प्रोग्राम या फ़ंक्शन इनपुट के रूप में दो स्ट्रिंग्स लेता है: दो टीमों का 3-अक्षर देश कोड और विजेता टीम का देश कोड लौटाता है (आप मानक इनपुट / आउटपुट, या दो फ़ंक्शन पैरामीटर / वापसी मान का उपयोग कर सकते हैं)। यदि दी गई दो टीमें आपके अनुमानों के अनुसार नहीं खेलेंगी, तो आपको कुछ और लौटाना होगा (यह कुछ भी हो सकता है, लेकिन देश कोड, जैसे कि रिक्त स्ट्रिंग, अशक्त, त्रुटि संदेश)। आप मान सकते हैं कि इनपुट सही है (दो अलग-अलग देश कोड जो सूची में हैं)।

यह मुख्य रूप से एक कोड-गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा कार्यक्रम है। हालांकि, अच्छा और मुश्किल समाधान भी मूल्यवान हैं।

उदाहरण (निश्चित रूप से, आप अपने अनुमान लगा सकते हैं):

इनपुट: बीआरआई ची आउटपुट: बीआरए

इनपुट: CHI BRA आउटपुट: BRA

इनपुट: CHI GER आउटपुट: कोई परिणाम नहीं

code-golf

— डेविड फ्रैंक
स्रोत

होना चाहिए था [एक अंडरहैंड] जो यादृच्छिक अनुमानों का उत्पादन करता है, लेकिन हमेशा अपनी पसंदीदा टीम को जीतते हैं;) (जैसा कि: एक यादृच्छिक अनुमान-ट्री को आउटपुट करता है)

— 27ıʇǝɥʇuʎs

@ stıackuʎs codegolf.stackexchange.com/questions/32092/… यह एक बहुत समान है

— डेविड फ्रैंक

4

@ moreı interestinguʎs, यह कहीं अधिक दिलचस्प है। हमें संभावित कार्यक्रमों का एक स्थान दिया गया है, जो तीन-तत्व सेट पर हैश फ़ंक्शन के अनुरूप है, और हमें सबसे छोटा कार्यक्रम ढूंढना होगा जो उस स्थान के किसी भी कार्यक्रम के बराबर हो।

— पीटर टेलर

1

मान इनपुट वैध है या होगा होगा हो सकता है BRA BRAऔर HAZ CHEEZBURGERठीक से संभाला जा करने के लिए है?

— डेनिस

@ डेनिस मेरा संपादन देखें - इनपुट हमेशा वैध है

— डेविड फ्रैंक

6

पायथन 2.x - 368 283

दिलचस्प चुनौती। बेशक हमें फीफा से वर्तमान रैंकिंग प्राप्त करने की आवश्यकता है । ब्राजील में तथाकथित "12 वें आदमी" हैं क्योंकि उन्हें घरेलू लाभ है इसलिए 12/11 का भार।

a='BRA CHI COL URU FRA NGA ALG GER MEX NED CRC GRE ARG SUI BEL USA'.split()
d=[1242*12/11,1026,1137,1147,913,640,858,1300,882,981,762,1064,1175,1149,1074,1035]
m={}
for n in[16,8,4,2]:
 j=0
 for k in range(0,n,2):
  s=a[k] if d[k]>d[k+1] else a[k+1]
  m[a[k]+' '+a[k+1]]=s
  a[j]=s    
  j+=1
def f(s): 
 try: print m[s] 
 except: print 'no result'

ऊपर संक्षिप्त करने के लिए युक्तियाँ स्वागत है :-)।

@ TheRare और @MrLemon के लिए सुधार

a='BRA CHI COL URU FRA NGA ALG GER MEX NED CRC GRE ARG SUI BEL USA'.split()
d=15,6,10,11,4,0,2,14,3,5,1,8,13,12,9,7
m={}
for n in 16,8,4,2:
 j=0
 for k in range(0,n,2):s=a[k]if d[k]>d[k+1]else a[k+1];m[a[k]+' '+a[k+1]]=s;a[j]=s;j+=1     
def f(s):print s in m and m[s]or'no result'

यह निम्नलिखित परिणामों की ओर जाता है:

BRA CHI: BRA
COL URU: URU
FRA NGA: FRA
ALG GER: GER
MEX NED: NED
CRC GRE: GRE
ARG SUI: ARG
BEL USA: BEL
------------
BRA URU: BRA
FRA GER: GER
NED GRE: GRE
ARG BEL: ARG
------------
BRA GER: BRA
GRE ARG: ARG
------------
BRA ARG: BRA

उदाहरण कॉल:

f('BRA MEX')
no result
f('BRA CHI')
BRA

— विलेम
स्रोत

1. आप उपयोग नहीं करते j(यह हमेशा शून्य है)। 2. सीमांकक for kका उपयोग करके एक पंक्ति में लिखा जा सकता है ;। 3. आप जैसे कीवर्ड के बाद अंतरिक्ष की जरूरत नहीं है tryया except4. आप कोष्ठक और कीवर्ड (बीच रिक्त स्थान को हटा सकते हैं a[k]if d[k]>d[k+1]else a[k+1]मान्य है) 5. for n in 16,8,4,26.def f(s):print s in m and m[s]or'no result'

— seequ

@ TheRare वह उपयोग करता है j, लेकिन इसके साथ एक मामूली स्वरूपण त्रुटि है j+=1। और आप फीफा डेटा को फिर से [15,6,10,11,4,0,2,14,3,5,1,8,13,12,9,7], निश्चित रूप से बहुत सारे पात्रों को बचा सकते हैं ।

— मृत्युंजय

@ श्रीमन आह, मैंने खुद कोड की कोशिश नहीं की, बस इसे देखा।

— देखिए

5

सी, 182 178 133 (या 126)

यहां सबसे छोटा कार्यक्रम नहीं है, लेकिन यह सबसे छोटा है जिसमें भविष्यवाणी को आसानी से बदला जा सकता है। अब जब सभी सेमीफाइनलिस्ट जाने जाते हैं, तो मैं अपडेट कर रहा हूं।

कोड में कुछ बदलाव भी हुए हैं। टिप्पणियों में डेनिस के सुझावों के अलावा, कार्यक्रम को एक फ़ंक्शन में बदल दिया गया है (जैसा कि नियमों को फिर से पढ़ने की अनुमति है) और हैशिंग को छोटा कर दिया गया है।

कोड, 133

f(char*a,char*b){
  char*p,*t=" HIAEAIH N?=R=?N ;@4S4@; 5BDGDB5 B@?I?@B",h[3]={*a-a[1]%16,*b-b[1]%16};
  (p=strstr(t,h))&&puts(p-t&2?a:b);
}

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

इनपुट aऔर एक ही चरित्र के bलिए अभिव्यक्ति द्वारा hashed हैं *a-a[1]%16( *aएक छोटे से बराबर है a[0])। टीमों के लिए हैश परिणाम है aऔर bमें संग्रहीत हैं h। उदाहरण के लिए BRA CHI बन जाता है @;। हशेड मान इस प्रकार हैं (पुष्टि किए गए सेमीफाइनलिस्ट और मेरे पूर्वानुमानित चैंपियन के साथ चिह्नित हैं *।)

GRE E   CRC A   *NED I   MEX H
USA R   BEL =   *ARG ?   SUI N
URU S   COL 4  **BRA @   CHI ;
NGA G   FRA D   *GER B   ALG 5

t[]मेरी भविष्यवाणियों को संग्रहीत करता है। 16 और क्वार्टर फाइनल के दौर के परिणाम अब ज्ञात हैं। 4 टीमों के प्रत्येक समूह को आदेश दिया जाता है कि 1 और 4 को समाप्त कर दिया गया, और 3 सेमीफाइनलिस्ट है। सेमीफाइनलिस्ट की तरह, मैं यह अनुमान लगा रहा हूं कि 1 और 4 को समाप्त कर दिया जाएगा और 3 डी सेमीफाइनलिस्ट समग्र विजेता होगा। यदि आप मेरी भविष्यवाणियों से असहमत हैं, तो बस तालिका को पुनः व्यवस्थित करें।

भविष्यवाणियों को संभावित क्रम में टीमों में प्रवेश करने वाले उपयोगकर्ता की संभावना को समायोजित करने के लिए पैलिंड्रोमिक ब्लॉकों में संग्रहीत किया जाता है। आदेश तीसरे मैच खेलने के लिए प्रत्येक सेट की विजेता टीमों को एक साथ रखता है। इस प्रकार पहले समूह में GRE ECRC से हार गया और MEX HNED से हार गया। यह टाइपिंग दोहराने के बिना क्वार्टर फाइनल में ANED खेलने के लिए CRC सेट करता है I। स्ट्रिंग को 4 टीमों / 7 वर्णों के प्रत्येक समूह के बीच एक स्थान के साथ रखा गया है ताकि यह सुनिश्चित हो सके कि टीमों के लिए कोई आउटपुट नहीं है जो एक दूसरे को नहीं खेलेंगे।

8 अक्षरों में से प्रत्येक समूह में प्रत्येक संभव मैच के विजेता इस प्रकार है: invalid,b,a,a,b,b,a,invalid। इस प्रकार विजेता का सही विकल्प का स्थान ज्ञात किया जा सकता है hमें t और 2 । दुर्भाग्यवश यह strstrफ़ंक्शन सबसे स्ट्रेन्गवर्डवर्ड नहीं है क्योंकि यह एक पॉइंटर लौटाता है p, इसलिए हमें वास्तविक स्थिति प्राप्त करने के लिए इसमें pसे घटा देना चाहिए यदि मैच अमान्य है (पाया नहीं जा सकता है ), शून्य है और वाक्यांश मुद्रित है।tt.tpno result

कुछ संदिग्ध सुधार, 126

एक बेहतर हैश अभिव्यक्ति द्वारा सहेजे गए 2 वर्ण। दुर्भाग्य से, इसके लिए टीमों के मामले की आवश्यकता होती है जैसा कि नीचे दिए गए परीक्षण कार्यक्रम में दिखाया गया है (उदाहरण के लिए ऊपर दिए गए प्रोग्राम में उपयोग किए जाने के Braबजाय BRA।) मैंने खुद को संतुष्ट किया है कि किसी एकल ऑपरेटर के साथ ऐसा करने का कोई तरीका नहीं है। इसलिए 2 ऑपरेटर और एक एकल-चरित्र स्थिरांक जितना अच्छा हो उतना अच्छा है। ध्यान दें कि टीमकोड के समूहों को अलग करने के लिए एक वैकल्पिक चरित्र के Uruलिए नक्शे की आवश्यकता है।space|

5 tस्ट्रिंग को शाब्दिक रूप से भविष्यवाणी स्ट्रिंग को नष्ट करने और इलाज करके बचाया गया । इसका मतलब यह है कि यह पता करना असंभव है कि स्ट्रिंग कहाँ संग्रहीत है। हालाँकि, बशर्ते कि यह शून्य पर संग्रहीत नहीं है, हम केवल रुचि रखते हैं p&2इसलिए कोड काम करेगा यदि पता 4 से विभाज्य है। (ध्यान दें कि यह pसीधे सूचक को पूर्णांक के रूप में व्यवहार करने की अनुमति नहीं है , इसे दूसरे सूचक से घटाया जाना चाहिए। । मैं पॉइंटर का उपयोग करता हूं aइसलिए a4. से भी विभाज्य होना चाहिए।) एक 32 या 64 बिट कंपाइलर / आर्किटेक्चर स्ट्रिंग्स पर काफी भरोसा किया जा सकता है इस तरह से संग्रहीत किया जाएगा। यह मेरे लिए जीसीसी / साइबरविन पर ठीक काम कर रहा है, हालांकि यह दृश्य स्टूडियो / खिड़कियों पर संकलन करने से इनकार करता है।

g(char*a,char*b){
  char*p,h[3]={*a^a[1]+3,*b^b[1]+3};
  (p=strstr("|%&626&%|+4*#*4+|(71 17(|./3$3/.|/74&47/",h))&&puts(p-a&2?a:b);
}

main(){
  char team[16][4]={"Gre","Crc","Ned","Mex", "Usa","Bel","Arg","Sui", "Uru","Col","Bra","Chi", "Nga","Fra","Ger","Alg"}; 
  int i;
  for(i=1;i<16;i++){printf("%s %s \n",team[i-1],team[i]);g(team[i],team[i-1]);g(team[i-1],team[i]);}  
}

— स्तर नदी सेंट
स्रोत

दिलचस्प दृष्टिकोण! आप के बीच की जगह को हटाने के द्वारा कुछ बाइट्स बचा सकता है charऔर *pऔर की जगह a[0], b[0]और h[0]साथ *a, b` और *h। इसके अलावा, सवाल यह कहता है कि * यदि दी गई दो टीमें आपके अनुमानों के अनुसार नहीं खेलेंगी, तो आपको कुछ और लौटाना होगा (यह कुछ भी हो सकता है, लेकिन देश कोड, जैसे कि खाली स्ट्रिंग, अशक्त, त्रुटि संदेश) , इसलिए मुद्रण का कोई परिणाम नहीं है आवश्यकता नहीं है और आप के puts(...)साथ बदल सकते हैं (p=strstr(t,h))&&puts(p-t&2?a:b)।

— डेनिस

विशेष रूप से सुझावों के लिए धन्यवाद a[0]->*a! जल्द ही अपडेट होगा। बस सोच रहा था, क्या एक एकल संख्या के साथ बहुआयामी सरणी तक पहुंचने का कोई तरीका है? मैंने समान लंबाई के इस कमांड लाइन संस्करण को लिखा है (1 बाइट को एक के साथ बचा सकता है #define।) इस और इसी तरह के मामलों में डबल सब्सक्रिप्शन से बचना अच्छा होगा:

char *p,h[2],*t="-LgRrRgL bA9j9Ab hp535ph OKYtYKO KpAgApK";main(int c,char**v){h[0]=v[1][1]*3-v[1][0]*2;h[1]=v[2][1]*3-v[2][0]*2;puts((p=strstr(t,h))?v[1+!(p-t&2)]:"no result");}

— लेवल रिवर सेंट

1. मुझे एक छोटा सा बग मिला। hअशक्त होना चाहिए, इसलिए यह होना चाहिए h[3]। 2. यदि आप सेट करते हैं p=v[1], तो आप उपयोग कर सकते हैं v[i][j]के रूप में p[4*(i-1)+j]। यह मेरी मशीन पर काम करता है, लेकिन मुझे नहीं पता कि यह पोर्टेबल है ... 3. hयदि आप इसे अंदर घोषित करने में सक्षम हो सकते हैं main:

main(int c,char**v){char*t="-LgRrRgL bA9j9Ab hp535ph OKYtYKO KpAgApK",*p=v[1],h[3]={p[1]*3-*p*2,p[5]*3-p[4]*2};(p=strstr(t,h))&&puts(v[1+!(p-t&2)]);}

— डेनिस

@ अपना कोड मेरी मशीन पर GCC / cygwin और VS / Windows दोनों पर ठीक काम करता है। for(int i=0;i<1000;i++)printf("%d %c ",i,i[*argv])वीएस पर कमांड लाइन के ईवे प्रिंट करने योग्य चरित्र को भी वापस करता है, लेकिन जीसीसी पर कार्यक्रम का नाम 0 पर है, पहला तर्क 40 पर है और दूसरा तर्क कहीं नहीं देखा जा सकता है (मैं 1000 तक गया)। उत्सुक। वैसे भी, मैं अपनी भविष्यवाणियों को अपडेट करने के अलावा, एक फ़ंक्शन में बदल गया हूं (मैं पोस्ट करने से पहले उन्हें पुष्टि करने के लिए आज रात के परिणाम का इंतजार कर रहा था।) फिर से धन्यवाद और मंगलवार को ब्राजील के खिलाफ शुभकामनाएं।

— लेवल रिवर सेंट

3

जावास्क्रिप्ट २१५ २०६ १२० ११६

सुधार के लिए बहुत जगह:

ईएस 5 - 215

a=prompt().split(' ');("BRACHI0COLURU0FRANGA0GERALG0NEDMEX0CRCGRE0ARGSUI0BELUSA0BRACOL0FRAGER0NEDCRC0ARGBEL0BRAGER0NEDARG0BRANED".split(0).filter(function(x){return x.match(a[0])&&x.match(a[1])})[0]||"").substr(0,3)

ईएस 6 - 206

a=prompt().split(' ');("BRACHI0COLURU0FRANGA0GERALG0NEDMEX0CRCGRE0ARGSUI0BELUSA0BRACOL0FRAGER0NEDCRC0ARGBEL0BRAGER0NEDARG0BRANED".split(0).filter((x)=>{return x.match(a[0])&&x.match(a[1])})[0]||"").substr(0,3)

रेगेक्स दृष्टिकोण - 116

इस लिंक को पोस्ट करने के लिए ʇǝɥʇı touʎs का धन्यवाद , इसने मुझे रेग्क्स बनाने में मदद की

a=prompt().split(' ').sort();a.join('').match(/LG(.R(A|G)|GE)|RG(S|BE|CR)|ELUS|AC(H|O)|OLUR|CGR|CM|FRANG|XNE/)&&a[0]

— विलियम बारबोसा
स्रोत

1

आप परिवर्तित करके अपने समाधान छोटा कर सकते हैं split(' ')करने के लिए split``और join('')करने के लिए join``।

— अर्जुन

2

अजगर ( 179 148 139 cq रास्ता बहुत लंबा)

f=lambda *l:sorted(l)[0]if"".join(sorted(l))in"BRACHI COLURU FRANGA ALGGER MEXNED CRCGRE ARGSUI BELUSA BRACOL ALGFRA CRCMEX ARGBEL BRAFRA CRCMEX ARGBEL BRAFRA ARGCRC ARGBRA"else 0

देश को हर कोई जानता है उस नाम के साथ जो वर्णमाला में पहली बार आता है वह जीतने वाला है। (यह जवाब सिर्फ चीजों को शुरू करने के लिए मौजूद है)

पुरुष (रों) से अधिक की दान करने के लिए धन्यवाद यहाँ , मैं थोड़ा द्वारा मेरा उत्तर को छोटा कर सकते हैं:

import re;f=lambda *l:sorted(l)[0]if re.match('RGB|CM|RGS|CGR|L.F|XNE|EL.S|O.UR|RGCR|B.AF|L.GE|^BRACHI$|^FRANGA$|^BRACOL$',"".join(sorted(l)))else 0

यह मान्य टीमों को मानता है, लेकिन एक वैध लाइन-अप ( f('BRA','NED')0 (अमान्य मैच) f('XNE')लौटाएगा ) की आवश्यकता नहीं है, लेकिन वापस आ जाएगा 'XNE'। मुझे आपके सवाल से नहीं मिलता है कि यह एक समस्या है। फिर से दुरुपयोग करने के लिए स्वतंत्र महसूस करें। जैसा कि आप फिट देखते हैं यह रेगेक्स।

धन्यवाद @Ventero, मुझे पता है कि regexes के बारे में कुछ भी नहीं है।

import re;f=lambda*l:sorted(l)[0]if re.match('RGB|CM|RGS|CGR|L.F|XNE|EL.S|O.UR|RGCR|B.AF|L.GE|BRACHI|FRANGA|BRACOL',"".join(sorted(l)))else 0

— ɐɔıʇǝɥʇuʎs
स्रोत

आप शायद re.searchगोल्फ संस्करण में चाहते हैं , नहीं re.match। इसके अलावा, आपको ^और $एंकर को गिराने में सक्षम होना चाहिए ।

— वेंचरो

2

स्काला (150)

type s=String;var m=Map[s,s]();def f(x:(s,s))={var a=x._1;var b=x._2;if(b<a){b=a;a=x._1};if(m.getOrElse(a,a)=="")m.getOrElse(b,b)else{m=m+(b->"");a}}

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

यह सिर्फ खोई हुई टीमों की रिकॉर्डिंग कर रहा है।

type s=String //just aliasing for saving characters
var m=Map[s,s]() //map for storing loosing teams, a set would do too
def f(x:(s,s))={
  var a=x._1 var b=x._2
  if(b<a){b=a;a=x._1};//swap if b<a lexographically
  if(m.getOrElse(a,a)=="")//if a has loosed previously
     m.getOrElse(b,b)// return b if b was not in the map else return ""
  else{
    m=m+(b->"") //add b to the map, because a will definitly win this amazing match
    a //and return a
  }
}

इसके साथ कॉल किया गया:

f(("GER","BRA"))

— थी जीजी
स्रोत

2

पॉवरशेल ( 261 221)

$a=Read-Host;$b=Read-Host;$x="CHIBRA","URUCOL","FRANGA","ALGGER","MEXNED","CRCGRE","SUIARG","BELUSA";0..($x.Length-2)|%{$x+=$x[2*$_].Substring(3)+$x[2*$_+1].Substring(3)};$x|?{"$a$b","$b$a"-eq$_}|%{$_.Substring(3);exit};0

अपेक्षाकृत नए PowerShell उपयोगकर्ता के रूप में, मुझे पाइप लाइन बिल्कुल आश्चर्यजनक लगी। मुझे लगता है कि अगली कोशिश करने के लिए और सरणी के साथ बेला हो सकता है उम्मीद है कि इन सभी प्रतिस्थापन कॉल को खत्म करने के लिए। (मुझे अंत में एक कॉल जोड़ना था या फिर यह दोनों टीमों को आउटपुट देता था)

नया सदस्य, कोड गोल्फ में पहला प्रयास!

कुछ वर्णों को सहेजने के लिए क्वार्टरफ़ाइनल, सेमी और फ़ाइनल को हार्ड-कोडित किया जा सकता था, लेकिन यह उतना मज़ेदार नहीं होगा।

समझने के लिए पर्याप्त सरल होना चाहिए, लेकिन यह दोनों शर्तों को पूरा करता है: एक ही विजेता देता है> बिना किसी आदेश के प्रवेश किया जाता है, और केवल मैचों के लिए एक विजेता देता है जो वास्तव में जगह लेता है!

सुधार के लिए कोई सलाह बहुत सराहना की जाएगी, धन्यवाद!

मूल

$a=Read-Host;$b=Read-Host;$x=("CHIBRA","URUCOL","FRANGA","ALGGER","MEXNED","CRCGRE","SUIARG","BELUSA");for($c=0;$c-lt$x.length-1;$c+=2){$x+=$x[$c].Substring(3)+$x[$c+1].Substring(3)}foreach($i in $x){if($i-match$a-and$i-match$b){return $i.Substring(3)}}return 0

— fuandon
स्रोत

1

कुछ चीजें (इसे पूरी तरह से तय करने में बहुत अधिक समय लगेगा): PowerShell को ऐसा न लिखें मानो वह C या C # हो। इसका मतलब है, returnज्यादातर मामलों में अनावश्यक है। foreachऔर सबसे स्पष्ट छोरों को ओवररेटेड और बेकार कर दिया गया है। जैसे तरीकों का .Substringउपयोग केवल चरम परिस्थितियों में किया जाना चाहिए (और फुटबॉल की उपयोगिता पर बहस हो सकती है, यह एक चरम खेल नहीं है)। आम तौर पर आप पाइपलाइन का अधिक से अधिक उपयोग करना चाहते हैं।

— जॉय

1

इसके बजाय एक लंबी घुमावदार forलूप लिखने की तरह for($c=0;$c-lt$x.length-1;$c+=2){$x+=$x[$c].Substring(3)+$x[$c+1].Substring(3)}आप बस एक सीमा और ForEach-Object(उपनाम %) के साथ एक पाइपलाइन का उपयोग कर सकते हैं 0..($x.Length/2)|%{$x+=$x[2*$_].Substring(3)+$x[2*$_+1].Substring(3)}:। आपके डेटा का प्रतिनिधित्व कैसे किया जाता है, इस पर सावधानी से विचार करके आप Substringकॉल से छुटकारा पा सकते हैं। प्रारंभिक सरणी के आसपास कोष्ठक अनावश्यक हैं। बड़े सरणियों के लिए यह एक विभाजक चरित्र और उपयोग करने के लिए भी समझ में आता है -split( -splitविभाजक अंतरिक्ष या टैब के मामले में एकात्मक )।

— जॉय

1

foreachउदाहरण के लिए अंतिम लूप को एक पाइपलाइन के रूप में भी लिखा जा सकता है ( ?है Where-Object): $x|?{$_-match$a-and$_-match$b}|%{$_;exit};0जो अनिवार्य रूप से कहता है »हर तत्व को फ़िल्टर करें $xकि क्या यह दोनों से मेल खाता है $aऔर $bपहले वाले को आउटपुट करता है, बाद में बाहर निकलता है। यदि कोई नहीं पाया जा सका, तो आउटपुट 0. «। जब से आप अपने तार के प्रारूप को जानते हैं, तो आप भी इसका उपयोग कर सकते हैं -match"$a$b|$b$a", मुझे लगता है। क्योंकि उन्हें स्ट्रिंग में या तो क्रम में प्रदर्शित होना है। जिसका अर्थ यह भी है कि हम यहां थोड़ी सी ट्रिक का उपयोग कर सकते हैं: "$a$b","$b$a"-eq$_गोल्फ के लिए अभी तक एक और बाइट।

— जॉय

2

सीजेएम, 64 58 बाइट्स

lS/$_0=\:+4b256b1>:ca"oM-YtM-mM-^@}gM-^VM-^U8tM-=nM-^MfM-]oM-xgM-)tM-|m@gim{g_"2/&,*

उपरोक्त कार्यवाहक और M- संकेतन का उपयोग करता है, क्योंकि कोड में अनपेक्षित वर्ण हैं।

छह अतिरिक्त बाइट्स की कीमत पर, उन पात्रों से बचा जा सकता है:

lS/$_0=\:+4b95b1>32f+:c"I8Vyv)2~N{VIEh1$IW32W)B82QBs2G"2/N*\#W>*

इसे ऑनलाइन आज़माएं।

परीक्षण चालन

$ base64 -d > worldcup.cjam <<< \
> bFMvJF8wPVw6KzRiMjU2YjE+OmNhIm/ZdO2AfWeWlTh0vW6NZt1v+GepdPxtQGdpbXtnXyIyLyYsKg==
$ wc -c worldcup.cjam
58 worldcup.cjam
$ for A in ALG ARG BEL BRA CHI COL CRC FRA GER GRE MEX NED NGA SUI URU USA; do
> for B in ALG ARG BEL BRA CHI COL CRC FRA GER GRE MEX NED NGA SUI URU USA; do
> [[ $A < $B ]] && echo $A - $B : $(LANG=en_US cjam worldcup.cjam <<< "$A $B")
> done; done | grep ': .'
ALG - ARG : ALG
ALG - BRA : ALG
ALG - FRA : ALG
ALG - GER : ALG
ARG - BEL : ARG
ARG - CRC : ARG
ARG - SUI : ARG
BEL - USA : BEL
BRA - CHI : BRA
BRA - COL : BRA
COL - URU : COL
CRC - GRE : CRC
CRC - MEX : CRC
FRA - NGA : FRA
MEX - NED : MEX

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

lS/$    " Read one line from STDIN, split at spaces and sort the resulting array.         ";
_0=\    " Extract the first element of a copy of the array and swap it with the array.    ";
:+      " Concatenate the strings.                                                        ";
4b      " Convert the resulting string into an integer by considering it a base 4 number. ";
256b    " Convert the integer into an array by considering it a base 256 number.          ";
1>:ca   " Drop the first element, convert into a string and create a singleton array.     ";
"…"     " Push a string of all matches encoded as explained above.                        ";
2/      " Split the string into an array of two-character strings.                        ";
&       " Intersect the two arrays. If the array is non-empty, the teams play.            ";
,*      " Multiply the string on the stack by the length of the array.                    ";

— डेनिस
स्रोत

निष्पक्ष होने के लिए आपको अपनी बैश स्क्रिप्ट का आकार CJam प्रोग्राम के आकार में जोड़ना चाहिए।

— डेविड फ्रैंक

1

@DavidFrank: मैंने सबूत दिखाने के लिए बैश स्क्रिप्ट को शामिल किया है कि मेरा कार्यक्रम केवल 15 मैचों के लिए आउटपुट प्रदान करता है। यह अपने आप काम करता है और किसी बाहरी कार्यक्रम की आवश्यकता नहीं है।

— डेनिस

2

सीजेएम, 49 48 बाइट्स

lS/$_0="^\16@&^^/+(^]^W^Y,>O?"{_2%+}3*@{2b91%c}%#1&!*

उपरोक्त कार्यवाहक संकेतन का उपयोग करता है, क्योंकि कोड में अनपेक्षित वर्ण हैं।

दो अतिरिक्त बाइट्स की कीमत पर, उन पात्रों से बचा जा सकता है:

lS/$_0="(=BL2*;74)#%8J[K"{_2%+}3*@{2b91%C+c}%#1&!*

इसे ऑनलाइन आज़माएं।

परीक्षण चालन

$ base64 -d > wc.cjam <<< bFMvJF8wPSIcMTZAJh4vKygdFxksPk8/IntfMiUrfTMqQHsyYjkxJWN9JSMxJiEq
$ wc -c wc.cjam
48 wc.cjam
$ for A in ALG ARG BEL BRA CHI COL CRC FRA GER GRE MEX NED NGA SUI URU USA; do
> for B in ALG ARG BEL BRA CHI COL CRC FRA GER GRE MEX NED NGA SUI URU USA; do
> [[ $A < $B ]] && echo $A - $B : $(cjam wc.cjam <<< "$A $B"); done; done | grep ': .'
ALG - ARG : ALG
ALG - BRA : ALG
ALG - FRA : ALG
ALG - GER : ALG
ARG - BEL : ARG
ARG - CRC : ARG
ARG - SUI : ARG
BEL - USA : BEL
BRA - CHI : BRA
BRA - COL : BRA
COL - URU : COL
CRC - GRE : CRC
CRC - MEX : CRC
FRA - NGA : FRA
MEX - NED : MEX

पृष्ठभूमि

हम प्रत्येक टीम को उसके नाम के आधार 2 नंबर पर विचार करके और परिणामित पूर्णांक modulo 91 लेकर, 12 जोड़ते हैं (अनपेक्षित वर्णों से बचने के लिए) और परिणामी ASCII कोड के अनुरूप चरित्र का चयन करके प्रत्येक टीम को असाइन करना और ASCII चरित्र। CJam कोड में, यह हासिल किया है 2b91%c।

उदाहरण के लिए, वर्ण कोड ALGहैं 65 76 71। के बाद से (4 × 65 + 2 × 76 + 71) = 483, 483 % 91 + 12 = 40और 40 अगर चरित्र कोड (।

यह निम्नलिखित मानचित्रण देता है:

ALG (    ARG 4    BEL #    BRA 2    CHI *    COL ;    CRC 8    FRA B
GER =    GRE J    MEX [    NED K    NGA L    SUI )    URU 7    USA %

अब, हम 16 राउंड के मैचों को निम्नानुसार सांकेतिक शब्दों में बदलना कर सकते हैं:

(=BL2*;74)#%8J[K

यदि हम मानते हैं कि वर्णमाला क्रम में पहली टीम हमेशा जीतती है, तो क्वार्टर फाइनल के मैच इस प्रकार हैं:

(B2;4#8[

ध्यान दें कि यह स्ट्रिंग पहले से शुरू होने वाले प्रत्येक दूसरे वर्ण का चयन करके पहले से प्राप्त की जा सकती है। CJam कोड में, यह हासिल किया है 2%।

इसी विचार का उपयोग करते हुए, सेमीफाइनल और फाइनल मैच के मैच इस प्रकार हैं:

(248
(4

कोड

"(=BL2*;74)#%8J[K"{_2%+}3*

स्ट्रिंग को 16 के दौर के मैचों से ढंकता है, फिर निम्नलिखित तीन बार करता है: स्ट्रिंग को डुप्लिकेट करें, प्रतिलिपि के प्रत्येक दूसरे चरित्र को निकालें, समतल करें। परिणाम स्ट्रिंग है

(=BL2*;74)#%8J[K(B2;4#8[(B2;4#8[(248(B2;4#8[(248(248(4

जिसमें सभी मैच होते हैं (उनमें से कुछ एक से अधिक बार)।

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

lS/$        " Read one line from STDIN, split at spaces and sort the resulting array.     ";
_0=         " Extract the first element of a copy of the array.                           ";
"…"         " Push the string containing the matches of the round of 16.                  ";
{_2%+}3*    " Push the remaining matches.                                                 ";
@           " Rotate the input array on top of the stack.                                 ";
{2b91%C+c}% " Perform the mapping for each team in the input array.                       ";
#           " Push the index of the match in the array of all matches (-1 for not found). ";
1&!         " Push 1 if the index is even (valid match) and 0 if it is odd.               ";
,*          " Repeat the string on the stack that many times.                             ";

— डेनिस
स्रोत

यह अद्भुत है कि आप Cjam के साथ क्या करते हैं। जब भी मुझे लगता है कि आप मेरे विचारों में से एक को उधार ले सकते हैं, तो आप कुछ बेहतर लेकर आएंगे! आपकी भविष्यवाणी कोड "(=BL2*;74)#%8J[K"{_2%+}3*मेरी भविष्यवाणी स्ट्रिंग के गैर-विचित्र रूप के समान लंबाई है "rRgL j9Ab 35ph tYKO gApK"लेकिन संभाल करने के लिए बहुत आसान है।

— स्तर नदी सेंट

0

जावास्क्रिप्ट 271

t=prompt('Match?').split('-')
x=t[0],y=t[1],T='BRACHICOLURUFRANGAGERALGNEDMEXCRCGREARGSUIBELUSA'
v='\n',R='',W='No Game'
for(z=1;T!='USA';++z,T=n){R+=v+z+v,n='',r=/(...)(...)/g
while(m=r.exec(T))a=m[1],n+=b=m[2],R+=a+'-'+b+v,W=a==x&&b==y||a==y&&b==x?b:W
}
alert(W+'\n'+R)

— wolfhammer
स्रोत

एक विश्व कप अनुमान लगाने का कार्यक्रम बनाएं

पायथन 2.x - 368 283

सी, 182 178 133 (या 126)

जावास्क्रिप्ट २१५ २०६ १२० ११६

अजगर ( 179 148 139 cq रास्ता बहुत लंबा)

स्काला (150)

पॉवरशेल ( 261 221)

मूल

सीजेएम, 64 58 बाइट्स

परीक्षण चालन

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

सीजेएम, 49 48 बाइट्स

परीक्षण चालन

पृष्ठभूमि

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

जावास्क्रिप्ट 271