एक बेल को पहचानें

Question

पृष्ठभूमि

मेरे पास पुरानी और दानेदार काली-और-सफेद छवियों का एक गुच्छा है। उनमें से कुछ दाखलताओं को एक दीवार पर चढ़ने का चित्रण करते हैं, दूसरों को नहीं - आपका काम मेरे लिए उन्हें वर्गीकृत करना है।

इनपुट और आउटपुट

आपका इनपुट किसी भी सुविधाजनक प्रारूप में दिए गए बिट्स A का आयताकार 2D सरणी है । यह खाली नहीं होगा, लेकिन इसमें 0s और 1s दोनों शामिल होने की गारंटी नहीं है। यदि निम्न स्थितियाँ हैं तो सरणी में बेल को दर्शाया गया है:

• A की निचली पंक्ति में कम से कम 1 होता है। ये बेल की जड़ें हैं।
• प्रत्येक 1 A , 1s के पथ से सबसे नीचे की पंक्ति से जुड़ा होता है, जो केवल बाएं, दाएं और नीचे (ऊपर, और तिरछे नहीं) पर जाता है। ये रास्ते बेल की शाखाएँ हैं।

आपका आउटपुट एक सुसंगत सत्य मूल्य है यदि इनपुट में एक बेल को दर्शाया गया है, और एक निरंतर मिथ्या मूल्य है।

उदाहरण

इस सरणी में एक बेल को दर्शाया गया है:

0 0 1 0 0 1
0 1 1 0 0 1
0 1 0 1 1 1
1 1 0 1 0 1
0 1 1 1 0 1
0 0 1 0 1 1

यह इनपुट एक बेल को चित्रित नहीं करता है, क्योंकि एक सही सीमा के बीच में 1 है जो एक शाखा द्वारा जड़ों से जुड़ा नहीं है:

0 0 0 1 1 0
0 1 0 1 1 1
0 1 0 1 0 1
0 1 1 1 1 0
0 0 1 1 0 1

सभी -० सरणी में एक बेल का चित्रण नहीं है, लेकिन सभी -1 सरणी हमेशा करता है।

नियम और स्कोरिंग

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

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

सत्य इनपुट्स:

1

0
1
1

01
11

0000
0111
1100
1001

1111
1111
1111
1111

001001
011001
010111
110101
011101
001011

1011011
1001001
1111111
0100000
0111111
1111001
1001111
1111101

0000000
0011100
0010100
0011100
0001000
1111111
0001000
0011100
0010100
0010100

झूठा इनपुट:

0

1
0

10
01

000
000
000

011
110
000

111111
000000
101011
111001

010010
001000
000010
110001

001100
111111
110101
010011
111011

000110
010111
010101
011110
001101

11000000
10110001
10011111
11110001
01100011
00110110
01101100
01100001
01111111

Comments

लता नीचे की ओर बढ़ने नहीं कर सकते हैं एहसास नहीं था, एक अच्छा विचार एक ग्राफ के जुड़े उपकरणों, आह का उपयोग कर ... था

— बेंत की मार

@swish इसका मतलब है कि प्रत्येक पंक्ति को बदले में नीचे की ओर 1s की पंक्ति से जुड़े ग्राफ में परिणामित करना जारी रखना चाहिए।

— नील

Answer 1

घोंघे , 25 19 17 बाइट्स

&
\0z),(\1dlr)+d~

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

व्याख्या

घोंघे एक 2 डी पैटर्न-मिलान भाषा है जो रेगेक्स से प्रेरित है, जिसे मूल रूप से हमारे 2 डी पैटर्न मिलान भाषा डिजाइन चुनौती के लिए विकसित किया गया था ।

&बनाता है घोंघे हर संभव प्रारंभिक स्थिति और प्रिंट से पैटर्न की कोशिश 0या 1चाहे पैटर्न उन सभी में उन्हें या किसी भी मैच में विफल रहता है पर निर्भर करता है।

अब घोंघे निहित कोष्ठक के साथ काम कर सकते हैं, इसलिए पैटर्न निम्नलिखित के लिए आशुलिपि है:

(\0z),(\1dlr)+d~

,एक तरह काम करता है *, regex में (यानी मेल खाते शून्य या अधिक बार) जबकि +regex (एक या अधिक बार से मेल खाते हैं) के रूप में ही है। इसलिए हम \0zजितनी बार आवश्यक हो, मिलान करते हुए शुरू करते हैं , जो एकल से मेल खाता है 0और फिर घोंघा को अपनी दिशा को मनमाने ढंग से रीसेट करने की अनुमति देता है z। यह इनपुट में शून्य की अनुमति देता है, बशर्ते एक वैध बेल सेल कहीं और पाया जा सकता है।

फिर हम कम से कम एक से मेल खाते हैं \1dlr, जो एकल से मेल खाता है 1और फिर घोंघा को अपनी दिशा को नीचे, बाएं या दाएं रीसेट करने की अनुमति देता है। ध्यान दें कि यदि हमने जो सेल शुरू की है, उसमें 1हम केवल इस भाग का मिलान कर रहे हैं। यह मूल रूप से घोंघे को एक शाखा से जड़ों तक एक बेल को पार करने की अनुमति देता है।

अंत में, हमें यह सुनिश्चित करने की आवश्यकता है कि हमने ~नीचे ( d) ( ) नीचे आउट-ऑफ-बाउंड सेल की तलाश करके जमीन तक पहुंचाया ।

Comments

मुझे सुखद आश्चर्य है कि कोई भी प्रलेखन का पालन करने में सक्षम था :)

— feersum

Answer 2

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

