एक विशेषज्ञ की तरह निम बोर्ड की कल्पना करें

Question

पृष्ठभूमि

निम के खेल में , खिलाड़ी वैकल्पिक रूप से "पत्थर" को "बवासीर" से हटाते हैं: प्रत्येक मोड़ पर, एक खिलाड़ी को एक ढेर से एक और सभी पत्थरों के बीच निकालना होगा । निम का उद्देश्य अंतिम पत्थर को लेना है या गलत तरीके से, अपने प्रतिद्वंद्वी को ऐसा करने के लिए मजबूर करना है - हालांकि, यह पता चला है कि रणनीतियां लगभग समान हैं।

निम एक मजेदार बार गेम बनाता है। आप "पत्थरों" के लिए माचिस या सिक्कों का उपयोग कर सकते हैं, और "ढेर" आमतौर पर एक पंक्ति में व्यवस्थित होते हैं। नीचे 1, 3, 5 और 7 के ढेर के साथ एक क्लासिक सेटअप है:

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

रणनीति

निम में इष्टतम रणनीति काफी मुश्किल है कि ज्यादातर लेटे हुए लोग एक विशेषज्ञ से लगातार हारते हैं, लेकिन बाइनरी अंकगणित के साथ वर्णन करने के लिए सरल है ।

हालांकि, मानसिक बाइनरी एक्सओआर संचालन करना कठिन है, इसलिए सौभाग्य से सही रणनीति की कल्पना करने का एक समान तरीका है जो वास्तविक समय में लागू करना आसान है, भले ही नशे में हो।

केवल तीन चरण हैं:

1. मानसिक रूप से प्रत्येक पंक्ति में "पत्थरों" को उपसमूहों में समूहित करें जिनके आकार 2 की शक्तियां हैं, जो सबसे बड़े संभावित आकार से शुरू होता है: 8, 4, 2, और 1 अधिकांश खेलों के लिए पर्याप्त हैं।
2. प्रत्येक समूह को दूसरी पंक्ति में जुड़वा के साथ मिलाने का प्रयास करें, ताकि हर समूह में एक जोड़ी हो।
3. यदि यह संभव नहीं है, तो एक पंक्ति से अप्रकाशित "पत्थरों" को हटा दें (यह हमेशा संभव होगा - विकिपीडिया लिंक को क्यों देखें) ताकि चरण 2 संभव हो जाए।

या, एक और तरीका कहा: "एक ढेर से कुछ पत्थर (ओं) को हटा दें, जैसे कि यदि आप ढेर को 2 सभी समूहों की शक्तियों में समूहित करते हैं तो किसी अन्य ढेर में एक समूह के साथ जोड़ा जा सकता है।" इस चेतावनी के साथ कि आप 2 की बड़ी शक्तियों को छोटे में नहीं तोड़ सकते - जैसे, आप 8 पत्थरों के साथ 4 के दो समूहों में एक पंक्ति नहीं बना सकते।

उदाहरण के लिए यहां आप ऊपर दिए गए बोर्ड की कल्पना कैसे करेंगे:

यह बोर्ड पूरी तरह से संतुलित है, इसलिए आप अपने प्रतिद्वंद्वी को पहले स्थानांतरित करना चाहते हैं।

चुनौती

निम "बवासीर" के आकार का प्रतिनिधित्व करने वाले सकारात्मक पूर्णांक की एक सूची को देखते हुए, निम बोर्ड के एक सादे पाठ दृश्य को एक विशेषज्ञ द्वारा देखा के रूप में लौटाएं।

एक मान्य विज़ुअलाइज़ेशन का गठन सबसे अच्छा उदाहरण द्वारा समझाया गया है, लेकिन आपको यह करना चाहिए:

1. प्रत्येक "पावर-ऑफ -2 सबग्रुप" और उसकी जोड़ी (अयोग्य उपसमूह योग्य नहीं हैं) के लिए एक अलग चरित्र निर्दिष्ट करें, और उस चरित्र का उपयोग उपसमूह और जोड़ी दोनों में "पत्थरों" का प्रतिनिधित्व करने के लिए करें।
2. किसी भी अनपेक्षित "पत्थरों" का प्रतिनिधित्व करें (यानी, जो एक विशेषज्ञ सामान्य खेल को हटा देगा - गलत नहीं - निम) एक हाइफ़न का उपयोग कर -:।

