क्या ईंट की संरचना स्थिर है?

Question

के एक प्रतिनिधित्व करते हैं मानक चिनाई ईंट के रूप में [__](और तथ्य यह है कि शीर्ष खुला है पर ध्यान न दें)। जब इन ईंटों को ढेर कर दिया जाता है तो हर दूसरी परत आधी ईंट से भर जाती है, जैसा कि ईंट निर्माण में होता है:

  [__][__][__][__]
[__][__][__][__]  
  [__][__][__][__]
[__][__][__][__]  

इस प्रकार प्रत्येक ईंट में अधिकतम छह पड़ोसी होते हैं और दो ईंटों के लिए सीधे खड़ी रेखा के लिए असंभव है।

मुख्य बिंदु यह है कि इन ईंटों की व्यवस्था नहीं है मोर्टार जाता है , लेकिन केवल गुरुत्वाकर्षण द्वारा एक साथ रखा जाता है। इसलिए यह महत्वपूर्ण है कि संरचना में प्रत्येक ईंट स्थिर है, अन्यथा पूरी संरचना अस्थिर है।

व्यक्तिगत ईंट स्थिर होने के तीन तरीके हो सकते हैं:

1. जमीन पर कोई भी ईंट (ईंटों की सबसे निचली पंक्ति) स्थिर है।

2. कोई भी ईंट जिसके नीचे दो ईंटें हों, वह स्थिर है:

     [__]   <- this brick is stable
   [__][__] <- because these bricks hold it up
   

3. कोई भी ईंट जिसमें ऊपर और नीचे दोनों तरफ एक ईंट होती है वह स्थिर होती है:

     [__]  [__]
   [__]      [__] <- these middle bricks are stable
     [__]  [__]      because the upper and lower bricks clamp them in
   
   [__]          [__]
     [__]      [__]   <- these middle bricks are NOT stable
       [__]  [__]
   

इन नियमों से हम देख सकते हैं, उदाहरण के लिए, व्यवस्था

  [__][__][__][__]
[__][__][__][__]  
  [__][__][__][__]
[__][__][__][__]  

अस्थिर है क्योंकि शीर्ष दाहिनी ईंट अस्थिर है, जो यह सब लेता है।

एक ईंट संरचना केवल स्थिर है यदि इसकी सभी ईंटें स्थिर हैं।

चुनौती

आपका कार्य एक फ़ंक्शन लिखना है जो एक ईंट संरचना स्ट्रिंग में लेता है और एक सत्य मान देता है यदि संरचना स्थिर है, और अस्थिर मूल्य यदि अस्थिर है। ( सत्य / असत्य परिभाषा )

इनपुट स्ट्रिंग मनमाने ढंग से बड़ी हो सकती है, लेकिन यह हमेशा पात्रों का एक आयताकार ग्रिड होगा, जिसमें रिक्त स्थान भरने वाले स्थान ईंटों से भरे होंगे। वर्ण ग्रिड की चौड़ाई 4 से विभाज्य होगी लेकिन ऊँचाई विषम या सम हो सकती है।

ईंट ग्रिड हमेशा ऊपर और निचले बाएँ ईंट स्थिति के दाईं ओर फैली होती है:

         .
         .
         .
  BRK?BRK?BRK?BRK?  
BRK?BRK?BRK?BRK?BRK?
  BRK?BRK?BRK?BRK?  
BRK?BRK?BRK?BRK?BRK? . . .
  BRK?BRK?BRK?BRK?  
BRK?BRK?BRK?BRK?BRK?

संरचना के आधार पर, प्रत्येक BRK?या तो एक ईंट का प्रतिनिधित्व करता है ([__] ) या खाली स्थान (4 रिक्त स्थान) का ।

ध्यान दें कि वर्ण ग्रिड आयताकार है यह सुनिश्चित करने के लिए आधा-ईंट गुहा रिक्त स्थान से भरे हुए हैं।

स्कोरिंग

बाइट्स में सबसे छोटा कोड जीतता है।

टिप्पणियाँ