s=>s.replace(/^[^1]*\n/,``).split`
`.map(s=>+`0b${s}`).reverse(g=(n,m,o=(m<<1|m|m>>1)&n)=>n-m?o-m&&g(n,o):n).reduce((m,n,i)=>g(n,n&m))

नोट: पूर्णांक प्रकार की सीमाओं के कारण, केवल 31 वर्णों तक की लताओं के लिए काम करता है। व्याख्या: कनेक्शन बिंदुओं को निर्धारित करने के लिए आसन्न पंक्ति के साथ प्रत्येक पंक्ति बिटवाइड एंडेड है, और फिर gफ़ंक्शन का उपयोग पंक्ति को क्षैतिज रूप से विस्तारित करने के लिए किया जाता है जब तक कि यह अधिक विस्तार नहीं कर सकता। उदाहरण के लिए, यदि दो आसन्न पंक्तियाँ हैं 1110111और 1011100फिर कनेक्शन बिंदु हैं 1010100और फिर इसे फिर से विस्तारित किया जाता है 1110110और फिर 1110111यह पता चलता है कि पंक्ति जुड़ी हुई है। यदि gफ़ंक्शन विफल हो जाता है, तो यह शून्य देता है जो बाद के सभी gकार्यों को भी विफल कर देता है, और परिणाम फिर गलत है। यदि gफ़ंक्शन सफल होता है तो वह नई पंक्ति लौटाता है जिसे बाद reduceमें अगली पंक्ति का परीक्षण करने के लिए प्रचारित किया जाता है ।

s=>s.replace(/^[^1]*\n/,``)         Remove irrelevant leading "blank" rows
    .split`\n`                      Split into lines
    .map(s=>+`0b${s}`)              Convert into binary
    .reverse(                       Process from bottom to top
     g=(n,m,o=(m<<1|m|m>>1)&n)=>     Expand row horizontally
      n-m?o-m&&g(n,o):n)             Check whether rows are connected
    .reduce((m,n,i)=>g(n,n&m))      Check all rows

Comments

मैं नियम देता हूँ कि 31 वर्ण पर्याप्त विस्तृत हैं, और यह दृष्टिकोण मान्य है।

— झगरब

Answer 3

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

कोई पुस्तकालय नहीं

def f(A,r=0,c=-1):
 B=A[r];R=len(A)-1;C=len(B);i=1 in A[R]
 if c<0:
    for j in range(R*C+C):
        if A[j/C][j%C]:i&=f(A,j/C,j%C)
    return i&1
 _=B[c];B[c]=0;i=_&(r==R)
 if _:
    if c>0:i|=f(A,r,c-1)
    if r<R:i|=f(A,r+1,c)
    if c<C-1:i|=f(A,r,c+1)
 B[c]=_;return i

ध्यान दें कि दूसरे और तीसरे स्तर के इंडेंट बाइट काउंट में टैब के साथ बनते हैं।

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

Answer 4

वोल्फ्राम - 254

इस काम को करने में कुछ समय बिताइए, इसलिए मैं इसे यहाँ छोड़ दूँगा:

f[s_]:=(
v=Characters@StringSplit@s;
{h,w}=Dimensions@v;
g=GridGraph@{w,h};
r=First/@Position[Flatten@v,"0"];
g=VertexDelete[Graph[VertexList@g,
EdgeList@g/.x_y_/;Abs[x-y]>1yx],r];
v=VertexList@g;
v≠{}∧v~Complement~VertexOutComponent[g,Select[v,#>w h-w&]]{}
)

मूल रूप से मैं निर्देशित किनारों के साथ एक ग्रिड ग्राफ का निर्माण करता हूं, 0 से मेल खाने वाले शीर्षकों को हटाता हूं, जांचता हूं कि नीचे के शीर्ष घटकों में कई कोने हैं। हास्यास्पद, मुझे पता है ...

Comments

यह गैर-प्रतिस्पर्धा क्यों है?

— डाउनगेट

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

— एलेक्स ए।

Answer 5

पायथन + न्यूमपी 204 202 195 बाइट्स

from numpy import*
def f(A):
 r,c=A.shape
 z,s=zeros((r,1)),array([0,2,c+3])
 B=hstack((z,A,z)).flat
 for i in range(1,(r-1)*(c+2)):
    if B[i]and not any(B[s]):return 1<0
    s+=1
 return any(B[i:])

Aएक 2 डी संख्यात्मक सरणी होने की उम्मीद है।

मैट्रिक्स लेता है, शून्य कॉलम को बाएँ और दाएँ पैड करता है और मैट्रिक्स को समतल करता है। sएक स्टैंसिल है जो बाएं, दाएं और निचले तत्व को इंगित करता है। लूप अंतिम पंक्ति को छोड़कर प्रत्येक तत्व की जांच करता है यदि यह है 1और कम से कम इसकी एक स्टैंसिल है 1, Falseअन्यथा वापस आ जाता है। बाद में, जांचें कि क्या अंतिम पंक्ति में कोई है 1।

आपके लिए दो टेस्टकेस:

I1 = '001001\n011001\n010111\n110101\n011101\n001011'
A1 = array([int(c) for c in I1.replace('\n','')]).reshape(6,6)
print f(A1) #True

I2 = '001100\n111111\n110101\n010011\n111011'
A2 = array([int(c) for c in I2.replace('\n','')]).reshape(5,6)
print f(A2) #False

Edit1: 1<0से छोटा हैFalse

Edit2: लूप में दूसरे इंटेंडेशन के लिए टेबुलेटर का उपयोग और उपयोग flatकरने के लिए एक अच्छा विकल्प हैflatten()