घड़ी (कार्ड गेम)

Question

घड़ी एक दिलचस्प कार्ड गेम है, क्योंकि इसके लिए किसी कौशल की आवश्यकता नहीं है। यह एक एकल खिलाड़ी खेल है, और एक ही कार्ड कॉन्फ़िगरेशन हमेशा एक जीत या नुकसान की ओर जाता है। इस चुनौती में, आपको यह पता लगाने की आवश्यकता है कि क्या कोई कार्ड कॉन्फ़िगरेशन जीतता है या खो देता है । आप यहां खेल खेल सकते हैं ।

खेल इस प्रकार खेला जाता है:

1. कार्डों के तेरह ढेरों का सामना किया जाता है। प्रत्येक ढेर को 0 से 12 तक गिना जाता है।
2. हमने वर्तमान ढेर होने के लिए 0 वें ढेर को निर्धारित किया है
3. हम वर्तमान ढेर चेहरे के शीर्ष कार्ड को फ्लिप करते हैं।
4. हम चेहरे के कार्ड को उसके संबंधित ढेर के नीचे ले जाते हैं (A 4 कार्ड 4 वें ढेर के नीचे जाता है) । कार्ड चेहरा बना हुआ है। यह ढेर वर्तमान ढेर बन जाता है।
5. यदि वर्तमान ढेर पूरी तरह से सामना कर रहा है, तो खेल खत्म हो गया है। अन्यथा, चरण 3 पर वापस जाएं।

युक्ति: खेल हमेशा 0 वें ढेर पर समाप्त होगा

यदि सभी कार्डों का सामना खत्म हो जाता है, तो गेम जीत लिया जाता है, और यदि शेष कार्ड डाउन फेस होते हैं तो हार जाते हैं।

इनपुट आउटपुट

बवासीर के प्रत्येक युक्त एक 2 डी सरणी। कार्ड को 0 से 12 तक संख्याओं के साथ दर्शाया जाता है (सूट अप्रासंगिक है, और नहीं दिया गया है)। प्रत्येक ढेर का शीर्ष कार्ड प्रत्येक सरणी का पहला तत्व है।

आप मान सकते हैं कि इनपुट अच्छी तरह से बनेगा: इसमें 0 से 12 तक (समावेशी) 52 कार्ड होंगे, और प्रत्येक संख्या में ठीक 4 बार शामिल होंगे।

यदि गेम जीता जा सकता है, तो आपको एक सत्य मान वापस करना होगा और यदि यह नहीं हो सकता है तो झूठा होना चाहिए।

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

Truthy:

