कौन फुटबॉल खेल जीतने वाला है?

17

अमेरिकी फुटबॉल चैम्पियनशिप, सुपर बाउल 50 , आज रात 11:30 बजे यूटीसी (और आप इसे ऑनलाइन लाइव देख सकते हैं ) हो रहा है। इसे मनाने के लिए यह चुनौती दी गई थी।

एक अमेरिकी फुटबॉल खेल में, दो टीमें सबसे अधिक अंक प्राप्त करने के लिए प्रतिस्पर्धा करती हैं और इन अंकों को स्कोर करने के छह तरीके हैं । हम प्रत्येक को एक संक्षिप्त नाम देंगे:

एक प्रोग्राम या फ़ंक्शन लिखिए जो एक ही लाइन स्ट्रिंग में होता है जिसमें केवल ऊपर और नीचे दोनों में केवल छह संक्षिप्तियाँ होती हैं।

यह तार एक खेल (या गेम के हिस्से) में फुटबॉल की सभी स्कोरिंग घटनाओं का प्रतिनिधित्व करता है, जिसमें एक टीम के अपरकेस और दूसरे से संबंधित लोअरकेस होते हैं।

आपका काम खेल के अंतिम स्कोर की रिपोर्ट करना है और यह बताना है कि फॉर्म के आउटपुट के साथ कौन जीता

[score 1] [to] [score 2]

कहाँ पे:

  • [score 1] हमेशा दो अंकों (यदि बराबर नहीं) से बड़ा है, भले ही अपरकेस या लोअरकेस जीता हो।
  • [score 2] दो अंकों से छोटा है (यदि नहीं के बराबर है)।
  • [to]है TOअगर अपरकेस टीम जीता, toअगर लोअरकेस टीम जीता है, और Toअगर यह एक टाई है।

उदाहरण: सुपर बाउल XLIX में सभी स्कोरिंग घटनाओं को स्ट्रिंग द्वारा संक्षेपित किया जा सकता है

TDXPtdxpTDXPtdxpfgtdxpTDXPTDXP

जहाँ अपरकेस न्यू इंग्लैंड पैट्रियट्स है और लोअरकेस सिएटल Seahawks है । पैट्रियट्स ने 28 और हॉक्स ने 24 रन बनाए, इसलिए आउटपुट होगा:

28 TO 24

टिप्पणियाँ

  • आपके प्रोग्राम / फ़ंक्शन को खाली स्ट्रिंग सहित किसी भी मनमाने इनपुट का समर्थन करना चाहिए।
  • XPऔर XDसही होने के बाद ही होगा TD। xpऔर xdसही होने के बाद ही होगा td।
  • आप यह नहीं मान सकते हैं कि इनपुट स्ट्रिंग एक निश्चित मामले में शुरू या समाप्त होती है।
  • एक एकल अनुगामी न्यूलाइन को वैकल्पिक रूप से इनपुट और आउटपुट दोनों में अनुमति दी जाती है

स्कोरिंग

बाइट्स में सबसे छोटा कोड जीतता है। सुपर बाउल 50 के किकऑफ़ ( अब देर से! ) से पहले पोस्ट किए गए उत्तर विजेता टीम ( पैंथर्स या ब्रोंकोस ) की भविष्यवाणी कर सकते हैं ) की , और यदि वे सही हैं, तो एक -10% बाइट बोनस प्राप्त करें!

(मैं यह सुनिश्चित करने के लिए संशोधन इतिहास की जांच करूंगा कि भविष्यवाणियां नहीं बदली हैं और वास्तव में किकऑफ से पहले बनाई गई थीं।)

परीक्षण के मामलों

