नोट: यह खेल रूममिकब की भिन्नता से संबंधित है

पृष्ठभूमि और नियम

रुम्मिकूब एक टाइल-आधारित खेल है। चार रंग हैं: लाल, नारंगी, नीला और काला। प्रत्येक रंग के लिए 13 टाइलें हैं (1 से 13 तक लेबल), और 2 जोकर भी हैं जो रंग-स्वतंत्र हैं, इसलिए कुल 54 टुकड़े हैं। रुम्मिकूब की इस भिन्नता में, प्रत्येक खिलाड़ी को 14 टाइलें मिलती हैं और उन्हें एक और टाइल मिलनी चाहिए और प्रत्येक दौर में एक दूसरे को गिरा देना चाहिए, जैसे कि टाइल की गिनती स्थिर है। खिलाड़ियों को एक-दूसरे की टाइलें दिखाई नहीं देती हैं। लक्ष्य टाइल्स को समूहित करना है, जैसे कि सभी टुकड़े कम से कम एक समूह (नीचे देखें) से संबंधित हैं। जब एक खिलाड़ी के पास सभी समूह होते हैं, तो वे अपने टाइल बोर्ड को छोड़ देते हैं और अपने टुकड़ों को प्रकट करते हैं। दूसरे तब जांचते हैं कि क्या सभी संयोजन वैध हैं, और यदि वे हैं, तो खिलाड़ी गोल जीतता है।

टाइल्स को कैसे समूहीकृत किया जा सकता है?

केवल दो प्रकार के समूह हैं:

बहु-रंग समूह:
- इनमें 3 या 4 टाइलें होती हैं।
- वे केवल उन पर समान संख्या के साथ टाइल होते हैं।
- सभी टाइलें अलग-अलग रंगों की हैं।
- उदाहरण: RED 9, BLUE 9, BLACK 9।
मोनो-रंग समूह:
- इनमें कम से कम 3 टाइलें होती हैं।
- इनमें 13 से अधिक टाइलें नहीं हो सकती हैं।
- उनके पास केवल आरोही क्रम में उन पर अलग-अलग, लगातार संख्याओं के साथ टाइलें हैं।
- सभी टाइल्स का रंग एक जैसा है।
- जिन टाइलों पर लेबल लगाए गए हैं, वे टाइल के बाद के स्थान 1 नहीं हो सकते हैं 13।
- उदाहरण: RED 5, RED 6, RED 7।

रुको, जोकर क्या करते हैं?

जोकर खेल में किसी भी टुकड़े को प्रतिस्थापित कर सकते हैं। उदाहरण के लिए, हमारा पहला उदाहरण बन सकता है JOKER, BLUE 9, BLACK 9, RED 9, JOKER, BLACK 9या RED 9, BLUE 9, JOKER। वही हमारे दूसरे उदाहरण पर लागू होता है। हालाँकि, हो सकता है कि एक ही समूह में दो जोकर न हों , इसलिए ऐसी चीजें JOKER, ORANGE 8, JOKERवर्जित हैं।

कार्य

रुम्मिकूब टाइल समूह को देखते हुए, यह निर्धारित करें कि क्या यह वैध है। आपको गारंटी दी जाती है कि 2 जोकरों के अलावा कोई डुप्लिकेट टाइल दिखाई नहीं देगी और यह कि आपको प्राप्त होने वाली टाइलें वैध हैं (उदाहरण के लिए जैसी चीजें 60दिखाई नहीं देंगी)।

इनपुट आउटपुट

आप इनपुट ले सकते हैं और किसी भी मानक विधि द्वारा आउटपुट प्रदान कर सकते हैं।

कुछ मान्य इनपुट प्रारूप: तार की सूची, ट्यूपल्स की सूची, नेस्टेड सूची, तार, या कुछ और जो आपको उपयुक्त लगता है। रंगों को स्ट्रिंग्स (उदाहरण के लिए "Blue","Red", etc.) के रूप में लिया जा सकता है , स्ट्रिंग संक्षिप्तीकरण के रूप में (कृपया ब्लू और ब्लैक टाइल्स को अलग पहचान दें), या एक रंग के पूर्णांक के रूप में। जब यह जोकर की बात आती है, तो आपको अपने प्रोग्राम को इनपुट के रूप में प्राप्त करने के तरीके का उल्लेख करना चाहिए। यदि आप स्ट्रिंग्स चुनते हैं RED 9, JOKER, ..., तो आपके पास कुछ हो सकता है , यदि आप ट्यूपल्स चुनते हैं तो आपके पास (9,"RED"), ("JOKER")या कुछ समान हो सकते हैं । यदि यह मदद करता है, तो आप उस जोकर के लिए एक रंग प्राप्त कर सकते हैं (जो आपके प्रोग्राम के आउटपुट को प्रभावित नहीं करना चाहिए)। उदाहरण के लिए, आपके पास ("JOKER","RED")या हो सकता है ("JOKER","BLUE"), लेकिन यह आउटपुट को किसी भी तरह से प्रभावित नहीं करना चाहिए।