[[11, 11, 7, 7], [8, 6, 5, 0], [2, 10, 9, 1], [12, 3, 0, 6], [8, 7, 4, 8], [3, 10, 5, 12], [11, 7, 1, 10], [3, 1, 6, 0], [2, 3, 0, 6], [5, 10, 5, 4], [12, 9, 11, 2], [9, 4, 12, 4], [1, 9, 8, 2]]
[[0, 9, 4, 8], [1, 4, 11, 3], [10, 12, 4, 0], [5, 9, 11, 5], [7, 0, 11, 2], [6, 5, 6, 0], [5, 7, 6, 7], [1, 10, 3, 4], [10, 11, 12, 3], [9, 9, 3, 6], [12, 12, 2, 1], [1, 8, 8, 2], [7, 2, 10, 8]]
[[11, 11, 9, 5], [3, 0, 1, 7], [6, 2, 9, 4], [6, 9, 11, 2], [10, 9, 6, 1], [12, 8, 10, 0], [2, 3, 12, 3], [3, 12, 5, 11], [4, 1, 8, 12], [7, 0, 2, 5], [4, 1, 10, 4], [7, 10, 6, 5], [8, 8, 0, 7]]
[[2, 3, 4, 11], [6, 12, 5, 9], [11, 0, 5, 9], [1, 8, 0, 12], [11, 9, 5, 8], [12, 7, 1, 0], [10, 3, 1, 11], [3, 12, 7, 2], [2, 7, 1, 5], [6, 3, 4, 10], [10, 10, 9, 8], [6, 2, 4, 4], [6, 8, 0, 7]]
[[1, 2, 12, 9], [5, 6, 4, 11], [0, 0, 7, 10], [9, 7, 12, 0], [12, 1, 8, 6], [10, 1, 4, 8], [9, 2, 6, 11], [10, 12, 1, 8], [6, 7, 0, 3], [2, 2, 5, 5], [8, 11, 9, 3], [4, 7, 3, 10], [5, 11, 4, 3]]
[[8, 12, 5, 3], [3, 10, 0, 6], [4, 11, 2, 12], [6, 1, 1, 12], [7, 6, 5, 0], [0, 8, 8, 7], [4, 8, 1, 2], [2, 3, 11, 6], [11, 10, 5, 2], [10, 1, 9, 4], [12, 5, 9, 7], [7, 3, 10, 9], [9, 0, 11, 4]]
[[3, 4, 8, 7], [2, 2, 8, 9], [12, 7, 0, 4], [4, 7, 10, 11], [5, 10, 3, 11], [10, 9, 8, 7], [5, 2, 11, 8], [6, 0, 3, 10], [9, 1, 4, 12], [12, 3, 12, 6], [2, 5, 1, 1], [6, 11, 5, 1], [6, 9, 0, 0]]
[[11, 9, 11, 1], [1, 3, 2, 8], [3, 3, 6, 5], [8, 11, 7, 4], [9, 4, 5, 1], [6, 4, 12, 6], [12, 10, 8, 7], [3, 9, 10, 0], [2, 8, 11, 9], [2, 4, 1, 0], [12, 5, 6, 0], [10, 7, 10, 2], [5, 0, 12, 7]]
[[9, 9, 6, 5], [7, 5, 11, 9], [8, 12, 3, 7], [1, 2, 4, 10], [11, 3, 3, 10], [2, 0, 12, 11], [4, 7, 12, 9], [3, 6, 11, 1], [1, 10, 12, 0], [5, 6, 8, 0], [4, 10, 2, 5], [8, 8, 1, 6], [0, 7, 2, 4]]
[[4, 0, 7, 11], [1, 5, 2, 10], [2, 9, 10, 0], [4, 12, 1, 9], [10, 12, 7, 0], [9, 4, 1, 8], [6, 6, 9, 12], [5, 3, 6, 2], [11, 3, 6, 4], [7, 3, 5, 5], [11, 8, 1, 11], [10, 7, 2, 8], [8, 12, 0, 3]]

Falsy:

