चलो कुछ बोर्डगेम खेलते हैं!

Question

परिचय

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

चुनौती

मान लीजिए यह बोर्डगेम: >---#<---X---<X<--#-$

>   means the start of the game
-   means a position without danger
<   means the player should return one step back
X   means the player won't move next round
#   means a portal where the player returns to the start position
$   the first player to get there or after there wins the game

इनपुट ऊपर वर्णित boardgame के पहलुओं और (से कुछ मूल्यों के साथ दो सरणियों के साथ एक स्ट्रिंग के होते हैं 1करने के लिए 6क्रम में) है कि दोनों खिलाड़ियों (बच्चा Aऔर बच्चे Bजब एक घन की भूमिका में) मिला था।

दोनों सरणियों में हमेशा समान लंबाई> = 1 होगी।

बच्चा Aहमेशा खेल शुरू करता है।

आपको उस बच्चे को आउटपुट करना होगा जो अंत में मिला या पहले अंत के करीब था।

यदि दोनों में से किसी को भी अंत नहीं मिला और दोनों बच्चे एक ही स्थिति के प्रिंट 0या किसी अन्य गलत मूल्य पर बने रहे।

यदि एक ऐरे से निकलता है, जबकि दूसरे में डाइस रोल बचे हैं (एक खिलाड़ी के एक्स पर कई मोड़ गायब होने के कारण), शेष डाइस रोल का उपयोग किया जाना चाहिए।

इस कार्य के लिए, आप एक प्रोग्राम / फ़ंक्शन बना सकते हैं, जो स्टड से इनपुट पढ़ता है, या पैरामीटर / तर्क और आउटपुट / रिटर्न / विजेता बच्चे को प्रिंट करता है।

चूंकि यह कोड-गोल्फ है , बाइट्स जीत में सबसे छोटा जवाब!

उदाहरण इनपुट और आउटपुट

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

उदाहरण 1:

board:  >---#<---X---<X<--#-$
kid-A:  [3,6,6,5,2,1]
kid-B:  [4,5,3,5,5,5]

output: A

व्याख्या:

>---#<---X---<X<--#-$     # both kids in position
B--A#<---X---<X<--#-$     # kid-A moved 3 to -
B--A#<---X---<X<--#-$     # kid-B moved 4 to # and returned home
B---#<---A---<X<--#-$     # kid-A moved 6 to X and will wait one round
B---#<---A---<X<--#-$     # kid-B moved 5 to < returned one to # and returned home
>--B#<---A---<X<--#-$     # kid-B moved 3 to -
>--B#<---X---<A<--#-$     # kid-A moved 6 to < returned one to X and will wait again
>---#<--BX---<A<--#-$     # kid-B moved 5 to -
>---#<---X--B<A<--#-$     # kid-B moved 5 to < returned one to -
>---#<---X--B<X<--#A$     # kid-A moved 5 to -
>---#<---X---<X<-B#A$     # kid-B moved 5 to -
>---#<---X---<X<-B#-$A    # kid-A moved 2 and won the game!

---

उदाहरण 2:

board:  >-<<<<<$
kid-A:  [1,2,3]
kid-B:  [5,5,4]

output: 0

---

उदाहरण 3:

board:  >-<-<#<-<-<-$
kid-A:  [5,4,2]
kid-B:  [1,1,1]

output: B

व्याख्या:

>-<-<#<-<-<-$     # both kids in position
>-<-<#<-<-<-$     # kid-A moved 5 to # returned home
AB<-<#<-<-<-$     # kid-B moved 1 to -
>B<A<#<-<-<-$     # kid-A moved 4 to < returned one to -
>B<A<#<-<-<-$     # kid-B moved 1 to < returned one to -
AB<-<#<-<-<-$     # kid-A moved 2 to # returned home
AB<-<#<-<-<-$     # kid-B moved 1 to < returned one to -

Current position: (A:0, B:1) output: B

Comments

क्या हम मान सकते हैं कि दो सरणियाँ (ए और बी के लिए) हमेशा एक ही लंबाई की होंगी?

— ट्राइकोप्लाक्स