एक वैध दृश्य प्राप्त करने के कई तरीके होंगे, और सभी वैध हैं। चलो कुछ परीक्षण मामलों के माध्यम से काम करते हैं:

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

इनपुट: १, ३, ५,,

संभावित आउटपुट 1:

A
BBA
CCCCD
CCCCBBD

आप वैकल्पिक रूप से वर्णों के बीच और साथ ही पंक्तियों के बीच रिक्त स्थान शामिल कर सकते हैं:

संभावित आउटपुट 2:

A

B B A

C C C C D

C C C C B B D

इनपुट: १, २, ३, ४, ५, ६,,,,, ९, १०

वर्णों का क्रम और विकल्प जो भी आपको पसंद हो:

संभावित आउटपुट 1:

G
E E
E E G
C C C C
C C C C F
B B B B D D
B B B B D D F
H H I - - - - -
A A A A A A A A I
A A A A A A A A H H

यूनिकोड प्रतीक ठीक भी हैं:

संभावित आउटपुट 2:

◎
◈  ◈
◈  ◈  ◎
△  △  △  △
△  △  △  △  ◉
◐  ◐  ◐  ◐  ◀  ◀
◐  ◐  ◐  ◐  ◀  ◀  ◉
▽  ▽  ◒  -  -  -  -  -
▥  ▥  ▥  ▥  ▥  ▥  ▥  ▥  ◒ 
▥  ▥  ▥  ▥  ▥  ▥  ▥  ▥  ▽  ▽  

इनपुट: 7

नियमों से यह निम्न है कि किसी भी "एकल ढेर" को पूरी तरह से हटा दिया जाना चाहिए।

संभावित आउटपुट 1:

-------

संभावित आउटपुट 2:

- - - - - - -

इनपुट: ५, ५

संभावित आउटपुट:

A A A A B
A A A A B

अतिरिक्त नियम

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

Comments

क्या प्रत्येक ढेर में कितने पत्थर हो सकते हैं या दृश्य के लिए कितने अलग-अलग वर्ण आवश्यक होंगे इसकी कोई सीमा है? (चरम मामले में, क्या हुआ अगर, उदाहरण के लिए, प्रिंट योग्य ASCII वर्ण की संख्या से अधिक की जरूरत थी, या अधिक से अधिक 255 अलग वर्ण?)

— दरवाज़े

@Doorknob आप मान सकते हैं कि ऐसा नहीं होगा। आप यह भी मान सकते हैं कि वर्णमाला के अक्षर किसी भी इनपुट के लिए पर्याप्त होंगे।

— योना

@ जोनाह दूसरे टेस्ट केस के लिए वैध आउटपुट होगा? ["H","EE","EEH","CCCC","CCCCI","DDDDFF","DDDDFFI","AAAAAAAA","AAAAAAAA-","----------"]

— ngn

@ Οurous मुझे लगता है कि सरल उत्तर हां है। तकनीकी रूप AAAABBBBसे वास्तव में अमान्य है, और ABBनहीं है - लेकिन यह आउटपुट को कम पठनीय बनाता है इसलिए मुझे लगता है कि एक पंक्ति के भीतर घटते हुए एक स्पष्ट नियम सबसे अच्छा है।

— योना

@JonathanAllan हां, मैं इस तर्क पर भरोसा कर रहा हूं कि सभी 3 चरण एक साथ होने चाहिए। इसलिए यदि आप चरण 1 और 2 का पालन करते हैं, लेकिन चरण 3 का प्रदर्शन नहीं कर सकते, तो आपको अपने समाधान को चरण 1 और 2 में समायोजित करना होगा, जिसे मैं भ्रमित होते हुए देख सकता हूं। मैंने आपका विवरण नीचे जोड़ा है।

— योना

Answer 1

रूबी, 169 164 148 बाइट्स

