एक ASCII डेक का सौदा करें

13

वहाँ वास्तव में एक निश्चित ASCII कार्ड AFAIK चुनौती कभी नहीं किया गया है। तो, ASCII कार्ड के निम्नलिखित डेक का उपयोग कर:

.------..------..------..------..------..------..------..------..------..------..------..------..------.
|2.--. ||3.--. ||4.--. ||5.--. ||6.--. ||7.--. ||8.--. ||9.--. ||T.--. ||J.--. ||Q.--. ||K.--. ||A.--. |
| (\/) || (\/) || (\/) || (\/) || (\/) || (\/) || (\/) || (\/) || (\/) || (\/) || (\/) || (\/) || (\/) |
| :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: |
| '--'2|| '--'3|| '--'4|| '--'5|| '--'6|| '--'7|| '--'8|| '--'9|| '--'T|| '--'J|| '--'Q|| '--'K|| '--'A|
'------''------''------''------''------''------''------''------''------''------''------''------''------'
.------..------..------..------..------..------..------..------..------..------..------..------..------.
|2.--. ||3.--. ||4.--. ||5.--. ||6.--. ||7.--. ||8.--. ||9.--. ||T.--. ||J.--. ||Q.--. ||K.--. ||A.--. |
| :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: |
| :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: || :\/: |
| '--'2|| '--'3|| '--'4|| '--'5|| '--'6|| '--'7|| '--'8|| '--'9|| '--'T|| '--'J|| '--'Q|| '--'K|| '--'A|
'------''------''------''------''------''------''------''------''------''------''------''------'
.------..------..------..------..------..------..------..------..------..------..------..------..------.
|2.--. ||3.--. ||4.--. ||5.--. ||6.--. ||7.--. ||8.--. ||9.--. ||T.--. ||J.--. ||Q.--. ||K.--. ||A.--. |
| :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: || :/\: |
| (__) || (__) || (__) || (__) || (__) || (__) || (__) || (__) || (__) || (__) || (__) || (__) || (__) |
| '--'2|| '--'3|| '--'4|| '--'5|| '--'6|| '--'7|| '--'8|| '--'9|| '--'T|| '--'J|| '--'Q|| '--'K|| '--'A|
'------''------''------''------''------''------''------''------''------''------''------''------''------'
.------..------..------..------..------..------..------..------..------..------..------..------..------.
|2.--. ||3.--. ||4.--. ||5.--. ||6.--. ||7.--. ||8.--. ||9.--. ||T.--. ||J.--. ||Q.--. ||K.--. ||A.--. |
| :(): || :(): || :(): || :(): || :(): || :(): || :(): || :(): || :(): || :(): || :(): || :(): || :(): |
| ()() || ()() || ()() || ()() || ()() || ()() || ()() || ()() || ()() || ()() || ()() || ()() || ()() |
| '--'2|| '--'3|| '--'4|| '--'5|| '--'6|| '--'7|| '--'8|| '--'9|| '--'T|| '--'J|| '--'Q|| '--'K|| '--'A|
'------''------''------''------''------''------''------''------''------''------''------''------''------'

दो पूर्णांक लें, pऔर qइनपुट के रूप में; pखिलाड़ियों की संख्या कहां है और qप्रत्येक खिलाड़ी को कितने कार्ड मिलते हैं।

  • बेतरतीब ढंग से कार्ड के डेक को फेरबदल करें (यह अस्पष्ट है, लेकिन इसका मतलब है कि सभी कार्डों को एक बार कहीं भी दिखाई देने की संभावना समान रूप से होनी चाहिए)।
  • प्रति खिलाड़ी कार्ड के 1 राउंड का सौदा, कार्ड की qपंक्तियों को pप्रत्येक पंक्ति में आउटपुट करना ।