यदि एक ऐरे से निकलता है, जबकि दूसरे में डाइस रोल (शायद एक खिलाड़ी के एक्स पर कई मोड़ गायब होने के कारण) है, तो क्या वर्तमान स्थिति का उपयोग आउटपुट को निर्धारित करने के लिए किया जाना चाहिए, या शेष डाइस रोल का उपयोग पहले किया जाना चाहिए?

— ट्राइकोप्लाक्स

@trichoplax। हां, वे हमेशा एक ही लंबाई के होंगे .. मैं सवाल में स्पष्ट कर दूंगा

— हटा दिया गया

@trichoplax। शेष पासा रोल पहले इस्तेमाल किया जाना चाहिए

— हटा दिया

उदाहरण 3 सही है? मैं इसे अपने सिर में चलाता हूं और बी को कभी भी स्पेस 2 नहीं मिलता है, जबकि ए को स्पेस 4 मिलता है।

— ड्रेको 18 को अब एसई

Answer 1

पर्ल, 188 180 + 2 = 182 बाइट्स

वुहू, का उपयोग करने के लिए मिला goto।

@q=/.(?!$)/g,next if$w=$e=!@q;for(@F){a:$w+=$_;$_=$q[$w];/</?($_=-1,goto a):/X/?$e++:/#/?$w=0:!$_&&last;$e++}$r+=$"lt$r?-$w:$w;$t+=$"lt$t?-$e:$e-1}{say$w>@q?$t<0?B:A:!$r?0:$r<0?B:A

आवश्यकता -aऔर -E| -M5.010:

$ echo $'>-<-<#<-<-<-<-$\n5 4 2\n1 1 1' | perl -M5.010 boardgame.pl
B

कुछ असम्बद्ध संस्करण:

#!/usr/bin/perl -a

# Read all but last char from the board into an array
@board = /.(?!$)/g,next if $pos = $turns = !@board;
for (@F) {
    a:
    $pos+=$_;
    $_=$board[$pos];
    /</?($_=-1,goto a):
    /X/?$turns++:
    /#/?$pos=0:
    # End of Game (Victory!)
    !$_&&last;

    $turns++
}
# Make sure '$pos_diff' and '$turns_diff' are not zero by checking against [:space:]
# ' ' is less than 0 on the ascii table
$pos_diff += $"lt$pos_diff ? -$pos : $pos;
$turns_diff += $"lt$turns_diff ? -$turns : $turns-1;
}{
    say $pos>@board?
            $turns_diff<0?B
            :A
        :
        !$pos_diff?0:
        $pos_diff<0?B:
        A

Answer 2

हास्केल, 142

_![]=fail;g!(x:y)|x>length g=Just|1<2=g!fix(\f x->case(g!!x)of;'<'->f$x-1;'X'->(0:);'#'->map$(-)(-x);_->map(+x))x y;(g?a)b=(g!)a"A"<|>(g!)b"B"

उपयोग:

(?) "GAME" [kidA moves] [kidB moves]

आउटपुट:

(?) ">---#<---X---<X<--#-$" [3,6,6,5,2,1] [4,5,3,5,5,5]
Just "A"

---

संपादित करें:
बाइक, मैंने इसे मौत के घाट उतारा; यह अंतिम उदाहरण के लिए विफल रहता है। मैं इसे शीघ्र ही पुनर्जीवित करूंगा।

Comments

हम आम तौर पर importएस के लिए बाइट्स की गिनती करते हैं , और मुझे लगता है कि आपको कुछ की आवश्यकता होगी fixऔर <|>, क्योंकि वे Prelude में नहीं हैं (या क्या कोई संस्करण है जिसमें उन्हें शामिल किया गया है?)।

— nimi

आप सही कह रहे हैं, वे प्रील्यूड में नहीं हैं, बुयुट वे डिफ़ॉल्ट रूप से आयात किए जाते हैं यदि आप लैम्ब्डाबॉट का उपयोग एक दुभाषिया के रूप में करते हैं (मुझे लगता है कि गिनती आयात उचित है; मैं जब भी इसे ठीक

— करूंगा

दुभाषिया भाषा को परिभाषित करता है , इसलिए आप भाषा lambdabot-Haskellया समान को कॉल कर सकते हैं और आयात के लिए बाइट काउंट को बाहर कर सकते हैं ।

— निमि