[empty string] -> 0 To 0
TDXPtdxpTDXPtdxpfgtdxpTDXPTDXP -> 28 TO 24
FG -> 3 TO 0
fg -> 3 to 0
TD -> 6 TO 0
td -> 6 to 0
TDXP -> 7 TO 0
tdxp -> 7 to 0
TDXD -> 8 TO 0
tdxd -> 8 to 0
S -> 2 TO 0
s -> 2 to 0
FCK -> 3 TO 0
fck -> 3 to 0
TDTDXDSssFCKfgfckFGtd -> 22 TO 16
fcksFCKS -> 5 To 5
tdtdtdtdxp -> 25 to 0
SSSSSSSTD -> 20 TO 0
fgSfckFGfgtdxptdxdTDs -> 26 to 11
FGTDXPtdxdtdsStdxpfgTDfckTDXDFCK -> 29 To 29

code-golf  string  arithmetic  game 
— केल्विन के शौक
स्रोत
26
मेरा मानना ​​है कि इसे "शानदार उल्लू" के रूप में
— शैलीबद्ध किया गया है
क्या बोनस तब भी लागू होता है जब आप सुपर बाउल समाप्त होने के बाद अपना पोस्ट संपादित करते हैं ?
— दरवाज़े
1
@Doorknob इसके बारे में कैसे: यदि आप किकऑफ से पहले भविष्यवाणी करते हैं और इसे किसी भी संपादन के साथ नहीं बदलते हैं, तो आप अपने कोड को जितना चाहें उतना संपादित कर सकते हैं। (लेकिन आपकी भविष्यवाणी आपके उत्तर में होनी चाहिए, कुछ टिप्पणी में नहीं। इसलिए आपको शुरू करने के लिए वर्किंग कोड की आवश्यकता है।)
— केल्विन का अनुवाद
2
क्या मैं सिर्फ एक भविष्यवाणी कर सकता हूं और जवाब नहीं? : पी
— आरɪᴋᴇʀ
2
मैं स्कोरिंग बोनस का बहुत बड़ा प्रशंसक नहीं हूं। यह उन लोगों के लिए अनुचित है जिन्होंने पहली बार इस चुनौती को शानदार उल्लू के बाद देखा था , यह उन लोगों के प्रति पक्षपाती है जो एनएफएल पर ध्यान देते हैं, और यह प्रोग्रामिंग क्षमता से पूरी तरह से असंबंधित है।
— DJMcMayhem

जवाबों:

3

पायथ, 49 46 43 42 बाइट्स (बोनस के साथ 37.8 बाइट्स)

jr" to "xh._-FJmsmhx"PSFT"kXd\D\S,rz2z2_SJ

4 बाइट्स बचाने में मेरी मदद करने के लिए @ मैलेटेन को धन्यवाद!

इसे Pyth Compiler में आज़माएँ ।

मुझे सभी आधारों को कवर करना पसंद है, इसलिए मैं ब्रोंकोस पर दांव लगाऊंगा।

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

jr" to "xh._-FJmsmhx"PSFT"kXd\D\S,rz2z2_SJ Input: z

                                  rz2      Swap the case of z.
                                 ,   z     Pair the result with z.
               m                           Map; for each d in the pair:
                           Xd\D\S            Replace each D with an S.
                 m                           Map; for each character k:
                   x"PSFT"k                    Compute k's first index on "PSFT".
                  h                            Increment the index.
                s                            Compute the sum of the incr. indices.
                                               "FG"  -> [3, 0]     -> 3
                                               "TD"  -> [4, 2]     -> 6
                                               "XP"  -> [0, 1]     -> 1
                                               "XD"  -> [0, 2]     -> 2
                                               "S"   -> [2]        -> 2
                                               "FCK" -> [3, 0, 0]  -> 3
                                               (lowercase letters) -> 0
              J                            Save the resulting list of scores in J.
            -F                             Reduce J by subtraction.
          ._                               Compute the sign of the difference.
         h                                 Add 1.
        x                             2    XOR the result with 2.
 r" to "                                   Pick‡ a function and apply it to " to ".
                                       _SJ Sort and reverse the list of scores.
j                                          Join, separating by the modified string.