नियम:

  • परिणाम समान रूप से यादृच्छिक होना चाहिए, प्रत्येक कार्ड को समान रूप से कहीं भी दिखाई देने की संभावना होनी चाहिए।
  • यह गारंटी है कि 0 < p*q <= 52 and p < 10, आपके पास उन परिदृश्यों के लिए अपरिभाषित व्यवहार हो सकता है जहां यह पूरा नहीं हुआ है।
  • आपको प्रति पंक्ति के qसाथ pकार्ड की पंक्तियों का उत्पादन करना चाहिए ।
  • प्रत्येक स्तंभ को अलग किया जाना चाहिए | (एक पाइप चार स्थानों से घिरा हुआ); यदि आप इससे अलग कोई चार्ट चुनते हैं, तो इसकी व्याख्या करें। आसपास के स्थान वैकल्पिक नहीं हैं।
  • प्रत्येक पंक्ति में 1 या अधिक न्यूलाइन्स होनी चाहिए, उन्हें इनबिल्ट करना चाहिए, एक से अधिक स्वीकार्य है, 0 नहीं है (1 न्यूलाइन का अर्थ नई लाइन डिफ़ॉल्ट रूप से है)।
  • प्रत्येक पंक्ति को उस खिलाड़ी के साथ लेबल किया जाना चाहिए जो इसे "प्लेयर एन" (0 या 1-अनुक्रमित ठीक है) प्रारूप में रखता है।
  • कोई भी कार्ड एक से अधिक बार दिखाई नहीं दे सकता है।
  • T दस के लिए है।

उदाहरण:

समारोह ( p=1,q=1):

Player 1 # Can also be 0.
.------.
|2.--. |
| (\/) |
| :\/: |
| '--'2|
'------'

समारोह ( p=2,q=1):

Player 1 | Player 2 # Can also be "Player 0 | Player 1"
.------. | .------.
|2.--. | | |T.--. |
| (\/) | | | (\/) |
| :\/: | | | :\/: |
| '--'2| | | '--'T|
'------' | '------'

समारोह ( p=2,q=2):

Player 1 | Player 2 # Can also be "Player 0 | Player 1"
.------. | .------.
|J.--. | | |3.--. |
| (\/) | | | :/\: |
| :\/: | | | :\/: |
| '--'J| | | '--'3|
'------' | '------'
.------. | .------.
|8.--. | | |6.--. |
| :(): | | | :/\: |
| ()() | | | (__) |
| '--'8| | | '--'6|
'------' | '------'

एक फ़ॉन्ट पर कलात्मक क्रेडिट: http://patorjk.com/software/taag

code-golf  ascii-art  random  card-games 
— जादू ऑक्टोपस Urn
स्रोत
5
क्या आप कार्ड से मिलने वाली कई चुनौतियों को patorjk.com/software/taag पर पोस्ट करने जा रहे हैं ?
1
Soooo ... क्या हम परिणाम को आउटपुट करने के लिए इस साइट का "उपयोग" कर सकते हैं ???
— J42161217
1
मेरा मतलब है: क्या मैं एक प्रोग्राम बना सकता हूं जो आपके आखिरी टेस्ट केस के लिए patorjk.com/software/taag/… को आउटपुट करता है ?
— J42161217
5
इसके अलावा, Each row must have 1 or more newlines inbetween them, more than one is acceptable, 0 is not.... लेकिन आपके परीक्षण मामलों में कार्ड के बीच की नई सीमा नहीं है ..?
— 23
1
ASCII कार्डों पर लगभग एक चुनौती थी: मेरे द्वारा पोस्ट किया गया प्ले टाइम ।
— सर्जियोल

जवाबों:

6

चारकोल , 142 133 125 बाइट्स