आउटपुट के संबंध में, निर्णय-समस्या के लिए मानक नियम लागू होते हैं।

काम के उदाहरण

आइए एक उदाहरण लेते हैं, जो उम्मीद करता है कि इसे समझना आसान हो जाएगा। एक समूह को निम्नानुसार दिया गया है, जहां प्रत्येक ट्यूल टाइल का प्रतिनिधित्व करता है:

[(9, "RED"), (9, "ORANGE"), ("जोकर"), (9, "BLACK")]

यह एक सत्य मान लौटना चाहिए, क्योंकि इनपुट वैध है। इस मामले में, जोकर विकल्प देता है (9, "BLUE"), और वे एक बहु-रंग समूह बनाते हैं।

यदि आपको निम्नलिखित समूह दिया जाएगा:

[(९, "ब्लू"), (९, "ऑरेंज"), (९, "रेड"), (९, "ब्लैक"), ("जोकर")]

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

अतिरिक्त परीक्षण मामले

ये एक विस्तारित परीक्षण सूट के लिए हैं जो लगभग सभी संभावित स्थितियों को कवर करते हैं:

इनपुट -> आउटपुट 

[(1, "BLUE"), (2, "BLUE"), (3, "BLUE"), (4, "BLUE"), (5, "BLUE"), (6, "BLUE")] - > सत्य

