क्या यह एल-उत्तल है?

Question

पृष्ठभूमि

एक पॉलोमिनो को एल-उत्तल कहा जाता है , अगर एल-आकार के मार्ग से किसी भी टाइल से किसी अन्य टाइल की यात्रा करना संभव है, अर्थात् , एक पथ जो कार्डिनल दिशाओं में जाता है और सबसे अधिक बार दिशा बदलता है। उदाहरण के लिए, 1आकृति में एस के पॉलीमिनो

0 0 1 1 1 0

1 1 1 1 0 0

1 1 0 0 0 0

L- उत्तल नहीं है, क्योंकि L के आकार के मार्ग नीचे 1से ऊपर दाईं ओर स्थित 1हैं 0:

0>0>1>1>1 0
^       ^
1 1 1 1 0 0
^       ^
1>1>0>0>0 0

हालांकि, 1इस आंकड़े में एस का पोलीमिनो एल-उत्तल है:

0 1 1 1 0 0

1 1 1 1 1 1

0 1 1 0 0 0

इनपुट

यदि आपकी भाषा में सरणियों का अभाव है, तो आपका इनपुट आपकी भाषा के मूल प्रारूप में, या न्यूलाइन-सीमांकित स्ट्रिंग के रूप में बिट्स का 2 डी सरणी है। इसमें कम से कम एक होने की गारंटी है 1।

उत्पादन

यदि आपका सेट 1एक L- उत्तल पॉलीमिनो है, और एक गलत मान है, तो आपका आउटपुट एक सत्य मूल्य होगा। ये आउटपुट सुसंगत होना चाहिए: आपको सभी एल-उत्तल आदानों के लिए समान सत्य मूल्य, और अन्य लोगों के लिए समान नकली मूल्य का उत्पादन करना चाहिए। ध्यान दें कि 1s का डिस्कनेक्ट किया गया सेट (जो कि पॉलीमिनो नहीं है) एक झूठा आउटपुट देता है।

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

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

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

ये परीक्षण मामले तब भी काम करते हैं जब आप सरणियों को घुमाते या प्रतिबिंबित करते हैं, या 0किसी सीमा में एस की पंक्तियों को जोड़ते हैं।

False instances
01
10

111
101
111

1101
1111
1110

1100
1000
0011

01100
11110
01110
00110

011000
011110
001111

True instances
1

01
11

010
111
010

001
011
111

11100
11110
01100
01000

011000
011000
111100
111111
001000

Comments

बहुत अच्छी चुनौती है, मैंने इसका आनंद लिया =)

— दोष

इनपुट के बारे में: यदि हमारी भाषा में सरणियों की कमी नहीं है , तो यह एक नई पंक्तिबद्ध स्ट्रिंग की अनुमति है ?

— edc65

@ edc65 (क्षमा करें, कुछ दिनों के लिए ग्रिड बंद कर दिया गया है।) ज़रूर, यह भी अनुमति है, यह सिर्फ मेरी ओर से बुरी तरह से शब्द है।

— जर्बर्ग

Answer 1

घोंघे , ४५ २४