ＮθＦＮ«Ｆ¬¬ι«→↑×⁶θ| »Player ＩιＦθ«↙↓.↓⁴←'←⁶↑'↑⁴.Ｐ⁶↓≔‽⁵²εＷ№υε≔‽⁵²ε⊞υε≔§”w↘τ[⁵ＰkxτG”εδδ.--.¶✂”{➙aＥTê；s∨Hμ⁼⎚↑Ｚ～ＳÀd～⌀Ｔê”﹪ε⁴φ⁴'--'δ↘

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। संपादित करें: मेरे यादृच्छिक नमूना कोड में सुधार करके 9 बाइट्स सहेजे गए। मेरा सूट प्रिंटिंग कोड सुधार कर 8 बाइट्स बचा लिया। स्पष्टीकरण:

Ｎθ

में कार्ड की संख्या पढ़ें q।

ＦＮ«

प्रत्येक खिलाड़ी पर लूप।

Ｆ¬¬ι«→↑×⁶θ| »

यदि यह पहला खिलाड़ी नहीं है, तो पिछले और इस खिलाड़ी के बीच लंबवत रेखा को प्रिंट करें।

Player Ｉι

प्लेयर नंबर प्रिंट करें।

Ｆθ«

प्रत्येक कार्ड पर लूप।

↙↓.↓⁴←'←⁶↑'↑⁴.Ｐ⁶↓

कार्ड के किनारे प्रिंट करें।

≔‽⁵²εＷ№υε≔‽⁵²ε⊞υε

एक कार्ड इंडेक्स चुनें जिसे पहले से नहीं उठाया गया है, और इसे चुने हुए कार्ड इंडेक्स की सूची में जोड़ें।

≔§”w↘τ[⁵ＰkxτG”εδδ

वैध कार्ड रैंक ( 2-9, T, J, Q, K, A) के एक स्ट्रिंग में चक्रवात अनुक्रमण द्वारा कार्ड की रैंक चुनें और प्रिंट करें ।

.--.¶

सूट के ऊपर प्रिंट करें।

✂”{➙aＥTê；s∨Hμ⁼⎚↑Ｚ～ＳÀd～⌀Ｔê”﹪ε⁴φ⁴

एक स्ट्रिंग में टुकड़ा करके सूट के बीच में प्रिंट करें। टुकड़ा कार्ड इंडेक्स मोडुलो 4 से शुरू होता है और जब तक स्ट्रिंग बाहर नहीं निकलता (या f= 1000 वां वर्ण तक पहुंच जाता है) तब तक हर 4 वां वर्ण लेता है । चूंकि 4 और 13 कोप्रेम हैं, यह सुनिश्चित करता है कि सभी 52 कार्ड संभव हैं।

'--'δ↘

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

— नील
स्रोत
जब मैंने इसे सैंडबॉक्स में देखा तो डेक प्रिंट करना एक केसी चुनौती थी, जिसमें मुझे 102 बाइट्स लगीं: इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है।
— नील
3

पायथन 2 , 357 बाइट्स

from random import*
p,q=input()
A,V=':/\:',':\/:'
c=sample([(""".------.
|%s.--. |
| %s |
| %s |
| '--'%s|
'------'"""%(n,s,t,n)).split('\n')for s,t in('(\/)',V),(A,V),(A,'(__)'),(':():','()()')for n in'123456789TJQKA'],p*q)
print' | '.join('Player '+`i`for i in range(p))
for i in range(0,p*q,p):print'\n'.join(map(' | '.join,zip(c[i:i+p][0],c[i:i+p][1])))

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

मुझे कोई फ्रिंजिन नहीं है।

— totallyhuman
स्रोत
3

जावास्क्रिप्ट (ईएस 6), 328 ... 312 बाइट्स

करी सिंटैक्स में इनपुट लेता है (p)(q)। खिलाड़ी 0-अनुक्रमित हैं।

p=>g=(q,i=p*q*6,d=[...Array(52).keys(a=`:\\/:,(__),()(),(\\/),:/\\:,:():, | ,
,.3.,|0.--. |,| 1 |,| 2 |,| '--'0|,'3',Player 4`.split`,`)].sort(_=>Math.random()-.5))=>i--+p?g(q,i,d)+a[i%p?6:7]+a[i<0?14:i/p%6|8].replace(/\d/,c=>['TJQKA'[j=x>>2]||j-3,a['3454'[x&=3]],a[x%3],'------',p+i][c],x=d[i%p+p*(i/p/6|0)]):''

डेमो

कोड स्निपेट दिखाएं

कैसे?

यह एक पुनरावर्ती कार्य है, नीचे से ऊपर तक आउटपुट का निर्माण करता है। मुख्य भाग के दौरान जिसमें कार्ड खींचे जाते हैं, तब तक इसे iइनिशियलाइज़ p*q*6और डिक्रिप्ट किया जाता है जब तक कि यह नहीं पहुँच जाता 0। हम तब iतक हेडर खींचते हैं जब तक कि वह पहुंच न जाए -p।

ASCII कला सरणी में संग्रहीत छोटे टुकड़ों में विभाजित है a[]। नीचे दी गई तालिका उस सामग्री का वर्णन करती है a[], जिससे बाकी कोड समझने में आसान हो जाते हैं।

 Index | Content    | Description
-------+------------+------------------------------------------------
    0  | ":\\/:"    | bottom of 'diamonds' and 'hearts'
    1  | "(__)"     | bottom of 'spades'
    2  | "()()"     | bottom of 'clubs'
    3  | "(\\/)"    | top of 'hearts'
    4  | ":/\\:"    | top of 'diamonds' and 'spades'
    5  | ":():"     | top of 'clubs'
    6  | " | "      | player separator
    7  | "\n"       | line-feed
    8  | ".3."      | card row #1, "3" --> "------"
    9  | "|0.--. |" | card row #2, "0" --> symbol of card value
   10  | "| 1 |"    | card row #3, "1" --> top of color ASCII art
   11  | "| 2 |"    | card row #4, "2" --> bottom of color ASCII art
   12  | "| '--'0|" | card row #5, "0" --> symbol of card value
   13  | "'3'"      | card row #6, "3" --> "------"
   14  | "Player 4" | header, "4" --> player ID

प्रारूपित और टिप्पणी की गई

p => g = (                                // p = number of players
  q,                                      // q = number of cards
  i = p * q * 6,                          // i = counter
  d = [...Array(52).keys(                 // d = deck
    a = `:\\/:,(__),...`.split`,`         // a = ASCII art pieces (truncated, see above)
  )].sort(_ => Math.random() - .5)        // shuffle the deck
) =>                                      //
  i-- + p ?                               // if i is greater than -p:
    g(q, i, d) +                          //   do a recursive call and append ...
    a[i % p ? 6 : 7] +                    //   separator or line-feed
    a[i < 0 ? 14 : i / p % 6 | 8]         //   header or card row
    .replace(/\d/, c => [                 //   where digits are replaced with:
        'TJQKA'[j = x >> 2] || j - 3,     //     0: symbol of card value
        a['3454'[x &= 3]],                //     1: top of color ASCII art
        a[x % 3],                         //     2: bottom of color ASCII art
        '------',                         //     3: horizontal border
        p + i                             //     4: player ID
      ][c],                               //
      x = d[i % p + p * (i / p / 6 | 0)]  //   x = current card with: bits 0-1 = color
    )                                     //                          bits 2-5 = value
  :                                       // else:
    ''                                    //   stop recursion
— Arnauld
स्रोत
2

पायथन 2 , 382 358 346 338 332 बाइट्स

from random import*
p,n=input()
d=zip([0,1,2,3]*13,'23456789TJQKA'*4)
shuffle(d)
C=""".------.
|%s.--. |
| %s |
| %s |
| '--'%s|
'------'"""
print' | '.join('Player '+`i`for i in range(p))
exec"for l in zip(*[(C%(v,'(:::\/(//\)\):::'[s::4],':((:\_)\/_(/:)):'[s::4],v)).split('\\n')for s,v in d[:p]]):print' | '.join(l)\nd=d[p:]\n"*n

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

— TFeld
स्रोत
2

SOGL V0.12 , 106 बाइट्स

E⁽⁰⅜║(Ηe─t¦4»\$²‘8n{"1<ω⅛┘‘4n╬¡;4n33žASUjk"TJQKA”+{a;22žF75ž}}'#δ№{ψ⌡≤οc+C}c_.∫:"▓⅛▲ŗ‘Κ⁽e{≤+};H?;lƧ |Γ∙┼;┼

यह कोशिश करो!

कार्ड जनरेटिंग:

...‘                     push "(\/):\/::/\::\/::/\:(__):():()()" - the suits
    8n                   split to line lengths of 8 - individual suits
      {                  for each suit
       "...‘               push ".---| .-|   " - a quarter of a suit
            4n             split to line lengths of 4 - [".---", "| .-", "|   "]
              έ           quad palindromize - empty card
                ;          get the suit on top
                 4n        split to line lengths of 4
                   33ž     insert in the card at [3; 3]
                      A    save on variable A - card template
SU                         push "1234567890"
  jk                       remove the first and last digits
    "TJQKA”+               append "TJQKA"
            {         }    for each number - "23456789TJQKA"
             a               load the template
              ;22ž           at [2; 2] insert the current number
                  F75ž       at [7; 5] insert the current number

फेरबदल:

'#             push 52
  δ            lower range - [0, 1, ..., 50, 51]
   №           reverse - [51, 50, ..., 1, 0]
    {       }  for each, pushing the current item
     ψ           get a random number from 0 to ToS (inclusive)
      ⌡          that many times
       ≤           put the first item of the stack on the top
        οc+C     prepend that to the variable C, predefined with an empty array

व्यवहार:

c_              push Cs contents on the stack - the stack is now a mess of cards
  .∫            repeat input times - each player - pushing the current player number
    :             duplicate the number
     "..‘         push "player "
         Κ        prepend "player " to the number
          ⁽       uppercase the 1st letter
           e{  }  repeat 2nd input times
             ≤      put the first stack item on the top
              +     append it to "Player X" vertically (making an array)
;                 get the other copy of the player number
 H?               if POP-1 (aka if it's not 1)
   ;                swap the top 2 items - the current collumn and all the previous ones (by then they've been joined together)
    l               get its (vertical) length
     Ƨ |            push " |"
        Γ           palindromize - [" | "]
         ∙          multiply " | " vertically that length times
          ┼         append it horizontally (to the previous collumns)
           ;┼       append the current collumn
— dzaima
स्रोत
2

रूबी, 262 बाइट्स

->p,q{a=[*0..51].shuffle
puts ["Player %d"]*p*(d=" | ")%[*1..p],(1..q*6).map{|i|(["'------'
.------.
|%X.--. |
| %s |
| %s |
| '--'%X|".split($/)[i%6]]*p*d%a[i/6*p,p].map{|j|["(\\/):()::/\\:"[u=j%4*4-4,4],":\\/:()():\\/:(__)"[u,4],j/4][i%3]}).tr("01BC","TJQK")}}

पालन ​​करने के लिए कठिन है, लेकिन कम!

रूबी, 279 बाइट्स

->p,q{puts [*1..p].map{|k|"Player #{k}"}*" | "
a=[*0..51].shuffle
(q*6).times{|i|puts [".------.
|%s.--. |
| %s |
| %s |
| '--'%s|
'------'".split($/)[i%6]]*p*" | "%a[i/6*p,p].map{|j|[":\\/:()():\\/:(__)"[u=j%4*4-4,4],("%X"%(j/4)).tr("01BC","TJQK"),"(\\/):()::/\\:"[u,4]][i%3]}}}

प्रत्येक पंक्ति के लिए एक प्रारूप बनाता है, फिर %ऑपरेटर sprintfको पॉप्युलेट करना पसंद करता है।

तथ्य यह है कि हर तीसरी पंक्ति में कार्ड का मूल्य प्रकट होता है। कार्ड मूल्यों अंकों के साथ हेक्साडेसिमल में प्रस्तुत कर रहे हैं 01BCकरने के लिए एवजी TJQK।

सूट के प्रतीकों में से 4 बाइट्स को यह मानकर सहेजा जाता है कि हीरे और हुकुम के शीर्ष समान हैं, लेकिन सूट कोड -4के अंत में 2 जोड़ दिए गए j%4*4-4हैं - 4 0 4 या 8 जहां [-4,4]4 वर्णों में 4 वां अंतिम वर्ण शुरू होता है। स्ट्रिंग।

शायद कुछ और बाइट्स बचा सकता है। खिलाड़ी की पहचान के लिए कोड दोहराना बदसूरत है।

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

PHP, 509 बाइट्स

<?$hu='(\/}';$hv=$dv=':\/:';$du=$su=':/\:';$sv='(__)';$cu=':():';$cv='()()';$q="------";$t=$argv[1];foreach([h,d,s,c]as$a)foreach([2,3,4,5,6,7,8,9,T,J,Q,K,A]as$b)$c[]=[$b,$a];shuffle($c);$h=$a=0;for(;$a<$t;$a++)$e[]="Player $a";$f[]=join(" | ",$e);for($g=$argv[2];$g--;){$p=$i=$k=$l=$m=$r=[];$j=$h+$t;for(;$h<$j;$h++){$n=$c[$h][0];$o=$c[$h][1];$p[]=".$q.";$i[]="|$n.--. |";$k[]="| ${$o.u} |";$l[]="| ${$o.v} |";$m[]="| '--'$n|";$r[]="'$q'";}foreach([p,i,k,l,m,r]as$b)$f[]=join(" | ",${$b});}echo join('
',$f);

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

कोड गोल्फ में यह मेरा पहला प्रयास है, इसलिए संभवत: इसमें बहुत सुधार किया जा सकता है। मुझे लगा कि मुझे कहीं शुरुआत करनी है। :)

— Jo।
स्रोत
1

जावा (ओपनजेडके 8) , 784 835 843 826 815 781 775 बाइट्स

String k(String s){return s.replaceAll("...$","\n");}
p->q->{int c=0,l=0,s[]=new int[p*q],i=0,j,t,b;java.util.List e=new java.util.Stack();String v="TJQK",o="",n[]=new String[p*q],x=o;for(;i<p;o+="Player "+i+++" | ",x+=v);o=k(o);for(i=0;i<q;i++){o=k(o+x.replace(v,".------. | "));for(j=0;j<p;j++){do{t=(int)(Math.random()*13)+1;b=(int)(Math.random()*4);}while(e.contains(t+""+v.charAt(b)));e.add(t+""+v.charAt(b));s[c]=b;n[c]=t<2?"A":t<10?""+t:""+v.charAt(t-10);o+="|2.--. | | ".replace("2",n[c++]);}o=k(o);for(j=0;j<p;j++,l++)o+="| "+(s[l]<1?"(\\/)":s[l]<3?":/\\:":":():")+" | | ";o=k(o);for(j=0;j<p;j++)o+="| "+(s[i*p+j]<2?":\\/:":s[i*p+j]<3?"(__)":"()()")+" | | ";o=k(o);for(j=0;j<p;)o+="| '--'2| | ".replace("2",n[i*p+j++]);o=k(k(o)+x.replace(v,"'------' | "));}return o;}

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

क्यों नीचे, यह कल्पना के साथ पालन करता है

— रॉबर्टो ग्राहम
स्रोत
इसके अलावा, आपको बनाने के बजाय वैकल्पिक तरीके बनाने चाहिए Function<String,String>: उत्तरार्द्ध बहुत, बहुत महंगा है। निर्माण और जब उपयोग में दोनों।
— ओलिवियर ग्रेगोइरे
मैं मान रहा हूँ कि डाउनवॉट मूल बगदार उत्तर के लिए था, लेकिन वर्तमान सही लगता है, इसलिए मैंने इसे बेअसर करने के लिए अपवोट किया है। गोल्फ के लिए कुछ छोटी चीजें: कोष्ठक पर हटाया जा सकता है n[c]=t<2?"A":t<10?""+t:""+"TJQK".charAt(t-10); for(j=0;j<p;j++){o+=...;l++;}हो सकता है for(j=0;j<p;l++,j++)o+=...;; आप return o;इसके बजाय System.out.print(o);एक दूसरे का उपयोग करके कर सकते Functionहैं Consumer; ,y=p*qहटाया जा सकता है और आप p*qइसके बजाय सीधे दो बार उपयोग कर सकते हैं y। इसमें कोई संदेह नहीं है कि गोल्फ के लिए बहुत कुछ है, लेकिन मेरे पास उस समय देखने का समय नहीं है ..
— केविन क्रूज़सेन
1
@KevinCruijssen वास्तव में, नहीं। मैं रिक्त स्थान को हटाने और 1-चर चर नामों का उपयोग करने से परे "गोल्फिंग में कोई प्रयास नहीं" के लिए पहले संपादित करने के बाद डाउनवोट हो गया। मेरा अनुमान है कि रॉबर्टो ग्राहम को पूरी तरह से जावा में गोल्फिंग के लिए टिप्स को फिर से पढ़ना चाहिए । मुद्दा यह है कि यह वास्तव में चुनौती की कल्पना के अनुरूप है, लेकिन कोड-गोल्फ टैग की कल्पना के लिए नहीं।
— ओलिवियर ग्राएगोइरे
मुझे कैसे पता चलेगा कि इसे और आगे बढ़ाया जा सकता है? जब मैं इस उत्तर को देख कर हार मान गया, तो मैं लगभग 400 बाइट्स था, और मैंने इसे खत्म करने के लिए लगभग 50 और बाइट्स का अनुमान लगाया। 450 बाइट्स 850, इसमें बमुश्किल कोई गोल्फ शामिल है।
— ओलिवियर ग्राईगोइरे
s[l]<2?":/\\:":s[l]<3?":/\\:"हो सकता है s[l]<3?":/\\:"और s[i*p+j]<1?":\\/:":s[i*p+j]<2?":\\/:"हो सकता है s[i*p+j]<2?":\\/:"। @ ओलिवियरग्रेयर और मुझे पता है कि इसकी संभावना लगभग आधी हो सकती है, इसलिए मुझे समझ में आता है। लेकिन यह ज्यादातर अनुभव की कमी है, और वास्तव में कई बार सभी युक्तियों को नहीं पढ़ना है। उत्तर में कुछ चीजें मैंने पहले भी की हैं, और यह जावा के लिए कोई विशेष आसान चुनौती नहीं है। Btw, यदि आपके पास 400-450 बाइट का उत्तर है, तो आप इसे एक अलग उत्तर के रूप में क्यों पोस्ट नहीं करते हैं (यदि काफी अलग है)? तुम मेरे upvote होगा। ;)
— केविन क्रूज़सेन
1

पायथन 3, 332 बाइट्स

from random import*
P=lambda x:print(*x,sep=' | ')
R=range
def f(p,c):
 P(f"Player {i}"for i in R(p))
 d=[f".------.,|{n}.--. |,| {a[:4]} |,| {a[4:]} |,| '--'{n}|,'------'".split(",")for a,n in sample([*zip(r':/\:(__) (\/):\/: :/\::\/: :():()()'.split()*13,'A23456789TJQK'*4)],p*c)]
 for i in R(c):
  for t in zip(*d[i::c]):
   P(t)
— RootTwo
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.