आयत का पता लगाना

Question

एक प्रोग्राम या फंक्शन लिखिए जो 0's 1' और 's ' के मल्टीलाइन स्ट्रिंग में लेता है । कोई अन्य वर्ण स्ट्रिंग में नहीं होगा और स्ट्रिंग हमेशा आयताकार होगी (सभी पंक्तियों में समान वर्ण होंगे), आयामों के साथ 1 × 1 जितना छोटा होगा, लेकिन अन्यथा 0's 1' और 's' की व्यवस्था मनमाने ढंग से की जा सकती है।

आप मान सकते हैं स्ट्रिंग एक वैकल्पिक अनुगामी न्यू लाइन है, और अगर वांछित आप किसी भी दो अलग-अलग उपयोग कर सकते हैं प्रिंट योग्य ASCII के स्थान पर वर्ण 0और 1।

प्रिंट या एक वापसी truthy मूल्य अगर सब के पथ जुड़ा के क्षेत्रों दोनों 0के और 1की स्ट्रिंग में हैं ठोस आयतों , और उत्पादन एक falsy मूल्य ।

एक पथ जुड़े क्षेत्र के 0के का मतलब है कि किसी भी एक से 0क्षेत्र में, अन्य सभी 0के केवल ऊपर जा रहा द्वारा पहुंचा जा सकता, नीचे, बाएँ और दाएँ दूसरे से 0की (और नहीं तिरछे चलती, न किसी के लिए आगे बढ़ 1, और स्ट्रिंग सीमा के बाहर नहीं बढ़ रहा है)। यही विचार 1पथ से जुड़े क्षेत्रों पर लागू होता है ।

आयत का एक ठोस आयत का 0अर्थ है कि आयत का पूरा क्षेत्र 0's और नहीं 1' से भरा है । एक ही विचार 1ठोस आयतों पर लागू होता है ।

बाइट्स में सबसे छोटा कोड जीतता है। टाईब्रेकर पहले जवाब है।

(ध्यान दें कि स्ट्रिंग टॉरॉइडल सीमा स्थितियों के साथ चारों ओर लपेटती नहीं है ।)

उदाहरण

1) इस इनपुट स्ट्रिंग में 3 पथ जुड़े क्षेत्र हैं (2 के लिए 0और 1 के लिए 1)। केवल निचला दायाँ 00क्षेत्र एक ठोस आयत है, हालांकि, उत्पादन मिथ्या होगा।

0011
0111
0100

2) इस इनपुट स्ट्रिंग में 4 पथ जुड़े क्षेत्र हैं (2 दोनों के लिए 0और 1)। उनमें से सभी ठोस आयताकार हैं, इसलिए आउटपुट सत्य होगा।

0011
0011
1100

3) इस इनपुट में 2 पथ जुड़े हुए क्षेत्र हैं, लेकिन उनमें से केवल एक ठोस आयताकार है, इसलिए आउटपुट मिथ्या होगा।

00000000
01111110
00000000

4) इस इनपुट में केवल 1 पथ जुड़ा हुआ क्षेत्र है और तुच्छ रूप से एक ठोस आयत है, इसलिए आउटपुट सत्य है।

11111111
11111111
11111111

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

एक Tबस इनपुट स्ट्रिंग साधन truthy नीचे, Fसाधन falsy।

0
T

1
T

00
T

01
T

10
T

11
T

0000000
T

1111111
T

011100100100101100110100100100101010100011100101
T

00
11
T

01
10
T

01
11
F

00
01
F

11
11
T

110
100
F

111
000
T

111
101
111
F

101
010
101
T

1101
0010
1101
0010
T

1101
0010
1111
0010
F

0011
0111
0100
F

0011
0011
1100
T

00000000
01111110
00000000
F

11111111
11111111
11111111
T

0000001111
0000001111
T

0000001111
0000011111
F

0000001111
1000001111
F

1000001111
1000001111
T

1110100110101010110100010111011101000101111
1010100100101010100100010101010101100101000
1110100110010010110101010111010101010101011
1010100100101010010101010110010101001101001
1010110110101010110111110101011101000101111
F

Answer 1

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

ṣ⁷µ=ḢZE