‡ r फ़ंक्शंस का एक परिवार है जो स्ट्रिंग्स पर काम करता है।

  • यदि पहला स्कोर J(स्वैप किए गए मामले के अनुसार z, यानी, मूल लोअरकेस अक्षर) दूसरे स्कोर से कम है, तो साइन फंक्शन वापस आ जाएगा -1, (-1 + 1) ^ 2 == 2औरr" to "2 है swapcase, तो यह रिटर्न " TO "।

  • तो पहले स्कोर दूसरी स्कोर से अधिक है, पर हस्ताक्षर समारोह वापस आ जाएगी 1, (1 + 1) ^ 2 == 0और r" to "0है lowercase, तो यह रिटर्न " to "।

  • यदि स्कोर बराबर हैं, तो साइन फ़ंक्शन वापस आएगा 0, (0 + 1) ^ 2 == 3और r" to "3है title, इसलिए यह रिटर्न करता है " To "।

— डेनिस
स्रोत
मैंने यह कोशिश नहीं की, लेकिन आप शायद toविभिन्न मूल्यों के माध्यम से विभिन्न एस बनाकर बचा सकते हैंr
— माल्टीसेन
@Maltysen कि अच्छी तरह से काम किया। धन्यवाद!
— डेनिस
4

MATL , 51 * 0.9 = 45.9 54 57 58 63 बाइट्स

3 बाइट्स निकालने के लिए डेनिस के लिए धन्यवाद!

'%i To %i'j0h!3'PDFTS'tkXc=s4:Hh*sSPYD3MdXK?kK0<?Xk

एक एकल इनपुट लाइन के रूप में ऑनलाइन संकलक में एक खाली इनपुट स्ट्रिंग का प्रतिनिधित्व किया जाता है।

EDIT (8 जून, 2016): नीचे दिए गए लिंक में भाषा के 18.1.0 रिलीज के अनुसार एक संशोधन शामिल है ( 3इससे पहले कि वह सही हो Xc)

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

मैंने ब्रोंकोस पर दांव लगाया।

व्याख्या

एक अक्षर का उपयोग करके स्कोर का पता लगाया जाता है, या तो ऊपरी या निचला भाग (अपरकेस निम्नलिखित में दिखाया गया है):

  • P XP के लिए (1 अंक)
  • D XD के लिए (2 अंक)
  • F एफजी के लिए (3 अंक) और एफसीके के लिए (3 अंक)
  • T टीडी के लिए (6 अंक)
  • S एस के लिए (2 अंक)

इन पांच अक्षरों में से प्रत्येक को छोड़कर एक स्कोर घटना के लिए विशिष्ट रूप से मेल खाती है

  • Fके लिए पुन: उपयोग किया जाता है FGऔर FCKजिसका स्कोर समान है। इसके लिए @ डेनिस का शुक्रिया !
  • Dटीडी और एक्सडी दोनों का पता लगाएगा। इसलिए Tक्षतिपूर्ति के लिए 6 के बजाय 4 अंक दिए जाएंगे।

आदेश PDFTS, अंक निर्दिष्ट करने वाले संख्या सरणी को परिभाषित करते समय कुछ बाइट्स बचाता है:[1,2,3,4,2] :।

प्रत्येक घटना को अपरकेस या लोअरकेस में उपरोक्त अक्षरों में से एक की उपस्थिति से पता लगाया जाता है। तुलना तीन आयामों में की जाती है: इनपुट स्ट्रिंग की लंबाई ( N ) × टीमों की संख्या (2) × पता लगाने की घटनाओं की संख्या (5)। व्यापक उपयोग प्रसारण से बना है , जो एक सरणी के स्वचालित विस्तार के साथ एक सिंगलटन आयाम के साथ एक बड़े सरणी के आकार से मेल खाता है।

