9

बल्गेरियाई सॉलिटेयर एक एकल-खिलाड़ी खेल है जिसे मार्टिन गार्डनर ने वैज्ञानिक अमेरिकी में अपने गणितीय कॉलम में लोकप्रिय बनाया है ।

आपके पास Nसमान कार्ड हैं, बवासीर में विभाजित हैं। आप प्रत्येक ढेर से एक कार्ड लेते हैं और हटाए गए कार्ड के साथ एक नया ढेर बनाते हैं। आप इस प्रक्रिया को तब तक दोहराते हैं जब तक कि आप एक ऐसी स्थिति तक नहीं पहुंच जाते जो आपने पहले ही देख ली है और इसलिए लगातार लूप को दोहराते रहेंगे।

उदाहरण के लिए, मान लें कि आपके पास 8कार्ड हैं, के ढेर 5और के ढेर में विभाजित हैं 3। हम ढेर के आकार को अवरोही क्रम में लिखते हैं 5 3:। यहाँ खेल का एक प्रतिलेख है:

आप पहले दो ढेर में से प्रत्येक से एक कार्ड निकालने के लिए, के ढेर छोड़ने 4और 2, और की एक नव निर्मित ढेर 2, दे रही है 4 2 2। अगले चरण में, 3 1 1नए ढेर के साथ इनका पालन किया जाता है 3। अंत में, अंतिम चरण आकार के ढेर को खाली 1करता है और उत्पादन करता है 4 2 2जो पहले से ही दिखाई दिया है, इसलिए हम रोकते हैं।

ध्यान दें कि ढेर-आकारों का योग समान रहता है।

आपका लक्ष्य दिए गए शुरुआती कॉन्फ़िगरेशन से गेम के ऐसे ट्रांसक्रिप्ट को प्रिंट करना है। यह कोड गोल्फ है, इसलिए सबसे कम बाइट जीतती है।

इनपुट

शुरुआती ढेर के आकारों का प्रतिनिधित्व करते हुए अवरोही क्रम में सकारात्मक संख्याओं की एक सूची। STDIN या फ़ंक्शन इनपुट के माध्यम से इनपुट लें। आप किसी भी सूची जैसी संरचना का उपयोग कर सकते हैं।

आपको Nइनपुट के रूप में कुल कार्ड नहीं मिलते हैं ।

उत्पादन

ढेर के आकार के क्रम को प्रिंट करें बल्गेरियाई त्यागी का खेल। ध्यान दें कि मुद्रण की आवश्यकता है, वापस नहीं। प्रत्येक चरण की अपनी रेखा होनी चाहिए।

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

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

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

>> [1]
1
1

>> [2]
2
1 1
2

>> [1, 1, 1, 1, 1, 1, 1]
1 1 1 1 1 1 1
7
6 1
5 2
4 2 1
3 3 1
3 2 2
3 2 1 1
4 2 1

>> [5, 3]
5 3
4 2 2
3 3 1 1
4 2 2

>> [3, 2, 1]
3 2 1
3 2 1

>> [4, 4, 3, 2, 1]
4 4 3 2 1
5 3 3 2 1
5 4 2 2 1
5 4 3 1 1
5 4 3 2
4 4 3 2 1

code-golf game

— XNOR
स्रोत

4

अजगर, ४० २५

QW!}QY~Y]Q=Q_S+fTmtdQ]lQQ

यह मेरे अजगर 2 उत्तर के अनुवाद के बहुत करीब है।

नमूना रन:

इनपुट:

[4,4,3,2,1]

आउटपुट:

[4, 4, 3, 2, 1]
[5, 3, 3, 2, 1]
[5, 4, 2, 2, 1]
[5, 4, 3, 1, 1]
[5, 4, 3, 2]
[4, 4, 3, 2, 1]

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

Q                          Q = eval(input()) # automatic
 W!}QY                     while not Q in Y:
      ~Y]Q                     Y += [Q]
               fTmtdQ                     filter(lambda T: T, map(lambda d: d - 1, Q))
            _S+      ]lQ           sorted(                                             + [len(Q)])[::-1]
          =Q_S+fTmtdQ]lQ       Q = sorted(filter(lambda T: T, map(lambda d: d - 1, Q)) + [len(Q)])[::-1]
                        Q      print(Q)
QW!}QY~Y]Q=Q_S+fTmtdQ]lQQ

— जस्टिन
स्रोत