• यदि आप चाहें तो उपयोग कर सकते हैं . रिक्त स्थान के स्थान के रूप में ।
• खाली स्ट्रिंग को स्थिर माना जाता है।
• यदि आपकी भाषा में फ़ंक्शंस नहीं हैं, तो आप एक नामित स्ट्रिंग चर को इनपुट के रूप में उपयोग कर सकते हैं और परिणाम को दूसरे चर पर असाइन कर सकते हैं।
• यदि आपकी भाषा में तार नहीं हैं, तो आप इनपुट के लिए जो भी उचित लगे, कर सकते हैं।

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

विभिन्न परीक्षण मामलों, खाली लाइनों द्वारा अलग किए गए। .खाली स्थानों के लिए जगह के बजाय स्पष्टता का उपयोग किया जाता है।

स्थिर:

[__]

..[__]..
[__][__]

........[__]........
......[__][__]......
........[__]........

..[__][__]..
[__][__][__]
..[__][__]..
[__]....[__]

............[__]..
..[__][__][__][__]
[__][__][__][__]..
..[__][__][__][__]
[__][__][__][__]..

..[__]........[__]..
[__][__][__][__][__]
..[__][__][__][__]..
....[__][__][__]....
......[__][__]......
........[__]........

अस्थिर:

..[__]..
........

..[__]..
[__]....

..[__]..
....[__]

..[__][__]..
[__]....[__]
..[__][__]..
[__]....[__]

..[__][__][__][__]
[__][__][__][__]..
..[__][__][__][__]
[__][__][__][__]..

[__][__][__][__][__]
..[__][__][__][__]..
....[__][__][__]....
......[__][__]......
........[__]........

Comments

मुझे पूरा यकीन है कि स्थिरता की आपकी परिभाषा वास्तविकता से मेल नहीं खाती ;-)

— जॉन ड्वोरक

@JDDvorak मुझे पता है, लेकिन जो एक पूरे भौतिकी इंजन को गोल्फ करना चाहेगा: P

— केल्विन के शौक

........[__].... ......[__][__].. ....[__][__].... ..[__][__]...... [__][__]........ ..[__]..........(आपको मानसिक रूप से उन पंक्तियों को एक-दूसरे के ऊपर रखना होगा। बिंदु यह है कि आपके नियम ऐसे ढांचे की अनुमति देते हैं जिनके गुरुत्वाकर्षण का केंद्र जमीन के संपर्क से उनके बिंदु से बहुत दूर है। इससे बचने के लिए उन्हें कसने के लिए संभव होना चाहिए। , बिना किसी भौतिकी इंजन की आवश्यकता के, अगर आपको यह पसंद आया।)

— नाथनियल

भौतिकी में सत्यापन एक बहुत बड़ी बीमारी है। एक कई सरल मामलों के साथ आ सकता है जहां स्थिरता घर्षण के गुणांक और / या शीर्ष पर ईंटों के वजन पर निर्भर करती है।

— सीओटीओ

"स्थिर" ... हे

— wchargin

Answer 1

80386 मशीन कोड, 98

कोड:

60 8b f1 8b f9 b0 0a f2 ae 8b ef 2b ee b0 00 f2
ae 2b fe 83 ef 02 2b fd 72 41 03 f7 2b f5 33 c9
8a 7c 6e fc 8a 1c 6e b1 02 33 d2 8b c7 f7 f5 83
fa 02 75 03 b7 00 41 8a 66 fc 8a 06 3b fd 7d 02
33 c0 23 c3 0a c4 22 df 0b c3 f6 44 2e fe 01 74
04 d1 e8 73 06 2b f1 2b f9 73 c5 61 d1 d0 83 e0
01 c3

एक समय में 2 वर्णों को कूदते हुए, कोड शुरू से अंत तक ASCII कला को स्कैन करता है। यह दो बार आवश्यक जांच करता है (यह 4 वर्णों को कूदने के लिए पर्याप्त होगा), लेकिन तर्क को सरल करता है।