[(6, "BLUE"), (6, "RED"), (6, "BLACK)] -> सत्य

[(5, "काला"), (6, "काला"), (7, "काला"), (8, "काला") (9, "काला"), (10, "काला"), ( "जोकर"), (12, "ब्लैक")] -> सत्य 

[("जोकर"), (3, "BLUE"), (3, "RED")] -> सत्य

[(8, "ब्लैक"), (2, "RED"), (13, "BLUE")] -> मिथ्या

[(4, "RED"), (3, "RED"), (5, "RED")] -> मिथ्या

[(5, "ब्लैक"), (6, "ब्लैक)] -> मिथ्या

[("जोकर"), (5, "रेड"), ("जोकर")] -> मिथ्या

[(4, "RED"), (5, "RED"), (6, BLUE ")] -> मिथ्या

[(4, "RED"), ("जोकर"), (5, "RED")] -> मिथ्या

[(१२, "ब्लैक"), (१३, "ब्लैक), (१," ब्लैक ")] -> मिथ्या

यह कोड-गोल्फ है , इसलिए हर भाषा में बाइट्स में सबसे छोटा कोड जीत जाता है!

code-golf decision-problem board-game

— श्री एक्सकोडर
स्रोत

APL (Dyalog) , 58 बाइट्स

दाएं तर्क के रूप में रंगों की सूची (1-4) और बाएं तर्क के रूप में संख्याओं की सूची लेता है। एक जोकर की संख्या को निरूपित (⍳4)किया जाता है जो (1 2 3 4)यह इंगित करने के लिए बराबर है कि यह उनमें से कोई भी हो सकता है। इसी तरह, इसका रंग यह इंगित (⍳13)करने के लिए दर्शाया गया है कि यह 1 से 13 तक की संख्या में से कोई भी हो सकता है।

{(3≤≢⍺)∧((s⍵)∧⍺≡∪⍺)∨((s←{1∊≢∘∪¨⊃,¨/⍵})⍺)∧∨/∊(⊃,¨/⍵)⍷¨⊂⍳13}

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

कलन विधि

तीन स्थितियां हैं, जिनमें से अंतिम दो में दो स्थितियां हैं:

रन की लंबाई 3 से अधिक या उसके बराबर होनी चाहिए

और या तो

1. एक एकल संख्या और
2. अनोखे रंग

या

1. एक रंग और
2. अनुक्रमिक संख्या

क्रम में मान्य होने के लिए।

पढ़ने का क्रम

3≤3 ≢⍺टाइल्स की संख्या से कम या बराबर है

∧ तथा

s⍵ सभी नंबर समान हैं

∧ तथा

⍺≡∪⍺ रंग अद्वितीय हैं

∨ या

1∊1 ≢∘∪¨अद्वितीय ⊃,¨/विस्तारित ⍺ रंगों की संख्या के बीच है

∧ तथा

∨/∊सभी ⊃,¨/⍵विस्तारित संख्याओं में से कम से कम एक मौजूद है ⍷¨⊂जो एक में पाया जाता है⍳13 13 1

पूर्ण कोड स्पष्टीकरण

{… } अनाम फ़ंक्शन जहां ⍺बाएं तर्क है और ⍵सही तर्क है

3.2।

⍳13 13 के माध्यम से संख्या 1

(… )⍷¨निम्न में से प्रत्येक रन के शुरुआती स्थान खोजें:

,¨/⍵ संख्या के प्रत्येक तत्व में शामिल हों (प्रत्येक जोकर मूल्य के लिए एक रन बनाता है)

⊃ खुलासा (क्योंकि /रैंक कम करता है)

∊ ϵ nlist (समतल)

∨/ या कमी (कोई भी सच है?)

(… )∧ और:

3.1

(… )⍺ रंगों की सूची में निम्नलिखित फ़ंक्शन को लागू करने का परिणाम:

s←{... } रों (के लिए रों निम्नलिखित गुमनाम समारोह है जो एएमई) ( ⍵है अपने तर्क):

,¨/⍵ प्रत्येक तत्व में शामिल हों (प्रत्येक जोकर मूल्य के लिए एक रन बनाता है)

⊃ खुलासा (क्योंकि /रैंक कम करता है)

≢∘∪¨ प्रत्येक सूची में अद्वितीय तत्वों की संख्या

1∊ क्या कोई सदस्य है? (यानी कोई सभी समान सूची हैं?)

(… )∨ या:

2.2।

∪⍺ अद्वितीय रंग

⍺≡ रंगों के समान हैं (अर्थात वे अद्वितीय हैं)

(… )∧ और:

2.1।

s⍵ संख्या सभी समान हैं

(… )∧ और

1।

≢⍺ रंगों की संख्या (यानी टाइल्स की संख्या)

3≤ तीन उससे कम या उसके बराबर है

— एडम
स्रोत

1

वाह, ऐसा लग रहा है कि एपीएल इस चुनौती के लिए एक महान उपकरण है

— श्री एक्सकोडर

3

जेली , 41 40 38 36 बाइट्स

EȧI=1ȦȯE
0,W€yµZç/ɓQ⁼⁸ȧ
L>2ȧ4p13ðç€Ṁ

इसे ऑनलाइन आज़माएं! (एक परीक्षण सूट पाद के साथ आता है)

(color, value)नियमित टाइल के लिए और 0जोकर के लिए एक सरणी के रूप में इनपुट लेता है । रंगों को पूर्णांक के रूप में दर्शाया जाता है (हालांकि मुझे यकीन नहीं है कि अगर यह वर्तमान कोड के लिए भी मायने रखता है)।

आउटपुट 1(सत्य) या 0(मिथ्या)।

व्याख्या

L>2ȧ4p13ðç€Ṁ    Main link, checks if a sequence is valid. Args: sequence
L                 Get the length of the sequence.
 >2               Check if it's at least 3 tiles.
   ȧ4             And: yield 4 if it is, 0 otherwise.
     p13          Cartesian product: yield all possible tiles if
                  result was 4, empty array otherwise.
        ð         Begin a new dyadic chain with args (tiles, sequence).
         ç€       Call the first helper link for each tile with args (tile, sequence).

0,W€yµZç/ɓQ⁼⁸ȧ    First helper link, checks if a sequence is valid if jokers
                  are substituted for the given tile. Args: tile, sequence
0,                  Make a pair [0, tile].
  W€                Turn that into [[0], [tile]].
    y               Map all 0's (jokers) into tile in the sequence.
     µ              Begin a new monadic chain with args (sequence).
      Z             Transpose to get list [colors, values].
       ç/           Call the second helper link with args (colors, values).
         ɓ          Begin a new dyadic chain with args (sequence, valid).
          Q         Remove duplicate tiles from the sequence.
           ⁼⁸       Check if the sequence is unchanged (i.e. there were no duplicates).
             ȧ      And with the output of the second helper.

EȧI=1ȦȯE    Second helper link, checks if a sequence is valid assuming no duplicates.
            Args: colors, values
E             Check if all the colors are the same.
 ȧ            Logical and with the values array.
              Yields the values if they were, 0 if not.
  I           Find the differences between each value.
              Yields [] if the colors differed.
   =1         See if each difference is equal to 1.
              Yields [] if the colors differed.
     Ȧ        Check if the list was nonempty and all values were truthy.
              Yields 1 for valid mono-colors, 0 otherwise.
      ȯ       Logical or with the values array.
              Yields 1 for valid mono-colors, the values otherwise.
       E      Check if all the values are the same. For valid mono-colors
              this tests if all items of [1] are equal (obviously true).
              Yields 1 for valid sequences, 0 otherwise.

— PurkkaKoodari
स्रोत

मुझे लगता है कि आपको लगातार सत्य / झूठ का उत्पादन करना होगा।

— Adám

@ Adám संपादित, सौभाग्य से बाइट गिनती को प्रभावित नहीं करता था।

— पुरकाकूदरी

2

पायथन 2 , 371 370 362 341 329 325 बाइट्स

@ Mr.Xcoder ने 1 बाइट बचाई: str.split()इसके बजायlist literal
8 बाइट्स बचाए गए: शॉर्टहैंड के लिए len(x)-1
19 बाइट्स बचाया: J O BK B Rके लिए Joker, Orange, Black, Blue, Redशाब्दिक
@ Mr.Xcoder अभी तक एक और 12 बाइट्स बचा लिया, धन्यवाद !!
एक और 4 बाइट्स @ Mr.Xcoder को धन्यवाद

def f(x):
 j=sum("J"in i for i in x);z=len(x)-1
 if j>1or z<2:return False
 if j<1:return(all(i[0]==x[0][0]for i in x)and sum(i[1]==x[0][1]for i in x)<2)or(all(i[1]==x[0][1]for i in x)and sum(int(x[m+1][0])==int(x[m][0])+1for m in range(z))==z)
 return any(f([[k,(i+1,j)]["J"in k]for k in x])for j in'RBbO'for i in range(13))

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

— officialaimm
स्रोत

2

370 बाइट्स

— मिस्टर एक्सकोडर

आप बदल सकते हैं BKके साथ bपरीक्षण मामलों के लिए अद्यतन के साथ 1 बाइट बचाने के लिए (TIOb ।

— श्री Xcoder

1

यह वास्तव में मेरे विचार से कहीं अधिक बाइट्स बचाता है: 329 ।

— मिस्टर एक्सकोडर

1

325 बाइट्स । बहुत देर से सुधार के लिए क्षमा करें ।

— श्री एक्सकोडर

1

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

var testcases = [[{n:1,c:"BLUE"},{n:2,c:"BLUE"},{n:3,c:"BLUE"},{n:4,c:"BLUE"},{n:5,c:"BLUE"}, {n:6,c:"BLUE"}],[{n:6,c:"BLUE"},{n:6,c:"RED"},{n:6,c:"BLACK"}],[{n:5,c:"BLACK"},{n:6,c:"BLACK"},{n:7,c:"BLACK"},{n:8,c:"BLACK"},{n:9,c:"BLACK"},{n:10,c:"BLACK"},{n:0,c:"JOKER"},{n:12,c:"BLACK"}],[{n:0,c:"JOKER"},{n:3,c:"BLUE"},{n:3,c:"RED"}],[{n:8,c:"BLACK"},{n:2,c:"RED"},{n:13,c:"BLUE"}],[{n:4,c:"RED"}, {n:3,c:"RED"}, {n:5,c:"RED"}],[{n:5,c:"BLACK"}, {n:6,c:"BLACK"}],[{n:0,c:"JOKER"},{n:5,c:"RED"},{n:0,c:"JOKER"}],[{n:4,c:"RED"},{n:5,c:"RED"},{n:6,c:"BLUE"}],[{n:4,c:"RED"},{n:0,c:"JOKER"},{n:5,c:"RED"}],[{n:12,c:"BLACK"},{n:13,c:"BLACK"},{n:1,c:"BLACK"}],[{n:11,c:"BLACK"},{n:12,c:"BLACK"},{n:0,c:"JOKER"}],[{n:1,c:"BLACK"},{n:2,c:"BLACK"},{n:3,c:"BLACK"},{n:1,c:"BLUE"},{n:2,c:"BLUE"},{n:3,c:"BLUE"}]];

g=a=>a.length
j=a=>a.n==0
l=(x,y)=>x.c==y.c||j(x)||j(y)
a=s=>g(s)>2&&([q=[0],x=s[0],s.map(y=>q[0]+=x==y||((l(x,y)||x.n==y.n)&&!(j(x)&&j(y)))&&(([n=s.indexOf(y),n<1||([x=s[n-1],!l(x,y)||y.n>0&&x.n<y.n])[1]||(n<g(s)-1&&x.n+1<s[n+1].n)||(n==g(s)-1&&y.n==0&&x.n<13)])[1])?1:0)])[0][0]==g(s)

testcases.forEach(H=>console.log(a(H)));

स्निपेट का विस्तार करें

(ध्यान दें कि ऊपर दिए गए परीक्षण मामलों में 2 अतिरिक्त परीक्षण मामले शामिल हैं जो प्रश्न में नहीं हैं: वे क्रमशः सही और गलत हैं: पठनीयता के लिए अनगुल्ड संस्करण देखें)।

किसी न किसी प्रक्रिया:

 Using first tile x:
   For each tile y:
     count for x: can group with y
 return: x matches n tiles, where n is the number of tiles

जोकर 0को उनके संख्यात्मक मान के रूप में इंगित किया जाता है (एक नकारात्मक संख्या भी काम करेगी); यह इनपुट संरचना को सुसंगत रखता है (जिसमें एक रंग और मान दोनों होते हैं) और c=="JOKER"7 बाइट्स की बचत होने पर जाँच करने पर निर्भर नहीं करता है ।

यह संभव है कि कुछ कोष्ठकों को हटाया जा सकता है, यह qएक सरणी के रूप में बॉक्स नहीं करना संभव हो सकता है (मैंने इसे आज़माया और मूल्य या तो 0 पर रहा या नाक राक्षसों का कारण बना )।

Ungolfed:

var testcases = [
[{n:1,c:"BLUE"},{n:2,c:"BLUE"},{n:3,c:"BLUE"},{n:4,c:"BLUE"},{n:5,c:"BLUE"}, {n:6,c:"BLUE"}],//true
[{n:6,c:"BLUE"},{n:6,c:"RED"},{n:6,c:"BLACK"}],//true
[{n:5,c:"BLACK"},{n:6,c:"BLACK"},{n:7,c:"BLACK"},{n:8,c:"BLACK"},{n:9,c:"BLACK"},{n:10,c:"BLACK"},{n:0,c:"JOKER"},{n:12,c:"BLACK"}],//true
[{n:0,c:"JOKER"},{n:3,c:"BLUE"},{n:3,c:"RED"}],//true
[{n:8,c:"BLACK"},{n:2,c:"RED"},{n:13,c:"BLUE"}],//false
[{n:4,c:"RED"}, {n:3,c:"RED"}, {n:5,c:"RED"}],//false
[{n:5,c:"BLACK"}, {n:6,c:"BLACK"}],//false
[{n:0,c:"JOKER"},{n:5,c:"RED"},{n:0,c:"JOKER"}],//false
[{n:4,c:"RED"},{n:5,c:"RED"},{n:6,c:"BLUE"}],//false
[{n:4,c:"RED"},{n:0,c:"JOKER"},{n:5,c:"RED"}],//false
[{n:12,c:"BLACK"},{n:13,c:"BLACK"},{n:1,c:"BLACK"}],//false
[{n:11,c:"BLACK"},{n:12,c:"BLACK"},{n:0,c:"JOKER"}],//true
[{n:1,c:"BLACK"},{n:2,c:"BLACK"},{n:3,c:"BLACK"},{n:1,c:"BLUE"},{n:2,c:"BLUE"},{n:3,c:"BLUE"}]
];

g=a=>a.length
i=(a,v)=>a.indexOf(v)
j=x=>x.n==0
m=(x,y)=>
       (l(x,y)||x.n==y.n)
    &&!(j(x)&&j(y))
l=(x,y)=>x.c==y.c||j(x)||j(y)
c=(a,v)=>([n=i(a,v),
      n<1
    ||([x=a[n-1],!l(x,v)||v.n>0&&x.n<v.n])[1]
    ||(n<g(a)-1&&x.n+1<a[n+1].n)
    ||(n==g(a)-1&&v.n==0&&x.n<13)])[1]
a=s=>g(s)>2&&([q=[0],x=s[0],s.map(y=>q[0]+=x==y||m(x,y)&&c(s,y)?1:0)])[0][0]==g(s)

testcases.forEach(H=>console.log(a(H)));

स्निपेट का विस्तार करें

संस्करण मैंने तर्क को सही करने के लिए काम किया। एकल-उपयोग वाले लंबोदर को लाइन में खड़ा किया गया; यहाँ उनके इसी समारोह है:

g() -> string.length
i() -> indexof
j() -> isJoker
m() -> do tiles match
l() -> do colors match
c() -> same-color isConsecutiveOrder
a() -> main lambda

— Draco18s को अब SE पर भरोसा नहीं है
स्रोत

1

सी # (.NET कोर) , 198 बाइट्स

using System.Linq;(C,N)=>{int l=C.Length,j=C.Count(x=>x<1),c=C.Distinct().Count(),n=N.Distinct().Count(),u=N.Min();foreach(var x in N)u*=0<(u&x)?2:0;return l>2&((u>0&n==l&c<2+j)|(n<2+j&c==l&l<5));};

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

हालांकि इनपुट नंबर के लिए प्रारूप बहुत खास है। जिस नंबर के लिए इनपुट होना जरूरी है वह नंबर n2 ^ n है, जबकि जोकर का प्रतिनिधित्व करने के लिए इस्तेमाल किया जाने वाला नंबर होना चाहिए (2 ^ 14) -1। यह बिटवाइज़ को सक्षम करता है और u&xयू का मूल्यांकन करता है यदि टाइल x का यू के बराबर मूल्य है या जोकर है।

सी # (.NET कोर) , 200 बाइट्स

using System.Linq;(C,N)=>{int l=C.Length,j=N.Count(x=>x<1),c=C.Distinct().Count(),n=N.Distinct().Count(),u=N.Min();foreach(var x in N)u=u==x|x<1?u+1:0;return l>2&((u>0&n==l&c<2+j)|(n<2+j&c==l&l<5));};

एक 2 बाइट लंबा समाधान जो इनपुट के बारे में उदार नहीं है। एक स्थान पर जोकरों के लिए सिर्फ एक विशेष मामले का उपयोग करने की बारी आती है, वे उस मुश्किल से निपटने में सक्षम नहीं थे जिस चतुर बिटवाइज़ ऑपरेशन की तुलना में मुझे बहुत गर्व था। यहाँ जोकर (0,0) हैं, अन्य संख्याएँ अपेक्षा के अनुरूप हैं, और रंगों को किसी भी 4 मानों का प्रतिनिधित्व किया जाता है, जो C # की डिफ़ॉल्ट तुलना से एक दूसरे से अलग होते हैं (विशेष रूप से, Linq Distinct()ऑपरेशन को समान रंग के लिए मानों पर विचार करना चाहिए जो 'अलग नहीं' है) और 'अलग' के रूप में विभिन्न रंगों के लिए मूल्य)।

जो कुछ अन्य भाषाओं के लिए हो सकता है, u*=!u++^x*xवह u=u==x|x<1?u+1:0कुछ भाषाओं में समतुल्य होगा ; u ^ x 0 iff u == x है, और 0 गुना कोई भी इंट 0 है, इसलिए u ^ x * x या तो u == x या x == 0 के लिए होगा, यदि C # ने बिटवाइज़ ऑपरेशंस को पहले से कम नहीं किया है गणितीय वाले। सी # भी स्पष्ट कास्टिंग के बिना बूल के रूप में ints की व्याख्या नहीं कर सकते। एक भाषा की कोशिश करता कठिन प्रकार काम मूल्यों कन्वर्ट कर सकती है बनाने के लिए है कि 0और not 0करने के लिए falseऔर trueलागू करने से पहले !हालांकि उन्हें, और फिर जब किसी पूर्णांक के लिए वापस जा व्याख्या !false1 के रूप में और !trueके रूप में 0. सब कहा, मैं किसी अन्य भाषा गारंटी नहीं दे सकते वास्तव में होगा बाकी एल्गोरिथ्म से लाभ तो यह भी नहीं आ सकता है।

— कामिल दकरी
स्रोत

1

स्काला, 491 477 चार्ट, 491 477 बाइट्स

यह चुनौती मजेदार थी; धन्यवाद।

var c=Seq("O","B","b","R")
t match{case _ if t.length<3=>false
case _ if t.exists(x=>x._1==0)=>{var b=false
if(t.filter(q=>q._1!=0).exists(q=>q._1==0))b else{for(y<-1 to 13)for(u<-c)b=b|f(t.takeWhile(q=>q._1!=0)++:(y,u)+:t.reverse.takeWhile(q=>q._1!=0).reverse)
b}}
case _::(x,_)::_ if t.forall(_._1==x)=>true
case _ if t.forall(_._2==c(0))|t.forall(_._2==c(1))|t.forall(_._2==c(2))|t.forall(_._2==c(3))=>(t(0)._1 to t(0)._1+t.length-1).toList equals t.map(_._1)
case _=>false}

तो fलाइन 4 में एक पुनरावर्ती कॉल है जहां मैं हर दूसरी टाइल द्वारा "जकार" को बदलने की कोशिश करता हूं। कोड के स्पष्ट दृश्य के लिए tio देखें । मैंने इनपुट को 2-ट्यूपल्स (इंट, स्ट्रिंग) के अनुक्रम के रूप में चुना - tमेरे कोड में कहा जाता है, tio देखें - इसलिए "JOKER" को 2-tuple (0, "JOKER") द्वारा दर्शाया गया है।

संपादित करें: 14 बाइट्स ने टिप्पणियों के लिए धन्यवाद बचाया, मैं ऑरेंज ब्लैक ब्लू रेड के लिए ओबी बी आर लेता हूं।

यह ऑनलाइन की कोशिश करो!

संपादित करें: -2 बाइट्स, एस (की स्थितियों के आसपास बेकार हटा दिया गयाcase _ if

— वी। कोर्टीस
स्रोत

बाइट्स को बचाने के O,B,b,Rबजाय आप उपयोग नहीं कर सकते ORANGE,BLUE,BLACK,RED? मुझे नहीं पता कि स्काला कैसे काम करती है, लेकिन मुझे लगता है कि आप कर सकते हैं।

— श्री एक्सकोडर

मैंने कोशिश की; वास्तव में यह इस तरह से बाइट्स बचाता है (तार का एक seq)। यह कुल 49 बाइट्स के लिए करता है var (O,B,b,R)=("ORANGE","BLACK","BLUE","RED")और कॉल करता है O B b R; जहां var c=Seq("ORANGE","BLACK","BLUE","RED")और कॉल कुल c(...)58 बाइट्स हैं। लेकिन पहले मामले की for(u<-c)जगह परमिट होता है for(u<-Seq(O,B,b,R)), इसलिए लागत -9 नहीं बल्कि +2 है। यद्यपि कोशिश करने के लिए धन्यवाद।

— वी। कोर्टोइस

@ V.Courtois मुझे विश्वास है कि मिस्टर एक्सकोडर सुझाव दे var c=Seq("O","B","b","R")रहे थे कि उन वर्णों का उपयोग कर रहे हैं और रंग के रूप में पूर्ण स्ट्रिंग्स के बजाय आपके इनपुट के रूप में ले रहे हैं। जैसा कि मूल पोस्ट में बताया गया है, "रंगों को ... स्ट्रिंग संक्षिप्ताक्षर" के रूप में लिया जा सकता है।

— कामिल दकरी

ओह ~ मैं देख रहा हूँ कि आपका क्या मतलब है, धन्यवाद @ आप दोनों

— वी। कोर्टोइस

रमीमकुब खेलते हैं!

पृष्ठभूमि और नियम

टाइल्स को कैसे समूहीकृत किया जा सकता है?

रुको, जोकर क्या करते हैं?

कार्य

इनपुट आउटपुट

काम के उदाहरण

अतिरिक्त परीक्षण मामले

APL (Dyalog) , 58 बाइट्स

कलन विधि

पढ़ने का क्रम

पूर्ण कोड स्पष्टीकरण

जेली , 41 40 38 36 बाइट्स

व्याख्या

पायथन 2 , 371 370 362 341 329 325 बाइट्स

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

सी # (.NET कोर) , 198 बाइट्स

सी # (.NET कोर) , 200 बाइट्स

स्काला, 491 477 चार्ट, 491 477 बाइट्स