&
!{\1t\1!{o\1,nf\1,!.!~

अपना प्रारंभिक समाधान पोस्ट करने के ठीक बाद, मुझे एहसास हुआ कि एक बेहतर तरीका था। मूल कार्यक्रम दो 1एस के बीच के रास्तों से बने वर्ग के चारों ओर घूमता है , प्रत्येक जोड़ी में 0 की उपस्थिति के लिए परीक्षण करता है। सीधी रेखा वाले रास्तों के लिए भी एक विशेष मामला रखना पड़ता था। नया संस्करण एक 1से दूसरे में टेलीपोर्टिंग द्वारा शुरू होता है , और 1शुरुआत में वापस एस के सीधे या एल-आकार के पथ की अनुपस्थिति के लिए परीक्षण करता है।

Comments

हे भगवान!! क्या कोई ऑनलाइन दुभाषिया है जहाँ हम इसके साथ खेल सकते हैं?

— दोष

@flawr आप इसे स्रोत कोड के साथ स्रोत से यहां बना सकते हैं ।

— एलेक्स ए।

Answer 2

मतलाब, 182 बाइट्स

आइडिया: 1पॉलीमिनो मैट्रिक्स में प्रत्येक के लिए दोहराएं :

• केवल दिए गए 1लेकिन बाकी शून्य के साथ नया मैट्रिक्स बनाएं ।
• 1इस नए मैट्रिक्स में प्रत्येक के लिए (तब तक दोहराएं जब तक कि कुछ भी न बदले)
  • 1x दिशा में पड़ोसी के रूप में जोड़ें यदि वहाँ 1बहुपदों में पड़ोसी हैं
• 1इस नए मैट्रिक्स में प्रत्येक के लिए (तब तक दोहराएं जब तक कि कुछ भी न बदले)
  • 1x दिशा में पड़ोसी के रूप में जोड़ें यदि वहाँ 1बहुपदों में पड़ोसी हैं

अब 1नए मैट्रिक्स 1में उन सभी पॉलिनियो- मैट्रिक्स को कवर किया जाना चाहिए जो पहले दिए गए शुरुआती बिंदु से एक्स-दिशा में और फिर y- दिशा में जा रहे हैं। अब हम उसी प्रक्रिया को दोहरा सकते हैं लेकिन पहले y- दिशा में और फिर x- दिशा में जा रहे हैं। अब हर 1पॉलीमिनो मैट्रिक्स को एक या दो बार पहुंचना चाहिए। यदि नहीं, तो हमने बहुपद मैट्रिक्स में एक ऐसी स्थिति पाई है जिसे एक L-पथ द्वारा हर दूसरी स्थिति से नहीं पहुँचा जा सकता है ।

golfed:

function r=f(a);[i,j,b]=find(a);N=nnz(i);r=1;for k=1:N;K=1:3;for l=1:2;c=b;b=a*0;b(i(k),j(k))=1;for z=1:2*N; b=conv2(b+0,K,'s')&a;if z==N;K=K';end;end;end;r=r*all(b(:)|c(:)>=a(:));end

टिप्पणियों के साथ:

function r=codegolf_L_convex(a);
%a=[0,1;1,1];
[i,j,b]=find(a);%b just needs to be initialized, does not really mattter
N=nnz(i);%number of ones in the matrix
r=1;%return value
for k=1:N;%go throu all '1' in the matrix
    %expand that pixel in x dir:
    K=1:3;%convolution kernel (just three positive values needed)
    for l=1:2;%first horizontal->vertical then vertical->horizontal
        c=b;%backup for considering both runs
        b=a*0;
        b(i(k),j(k))=1; %set the seed
        for z=1:2*N;     
            b=conv2(b+0,K,'s')&a; %expand the seed horizontally (or vertically for the second half) but only within the polyomino
            if z==N;
                K=K'; %change horizontal/vertical 
            end;
        end;
    end;
    r=r*all(b(:)|c(:)>=a(:));%check whether we can really reach every point
end

टेस्ट मामलों की स्क्रिप्ट:

disp('all false -------------');
a=[0,1;1,0];
f(a)
a=[1,1,1;1,0,1;1,1,1];
f(a)
a=[1,1,0,1;1,1,1,1;1,1,1,0];
f(a)
a=[1,1,0,0;1,0,0,0;0,0,1,1];
f(a)
a=[0,1,1,0,0;1,1,1,1,0;0,1,1,1,0;0,0,1,1,0];
f(a)
a=[0,1,1,0,0,0;0,1,1,1,1,0;0,0,1,1,1,1];
f(a)
 disp('all true +++++++++++++');
a=[1];
f(a)
a=[0,1;1,1];
f(a)
a=[0,1,0;1,1,1;0,1,0];
f(a)
a=[0,0,1;0,1,1;1,1,1];
f(a)
a=[1,1,1,0,0;1,1,1,1,0;0,1,1,0,0;0,1,0,0,0];
f(a)
a=[0,1,1,0,0,0;0,1,1,0,0,0;1,1,1,1,0,0;1,1,1,1,1,1;0,0,1,0,0,0];
f(a)

Answer 3

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

ठीक है, शायद यह संक्षिप्तता के लिए कोई पुरस्कार नहीं जीतेगा, लेकिन यह एक उपन्यास दृष्टिकोण का उपयोग करता है। यह कैसे काम करता है इसके लिए ungolfed संस्करण देखें।

इस पद्धति का प्रमाण इसमें पाया जा सकता है: सेलुलर ऑटोमेटा और असतत कॉम्प्लेक्स सिस्टम ।

L=a=>[1,0,1].every($=>(a=a[0].map((_,col)=>a.map(row=>row[col]))).map(r=>($?r.reverse():r).join``).every((r,i,b)=>r.replace(/^(0*)(1*)(0*)$|(.+)/,(_,s,m,o,e)=>(c=e)?'':!m||b[i-1]&&+b[i-1][s.length]?1:b.every((r,j)=>j<i||(c=c||!+r[l=s.length])?r.search(`0{${l}}.*0{${o.length}}`)+1:1)||'')))

Ungolfed:

function L(a) {
  /* Runs three times and ensure all pass validation
   * 1: horizontally reversed
   * 2: 90 degrees rotated
   * 3: original
   *
   *     | 1:  | 2:  | 3:
   * =====================
   * 001 | 100 | 111 | 001
   * 011 | 110 | 011 | 011
   * 111 | 111 | 001 | 111
   *
   * By finding maximal rectangles with corners on all NW and NE corners
   * (separately) of a HV-convex polyomino and ensuring it doesn't enter the
   * boundaries labelled ABCD for the rectangle X below:
   *
   *   A  |         |  B
   * -----===========-----
   *      |    X    |
   * -----===========-----
   *   C  |         |  D
   *
   * The first iteration tests the NE corners and horizontal convexity.
   * The second iteration test vertical convexity.
   * The third iteration tests the NW corners.
   *
   * If all pass then the polyomino is L-convex.
   */
  return [1,0,1].every(function($){
    return (a=a[0].map((_,col)=>{
      // Transpose rows with columns
      return a.map(row=>row[col])
    })).map(row=>{
      // Join rows as strings and on odd iterations reverse them
      return ($ ? row.reverse() : row).join``
    }).every(function(row, i, b) {
      if (i == 0) console.log(b.join('\n'));
      return row.replace(/^(0*)(1*)(0*)$|(.+)/, function(_, start, middle, end, invalid) {
        // Non H-convex polyomino (0 between 1s)
        if (invalid) return '';
        // Is not a NW corner (character above is 1)
        if (!middle || b[i-1] && +b[i-1][start.length]) return 1;
        c=1;
        return b.every(function(row, j) {
          // Above or below maximal rectangle from corner
          if (j < i || !(c=c&&+row[l=start.length])) {
            // Area before and after maximal rectangle doesn't contain 1
            return row.search(`0{${l}}.*0{${end.length}}`)+1
          }
          return 1;
        }) || '';
      });
    });
  });
}

Comments

हा, वह लेख जहाँ मुझे इस चुनौती की प्रेरणा मिली!

— जर्बर्ग

@Zgarb लेख बहुत अच्छा था और उन कुछ में से एक जो मुझे उस व्यक्ति के लिए समझ में आया जो गणितीय रूप से उन्मुख नहीं है।

— जॉर्ज रीथ

Answer 4

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

3>GraphDiameter@Graph[#,#<->#2&@@@Select[#~Tuples~2,!FreeQ[#-#2&@@#,0]&]]&@Position[#,1]&&{#,Thread@#}~FreeQ~{___,1,0..,1,___}&

स्पष्टीकरण:

सबसे पहले, यदि एक ही पंक्ति या स्तंभ पर 0दो 1s के बीच में है , तो सरणी L-उत्तल नहीं है, क्योंकि हम दो 1s को जोड़ नहीं सकते हैं ।

इस मामले को बाहर करने के बाद, 1एक ही पंक्ति या स्तंभ पर प्रत्येक दो एस को एक सीधे रास्ते से जोड़ा जा सकता है। हम एक ग्राफ उत्पन्न कर सकते हैं, जिसके कोने 1सरणी में s की स्थिति हैं , और किनारों को 1एक ही पंक्ति या स्तंभ पर s के जोड़े हैं । फिर सरणी एल-उत्तल है यदि और केवल अगर ग्राफ का व्यास 3 से कम है।

Comments

क्या आप एक स्पष्टीकरण दे सकते हैं कि यह कैसे काम करता है? मैं नहीं सोच रहा हूँ कि कोई भी व्यक्ति संभवतः समझ नहीं सकता है =)

— दोष

यह पहले और चौथे झूठे उदाहरणों (डिस्कनेक्ट किए गए लोगों) को कैसे पहचानता है?

— जर्बर्ग

@Zgarb यदि ग्राफ काट दिया जाता है, तो इसका व्यास अनंत है।

— एलेफाल्फा

Answer 5

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

खाली या भरी हुई कोशिकाओं की ग्रिड को देखते हुए, किसी भी भरे हुए कोशिकाओं की जोड़ी के लिए मैं दूसरे सेल कॉलम के क्षैतिज रास्तों की जांच करता हूं (वहां 1 हो सकता है यदि कोशिकाएं एक ही पंक्ति में हैं, अन्य या 2) और ऊर्ध्वाधर पथ। अन्य सेल पंक्ति (1 या 2 भी हो सकती है)। अगर मुझे ऊर्ध्वाधर रास्तों या दोनों क्षैतिज रास्तों में एक खाली सेल मिलती है, तो कोशिकाओं के बीच एक एल आकार का पथ नहीं हो सकता है।

(मुझे यह स्पष्टीकरण देने की कोशिश में एक कठिन समय था - मुझे उम्मीद है कि स्पष्ट होगा)

किसी भी EcmaScript 6 अनुरूप ब्राउज़र में नीचे स्निपेट का परीक्षण करें

F=p=>!p.some((n,y)=>n.some((q,x)=>q&&p.some((o,u)=>o.some((q,t)=>{for(f=0,i=y;q&i<=u;i++)f|=!p[i][x]|2*!p[i][t];if(f<3)for(f=0,j=x;q&j<=t;j++)f|=!n[j]|2*!o[j];return f>2}))))

// TEST
console.log=(...x)=>O.innerHTML+=x+'\n'

tko = [
 [[0,1],[1,0]]
,[[1,1,1],[1,0,1],[1,1,1]]
,[[1,1,0,1],[1,1,1,1],[1,1,1,0]]
,[[1,1,0,0],[1,0,0,0],[0,0,1,1]]
,[[0,1,1,0,0],[1,1,1,1,0],[0,1,1,1,0],[0,0,1,1,0]]
,[[0,1,1,0,0,0],[0,1,1,1,1,0],[0,0,1,1,1,1]]
]
tko.forEach(t=>(console.log(t.join`\n`+`\nFalse? ${F(t)}\n`)));
tok = [
 [[1]]
,[[0,1],[1,1]]
,[[0,1,0],[1,1,1],[0,1,0]]
,[[0,0,1],[0,1,1],[1,1,1]]
,[[1,1,1,0,0],[1,1,1,1,0],[0,1,1,0,0],[0,1,0,0,0]]
,[[0,1,1,0,0,0],[0,1,1,0,0,0],[1,1,1,1,0,0],[1,1,1,1,1,1],[0,0,1,0,0,0]]
]  
tok.forEach(t=>(console.log(t.join`\n`+`\nTrue? ${F(t)}\n`)));

// LESS GOLFED

U=p=>
  !p.some((n,y)=>  
    n.some((q,x)=> 
      q && p.some((o,u)=>  
        o.some((q,t)=>{
          for(f=0,i=y; q&i<=u; i++)f|=!p[i][x]|2*!p[i][t]
          if (f<3)
            for(f=0,j=x; q&j<=t; j++)f|=!n[j]|2*!o[j]
          return f>2
        })
      )
    )
  )

<pre id=O></pre>