वर्णों की अगली-से-अंतिम पंक्ति (अंतिम पंक्ति की जाँच करने की आवश्यकता नहीं) पर जाँच शुरू होती है। प्रत्येक पंक्ति में, यह दाईं ओर से 3 अक्षर शुरू करता है (दाईं ओर बहुत दूर तक जांच करने की आवश्यकता नहीं है)। प्रत्येक वर्ण के लिए, यह 4 आस-पास के वर्णों की जाँच करता है:

A...B
..X..
C...D

जाँच करने के लिए तार्किक परिस्थितियों का एक समूह है:

• यदि A और C ईंट वर्ण हैं, तो X समर्थित है
• यदि B और D ईंट वर्ण हैं, तो X समर्थित है
• यदि C और D ईंट वर्ण हैं, तो X समर्थित है
• यदि X एक ईंट चरित्र है, तो उसे समर्थन करना होगा; अन्यथा संरचना अस्थिर है

यह एक भाग्यशाली संयोग है कि सभी ईंट पात्रों [_]का एलएसबी सेट है; अन्य सभी वर्ण .\nस्पष्ट हैं। इसके अलावा, 80386 अनुदेश सेट इन आसान "उच्च" और "कम" रजिस्टरों (है ah, al, आदि) है, जो मदद के चेक थोड़ा parallelize। तो सभी जाँच कुछ अस्पष्ट बिट के लिए जाँच मात्रा।

मैंने निम्नलिखित C कोड से शुरुआत की:

int check(const char* ptr)
{
    int width, result = 0, pos;

    width = strchr(ptr, '\n') - ptr + 1;
    pos = strlen(ptr) - 1 - width; // pos points to the B character
    ptr += pos - width;

    while (pos >= 0)
    {
        int a = ptr[-4];
        int c = ptr[-4 + 2 * width];
        int b = ptr[0];
        int d = ptr[0 + 2 * width];
        int ab = a << 8 | b;
        int cd = c << 8 | d;
        if (pos < width)
            ab = 0; // A and B don't exist; set them to 0
        int jump = 2; // distance to next brick
        if (pos % width == 2) // leftmost brick?
        {
            cd &= 0xff; // C doesn't exist; set it to 0
            ++jump;
        }
        int support_v = ab & cd;
        support_v = support_v | support_v >> 8; // data in LSB
        int support_h = cd & cd >> 8; // data in LSB
        int support = (support_v | support_h) & 1;
        if (!support & ptr[-2 + width])
            goto UNSTABLE;
        ptr -= jump;
        pos -= jump;
    }
    return 1;
UNSTABLE:
    return 0;
}

मैं का एक golfed कार्यान्वयन सहित विधानसभा भाषा के लिए कोड अनुवाद (यह ज्यादातर एक-से-एक है), strchrऔर strlen। निम्नलिखित स्रोत कोड का अनुवाद एमएस विज़ुअल स्टूडियो ने मेरी पोस्ट के शीर्ष पर मशीन कोड में किया है।

__declspec(naked) int __fastcall check(const char* ptr) // MS Visual Studio syntax
{
    _asm
    {
        pushad;

        // ecx = ptr
        mov esi, ecx; // esi = ptr
        mov edi, ecx
        mov al, 10;
        repne scasb;
        mov ebp, edi;
        sub ebp, esi; // ebp = width

        mov al, 0;
        repne scasb;
        sub edi, esi;
        sub edi, 2;
        sub edi, ebp; // edi = pos
        jc DONE;

        add esi, edi;
        sub esi, ebp;

        xor ecx, ecx; // ecx = jump

    LOOP1:
        mov bh, [esi - 4 + 2 * ebp]; // bh = C
        mov bl, [esi + 2 * ebp]; // bl = D
        // bx = CD
        mov cl, 2;
        xor edx, edx
        mov eax, edi
        div ebp;
        cmp edx, 2;
        jne LABEL2;
        mov bh, 0
        inc ecx;
    LABEL2:

        mov ah, [esi - 4]; // ah = A
        mov al, [esi]; // al = B
        // ax = AB
        cmp edi, ebp;
        jge LABEL3;
        xor eax, eax;
    LABEL3:

        and eax, ebx; // ax = support_v
        or al, ah; // al = support_v
        and bl, bh; // bl = support_h
        or eax, ebx; // eax = support
        test byte ptr[esi - 2 + ebp], 1;
        jz LABEL4; // not a brick character - nothing to check
        shr eax, 1; // shift the LSB into the carry flag
        jnc DONE;
    LABEL4:
        sub esi, ecx;
        sub edi, ecx;
        jnc LOOP1;

    DONE:
        // here, the result is in the carry flag; copy it to eax
        popad;
        rcl eax, 1;
        and eax, 1;
        ret;
    }
}