[[8, 1, 6, 1], [7, 9, 0, 12], [11, 12, 12, 12], [11, 5, 9, 3], [2, 10, 9, 7], [11, 2, 0, 8], [0, 10, 4, 6], [8, 0, 4, 2], [6, 5, 3, 8], [4, 10, 3, 1], [5, 11, 9, 6], [7, 5, 1, 4], [2, 7, 3, 10]]
[[1, 4, 4, 6], [3, 11, 1, 2], [8, 5, 10, 12], [7, 10, 7, 5], [12, 8, 3, 7], [4, 0, 12, 12], [1, 1, 9, 6], [8, 7, 5, 10], [11, 0, 11, 0], [5, 10, 3, 11], [3, 2, 9, 8], [9, 6, 0, 2], [2, 6, 9, 4]]
[[10, 1, 10, 7], [12, 3, 11, 4], [0, 5, 10, 7], [5, 11, 1, 3], [6, 6, 9, 4], [9, 0, 8, 6], [9, 12, 7, 10], [1, 6, 3, 9], [0, 5, 0, 2], [4, 8, 1, 11], [7, 12, 11, 3], [8, 2, 2, 2], [8, 4, 12, 5]]
[[3, 8, 0, 6], [11, 5, 3, 9], [11, 6, 1, 0], [3, 7, 3, 10], [6, 10, 1, 8], [11, 12, 1, 12], [8, 11, 7, 7], [1, 8, 2, 0], [9, 4, 0, 10], [10, 2, 12, 12], [7, 4, 4, 2], [9, 4, 5, 5], [6, 2, 9, 5]]
[[0, 1, 9, 5], [0, 1, 11, 9], [12, 12, 7, 6], [3, 12, 9, 4], [2, 10, 3, 1], [6, 2, 3, 2], [8, 11, 8, 0], [7, 4, 8, 11], [11, 8, 10, 6], [7, 5, 3, 6], [0, 10, 9, 10], [1, 4, 7, 12], [5, 5, 2, 4]]
[[9, 8, 0, 6], [1, 1, 7, 8], [3, 2, 3, 7], [9, 10, 12, 6], [6, 12, 12, 10], [11, 4, 0, 5], [10, 11, 10, 7], [5, 3, 8, 8], [1, 2, 11, 4], [0, 5, 6, 0], [5, 9, 2, 4], [4, 2, 3, 11], [9, 1, 12, 7]]
[[4, 3, 5, 7], [1, 9, 1, 3], [7, 9, 12, 5], [9, 0, 5, 2], [7, 2, 11, 9], [1, 6, 6, 4], [11, 0, 6, 4], [3, 0, 8, 10], [2, 10, 5, 3], [10, 11, 8, 12], [8, 1, 12, 0], [7, 12, 11, 2], [10, 6, 8, 4]]
[[9, 5, 11, 11], [7, 7, 8, 5], [1, 2, 1, 4], [11, 11, 12, 9], [0, 12, 0, 3], [10, 6, 5, 4], [4, 5, 6, 8], [10, 9, 7, 3], [12, 6, 1, 3], [0, 4, 10, 8], [2, 0, 1, 12], [3, 9, 2, 6], [2, 7, 8, 10]]
[[4, 1, 5, 7], [7, 12, 6, 2], [0, 11, 10, 5], [10, 0, 0, 6], [10, 1, 6, 8], [12, 7, 2, 5], [3, 3, 8, 12], [3, 6, 9, 1], [10, 9, 8, 4], [3, 9, 2, 4], [11, 1, 4, 7], [11, 5, 2, 12], [0, 8, 11, 9]]
[[3, 11, 0, 1], [6, 1, 7, 12], [9, 8, 0, 2], [9, 6, 11, 8], [10, 5, 2, 5], [12, 10, 9, 5], [4, 9, 3, 6], [7, 2, 10, 7], [12, 6, 2, 8], [10, 8, 4, 7], [11, 3, 4, 5], [12, 11, 1, 0], [1, 3, 0, 4]]

Answer 1

ईएस 6, 57 बाइट्स

a=>(g=n=>a.map((x,i)=>i&&x[3]==n&&++c&&g(i)),g(c=0),c>11)

यह काम करता है क्योंकि केवल बवासीर 1-12 के नीचे के कार्ड प्रासंगिक हैं, और उन्हें ढेर में वापस निर्देशित ग्राफ बनाने की आवश्यकता है। इसलिए, मैं उन ढेरों की संख्या गिनता हूं जिनका निचला कार्ड 0 है, फिर ढेर की संख्या जिनकी निचला कार्ड उन ढेरों में से एक था जिन्हें मैंने पहले गिना था, अगर मैं 12 बवासीर तक पहुंचता हूं तो कॉन्फ़िगरेशन एक जीत है।

रूपरेखा प्रमाण:

खेल हमेशा समाप्त होता है जब आप अंतिम 0 से अधिक हो जाते हैं, क्योंकि उस ढेर में प्रभावी रूप से दूसरों की तुलना में कम कार्ड होता है।

यदि बवासीर पर नीचे के पत्ते 1-12 ढेर 0 के लिए एक निर्देशित ग्राफ बनाते हैं, तो ढेर 0 को साफ करने के लिए, हमें उन सभी ढेरों को साफ़ करना होगा जिनकी अंतिम प्रविष्टि 0 है, और इसलिए सभी ढेरों के पुनरावृत्ति पर हमें साफ़ करना होगा ताकि हम उन बवासीर को साफ़ कर सकें जिनकी अंतिम प्रविष्टि 0 है, और आगे। कॉन्फ़िगरेशन इसलिए एक जीतने वाला है।

