21

टकुज़ू एक लॉजिक गेम है जिसमें आपको 0एस और 1एस युक्त कोशिकाओं के साथ एक ग्रिड को पूरा करना होता है । ग्रिड को 3 नियमों का पालन करना चाहिए:

कोई तीन क्षैतिज या ऊर्ध्वाधर लगातार कोशिकाएं समान नहीं हो सकती हैं।
बराबर संख्या में होना चाहिए 0और1प्रत्येक पंक्ति और स्तंभ में s ।
कोई दो पंक्तियाँ समान नहीं हो सकती हैं, और कोई भी दो स्तंभ समान नहीं हो सकते हैं।

आइए देखें एक तैयार ग्रिड:

जैसा कि आप देख सकते हैं, यह बोर्ड नियम का पालन करता है 1, 2और 3। कोई तीन क्षैतिज या ऊर्ध्वाधर कोशिकाएं नहीं हैं जो समान हैं, सभी पंक्तियों और स्तंभों में समान संख्या में 0एस और हैं1 s हैं, और कोई भी दो पंक्तियाँ और कोई दो स्तंभ समान नहीं हैं।

आइए एक ग्रिड देखें जो मान्य नहीं है:

इस ग्रिड के साथ समस्याओं का एक गुच्छा है। उदाहरण के लिए, पंक्ति में एक पंक्ति में 5तीन 0s हैं, और स्तंभ में एक पंक्ति में 2तीन 1s हैं, उसके बाद तीन हैं0 s हैं। इसलिए, यह एक वैध ग्रिड नहीं है।

कार्य:

आपका कार्य एक ऐसा कार्यक्रम बनाना है, जिसे n* n 0s और 1s का एक 2D सरणी दिया गया है , यह देखने के लिए बोर्ड को सत्यापित करता है कि क्या यह वैध, समाप्त हुआ तक्जू बोर्ड है।

उदाहरण:

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

11
00

यह एक मान्य बोर्ड नहीं है - पंक्ति 1नियम का पालन नहीं करती है 2। आपको इसके लिए एक गलत मूल्य वापस करना होगा।

यह एक वैध बोर्ड नहीं है, यह नियम 3 के कारण विफल (केवल) है - पहली और चौथी पंक्तियाँ समान हैं।

यह एक वैध बोर्ड नहीं है, यह नियम 3 के कारण विफल (केवल) है - पहला और चौथा स्तंभ समान हैं।

यह एक वैध बोर्ड है।

नियम और विनिर्देश:

आप मान सकते हैं कि सभी बोर्ड आयामों के वर्ग हैं n * n, जहां nएक सकारात्मक भी पूर्णांक है।
आप यह मान सकते हैं कि सभी बोर्ड समाप्त हो चुके हैं।
आप एक 2D सरणी के रूप में इनपुट ले सकते हैं जिसमें मानों को हस्ताक्षरित किया जा रहा है 0और 1एक स्ट्रिंग के रूप में।
आपको सत्य और असत्य बोर्डों के लिए लगातार सत्य और गलत मूल्यों का उत्पादन करना चाहिए, और "सत्य" और "गलत" का प्रतिनिधित्व करने वाले मूल्य समान नहीं हो सकते।

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

— clismique
स्रोत

1

ब्रेकीलॉग , 20 18 बाइट्स

≠\≠,?¬{∋s₃=|∋ọtᵐ≠}

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

व्याख्या

≠                           All rows are different
 \                          Transpose
  ≠                         All columns are different
   ,?                       Append the list of rows to the list of columns
     ¬{          }          It is impossible that:
       ∋                      A row/column of the matrix…
        s₃=                   …contains a substring of 3 equal elements
           |                Or that:
            ∋ọ                The occurences of 1s and 0s in a row/column…
              tᵐ≠             …are not equal

— Fatalize
स्रोत

" पंक्तियों की सूची को स्तंभों की सूची में जोड़ें " इसे गोल्फ करने के लिए स्मार्ट तरीका! और यहां मुझे लगा कि आपका 20-बाइट का जवाब इस बिंदु पर था और जितना हो सकता था उतना गोल्फ किया। मैं देख रहा हूं कि ब्रैकीग्लॉट मैट्रिसेस को वैलिडेट करने में उतना ही अच्छा है जितना कि उन्हें हल करने में । :)