1. आप के v$input()$साथ बदल सकते हैं Q। 2. यदि आप सूची को घटते क्रम में संग्रहीत करते हैं, तो आपको इसकी आवश्यकता नहीं है N:W!}QYQ~Y]Q=Q_S+fTmtdQ]lQ;Q

— डेनिस

@ डेनिस धन्यवाद, मैं यह पता नहीं लगा सका कि यह कैसे करना है; मुझे पता था कि ऐसा करने का एक तरीका है।

— जस्टिन

1

यहाँ मैंने क्या किया, पूरी तरह से स्वतंत्र QW!}QY~Y]Q=Q_S+]lQfTmtdQQ:। यह बिल्कुल वैसा ही है, चरित्र के लिए चरित्र, कम्यूटिटी तक।

— isaacg

3

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

q{~_:(_,+0-$W%]___&=}g{p}/

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

उदाहरण चलाते हैं

$ cjam <(echo 'q{~_:(_,+0-$W%]___&=}g{p}/') <<< '[5 3]'
[5 3]
[4 2 2]
[3 3 1 1]
[4 2 2]

— डेनिस
स्रोत

वह कुछ सीजेम है!

— ऑप्टिमाइज़र

आओ !, मुझे पता है कि आप इसे पाइथ से कम कर सकते हैं!

— ऑप्टिमाइज़र

अगर :pकाम किया, तो मैं कर सकता था ...

— डेनिस

4

रोना कलपना बंद करो! :p

— ऑप्टिमाइज़र

3

रूबी, 98

f=->c{g={c=>1}
p *loop{c=(c.map(&:pred)<<c.size).sort.reverse-[0]
g[c]?(break g.keys<<c): g[c]=1}}

व्याख्या

इनपुट को लंबोदर के तर्क के रूप में लिया जाता है। यह एक उम्मीद है Array।
पिछले खेल राज्यों में संग्रहीत हैं Hash g।
एक नया गेम स्टेट बनाने के लिए, Array#mapप्रत्येक तत्व को 1 से कम करने के लिए उपयोग करें, Arrayएक तत्व की लंबाई जोड़ें , इसे घटते क्रम में सॉर्ट करें और तत्व को हटा दें 0।
यह जाँचने के लिए कि क्या कोई खेल राज्य पहले देखा गया है, यह जाँचने के लिए कि gक्या नए खेल राज्य के लिए एक कुंजी पर्याप्त है।

— britishtea
स्रोत

+1 वास्तव में साफ रूबी यहाँ गोल्फ! हालाँकि, जब sort_byबात निश्चित रूप से चतुर है, sort.reverseवास्तव में एक चरित्र कम है ^ ^

— daniero

ओ, यह बहुत बुरा है। धन्यवाद।

— २१

2

CJam, 35 34 33 बाइट्स

(धिक्कार है, इस शक्ति में कटौती कि मैं CJam में पोस्ट करने वाला पहला व्यक्ति नहीं था)