Answer 2

MATLAB - 119 बाइट्स

न्यूनतम किया गया:

function c=S(B),f=@(m)conv2([(0&B(1,:))+46;B]+3,m,'valid');M=[2 0;-1 -1;0 2];c=isempty(B)||all(all(f(M)&f(fliplr(M))));

विस्तारित:

function c = isstable( B )

f = @(m) conv2( [(0&B(1,:))+46; B] + 3, m, 'valid' );
M = [2 0;-1 -1;0 2];
c = isempty( B ) || all(all( f( M ) & f(fliplr( M )) ));

नमूना उपयोग:

S4 = [  '..[__][__]..'; ...
        '[__][__][__]'; ...
        '..[__][__]..'; ...
        '[__]....[__]'];

fprintf( 'S4: %d\n', isstable( S4 ) );

S4: 1

U4 = [  '..[__][__]..'; ...
        '[__]....[__]'; ...
        '..[__][__]..'; ...
        '[__]....[__]'];

fprintf( 'U4: %d\n', isstable( U4 ) );

U4: 0

विवरण

दिनचर्या .इनपुट मैट्रिक्स के शीर्ष पर एक पंक्ति को जोड़ती है, फिर ASCII वर्ण कोड में 3 जोड़कर एक संख्यात्मक मैट्रिक्स में परिवर्तित होती है। इस रूपांतरण को देखते हुए, कर्नेल के साथ एक 2D कनवल्शनशन

 2  0
-1 -1
 0  2

0वर्ण पैटर्न वाले स्थानों पर एक मैट्रिक्स देता है

 . *
 _ _
 * .

*"किसी भी चरित्र" का प्रतिनिधित्व करने के साथ मौजूद है । कर्नेल के निर्माण के कारण, यह एकमात्र वैध चरित्र पैटर्न है जो एक उपज देगा 0।

पता लगाने के लिए कर्नेल के बाएं-दाएं फ़्लिप किए गए संस्करण के साथ एक समान संकेतन किया जाता है

 * .
 _ _
 . *

एक इनपुट स्थिर है अगर या तो मैं ) यह खाली है, या ii ) कोई भी जीरो या तो कन्वेंशन में दिखाई नहीं देता है।

दो कुंठाएँ हैं

1. MATLAB का डिफ़ॉल्ट कन्वेन्शन ऑपरेंड मैट्रिक्स के किनारों पर चलता है, 0दोनों कंफोल्यूशन के लिए कोनों का विरोध करने में त्रुटिपूर्ण s का निर्माण करता है, आउटपुट को उस क्षेत्र में आउटपुट को सीमित करने के ,'valid'लिए conv2कॉल करने के लिए (8 बाइट्स) जोड़ने की आवश्यकता होती है, जहाँ कन्वेंशन मान्य है।

2. खाली स्ट्रिंग मामले को संभालने से 12 बाइट्स जुड़ते हैं।

Answer 3

जावास्क्रिप्ट (E6) 131 261

F=a=>
  [...a].every((e,p)=>
    !(d={']':-3,'[':3}[e])
     |a[p-r]=='_'&(x=a[p+r]!=' ')
     |a[p-r+d]=='_'&(y=a[p+r+d]!=' ')
     |x&y
  ,r=a.search(/\n/)+1)

FireFox / FireBug कंसोल में टेस्ट करें