->a{s=eval a*?^
c=?@
m={}
a.map{|x|z=x-(x^s);[$><<?-*z,x-=z,s=0]if z>0
n=1
eval'x&1>0?[$><<(m[n]||c.next!)*n,m[n]=!m[n]&&c*1]:0;n*=2;x/=2;'*x
puts}}

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

सबसे पहले, हम आरंभ करते हैं

• के साथ nim-sum s=eval a*?^(जो इससे कम है a.reduce:^)
• चर c, जो पहले अप्रयुक्त अद्वितीय चरित्र को संग्रहीत करता है
• एक नक्शा mजो पात्रों को पावर-ऑफ-टू लंबाई बताता है, उनका प्रतिनिधित्व करता था

फिर, प्रत्येक ढेर पर लूपिंग, हम निम्नलिखित चलाते हैं:

z=x-(x^s);[$><<?-*z,x-=z,s=0]if z>0

प्रति विकिपीडिया की रणनीति , अगर nim-राशि XOR ढेर से भी कम है ढेर , हम पत्थर कि ढेर ऐसी है कि इसकी लंबाई हो जाता है से निकाल देना चाहिए nim-राशि XOR ढेर । चर में अंतर को संग्रहीत करके z, हम यह देखने के लिए परीक्षण कर सकते हैं कि क्या यह अंतर सकारात्मक है, और यदि ऐसा है तो 1.) प्रिंट करें कि कई डैश, 2.) इसे ढेर से घटाएं, और 3.) निम-राशि चर सेट करें आगे पत्थर हटाने से रोकने के लिए शून्य।

n=1
eval'[...];n*=2;x/=2;'*x

अब हम प्रत्येक बिट पर "लूप" करते हैं और संचयकर्ता द्वारा बार-बार विभाजित xकरके 2और गुणा करके उनके मूल्यों पर नज़र रखते हैं । लूप वास्तव में एक स्ट्रिंग का मूल्यांकन किया गया समय है, जो उस समय की तुलना में कहीं अधिक है जो आवश्यक है, लेकिन कोई नुकसान नहीं हुआ है (एक तरफ से अक्षमता)। प्रत्येक बिट के लिए, हम निम्न को चलाते हैं यदि बिट 1 ( ) है:n2xlog2(x)x&1>0

$><<(m[n]||c.next!)*n

एक वर्ण nसमय मुद्रित करें । अगर हमने पहले ही इस कई पत्थरों के एक अप्रकाशित समूह को छाप दिया, तो उस पात्र का उपयोग करें; अन्यथा, अगले अप्रयुक्त वर्ण ( cइन- प्लेसिंग इन-प्लेस !) का उपयोग करें।

m[n]=!m[n]&&c*1

यदि m[n]अस्तित्व में है (यानी हमने अभी एक जोड़ी पूरी की है), तो m[n]रीसेट है। अन्यथा, हमने अभी एक नई जोड़ी शुरू की है, इसलिए m[n]हमारे द्वारा उपयोग किए जाने वाले चरित्र पर सेट करें ( *1प्रतिलिपि बनाने के लिए एक छोटा तरीका है c)।

Answer 2

पायथन 2 , 150 196 206 बाइट्स

def f(p):
 c=48;s=[l*'.'for l in p];m=2**len(bin(l))
 while m:
  if sum(m*'.'in l for l in s)>1:
   for i,l in enumerate(s):s[i]=l.replace('.'*m,chr(c)*m,`s`.count(chr(c)*m)<2)
   c+=1
  else:m/=2
 return s

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

Comments

मुझे नहीं लगता कि यह काम करता है 4, 9, 10।

— नील

@ नील अच्छा कैच, अब तय होना चाहिए

— TFeld

क्षमा करें, मैं इस बार फिर से मूर्ख बनाने में कामयाब रहा 14, 21, 35।

— नील

यह [1, 3, 4, 5] के लिए भी विफल रहता है, जहां इसे पूरे दूसरे ढेर को हटा देना चाहिए।

— दरवाज़े

@Doorknob, क्या यह आवश्यक है? नियम कहते हैंThere will be multiple ways to achieve a valid visualization, and all are valid

— TFeld

Answer 3

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