l~{_p:(_,+{},$W%_`_S\#0<\S+:S;}g`

इनपुट:

[1 1 1 1 1 1 1]

आउटपुट:

[1 1 1 1 1 1 1]
[7]
[6 1]
[5 2]
[4 2 1]
[3 3 1]
[3 2 2]
[3 2 1 1]
[4 2 1]

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

1

अजगर 2 - 103

p=input()
m=[]
print p
while p not in m:m+=[p];p=sorted([x-1 for x in p if x>1]+[len(p)])[::-1];print p

Quincunx के उत्तर के समान है, लेकिन इसके अतिरिक्त के साथ जुड़ता है और अंतिम दो पंक्तियों को हटा देता है।

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

[4, 4, 3, 2, 1]
[5, 3, 3, 2, 1]
[5, 4, 2, 2, 1]
[5, 4, 3, 1, 1]
[5, 4, 3, 2]
[4, 4, 3, 2, 1]

— नाथन मेरिल
स्रोत

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

— जस्टिन

मुझे मेरा जवाब पोस्ट करने के बाद ही पता चला। मैं उन्हें एक दूसरे के डुप्लिकेट मानने के साथ ठीक हूं।

— नाथन मेरिल

1

GolfScript, 50 46

~.p$[]{[1$]+\.{(.!";"*~}%\,+$.-1%p\.2$?)!}do];

लगभग निश्चित रूप से आगे गोल्फ हो सकता है। इसे यहाँ आज़माएँ।

— जस्टिन
स्रोत

1

हास्केल, 99

import Data.List
g l=until(nub>>=(/=))(\l->l++[reverse$sort$length(last l):[x-1|x<-last l,x>1]])[l]

— गर्वित हेकलर
स्रोत

1

सीजेएम, 40 36 34 बाइट्स

]l~{a+_W=_p:(_,+$W%{},1$1$a#0<}gp;

इसका परीक्षण यहां करें। इनपुट को CJam-style array के रूप में दर्ज करें, जैसे[5 3] , STDIN फ़ील्ड में। आउटपुट स्वरूप समान है, इसलिए वर्ग कोष्ठक और रिक्त स्थान के रूप में सीमांकक।

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

— मार्टिन एंडर
स्रोत

यकीन नहीं होता कि J मदद करेगा, मैं अपने एपीएल को 38 से नीचे नहीं पा सकता

— ट्विनट

1

जावास्क्रिप्ट (E6) 113

अब तक की सबसे खराब प्रविष्टि :(

F=l=>{
  for(k=[];console.log(l),!k[l];)
    k[l]=l=[...l.map(n=>(p+=n>1,n-1),p=1),l.length].sort((a,b)=>b-a).slice(0,p)
}

FireFox / FireBug कंसोल में टेस्ट करें

F([4,4,3,2,1])

उत्पादन

[4, 4, 3, 2, 1]
[5, 3, 3, 2, 1]
[5, 4, 2, 2, 1]
[5, 4, 3, 1, 1]
[5, 4, 3, 2]
[4, 4, 3, 2, 1]

— edc65
स्रोत

1

अजगर 2, 148 130 101

l=input()
s=[]
print l
while l not in s:s+=l,;l=sorted([i-1for i in l if 1<i]+[len(l)])[::-1];print l

यह बस पिछले सभी पुनरावृत्तियों को याद रखता है, और जाँचता है कि क्या नया उस सूची में है। फिर, इसे प्रिंट करता है।

नमूना रन:

इनपुट:

[4,4,3,2,1]

आउटपुट:

[4, 4, 3, 2, 1]
[5, 3, 3, 2, 1]
[5, 4, 2, 2, 1]
[5, 4, 3, 1, 1]
[5, 4, 3, 2]
[4, 4, 3, 2, 1]

संपादित करें: मैं गोल्फ के चश्मे को फिर से जोड़ देता हूं, साथ ही बहुत से गोल्फ भी लगाए हैं।

— जस्टिन
स्रोत

आपको सूचियों को सूचियों के रूप में मुद्रित करने की अनुमति है।

— xnor

@ एक्सनोर ओह धन्यवाद, पूरी तरह से याद किया।

— जस्टिन

यह [5,3] के साथ काम नहीं करेगा

— नाथन मेरिल

यह गलत आउटपुट देता है [4,2,2]। हालांकि एक आसान तय है।

— xnor

0

पायथन 3: 89 वर्ण

g=lambda l,s=[]:print(l)!=l in s or g(sorted([x-1for x in l if~-x]+[len(l)])[::-1],s+[l])

पहले से ही पोस्ट किए गए पायथन समाधानों की तरह, लेकिन लूप के बजाय पुनरावर्ती फ़ंक्शन कॉल के साथ। सूचिs पहले से ही देखी गई स्प्लिट्स को संग्रहीत करती है, और शॉर्ट-सर्किट एक पुनरावृत्ति के मामले में पुनरावृत्ति को बाहर निकालती है।

फ़ंक्शन print()(यह पायथन 3 है) बस किसी तरह से प्रत्येक लूप में बुलाया जाना चाहिए। मुश्किल बात यह है कि lambdaकेवल एक ही अभिव्यक्ति की अनुमति देता है, इसलिए हम ऐसा नहीं कर सकते print(l);...। इसके अलावा, यह आउटपुट करता है None, जिसके साथ काम करना मुश्किल है। मैं print(l)एक असमानता के एक तरफ डाल हवा ;==मुझे समझ में नहीं आता किसी कारण के लिए काम नहीं करता है।

एक सूची में इसे चिपकाने का एक वैकल्पिक दृष्टिकोण समान रूप से कई पात्रों का उपयोग करता है।

g=lambda l,s=[]:l in s+[print(l)]or g(sorted([x-1for x in l if~-x]+[len(l)])[::-1],s+[l])

उपयोग करने के बजाय print(*l)आउटपुट को स्वरूपित करना होगा ।4 2 2[4,2,2]

— XNOR
स्रोत