;['[__]', '  [__]  \n[__][__]', '        [__]        \n      [__][__]      \n        [__]        ',
 '  [__][__]  \n[__][__][__]\n  [__][__]  \n[__]    [__]',
 '            [__]  \n  [__][__][__][__]\n[__][__][__][__]  \n  [__][__][__][__]\n[__][__][__][__]  ',
 '  [__]        [__]  \n[__][__][__][__][__]\n  [__][__][__][__]  \n    [__][__][__]    \n      [__][__]      \n        [__]        ']
.forEach(x => console.log(x+'\n'+F(x)))

;['  [__]  \n        ', '  [__]  \n[__]    ' ,'  [__]  \n    [__]',
 '  [__][__]  \n[__]    [__]\n  [__][__]  \n[__]    [__]',
 '  [__][__][__][__]\n[__][__][__][__]  \n  [__][__][__][__]\n[__][__][__][__]  ',
 '[__][__][__][__][__]\n  [__][__][__][__]  \n    [__][__][__]    \n      [__][__]      \n        [__]        ']
.forEach(x => console.log(x+'\n'+F(x)))

उत्पादन

    [__]
true

  [__]  
[__][__]
true

        [__]        
      [__][__]      
        [__]        
true

  [__][__]  
[__][__][__]
  [__][__]  
[__]    [__]
true

            [__]  
  [__][__][__][__]
[__][__][__][__]  
  [__][__][__][__]
[__][__][__][__]  
true

  [__]        [__]  
[__][__][__][__][__]
  [__][__][__][__]  
    [__][__][__]    
      [__][__]      
        [__]        
true

  [__]  
false

  [__]  
[__]    
false

  [__]  
    [__]
false

  [__][__]  
[__]    [__]
  [__][__]  
[__]    [__]
false

  [__][__][__][__]
[__][__][__][__]  
  [__][__][__][__]
[__][__][__][__]  
false

[__][__][__][__][__]
  [__][__][__][__]  
    [__][__][__]    
      [__][__]      
        [__]        
false

Ungolfed

F=a=>(
  a=a.replace(/__/g,'').replace(/  /g,'.'),
  r=a.search(/\n/)+1,
  [...a].every((e,p)=>
    e < '0' ||
    (e ==']'
    ? // stable right side
     a[p-r]=='[' & a[p+r]!='.' 
     |
     a[p-r-1]==']' & a[p+r-1]!='.' 
     |
     a[p+r]!='.' & a[p+r-1] != '.'
    : // stable left side
     a[p-r]==']' & a[p+r]!='.' 
     |
     a[p-r+1]=='[' & a[p+r+1]!='.' 
     |
     a[p+r]!='.' & a[p+r+1] != '.'
    )  
  )
)

Comments

क्या है [...a]करते हैं, अगर आप मेरी पूछने कोई आपत्ति नहीं है? मुझे पता है कि ES6 ...argएक समारोह के अंतिम तर्क के रूप में चर को पकड़ने की अनुमति देता है, लेकिन मैंने कभी इस तरह से इसका इस्तेमाल नहीं किया है।

— सीओटीओ

@ COTO codegolf.stackexchange.com/a/37723/21348 , केस 2 का उपयोग करें (यह बहुत आम है, मैं इसे शायद मेरे 80% उत्तर में उपयोग करता हूं)

— edc65

Sunofagun। जैसे {:}MATLAB में। यह बहुत उपयोगी होने जा रहा है। धन्यवाद। :)

— सीओटीओ

Answer 4

पायथन 279

मुझे लगता है कि मैं कोड गोल्फ चुनौतियों में बहुत बुरा हूं और शायद मैं इसके लिए गलत भाषाओं का उपयोग करता हूं: डी बट आई लव कोड जिसे आसानी से पढ़ा जा सकता है :) Btw मैं एक पायथन कोड देखना चाहूंगा जो कम बाइट्स का उपयोग करता है!