यह @ LevelRiverSt के रूबी उत्तर के समान एल्गोरिथ्म का उपयोग करता है । वास्तविक एल्गोरिथ्म पिछले 4 बाइट्स में फिट बैठता है; इनपुट फॉर्मेट को पार्स करने के लिए पहले 3 बाइट्स की आवश्यकता होती है।

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

यह काम किस प्रकार करता है

ṣ⁷µ=ḢZE  Main link. Argument: t (string)

ṣ⁷       Split t at linefeeds..
  µ      Begin a new, monadic link. Argument: A (list of strings)
    Ḣ    Pop the first string of A.
   =     Compare all other strings in A with the first.
         = compares characters, so this yields a list of Booleans for each string.
         For a truthy input, all pairs of lines now have been transformed in lists
         of only 1's or only 0's. That means all columns must be equal.
     Z   Zip; transpose rows with columns.
      E  Check if all rows (former columns) are equal to each other.

Answer 2

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

ṣ⁷^2\⁺€FS¬

@ डेनिस को इसके मूल आकार के आधे से नीचे (अनिर्दिष्ट सुविधाओं के माध्यम से) के लिए बड़े पैमाने पर धन्यवाद।

इसे ऑनलाइन आज़माएं ! ध्यान दें कि ट्रिपल उद्धरण एक बहुस्तरीय स्ट्रिंग के लिए हैं।

व्याख्या

मूल एल्गोरिथ्म है: सही iff हर 2x2 सबग्रिड में 1s (या, समतुल्य, 0s) की एक समान संख्या होती है।

यह स्पष्ट है कि 1s की विषम संख्या क्यों काम नहीं कर सकती, क्योंकि हमारे पास निम्नलिखित में से एक होगा:

10  01  00  00  01  10  11  11
00  00  01  10  11  11  10  01

ध्यान दें कि पहले 4 एक ही चीज़ के घुमाव हैं, और अंतिम 4 के लिए डिट्टो। रिफ्लेक्स कोण एक आयत का हिस्सा नहीं हो सकता है, इसलिए यह अमान्य होगा।

दूसरे शब्दों में, सभी 2x2 सबग्रिड्स में से एक होना चाहिए:

00  00  11  01  10  01  10  11
00  11  00  01  10  10  01  11

यदि हम सीमाओं को देखते हैं, तो निम्नलिखित "पहेली टुकड़े" के रूप में कल्पना की जा सकती है:

 ___    ___    ___    ___
|   |  | | |  |   |  | | |
|   |  | | |  |---|  |-|-|
|___|  |_|_|  |___|  |_|_|

और उन पहेली टुकड़ों के साथ एक गैर-आयत बनाने की कोशिश करें :) (जबकि सिरों का मिलान होता है)

वास्तविक कार्यान्वयन इस प्रकार है:

ṣ⁷               Split input by newlines to give rows
  ^2\            Taking overlapping sets of 2 rows at a time: accumulate rows by XOR
                 Note that strings cast to integers automatically for bitwise operators
     ⁺€          Repeat the previous link (⁺), on each (€) element in the resulting array
       F         Flatten the array
        S        Sum (effectively reducing by OR)
         ¬       Logical negation of the result

उदाहरण के लिए, इनपुट के लिए

100
010
000
101

हमारे पास है:

  ṣ⁷: ["100", "010", "000", "101"]
 ^2\: [[1, 1, 0], [0, 1, 0], [1, 0, 1]]    (e.g. first entry is "100" ^ "010")
^2\€: [[0, 1], [1, 1], [1, 1]]             (e.g. the first entry is [1^1, 1^0] - this
                                            gives the counts of 1s in each subgrid, mod 2)
   F: [0, 1, 1, 1, 1, 1]
   S: 5                                    (this gives the number of invalid 2x2 subgrids,
                                            which is indeed all but the top left)
   ¬: 0

Comments

क्या आप कृपया आपके द्वारा उपयोग की जाने वाली सुविधाओं का दस्तावेज़ ले सकते हैं? अगर लोग ऐसा करेंगे तो प्रलेखन होगा!

— कैलक्यूलेटरफ्लेन

क्या आपको समतल करने की आवश्यकता है?

— कैलक्यूलेटरफैनलाइन