'%i To %i'  % string with format specifiers for two integers
j0h         % input string. Attach 0 so it's never empty. Gives string of length N>0
!           % transpose into char array of size N×1
3           % number literal
'PDFTS'     % characters to detect the five combined types of score
tk          % duplicate and convert to lowercase
Xc          % concatenate along the third dimension to produce a 1×5×2 array
=           % test for equality with broadcast. Gives N×5×2 array
s           % sum along 1st dim. Gives 1×5×2 array
4:Hh        % array [1,2,3,4,2] to compute the total score. Size 1×5(×1) 
*           % multiply with broadcast. Gives 1×5×2 array
s           % sum along 2nd dim. Gives 1×1×2 array with the two scores
SP          % sort in reverse order along 3rd dim
YD          % sprintf. Gives output string with "To"
3M          % push array with the two scores again
dXK         % difference along 3rd dim. Gives a number. Copy to clipboard K
?           % is it non-zero? If so we need to make either lowercase or uppercase
  k         %   make (tentatively) lowercase
  K0<       %   did the uppercase team win?
  ?         %   if so...
    Xk      %     make uppercase
            % implicitly end the two if's and display string
— लुइस मेंडो
स्रोत
कोई जीत भविष्यवाणी?
— केल्विन के शौक
2
@ केल्विन के शौकीन मैं विकिपीडिया से परामर्श कर रहा था ... अमेरिकी फुटबॉल के बारे में मेरा ज्ञान शून्य के करीब है :-)
— लुइस मेंडो
2
पुनर्प्रयोग Fमें FGऔर FCKतीन बाइट्स को बचाने चाहिए।
— डेनिस
3

CJam, 57 55 54 53 50 49 बाइट्स

q_32f^]{"PSFTD"f#:)5Yer1b}%_$(@:-g"ToTOto"2/=\]S*

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

मुझे पता नहीं है कि ब्रोंको क्या है, इसलिए मैं पैंथर्स पर दांव लगाऊंगा।

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

q                              Read all input from STDIN.
 _                             Push a copy.
  32f^                         XOR all characters with 32. This swaps case.
      ]                        Wrap both strings in an array.
       {                 }%    Map; push the string S, then:
        "PSFTD"                    Push that string (T).
               f#                  Compute the index of each character of S in T.
                 :)                Increment each index.
                   5Yer            Replace 5's with 2's.
                       1b          Add the resulting integers.
                                       "FG"  -> [3 0]      -> 3
                                       "TD"  -> [4 2]      -> 6
                                       "XP"  -> [0 1]      -> 1
                                       "XD"  -> [0 2]      -> 2
                                       "S"   -> [2]        -> 2
                                       "FCK" -> [3 0 0]    -> 3
                                       (lowercase letters) -> 0

                               We've now computed the scores of the first (input)
                               and second (swapped case) team.

_$                             Push a copy of the array of scores and sort it.
  (                            Shift out the first (lower) score.
   @                           Rotate the array of scores on top.
    :-                         Reduce it by subtraction.
      g                        Compute the sign (1, 0 or -1) of the difference.
       "ToTOto"2/              Push ["To" "TO" "to"].
                 =             Select the string that corresponds to the sign.
                  \            Swap it with the lower score.
                   ]           Wrap the entire stack in an array.
                    S*         Join the resulting array, separating by spaces.
— डेनिस
स्रोत
3
— डिजिटल ट्रामा
1
:-gइससे पहले उस इमोटिकॉन को कभी नहीं देखा था
— ETHproductions
@ETHproductions घोंघा-मुंह?
— नहीं कि चार्ल्स
@ETHproductions यह वह है जिसका चश्मा उनके मुंह पर गिर गया है।
— CJ डेनिस
यह एक ब्रोंको है।
— DJMcMayhem
3

जावास्क्रिप्ट (ईएस 6), 128 130 बाइट्स

@ नील की नोक लगाने से 2 बाइट संपादित करें