f=
(a,c=0,x=eval(a.join`^`),i=a.findIndex(e=>(e^x)<e),b=a.map(_=>``),g=e=>(d=e&-e)&&a.map((e,i)=>e&d&&(a[i]-=d,b[i]=(c++>>1).toString(36).repeat(d)+b[i]))&&g(e-d))=>g(eval(a.join`|`),b[i]='-'.repeat(a[i]-(a[i]^=x)))||b

<textarea oninput=o.textContent=/\d/.test(this.value)?f(this.value.match(/\d+/g)).join`\n`:``></textarea><pre id=o>

केवल 36 अलग-अलग वर्णों के दृश्य हैं। मुझे इस काम के लिए राहत मिली है 1, 3, 4, 5।

Comments

बहुत अच्छे। वास्तविक समय में इसके साथ खेलना मजेदार है।

— योना

Answer 4

साफ , 454 बाइट्स

अभी भी गोल्फ

import StdEnv,Text,Data.List
$p=join"\n"[{#toChar c+'-'\\c<-e}\\e<-[take i(e++[0,0..])\\e<-r[[~c\\c<-reverse e,_<-[1..c]]\\e<-hd[q\\q<-foldr(\h t=[[a:b]\\a<-h,b<-t])[[]][[c\\c<-subsequences(takeWhile((>=)k)(iterate((*)2)1))|sum c<=k]\\k<-p]|sum[1\\a<-q&b<-p|sum a<>b]<2&&foldr(bitxor)0(flatten q)==0]]1&i<-p]]
r[]_=[]
r[h:t]n|all((<)0)h=[h:r t n]
#[m:_]=removeDup[e\\e<-h|e<0]
#(a,[x:b])=span(all((<>)m))t
=r([[if(e==m)n e\\e<-k]\\k<-[h:a]++[x]]++b)(n+1)

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

फ़ंक्शन को परिभाषित करता है $ :: [Int] -> String, ढेर के आकार ले रहा है और एक स्ट्रिंग लौटाता है जहां -से हटाए जाने वाले पत्थरों को निरूपित किया जाता है, और समूहों का प्रतिनिधित्व ASCII वर्णों से होता है -। यदि पर्याप्त समूहों की आवश्यकता होती है तो अक्षर अंततः चारों ओर से लपेट जाएंगे, और इसके कारण foldrदूसरे टेस्ट-केस को चलाने के लिए एक गीगाबाइट से अधिक मेमोरी की आवश्यकता होती है।

विशाल समझ का प्रस्तुत संस्करण:

$p=join"\n"[
    {#
        toChar c+'-'
        \\c<-j
    }
    \\j<-[
        take i(e++[0,0..])
        \\e<-r[
            [
                ~c
                \\c<-reverse e
                ,_<-[1..c]
            ]
            \\e<-hd[
                q
                \\q<-foldr(\h t=[
                    [a:b]
                    \\a<-h
                    ,b<-t
                ])[[]][
                    [
                        c
                        \\c<-subsequences(takeWhile((>=)k)(iterate((*)2)1))
                        |sum c<=k
                    ]
                    \\k<-p
                ]
                |sum[
                    1
                    \\a<-q
                    &b<-p
                    |sum a<>b
                ]<2&&foldr(bitxor)0(flatten q)==0
            ]
        ]1
        &i<-p
    ]
]

Comments

बस जिज्ञासु, स्वच्छ हैसेल के समान लगता है ... हास्केल पर इसके फायदे क्या हैं?

— योना

@ जोनाह काफी समान है, हाँ। मेरे सिर के ऊपर से, इसमें निम्न-स्तरीय प्रकार के हेरफेर, इनलाइन IL / असेंबली है, और C के साथ इंटरोप हास्केल की तुलना में आसान हासिल किया है। हालाँकि, वास्तविक उपयोग के लिए, स्वच्छ की अस्पष्टता और प्रयोगात्मक / अकादमिक प्रकृति के कारण, मैं हास्केल (जो पुस्तकालयों और संदर्भ जानकारी के संदर्भ में भी अधिक समर्थन प्राप्त है) की सिफारिश करूंगा। मुझे लगता है कि क्लीन सभी पसंद है।

— .urous