@CatsAreFluffy यदि आप समतल नहीं करते हैं, तो जेली वैक्टर की एक सूची की कोशिश करता है और आपको परिणाम के रूप में एक वेक्टर मिलता है

— Sp3000

बस योग और योग-यह बेहतर है!

— कैलक्यूलेटरफ्लिन

"अनिर्दिष्ट विशेषताएं" - अहा! तो यह है कि कैसे डेनिस सभी को बाहर कर देता है! : D

— AdmBorkBork 12

Answer 3

रूबी, 76

->s{j=!r=1
s.lines{|t|i=t.to_i(2)
j&&r&&=(j^i)%t.tr(?0,?1).to_i(2)<1
j=i}
r}

पूरी तरह से आयतों से बने किसी भी ग्रिड में, प्रत्येक पंक्ति पहले की रेखा के समान होनी चाहिए, या सभी बिट्स 0 से 1 तक फ़्लिप किए गए होंगे और इसके विपरीत।

यह साबित करना आसान है। कागज का एक टुकड़ा ले लो और मनमाने ढंग से खड़ी और क्षैतिज रेखाओं को उसके पार ले आओ। अब केवल 2 रंगों का उपयोग करके आयतों को रंग दें। आप एक विकृत चेकरबोर्ड के साथ समाप्त हो जाएंगे, जहां सभी रंग प्रत्येक पंक्ति में फ्लिप करते हैं।

रेखाओं के साथ आयतों को केवल उसी तरह से खींचना चाहते हैं? अपनी किसी भी पंक्ति के एक सेगमेंट को हटाने का प्रयास करें। अब आपको अपने डिज़ाइन को रंगने के लिए 2 से अधिक रंगों की आवश्यकता होगी, क्योंकि आपके पास ऐसे बिंदु होंगे जहां 3 आयताकार मिलते हैं (2 कोने और एक किनारे।) इस तरह के डिज़ाइन इस प्रश्न के लिए अप्रासंगिक हैं।

मुझे आश्चर्य है कि उत्तर अब तक इस पर ध्यान नहीं दिया गया है।

मुझे लगता है कि यह एल्गोरिथम किसी अन्य भाषा में बहुत छोटा होना चाहिए।

परीक्षण कार्यक्रम में अपराजित

f=->s{
  j=!r=1                              #r = truthy, j=falsy
  s.lines{|t|                         #for each line
    i=t.to_i(2)                       #i = value of current line, converted to a number in base 2 (binary)
    j&&                               #if j is truthy (i.e this is not the first line)
      r&&=(j^i)%t.tr(?0,?1).to_i(2)<1 #XOR i with the previous line. Take the result modulo (current line with all 0 replaced by 1)
                                      #if the result of the XOR was all 0 or all 1, the modulo == zero (<1). Otherwise, it will be a positive number.   
j=i}                                  #j = value of current line (always truthy in ruby, even if zero)
r}                                    #return 1 or true if all the modulo calculations were zero, else false.



#text to print after test case to check answer is as desired
T='T

'
F='F

'

#test cases
puts f['0'],T

puts f['1'],T