s=>(l=u=0,s.replace(/fck|s|../gi,x=>(z=+' 231  362'[parseInt(x,36)%10],x>'a'?l+=z:u+=z)),l>u?l+' to '+u:u+(u>l?' TO ':' To ')+l

परीक्षा

f=s=>(
  l=u=0,
  s.replace(/fck|s|../gi,x=>(
    z=+' 231  362'[parseInt(x,36)%10],
    x>'a'?l+=z:u+=z
  )),
  l>u?l+' to '+u:u+(u>l?' TO ':' To ')+l
)

//TEST
console.log=x=>O.textContent+=x+'\n'

;[
["","0 To 0"],
["TDXPtdxpTDXPtdxpfgtdxpTDXPTDXP", "28 TO 24"],
["FG", "3 TO 0"],
["fg", "3 to 0"],
["TD", "6 TO 0"],
["td", "6 to 0"],
["TDXP", "7 TO 0"],
["tdxp", "7 to 0"],
["TDXD", "8 TO 0"],
["tdxd", "8 to 0"],
["S", "2 TO 0"],
["s", "2 to 0"],
["FCK", "3 TO 0"],
["fck", "3 to 0"],
["TDTDXDSssFCKfgfckFGtd", "22 TO 16"],
["fcksFCKS", "5 To 5"],
["tdtdtdtdxp", "25 to 0"],
["SSSSSSSTD", "20 TO 0"],
["fgSfckFGfgtdxptdxdTDs", "26 to 11"],
["FGTDXPtdxdtdsStdxpfgTDfckTDXDFCK", "29 To 29"]
].forEach(t=>{
  var i=t[0],x=t[1],r=f(i)
  console.log(i+' -> '+r+(r==x?' OK':' FAIL expected '+x))
})
<pre id=O></pre>
स्निपेट का विस्तार करें

— edc65
स्रोत
1
वाह, यह चाल के साथ parseIntवास्तव में चालाक है! l>u?l+" to "+u:u+(u>l?" TO ":" To ")+lआउटपुट के लिए @ नील के टिप का उपयोग करने से 2 बाइट्स भी बचेंगे।
— user81655
@ user81655 अच्छी तरह से मैं विचार करता हूं कि हर बार जब मुझे असंवेदनशील तरीके से पत्रों के कुछ छोटे समूह पर काम करने की आवश्यकता होती है, तो ... 99% बार यह बेकार है। नील के टिप को इंगित करने के लिए धन्यवाद
— edc65
2

जावास्क्रिप्ट (ईएस 6), 165 156 151 149 बाइट्स

s=>(a=b=0,s.match(/S|FCK|../gi)||[]).map(m=>(u=m.toUpperCase(),p=u>"XO"?1:u=="TD"?6:u>"R"?2:3,u<m?a+=p:b+=p))&&a>b?a+" to "+b:b+(b>a?" TO ":" To ")+a

9 बाइट्स के लिए धन्यवाद बचाया @ देव-अशक्त करने के लिए, 5 धन्यवाद @Not कि चार्ल्स के लिए और 2 धन्यवाद @Neil !

व्याख्या

var solution =

s=>(
    a=b=0,                // scores for teams A and B
    s.match(/S|FCK|../gi) // get an array of each abbreviation
      ||[]                // if it returns null, default to an empty array
  ).map(m=>(              // for each abbreviation m
    u=m.toUpperCase(),    // u = abbreviation in upper-case
    p=                    // p = number of points for the abbreviation
      u>"XO"?1            // case "XP"
      :u=="TD"?6          // case "TD"
      :u>"R"?2            // case "XD" or "S"
      :3,                 // case "FG" or "FCK"
    u<m?a+=p:b+=p         // add the points to the appropriate team
  ))
  
  // Output the scores
  &&a>b?a+" to "+b
  :b+(b>a?" TO ":" To ")+a
<input type="text" id="input" value="FGTDXPtdxdtdsStdxpfgTDfckTDXDFCK" />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>
स्निपेट का विस्तार करें

— user81655
स्रोत
कठबोली आप का उपयोग करें /s|fck|../giऔर के map(..),a>bबजायmap(..)&&a>b
— 2
मुझे लगता है कि अगर आपने किया तो आप कुछ बचा सकते हैं...:u=="T"?6:u>"R"?2:3...
— न कि चार्ल्स
@ नॉटचार्ल्स ट्रू। पारितोषिक के लिए धन्यवाद!
— user81655
मुझे लगता है कि आप 2 बाइट्स बचा सकते हैंb+(b>a?" TO ":" To ")+a
— नील
2

पर्ल, 144 140 + 2 = 142 बाइट्स

%a=qw(fg 3 td 6 xp 1 xd 2 s 2 fck 3);@a=(0,0);$^=lc,$a[$^eq$_]+=$a{$^}for/fck|s|../gi;$,=$".(To,TO,to)[$a[1]-$a[0]<=>0].$";say sort{$b-$a}@a

-nध्वज की आवश्यकता है और -E:

$ echo "
TDXPtdxpTDXPtdxpfgtdxpTDXPTDXP
FG
fg
SSSSSSSTD
FGTDXPtdxdtdsStdxpfgTDfckTDXDFCK" | \
perl -nE'%a=qw(fg 3 td 6 xp 1 xd 2 s 2 fck 3);@a=(0,0);$^=lc,$a[$^eq$_]+=$a{$^}for/fck|s|../gi;$,=$".(To,TO,to)[$a[1]-$a[0]<=>0].$";say sort{$b-$a}@a'
0 To 0
28 TO 24 
3 TO 0
3 to 0
20 TO 0
29 To 29

संपादित करें: समर्थन करना भूल गए to, Toऔर TO।

— andlrc
स्रोत
अच्छा लगा। लेकिन के %a=qw(fg 3 td 6 xp 1 xd 2 s 2 fck 3)रूप में briefer है %a=(fg,3,td,6,xp,1,xd,2,s,2,fck,3)। और " "(आपकी परिभाषा में $,) के रूप में briefer है $"। लेकिन मैंने उन में से किसी का भी परीक्षण नहीं किया है।
— msh210
@ msh210, मैं उपयोग कर सकता हूं $"और मैं सरणी qwपर हटा सकता हूं to To TO, धन्यवाद!
— -lrc
1

लुआ, 231 200 बाइट्स

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

संपादित करें: मैं कुल मंद हूं। पहले विस्तार पर मैंने जो काम किया है, वह एरे विस्तार का उपयोग करते हुए घूमता है, फिर मैंने इसे बदल दिया और एरे जिसमें लोअरकेस और अपरकेस टीम दोनों के स्कोर शामिल थे, अब उपयोगी नहीं था। इसे हटाने और सादे चर का उपयोग करके एक सुंदर -31 बाइट्स बनाता है।

a={F=3,D=2,T=4,P=1,S=2}l,u=0,0 io.read():gsub(".",function(c)x=a[c:upper()]if a[c]then u=u+a[c]elseif x then l=l+x end end)w=l>u and" to "or l<u and" TO "or" To "print(math.max(l,u)..w..math.min(l,u))

अपुष्ट और स्पष्टीकरण

a={F=3,D=2,T=4,P=1,S=2}        -- define the table a with our scoring values
l,u=0,0                        -- scores for the upper and lowercase teams
io.read():gsub(".",function(c) -- iterate over each character in the input
  x=a[c:upper()]               -- x contains the score for a lowercase character
  if a[c]                      -- if a contains c (would evaluate to nil otherwise)
  then
    u=u+a[c]                   -- increment the score of the uppercase team
  elseif x                     -- if x isn't nil
  then                         -- same as "a contains c:upper()"
    l=l+x                      -- increment the score of the lowercase team
  end
end)                           -- exit the anonyme function
w=l>u and" to "               -- nested ternary, lower > upper, we will use "to"
    or l<u and" TO "       -- lower < uppercase, use "TO"
    or" To "                   -- else (draw), use "To"
print(math.max(l,u)        -- output the concatenated string using 
      ..b.w..math.min(l,u))-- min/max to put the winner in the first position
— Katenkyo
स्रोत
0

पायथन, 167 बाइट्स

शानदार उल्लू लंबे समय से अतीत है, लेकिन चूंकि अभी तक पायथन समाधान नहीं है:

def f(s):g=lambda s:0if s==""else{68:1,70:3,83:2,84:5,88:1}.get(ord(s[0]),0)+g(s[1:]);a=g(s);b=g(s.upper())-a;return"%i %s %i"%((a,("To","TO")[a>b],b),(b,"to",a))[a<b]

अजगर 2 या 3 में काम करता है।

— चक मॉरिस
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.