— केविन क्रूज़सेन

1

यह उत्पादन नहीं करना चाहिए falseके लिए यह ?

— H.PWiz

1

@ H.PWiz अच्छा लगता है, धन्यवाद। काम करने वाले 18 बाइट्स संस्करण पर वापस लौटा।

— घातक

@LuisMendo मैं मूल रूप से एक ही सूची में सभी पंक्तियों और सभी स्तंभों को डाल रहा हूं।

— बजे

2

@ ज़र्ब सही, धन्यवाद। यह तीसरी बार है जब मैंने एक संपादन रोलबैक किया है, शुरुआती पोस्ट बेहतर परीक्षण मामलों की सख्त जरूरत है ...

— 15

11

हस्क , 19 18 बाइट्स

S=‼(Tf§=LṁDum(ṁ↑2g

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

1 बाइट H.PWiz के लिए धन्यवाद बचा लिया!

मुख्य विचार इनपुट में परिवर्तनों की एक श्रृंखला को लागू कर रहा है जो एक वैध बोर्ड के लिए पहचान हैं और अंतिम परिणाम मूल इनपुट के समान है या नहीं, इसकी जाँच करें।

व्याख्या

S=‼(Tf§=LṁDum(ṁ↑2g
            m(ṁ↑2g    in each line, take at most two items for each sequence of equal items
           u          remove duplicate lines
     f§=LṁD          keep only those lines where the sum of each element doubled is equal to the length of the line
    T                 transpose the matrix (swap rows with columns)
  ‼                   do all the previous operations again
S=                    check if the final result is equal to the original input

— सिंह
स्रोत

2

कुछ को हटाने के लिए फेरबदल)

— H.PWiz 14

@ H.PWiz जो लगभग स्पष्ट था, मुझे गूंगा!

— सिंह

7

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

-*S;E3Ƥ€F$TȯQZµ⁺⁼

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

-6 बाइट मील और जोनाथन एलन के लिए धन्यवाद ।

— आउटगोल्फर को एरिक करें
स्रोत

1

मेरा मानना है कि आप इसे 21 बाइट्स तक छोटा कर सकते हैं। टीआईओ

— मीलों

@ मीलों ... शायद 19 बाइट्स भी ?

— जोनाथन एलन

1

@JonathanAllan कि 18 बाइट्स हैं ... हाँ आपने µZ$⁺फिर से बात की: p ... और 17 बाइट्स को थोड़ा स्वैप करके: D अब मैंने ब्रेकीलॉग hehe को हराया

— Eg the Outgolfer

@EriktheOutgolfer अब और नहीं, यह एक टाई है!

— बजे

@ जोनाथनअलन नाइस। इसके अलावा, मेरा मानना है कि यह पहला उपसर्ग / इन्फिक्स क्विक है जो मैंने जोड़ा था।

— मील

5

गणितज्ञ, 143 बाइट्स

And@@Flatten@(((s=#;Equal@@(Count[s,#]&/@{0,1})&&FreeQ[Subsequences@s,#]&/@{{1,1,1},{0,0,0}})&/@#)&&(DeleteDuplicates@#==#)&/@{#,Transpose@#})&

इनपुट

[{{0, 0, 1, 1}, {1, 1, 0, 0}, {0, 1, 0, 1}, {1, 0, 1, 0}}]

— J42161217
स्रोत

5

पायथन 2 , 127 बाइट्स

a=input()
n=len(a)
b=zip(*a)
print[n/2]*n*2==map(sum,a+b)>len(set(a))==len(set(b))==n<'0, 0, 0'not in`a+b`>'1, 1, 1'not in`a+b`

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

इनपुट के रूप में n n -tuples की सूची पढ़ता है ।

मैं बाहर निकलने के कोड को लिखने के 1/(…)बजाय आउटपुट कर सकता था , print…लेकिन यह डरावना लगता है। क्या मैं?

व्याख्या

nबोर्ड का आकार है; bस्तंभों की सूची (स्थानान्तरण a) है। बाकी एक लंबी जंजीर तुलना है:

[n/2]*n*2==map(sum,a+b) नियम नियम 2. प्रत्येक पंक्ति और स्तंभ को n / 2 के लिए योग करना चाहिए।
map(sum,a+b)>len(set(a)) हमेशा सच होता है (सूची> इंट)।
len(set(a))==len(set(b))==n नियम 3 की जाँच करता है।
n<'0, 0, 0' हमेशा सच होता है (int <str)।
'0, 0, 0'not in`a+b`>'1, 1, 1'not in`a+b`चेक नियम 1. `a+b`सभी पंक्तियों और स्तंभों का स्ट्रिंग प्रतिनिधित्व है; TIO पर उदाहरण इनपुट के लिए यह है
```
"[(0, 0, 1, 1), (1, 1, 0, 0), (0, 1, 0, 1), (1, 0, 1, 0), (0, 1, 0, 1), (0, 1, 1, 0), (1, 0, 0, 1), (1, 0, 1, 0)]"
```
`a+b`>'1, 1, 1'केंद्र में के बाद से इस तार के साथ शुरू करने के लिए गारंटी है हमेशा सच है "[", जो तुलना में अधिक है "1"।

— लिन
स्रोत

यदि आप एक्जिट कोड द्वारा आउटपुट करना चाहते हैं, तो आप कर सकते हैं [n/2]*n*2==map(sum,a+b)>len(set(a))==len(set(b))==n<'0, 0, 0'not in`a+b`>'1, 1, 1'not in`a+b`>x, जो कि विभाजन से 2 बाइट्स कम है और NameErrorसत्य इनपुट के लिए परिणाम है ।

— 13

3

भूसी , 27 25 बाइट्स

Λ§&Λȯ¬VEX3§&Λ§=#0#1S=uSeT

इनपुट सूची की एक सूची है और आउटपुट के 1लिए Trueऔर उसके 0लिए हैFalse

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

explaination

                      SeT    Create a list with the input and itself transposed
Λ                            Is the following function true for all in the list
 §&                          And the results of the following functions
   Λȯ¬VEX3                     Test for rule 1
          §&                   The and of:
            Λ§=#0#1                Test for rule 2
                   S=u             Test for rule 3

परीक्षण 1

Λȯ¬VEX3
Λ         Is it True for all ...
   V      Are any of the ...
     X3   Substrings of length 3 ...
    E     All equal
 ȯ¬       Logical not

परीक्षण २

Λ§=#0#1
Λ         Is it true for all that ...
 §=       The results of the two functions are equal
   #0         Number of 0s
     #1       Number of 1s

परीक्षण ३

S=u
S=    Is the result of the following function equal two its argument
  u   Remove duplicates

— H.PWiz
स्रोत

3

रेटिना , 129 89 85 बाइट्स

.+
$&,$&
O#$`.(?=.*,)
$.%`
.+
$&;$&
+`(01|10)(?=.*;)

1ms`(.)\1\1|\d,?;|(\D\d+\b).*\2

इसे ऑनलाइन आज़माएं! मान्य के लिए आउटपुट 0, अमान्य के लिए 1। संपादित करें: @MartinEnder के लिए धन्यवाद 4 बाइट्स सहेजे गए। स्पष्टीकरण:

.+
$&,$&

,विभाजक के साथ प्रत्येक पंक्ति को डुप्लिकेट करें ।

O#$`.(?=.*,)
$.%`

पहले डुप्लिकेट को स्थानांतरित करें।

.+
$&;$&

डुप्लिकेट फिर से, इस बार ;विभाजकों के साथ ।

+`(01|10)(?=.*;)

एक अर्धविराम से पहले अंकों के सभी मिलान जोड़े हटाएं।

1ms`(.)\1\1|\d,?;|(\D\d+\b).*\2

यह देखने के लिए जांचें कि क्या कोई स्तंभ या पंक्ति किसी भी नियम को विफल करती है; (.)\1\1एक पंक्ति में तीन समान अंकों के \d,?;लिए चेक, एक अनपेक्षित अंक के (\D\d+\b).*\2लिए चेक और एक डुप्लिकेट के लिए जांच करता है।

— नील
स्रोत

यदि (...).*अंतिम चरण का उद्देश्य बस करना है max(matches,1)तो आप 1कॉन्फ़िगरेशन में ए का उपयोग करके तीन बाइट्स बचा सकते हैं ।

— मार्टिन एंडर

और .\b\d+\bहो सकता है \D\d+\b।

— मार्टिन एंडर

@MartinEnder मूल रूप से मैंने अमान्य आउटपुट को बिना आउटपुट के बदल दिया और अंत में इसका परीक्षण किया ... मैंने आखिरकार इसे अंत में एक ही परीक्षण के लिए सम्मानित किया और महसूस किया कि मैं उस अग्रणी को छोड़ सकता .*हूं जिसका मैं पहले उपयोग कर रहा था लेकिन उपयोग करने के लिए नहीं सोचा था परिणाम को सीमित करने के लिए एक विन्यास, धन्यवाद!

— नील

3

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

@Leaky नन को बहुत धन्यवाद ।

.Asm++mqy/k\0lQdm<hk3srL8d{Id,C

सभी परीक्षण मामलों की जाँच करें या इसे यहाँ आज़माएँ!

पायथ , 48 46 44 42 बाइट्स

यह प्रारंभिक समाधान है।

&{IQ&{I.TQ.Am&q/d\0/d\1!+/d*3\0/d*3\1sC,.T

सभी परीक्षण मामलों की जाँच करें या इसे यहाँ आज़माएँ!

& {IQ & {I.TQ.Am & q / d \ 0 / d \ 1! + / D * 3 \ 0 / d * 3 \ 1sC,। निहित इनपुट के साथ पूरा कार्यक्रम।

 {आईक्यू डिडुप्लिकेटिंग के तहत इनपुट अनियंत्रित है?
& {I.TQ और क्या इसका पारगमन भी अपरिवर्तनीय है?
                                        .TQ स्थानांतरण
                                           Q इनपुट।
                                     एससी, ऊपर जिप, [^, ^ ^] (और चपटा)।
    और निम्नलिखित शर्त पूरी की है?
          ^ ^ पर मैप करने पर सभी तत्व सत्य हैं।
              q / d \ 0 / d \ 1 1s के रूप में कई 0 हैं।
             &! + / d * 3 \ 0 / d * 3 \ 1 और 3 समान तत्वों के कोई रन नहीं हैं।

— श्री Xcoder
स्रोत

3

MATL , 27 बाइट्स

,G@?!]tEqts~w7BZ+|3<bXBSdvA

इनपुट एक मैट्रिक्स युक्त 0और है 1। 0सत्य के लिए उत्पादन मिथ्या के 1लिए है।

इसे ऑनलाइन आज़माएं! या परीक्षण मामलों को देखें: 1 , 2 , 3 , 4 , 5 ।

व्याख्या

,       % Do twice. First iteration will use the input, second its transpose
  G     %   Push input
  @     %   Push iteration index: first 0, then 1
  ?     %   If nonzero
    !   %     Transpose
  ]     %   End
  t     %   The top of the stack contains the input or its transpose. Duplicate
  Eq    %   Convert to bipolar form, i.e. replace 0 by -1
  t     %   Duplicate
  s     %   Sum of each column
  ~     %   Negate. If all results are true, condition 2 is fulfilled
  w     %   Swap. Moves copy of bipolar input/transposed input to top
  7B    %   Push [1 1 1], obtained as 7 converted to binary
  Z+    %   2D convolution. Gives a matrix of the same size as the input
  |3<   %   Is each entry less than 3 in absolute value? If all results are true,
        %   condition 1 is fulfilled
  b     %   Bubble up. Moves copy of input/transposed input to top
  XB    %   Convert each row from binary to a number
  Sd    %   Sort, consecutive differences. If all results are nonzero, condition 3
        %   is fulfilled
  v     %   Concatenate all results so far into a column vector
  A     %   True if all entries are nonzero
        % End (implicit). Display (implicit)

— लुइस मेंडो
स्रोत

2

आर , 114 107 बाइट्स

-7 Giuseppe के लिए धन्यवाद, कार्यों को क्रम से बाहर करना और वास्तव में नीचे की स्थितियों को संपीड़ित करना

function(x)any(f(x),f(t(x)))
f=function(x)c(apply(x,1,function(y)max(rle(y)$l)>2+mean(y)-.5),duplicated(x))

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

यह केवल मैट्रिक्स के कॉलम के नियमों को लागू करता है, फिर मैट्रिक्स के संक्रमण के कॉलम।

फार्म में इनपुट लेता है:

matrix(c(0,0,1,1,1,1,0,0,0,1,0,1,1,0,1,0), ncol=4)

जो सिर्फ R कैसे 2D एरेज़ लेता है।

विफलताओं के लिए आउटपुट TRUE, पास के लिए FALSE।

— CriminallyVulgar
स्रोत

107 बाइट्स

— Giuseppe

सामान्य अपडेट: mean(y)-.5आंतरिक fफ़ंक्शन के अंदर का उपयोग इसके बजाय साधन प्राप्त करने के लिए किया जाता है colMeans, और gअनाम बना दिया जाता है । यह कॉल में कनवर्ट doubleकरने के लिए चेतावनी जोड़ देगा, लेकिन यह ठीक है। logicalany

— ग्यूसेप

@Giuseppe धन्यवाद! मुझे वास्तव में वह संयुक्त पसंद है, बहुत चतुर परिवर्तन! मेरे पास 2 प्रारंभिक अवस्था में सेपरेट लागू होता है और आपको पता नहीं था कि कितनी सफाई से आप उन्हें जोड़ सकते हैं।

— क्रिमिनलवल्गर

यहाँ थोड़ा और अच्छी तरह से इनपुट प्राप्त करने का एक तरीका है

— Giuseppe

2

पर्ल 6 ,100 93 बाइट्स

जंक्शनों FTW! वे 7 बाइट बचाते हैं।

कुछ समय के लिए, यह गैर-गोल्फ भाषाओं में लिखे गए सभी अन्य सबमिशन को मात देता प्रतीत होता है। यिप्पी!

{!max (@(.map(*.join)).&{.repeated| |.map:{$_~~/000|111/|.comb(0)-.comb(1)}}for @^a,[Z] @^a)}

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

व्याख्या : यह एक ऐसा ब्लॉक है जो बोर्ड को सूचियों की सूची के रूप में लेता है। हम एक प्रस्ताव रखते हैं [Z] @^a(ज़िप ऑपरेटर के साथ सूचियों की सूची कम करें)। तो @^a,[Z] @^aबोर्ड और उसके स्थानान्तरण की एक सूची है। हम इसके साथ लूप करते हैंfor बिल्कुल काम करता है map, बस इस मामले में 1 चार सस्ता है।

अंदर, हम पहले पंक्तियों में शामिल पंक्तियों को जोड़ते हैं, इसलिए हमारे पास सूचियों की सूची के बजाय तार की सूची है (@(.map(*.join)) ) के । फिर हम उस पर एक अनाम ब्लॉक का उपयोग करते हैं ( .&{...}), जहां हम वास्तव में नियमों का मूल्यांकन करते हैं। हम उन्हें केवल पंक्ति-वार मूल्यांकन करेंगे। (चूंकि हम इसे मूल सरणी के लिए करते हैं और साथ ही पारगमन भी करते हैं।)

काफी कुछ बचाने के लिए !, हम थोड़ा तर्क का उपयोग करते हैं और परीक्षण के बजाय (NO repeated rows) AND (NO 3 consecutive same symbols) AND (NOT different counts of 0 and 1), हम परीक्षण करते हैं NOT[ (repeated rows) OR (3 consecutive same symbols) OR (different counts) ]। अनाम ब्लॉक में हम यही करते हैं: .repeatedसभी पंक्तियों को देता है जो एक से अधिक बार होती हैं, फिर हम पंक्तियों पर नक्शा करते हैं, एक रेगेक्स का उपयोग करके लगातार 3 प्रतीकों का मिलान करने का प्रयास करते हैं, और 0 और 1 की संख्या को घटाते हैं। ये ऑर्ड्रेड हैं| । (वास्तव में यह एक बहुत शक्तिशाली चीज़ बनाता है जिसे जंक्शन कहा जाता है , लेकिन हम इसकी किसी भी शक्ति का उपयोग नहीं करते हैं :)) इन सभी के बाद, हमें 2 "बूल" (अनकैप्ड जंक्शन) की एक सूची मिलती है। हम अंत में या उन्हें (उपयोग करते हुए max) और नकारात्मक ( !), जो वांछित परिणाम देता है।

— Ramillies
स्रोत

2

जे, _४० ₃₈ 55 बाइट्स

0=[:([:+/^:_(3(0=3|+/)\"1 ]),:-.@~:,:#=[:+/"1+:@])|:,:]

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

इनपुट के रूप में एक वर्ग मैट्रिक्स लेने वाले फ़ंक्शन को परिभाषित करता है।

~~कम से कम यह पाइथ (अभी के लिए ...)~~ (गलत तरीके से) ~~को पीट रहा है~~ । मुझे अपने कोड में छिपे हुए इमोजी को गिनने के लिए वापस जाना चाहिए क्योंकि J भी खुद को अच्छी तरह से उधार देता है:

[: /^: :1 |: :] :-.@ :# :@] :~@

स्पष्टीकरण (थोड़ा पुराना)

यह मेरे उत्तर से अलग दिखता है, और मुझे इसे अपडेट करने की आवश्यकता हो सकती है। इसके भाग अभी भी वही हैं - मैं अभी नियम 3 के लिए जाँच नहीं कर रहा था और पहले नियम 2 के लिए अनुचित जाँच कर रहा था।

कुछ कार्यों और विभाजन में विभाजित:

join_trans  =. |: ,: ]
part_3      =. 3 (0 = 3 | +/)\"1 ]
f           =. 1 - 2 * ]
main        =. 0 = [: ([: +/^:_ part_3 , f) join_trans

join_trans

|: ,: ]
|:       Transpose
   ,:    Laminated to
      ]  Input

यह मैट्रिक्स के संक्रमण में शामिल हो जाता है, जिससे मैट्रिसेस की एक सरणी बन जाती है।

part_3

3 (0 = 3 | +/)\"1 ]
                  ]  Input (matrix and transpose)

यह 3 पंक्ति-वार के विभाजन के योग को यह देखने के लिए जाँचता है कि क्या यह 3 या 0 है (क्योंकि इनमें से कोई भी एक अमान्य बोर्ड का मतलब है), यदि यह है तो 1 और यदि नहीं तो वापस लौटा दिया जाए। यह दोनों को दिए जाने के बाद से मैट्रिक्स और इसके ट्रांसपोज़न दोनों पर काम करता है।

च

1 - 2 * ]

एक बेहतर नाम की कमी के लिए, मैं इसे कॉल करता हूं f। यह 0s को _1 से बदल देता है और 1s को अपरिवर्तित छोड़ देता है। यह मुझे अंततः जांचने की अनुमति देता है कि क्या प्रत्येक पंक्ति और स्तंभ में 0 और 1s की संख्या समान है (प्रत्येक पंक्तियों का योग 0 होना चाहिए)।

मुख्य

0 = [: ([: +/^:_ part_3 , f) join_trans
                             join_trans  Join transpose to input
                 part_3 , f              Apply the validity checks and join them
           +/^:_                         Sum until it converges
0 =                                      Equate to 0

असल में, मैं इस तथ्य का लाभ उठाता हूं कि मैंने इसे स्थापित किया है f join_transऔर part_3 join_transदोनों को 0 के बराबर होना चाहिए यदि बोर्ड मान्य है। part_3एक वैध बोर्ड के लिए सभी शून्य होना चाहिए और एक वैध बोर्ड के fलिए शून्य का योग होना चाहिए, जिसका अर्थ है कि उनके रकम का योग केवल एक वैध बोर्ड के लिए है।

— गोभी
स्रोत

कम से कम यह पाइथ (अभी के लिए ...) को पीट रहा है। - मुझे वास्तव में मेरे जवाब की आवश्यकता है

— श्री Xcoder

@ Mr.Xcoder haha हाँ, आप हमेशा खींचते हैं जिसके कारण मैंने "अब के लिए" बिट जोड़ा। ऐसा नहीं है कि मेरे जवाब में गोल्फ के लिए जगह नहीं है - मुझे नहीं पता कि यह कैसे करना है।

— कोल

आप उस हिस्से को अब हटा सकते हैं

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

1

33 बाइट्स के लिए यह कोड आपके बराबर होना चाहिए*/@,@,&(~:,(0~:3|3+/\]),#=2*+/)|:

— मील

2

हास्केल , 137 136 127 बाइट्स

9 बाइट्स ने लिन को दिया धन्यवाद!

import Data.List
j=isSubsequenceOf
l x=x==nub x&&and[sum y*2==length x&&not(j[0,0,0]y||j[1,1,1]y)|y<-x]
g x=l x&&l(transpose x)

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

— गेहूं का जादूगर
स्रोत

दोनों allको एक में रोल करें and: l x=x==nub x&&and[sum y*2==length x&&not(j[0,0,0]y||j[1,1,1]y)|y<-x]

— लिन

@Lynn धन्यवाद! मैं थोड़ी देर के लिए उन दोनों को एक साथ रोल करने की कोशिश कर रहा था। पता नहीं क्यों मैं समझ नहीं पाया।

— गेहूं जादूगर

1

आप को बदल सकता है j=isSubSequenceOfकरने के लिए j x=isSubSequenceOf[x,x,x]?

— साइओस

@Cyoce मुझे एक बाइट खोने लगता है। यदि आपके पास ऐसा करने का कोई तरीका है जो मुझे एक बाइट बचाता है तो मुझे इसे लागू करने में खुशी होगी। विचार अच्छा लगता है।

— गेहूं जादूगर

मोबाइल पर, हम्म् ... शायद j a bआह्वान के बजाय (और इसे परिभाषित करें) a#b?

— साइओस

2

जावा 8, 350 326 325 312 303 299 298 259 255 बाइट्स

int r,z,c,p,i,j,k,d,u,v=1;int c(int[][]b){v(b);k=v-=u=1;v(b);return r;}void v(int[][]b){String m="",x;for(d=b.length;j<d|k<d;k+=u,j+=v,r=m.contains(x)|z!=0?1:r,m+=x)for(x="#",c=0,k*=u,j*=v;j<d&k<d;z+=i|i-1,c*=i^p^1,x+=p=i,r=++c>2?1:r,k+=v,j+=u)i=b[k][j];}

0एक वैध बोर्ड होने पर वापस लौटता है ; 1यदि यह एक या तीन नियमों से अधिक के लिए अमान्य है।

-95 बाइट्स थैंक्स टू @ नवे ।

स्पष्टीकरण:

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

int r,z,c,p,i,j,k,d,u,v=1;
                     // Temp integers on class-level

int c(int[][]b){     // Method (1) with int-matrix parameter and int return-type
  v(b);              //  Validate the rows
  k=v-=u=1;          //  Switch rows with columns, and reset `u` to 1
  v(b);              //  Validate the columns
  return r;          //  Return the result
}                    // End of method (1)

void v(int[][]b){    // Separated method (2) with int-matrix parameter and no return-type
  String m="",s;     //  Two temp Strings to validate uniqueness of rows
  for(d=b.length;    //  Set the dimension of the matrix to `d`
      j<d|k<d        //  Loop (1) as long as either `j` or `k` is smaller than `d`
    ;                //   After every iteration:
     k+=u,j+=v       //    Increase the loop-indexes
     r=m.contains(s) //    If we've found a duplicated row,
     |z!=0?          //    or if the amount of zeroes and ones on this row aren't equal
      1:r,           //     Set `r` to 1 (invalid due to either rule 2 or 3)
     m+=s)           //    Append the current row to the String `m`
    for(s=",",       //   Set String `x` to a separator-character
        c=0,         //   Reset the counter to 0
        k*=u,j*=v,   //   Increase the loop-indexes
        j<d&k<d      //   Inner loop (2) as long as both `j` and `k` are smaller than `d`
     ;               //    After every iteration:
      z+=i|i-1,      //     Increase or decrease `z` depending on whether it's a 0 or 1
      c*=i^p^1,      //     Reset `c` if current digit `i` does not equal previous `p`
      s+=p=i,        //     Set previous `p` to current digit, and append it to String `s`
      r=++c>2?       //     If three of the same adjacent digits are found:
         1:r;        //      Set `r` to 1 (invalid due to rule 1)
        k+=v,j+=u)   //      Increase the loop-indexes
      i=b[k][j];     //    Set `i` to the current item in the matrix
                     //   End of inner loop (2) (implicit / single-line body)
                     //  End of loop (2) (implicit / single-line body)
}                    // End of separated method (2)

— केविन क्रूज़सेन
स्रोत

1

पायथन 3, 187 बाइट्स

lambda m,c=lambda m:all([len({*m})==len(m),sum(~-("000"in x)*~-("111"in x)and x.count("1")==x.count("0")for x in m)==len(m)]):c(["".join(x[i]for x in m)for i in range(len(m[0]))])and c(m)

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

इनपुट को लाइनों की सूची के रूप में लेता है।

— LyricLy
स्रोत

187 बाइट्स

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

171 बाइट्स

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

147 बाइट्स , @ Mr.Xcoder के सुझाव के आधार पर।

— ओवर्स

1

05AB1E , 29 बाइट्स

ø‚D€ÙQIDøì©O·IgQP®εŒ3ù€Ë_P}PP

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

व्याख्या

नियम: ३

ø‚        # pair the input with the zipped input
  D       # duplicate
   €Ù     # deduplicate each
     Q    # check for equality with the unmodified copy

नियम: २

IDøì          # prepend zipped input to input
    ©         # store a copy in register for rule 1
     O        # sum each row/column
      ·       # double
       IgQ    # check each for equality to length of input
          P   # product

नियम 1

®ε            # apply to each row/column in register
  Œ3ù         # get sublists of length 3
     €Ë       # check each if all elements are equal
       _      # logical not
        P     # product
         }    # end apply
          P   # product

फिर हम सभी 3 नियमों के परिणाम के साथ उत्पाद लेते हैं P

— Emigna
स्रोत

1

डायलाग एपीएल, 64 52 51 49 48 बाइट्स

आवश्यक है ⎕IO←0

{⍲/{(∨/∊⍷∘⍵¨3/¨⍳2)∧((⊢≡∪)↓⍵)∧∧/(≢=2×+/)⍵}¨⍵(⍉⍵)}

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

— जाकारी
स्रोत

1

PHP, 245 + 1 बाइट्स

ew यह भारी है। लाइनब्रेक केवल पढ़ने की सुविधा के लिए हैं:

$t=_;foreach($a=($i=str_split)($s=$argn)as$i=>$c)$t[$i/($e=strlen($s)**.5)+$i%$e*$e]=$c;
for(;$k++<2;$s=$t)$x|=preg_match("#000|111|(\d{"."$e}).*\\1#s",chunk_split($s,$e))
|($m=array_map)(array_sum,$m($i,$i($s,$e)))!=array_fill(0,$e,$e/2);echo!$x;

एक ही स्ट्रिंग को बिना नईलाइन, प्रिंट के लेता है 1 सत्य के लिए झूठे के लिए कुछ भी नहीं।

साथ पाइप के रूप में चलाएँ -nRऑनलाइन के या इसे आज़माएं ।

— टाइटस
स्रोत

क्या यह वैध तक्जू बोर्ड है?

कार्य:

उदाहरण:

नियम और विनिर्देश:

ब्रेकीलॉग , 20 18 बाइट्स

व्याख्या

हस्क , 19 18 बाइट्स

व्याख्या

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

गणितज्ञ, 143 बाइट्स

पायथन 2 , 127 बाइट्स

व्याख्या

भूसी , 27 25 बाइट्स

explaination

परीक्षण 1

परीक्षण २

परीक्षण ३

रेटिना , 129 89 85 बाइट्स

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

पायथ , 48 46 44 42 बाइट्स

MATL , 27 बाइट्स

व्याख्या

आर , 114 107 बाइट्स

पर्ल 6 ,100 93 बाइट्स

जे, ४० 38 55 बाइट्स

स्पष्टीकरण (थोड़ा पुराना)

join_trans

part_3

च

मुख्य

हास्केल , 137 136 127 बाइट्स

जावा 8, 350 326 325 312 303 299 298 259 255 बाइट्स

पायथन 3, 187 बाइट्स

05AB1E , 29 बाइट्स

डायलाग एपीएल, 64 52 51 49 48 बाइट्स

PHP, 245 + 1 बाइट्स

जे, _४० ₃₈ 55 बाइट्स