puts f['00
'],T

puts f['01'],T

puts f['10'],T

puts f['11
'],T

puts f['0000000'],T

puts f['1111111'],T

puts f['011100100100101100110100100100101010100011100101'],T

puts f['00
11'],T

puts f['01
10'],T


puts f['01
11'],F

puts f['00
01'],F

puts f['11
11
'],T

puts f['110
100'],F

puts f['111
000'],T

puts f['111
101
111'],F

puts f['101
010
101
'],T

puts f['1101
0010
1101
0010'],T

puts f['1101
0010
1111
0010'],F

puts f['0011
0111
0100
'],F

puts f['0011
0011
1100'],T

puts f['00000000
01111110
00000000'],F

puts f['11111111
11111111
11111111'],T

puts f['0000001111
0000001111'],T

puts f['0000001111
0000011111'],F

puts f['0000001111
1000001111'],F

puts f['1000001111
1000001111'],T

puts f['1110100110101010110100010111011101000101111
1010100100101010100100010101010101100101000
1110100110010010110101010111010101010101011
1010100100101010010101010110010101001101001
1010110110101010110111110101011101000101111'],F

Comments

मैं शर्त लगाता हूं कि s.scan(/^?.*\n/)बाइट को बचाने में मदद मिलेगी।

— नहीं है कि चार्ल्स

Answer 4

घोंघे , 20 बाइट्स

!{to{\0w`3\1|\1w`3\0

ग्रिड के क्षेत्र को प्रिंट करता है यदि 3 शून्य और एक या 3 वाले और शून्य के साथ 2x2 वर्ग नहीं है, या 0यदि ऐसा 2x2 वर्ग मौजूद है।

Answer 5

MATL , 12 बाइट्स

Ybc2thYCs2\~

समान एल्गोरिथ्म @ sp3000 के शानदार जवाब के रूप में ।

मल्टीलाइन इनपुट की अनुमति देने के लिए, MATL को पंक्ति वर्ण सरणी (स्ट्रिंग) की आवश्यकता होती है, जिसे स्पष्ट रूप से 10न्यूलाइन के लिए वर्ण का उपयोग करके बनाया जाना चाहिए । तो चार उदाहरणों के इनपुट हैं (ध्यान दें कि []यह संघनन है, इसलिए इनमें से प्रत्येक चार वर्णों का एक पंक्ति सरणी है):

['0011' 10 '0111' 10 '0100']
['0011' 10 '0011' 10 '1100']
['00000000' 10 '01111110' 10 '00000000']
['11111111' 10 '11111111' 10 '11111111']

और अंतिम तीन परीक्षण मामले हैं

['0000001111' 10 '1000001111']
['1000001111' 10 '1000001111']
['1110100110101010110100010111011101000101111' 10 '1010100100101010100100010101010101100101000' 10 '1110100110010010110101010111010101010101011' 10 '1010100100101010010101010110010101001101001' 10 '1010110110101010110111110101011101000101111']

ट्रू आउटपुट केवल लोगों के लिए एक सरणी है।

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

व्याख्या

यह इस तथ्य का उपयोग करता है कि वर्णों की समानता है '0'और '1'संख्याओं के समान है 0और 1, इसलिए इसे चार्ट से उस अंक में बदलने की आवश्यकता नहीं है जो यह प्रतिनिधित्व करता है,

Yb     % split implicit input by whitespace. Gives a cell array
c      % concatenate cell contents into 2D char array
2th    % push array [2 2]
YC     % get 2×2 sliding blocks and arrange as columns
s      % sum of each column
2\     % modulo 2 of each sum
~      % negate. Implicit display

Comments

इनपुट के लिए एक तार होना चाहिए

— केल्विन के

@HelkaHomba MATL मल्टीलाइन स्ट्रिंग इनपुट की अनुमति नहीं देता है ... इनपुट को फॉर्म की एक पंक्ति सरणी होना चाहिए ['first line' 10 'second llne'], जहां 10नई रेखा के लिए ASCII है। क्या यह स्वीकार्य है?

— लुइस मेंडू

@HelkaHomba मैंने अद्यतन उत्तर में इसका उपयोग किया है। वैकल्पिक रूप से, क्या न्यूलाइन की जगह स्पेस का उपयोग किया जा सकता है? पहला उदाहरण स्ट्रिंग होगा'0011 0111 0100'

— लुइस मेंडो

@LuisMendo मैं विचार की सराहना करता हूं, लेकिन मुझे लगता है कि रूबी का जवाब वास्तव में सामान्य रूप से गोल्फर हो सकता है :)

— Sp3000

@ Sp3000 ओह, मैंने वह नहीं देखा था। बहुत चालाक भी

— लुइस मेंडू

Answer 6

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

s=>!s.split`
`.some((t,i,u)=>[...t].some((v,j)=>v^t[0]^u[0][j]^s[0]))

मेरा मानना ​​है कि पथ संयोजकता आयत मानदंड किसी भी चार बिंदुओं को दिए जाने के लिए आवश्यक है, जो एक आयत के कोनों को बनाते हुए समतुल्य है कि सम संख्या है 1। ध्यान दें कि आयत (0, b), (x, y) की समता समान है (0, b), (a, y) ^(a, b), (x, y) इसलिए मुझे केवल जांच करनी है वे आयतें जिनके शीर्ष बाएँ कोने में (0, 0) है। इसके अलावा डी मॉर्गन के नियमों के अनुसार, !.some()वही है .every(!)जो मुझे कुछ बाइट्स बचाता है।

संपादित करें: मैं देखता हूं कि जेली समाधान सभी 2 × 2 आयतों के कोनों की समता की जांच करता है, जिसे समतुल्य दिखाया जा सकता है।

Comments

लगभग 7 बार, लेकिन +1

— edc65

Answer 7

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

@ Sp3000 से जेली उत्तर के समान एल्गोरिथ्म (और यह साबित करने के लिए खुश नहीं है कि यह काम करता है)। अभी 8 गुना लंबा है

s=>[...s].every((x,i)=>[++i,i+=s.search`
`,i+1].some(p=>!(x^=p=s[p],p>`
`))|!x) 

कम गोल्फ वाला

s=>[...s].every((x,i)=> // repeat check for every sub square
     [++i,                  // array of position for next char in row
      i+=s.search`\n`, i+1] // and 2 chars at same column in next row
       .some(p=> // for each position 
          !( 
            x^=s[p],  // xor current value with value at position p
            s[p]>`\n` // true if value at position p is valid
           ) // the condition is negated
       ) // if any value scanned is not valid, .some return true
         // else, we must consider the check for current square
       | !x // x can be 0 or 1, to be valid must be 0
   ) 

परीक्षण सूट

f=s=>[...s].every((x,i)=>[++i,i+=s.search`
`,i+1].some(p=>!(x^=p=s[p],p>`
`))|!x) 

testData=`
0
T

1
T

00
T

01
T

10
T

11
T

0000000
T

1111111
T

011100100100101100110100100100101010100011100101
T

00
11
T

01
10
T

01
11
F

00
01
F

11
11
T

110
100
F

111
000
T

111
101
111
F

101
010
101
T

1101
0010
1101
0010
T

1101
0010
1111
0010
F

0011
0111
0100
F

0011
0011
1100
T

00000000
01111110
00000000
F

11111111
11111111
11111111
T

0000001111
0000001111
T

0000001111
0000011111
F

0000001111
1000001111
F

1000001111
1000001111
T

1110100110101010110100010111011101000101111
1010100100101010100100010101010101100101000
1110100110010010110101010111010101010101011
1010100100101010010101010110010101001101001
1010110110101010110111110101011101000101111
F`

console.log=x=>O.textContent+=x+'\n'

testData.split('\n\n').forEach(t=>{
  var k=t.slice(-1)=='T',
      r=f(t.slice(0,-1))
  console.log(t+' '+r+ (k==r?' OK\n':' KO\n'))
})  

<pre id=O></pre>

Comments

अब 8 गुना लंबा है!

— नील

Answer 8

ग्राइम v0.1, 31 बाइट्स

E=\0+|\1+
N=.+&E!
e`(E/N|N/E)#!

1मैच के लिए और 0बिना किसी मैच के प्रिंट । इसे ऑनलाइन आज़माएं!

व्याख्या

Grime मेरी 2D पैटर्न से मेल खाने वाली भाषा है। मैंने इसे आज संशोधित किया है, लेकिन केवल एक सिंटैक्स तत्व के चरित्र को बदलने के लिए ( `इसके बजाय ,), इसलिए यह मेरे स्कोर को प्रभावित नहीं करता है।

मैं Sp3000 के समान दृष्टिकोण का उपयोग कर रहा हूं : एक इनपुट गलत है यदि इसमें 2 × N आयत है जिसकी एक पंक्ति में दोनों हैं 0और 1दूसरी पंक्ति में नहीं है।

E=             Define a nonterminal E, which matches
  \0+|           a horizontal run of one or more 0s, OR
      \1+        a horizontal run of one or more 1s.
N=             Define a nonterminal N, which matches
  .+             a horizontal run of one or more characters,
    &E!          which is NOT matched by E (so contains both 0 and 1).
e`             Match entire input to this pattern:
            !    not
           #     contains
  (E/N|N/E)      E on top of N, or N on top of E

Answer 9

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

s=>(a=s.split`
`).every(l=>l==a[0]|l==a[0].replace(/./g,n=>n^1))

@ LevelRiverSt के अवलोकन के आधार पर कि प्रत्येक पंक्ति पहले की समान या विपरीत होनी चाहिए।