def t(b):
    r=b.split()
    l=len(r[0])
    r=['.'*l]+r
    for i in range(len(r)-2,0,-1):
        r[i]+='...'
        for j in range(l):
            if(r[i][j]=='['):
                if(r[i+1][j]<>'_'or(r[i+1][j+3]<>'_'and r[i-1][j]<>'_'))and(r[i+1][j+3]<>'_'or r[i-1][j+3]<>'_'):
                    return False
    return True

संभावित उदाहरण:

A = "..[__][__][__][__]\n\
[__][__][__][__]..\n\
..[__][__][__][__]\n\
[__][__][__][__].."
print t(A) #False

B = "..[__]........[__]..\n\
[__][__][__][__][__]\n\
..[__][__][__][__]..\n\
....[__][__][__]....\n\
......[__][__]......\n\
........[__]........"
print t(B) #True

Comments

मैं अपने कोड के अंदर डॉट्स का उपयोग नहीं करता, वास्तव में आपका इनपुट किसी भी चार का उपयोग कर सकता है, लेकिन नहीं_[

— विकिनिया

आमतौर पर उपयोग करने के बजाय <>, आप उपयोग करेंगे !=।

— एथन बीरेलिन

@EthanBierlein निश्चित नहीं था, लेकिन हाँ !=पसंदीदा तरीका है

— विकुनिया

Answer 5

जावास्क्रिप्ट 2 (ES6) - 148 151 बाइट्स

F=s=>s.split(/\n/).every((b,i,a)=>(r=1,b.replace(/]/g,(m,o)=>(T=z=>(a[i-1+(z&2)]||[])[o-z%2*3]=='_',r&=i>a.length-2?1:T(2)?T(3)|T(0):T(3)&T(1))),r))

नई पंक्ति की एक स्ट्रिंग को अलग करती है ईंट की पंक्तियाँ (नोट: यदि हम एक अलग विभाजक वर्ण का उपयोग कर सकते हैं जैसे "|" पंक्तियों को अलग करने के लिए इसे 1 बाइट छोटा किया जा सकता है)।

इसके साथ फ़ायरफ़ॉक्स कंसोल में टेस्ट करें:

F('..[__]......\n[__][__][__]\n..[__][__]..\n[__]....[__]'); // false
F('..[__][__]..\n[__][__][__]\n..[__][__]..\n[__]....[__]'); // true

Answer 6

अजगर, 209

def s(b):
 c=b.split("\n");s="".join(c);l=len(c[0]);t=" "*l+s+"]]"*l;a=lambda x,y,z:t[x+l*y+z]=="]"
 return all([(a(i,1,1)&a(i,1,5))or(a(i,-1,1)&a(i,1,1))or(a(i,-1,5)&a(i,1,5))for i,x in enumerate(t)if x=="["])

टेस्ट:

towers=(
"[__]",

"..[__]..\n"
"[__][__]",

"........[__]........\n"
"......[__][__]......\n"
"........[__]........",

"..[__][__]..\n"
"[__][__][__]\n"
"..[__][__]..\n"
"[__]....[__]",

"............[__]..\n"
"..[__][__][__][__]\n"
"[__][__][__][__]..\n"
"..[__][__][__][__]\n"
"[__][__][__][__]..",

"..[__]........[__]..\n"
"[__][__][__][__][__]\n"
"..[__][__][__][__]..\n"
"....[__][__][__]....\n"
"......[__][__]......\n"
"........[__]........",

"..[__]..\n"
"........",

"..[__]..\n"
"[__]....",

"..[__]..\n"
"....[__]",

"..[__][__]..\n"
"[__]....[__]\n"
"..[__][__]..\n"
"[__]....[__]",

"..[__][__][__][__]\n"
"[__][__][__][__]..\n"
"..[__][__][__][__]\n"
"[__][__][__][__]..",

"[__][__][__][__][__]\n"
"..[__][__][__][__]..\n"
"....[__][__][__]....\n"
"......[__][__]......\n"
"........[__]........",
)
[s(x) for x in towers]

आउटपुट:

[True, True, True, True, True, True, False, False, False, False, False, False]