यदि बवासीर के नीचे 1-12 कार्ड ढेर 0 के लिए एक निर्देशित ग्राफ नहीं बनाते हैं, तो कम से कम एक चक्र मौजूद होना चाहिए। इस चक्र में कोई ढेर साफ नहीं किया जा सकता है, क्योंकि यह चक्र में पिछले ढेर पर निर्भर करता है। (लंबाई 2 के एक चक्र के मामले में, यह चिकन और अंडे की स्थिति है।) इसलिए विन्यास एक हार है।

Answer 2

सीजाम, 23 21 बाइट्स

q~({(\a@+1$ff-m<(}h*!

सभी परीक्षण मामलों को चलाएं।

अगर सच्चाई और झूठे का काम विपरीत था तो मैं 3 बाइट बचा सकता था:

q~{((\a@+1$ff-m<}h

व्याख्या

दूसरे ढेर के नीचे ताश के पत्तों को रखना एक लाल हेरिंग है। हम उन्हें खेल से हटा सकते हैं और तब तक खेल सकते हैं जब तक कि वर्तमान ढेर खाली न हो जाए। तो यह है कि मैं क्या कर रहा हूं: कोड बस खेल खेलता है जब तक कि वर्तमान ढेर खाली नहीं होता है और फिर जांचता है कि क्या कोई कार्ड बचा है।

q~    e# Read and evaluate input.
(     e# Pull off the first (current) pile.
{     e# While the current pile is non-empty...
  (\  e#   Pull off the top card and swap with the remaining pile.
  a   e#   Wrap the pile in an array.
  @+  e#   Prepend it to the list of piles
  1$  e#   Copy the drawn card.
  ff- e#   Subtract it from all all remaining cards.
  m<  e#   Rotate the stack to the left by the drawn card
  (   e#   Pull off the top pile as the new current pile.
}h
*     e# The top pile is empty. Joining the other piles with it, flattens them.
!     e# Logical not, turns an empty array into 1 and a non-empty array into 0.

Answer 3

हास्केल, 85 बाइट्स

(a:b)?n|n<1=tail a:b|1>0=a:b?(n-1)
l%i|null(l!!i)=all null l|1>0=l?i%(l!!i!!0)
f=(%0)

Answer 4

पायथ, 13 बाइट्स

!su@LGGXeMQZZ

@ नील के प्रमाण पर निर्भर करता है। !su&VG@LGGeMQभी काम करता है।

                 implicit: Q=input
! s u            Sum of (apply lambda G,H on ... until fixed point) equals 0
      @L         Index G into itself.
         G       
         G       
                  Apply that to:
      X                                            set to
        eM Q      Last elts of input, with the 
        Z                                      0th
        Z                                                 0

इसे यहाँ आज़माएँ ।

Comments

अनुरोध रेखा बहुत बड़ी है (7173> 4094)

— पागल

लिंक तय किया।

— lirtosiast

Answer 5

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

x=lambda l,i=0:x(l,l[i].pop(0))if l[i]else[]==sum(l,[])

यदि सबलिस्ट खाली नहीं है, तो पॉपिंग आइटम जारी रखें। जब यह खाली हो जाता है, तो या तो सभी सूची खाली होती हैं (उन्हें एक बड़ी सूची में समूहित करके) या नहीं।

Comments

मुझे पायथन 3.4.2 का उपयोग करके पहले सच्चे परीक्षण मामले के लिए झूठी जानकारी मिलती है।

— lirtosiast

मैं प्रत्येक सूची का अंतिम आइटम ले रहा हूं, इसलिए आपको सूचियों को फ्लिप करने की आवश्यकता है: l = [i [:: - 1] i for l में]

— Dantal

प्रश्न स्पष्ट रूप से कहता है कि प्रत्येक सूची का पहला आइटम शीर्ष है। आपको अपनी बाइट गिनती में फ्लिप करने के लिए कोड को शामिल करना होगा।

— lirtosiast

फिक्स्ड। अब यह पहला आइटम पॉपिंग कर रहा है।

— दांतल

Answer 6

जेली, 11 बाइट्स

‘ịa
Ṫ€ÇL¡S¬

इसे यहाँ आज़माएँ ।