मंजिल का सबसे सरल टाइलिंग

आपको एक प्रोग्राम या फ़ंक्शन लिखना चाहिए जो फर्श को इनपुट और आउटपुट के रूप में वर्णित करने वाला एक स्ट्रिंग प्राप्त करता है या सबसे सरल मेटा-टाइलिंग के क्षेत्र को लौटाता है जो फर्श के दिए गए पैटर्न को बना सकता है।

फर्श एक वर्ग ग्रिड का एक हिस्सा है। प्रत्येक वर्ग टाइल रंगीन या तो नीला या काला (द्वारा aऔर bइनपुट में दर्शाया गया है )।

एक उदाहरण मंजिल:

  aaaa
ababab
aaaaa

एक मेटा-टाइलिंग

एक से बनाया गया है Nद्वारा Mनीला और काले वर्गों के आयताकार मेटा-टाइल
प्रयुक्त मेटा-टाइलें अनुवाद के समान हैं (आप उन्हें घुमा या मिरर नहीं कर सकते हैं)
यदि दो मेटा-टाइलों के किनारे जुड़े हुए हैं, तो उन्हें अपनी पूरी लंबाई के साथ जोड़ना चाहिए (यानी मेटा-टाइलें एक ग्रिड की तरह फैशन में जगह को टाइल करती हैं)

एक उदाहरण मेटा-टाइल:

ba
aa

और इसके द्वारा बनाई गई मेटा-टाइलिंग:

       .
       .
       .
    babababa
    aaaaaaaa
... babababa ...
    aaaaaaaa    
    babababa
    aaaaaaaa
       .
       .
       .

यह मेटा-टाइलिंग ऊपरी दिखाए गए तल को बाएं अक्षरों को दिखाती है:

       .
       .
       .
    ********
    ***aaaa*
... *ababab* ...
    *aaaaa**    
    ********
    ********
       .
       .
       .

मेटा-टाइलिंग का क्षेत्रफल छोटा होने पर मेटा-टाइलिंग दूसरे की तुलना में सरल होती है। हमारे उदाहरण का एक क्षेत्र है 2*2 = 4जिसका उदाहरण मंजिल के लिए सबसे छोटा संभव है। तो 4उदाहरण के लिए आउटपुट होना चाहिए ।

इनपुट

पात्रों a b spaceसे newlineयुक्त एक स्ट्रिंग और जिसमें कम से कम एक aया होता है b।
अक्षर ( ab) एक 4-जुड़ा हुआ (साइड-बाय-साइड जुड़ा हुआ) आकार बनाते हैं।
पंक्तियों के सामने कोई अनावश्यक स्थान नहीं होगा यानी कम से कम एक पंक्ति होगी जिसके साथ aया शुरू हो रहा है b।
आप दो इनपुट प्रारूप चुन सकते हैं:
- पंक्तियों के अंत में कोई अनावश्यक व्हाट्सएप नहीं (जैसा कि उदाहरणों में देखा गया है)।
- सभी पंक्तियों को सबसे लंबी पंक्ति के समान लंबाई बनाने के लिए पंक्तियों के दाईं ओर रिक्त स्थान।
अनुगामी न्यूलाइन वैकल्पिक है।

उत्पादन

एक एकल पूर्णांक, सबसे छोटा संभव मेटा-टाइल का क्षेत्र जिसके टाइलिंग में इनपुट मंजिल शामिल है।

उदाहरण

उदाहरण डैश द्वारा सीमांकित किए गए हैं। एक उदाहरण के तीन भाग इनपुट, आउटपुट और संभावित सबसे छोटे मेटा-टाइल्स में से एक हैं।

a

1

a
-----------------
 aaaa
aaa
a

1

a
-----------------
aabaab
abaa
aaba

6

aab
aba
-----------------
aabaab
a  a a
aabab

18

aabaab
aaaaaa
aababa
-----------------
ba
aaab

8

baaa
aaab
-----------------
 aaaa
ababb
aaaa

10

aaaaa
ababb
-----------------
 a aa
ab ba
 aba

6

aa
ab
ba
-----------------
 aaaa
abab
aaaa

4

aa
ab
-----------------
ba
 ba
  b

4

ba
ab
-----------------
baa
aba
aab

9

baa
aba
aab
-----------------
 aaaa
aabaa
aaaa

6

aaa
aab

यह कोड गोल्फ है इसलिए सबसे छोटी प्रविष्टि जीतती है।

code-golf grid tiling

— randomra
स्रोत

@Ypnypn हर कोने को 3 अन्य कोनों को छूना पड़ता है (टाइलिंग के किनारे मेटा-टाइल्स को छोड़कर)। मैंने इसे "अगर दो मेटा-टाइल्स के किनारे जुड़े हुए हैं, तो उन्हें अपनी पूरी लंबाई के साथ जोड़ना चाहिए"। तो आपका दिया गया उदाहरण अवैध है।

— यादृच्छिक

सी - 208 बाइट्स

w,q,n,m,r,g,u;t(char*f){for(w=0;f[w++]-10;);for(q=1;;q++)for(n=1;m=q/n,n<=q;++n)if(n*m==q){char t[q];bzero(t,q);r=q;for(g=0;f[g];++g){u=g/w%m*n+g%w%n;r=t[u]+f[g]-195?r:0;if(f[g]&64)t[u]=f[g];}if(r)return r;}}

गोल्फिंग से पहले समान कोड:

#include <stdio.h>
#include <strings.h>

int t(char* f) {
    int w = 0;
    for ( ; f[w++] - 10; );

    for (int q = 1; ; q++) {
        char t[q];
        for (int n = 1; n <= q; ++n) {
            int m = q / n;
            if (n * m == q) {
                bzero(t, q);
                int r = q;
                for (int g = 0; f[g]; ++g) {
                    int u = g / w % m * n + g % w % n;
                    if (t[u] + f[g] == 195) {
                        r = 0;
                    }
                    if (f[g] & 64) {
                        t[u] = f[g];
                    }
                }
                if (r) {
                    return r;
                }
            }
        }
    }
}

एल्गोरिथ्म काफी क्रूर बल है, इसलिए यह काफी स्पष्ट होना चाहिए कि यह कोड के आधार पर कैसे काम करता है। यहाँ कुछ टिप्पणियाँ वैसे भी हैं:

इनपुट में अनुगामी रिक्त स्थान के साथ प्रपत्र होने की उम्मीद है ताकि सभी लाइनों की लंबाई समान हो।
पहला लूप पहली न्यूलाइन कैरेक्टर की तलाश करके चौड़ाई पाता है।
बाहरी लूप उम्मीदवार मेटा-टाइल आकारों पर है q। returnजब एक मेटा-टाइल फर्श को कवर कर सकती है, तब बाहर निकलता है । ध्यान दें कि लूप को एक और निकास स्थिति की आवश्यकता नहीं है क्योंकि हमेशा एक समाधान होता है (सबसे खराब स्थिति इनपुट का आकार है)।
पहले नेस्टेड लूप और निम्न ifआकार के लिए मान्य मेटा-टाइल की चौड़ाई / ऊंचाई संयोजनों की गणना करता है q।
उम्मीदवार मेटा-टाइल आकार से मेल खाने वाला एक चरित्र सरणी शून्य-आरंभीकृत है।
भीतरी लूप फर्श में सभी टाइलों पर निर्भर करता है।
u मेटा-टाइल में सूचकांक है जो फर्श टाइल से मेल खाती है।
यदि फर्श टाइल और मेटा-टाइल टाइल दोनों हैं aया bअलग-अलग हैं ( a = 97और b = 98का योग है 195), एक बेमेल है, और प्रयास आयामों के साथ मेटा-टाइल आकार काम नहीं करेगा।
अन्यथा, यदि फर्श टाइल है aया b, टाइल रंग को उम्मीदवार मेटा-टाइल में कॉपी किया जाता है।
सफल मैच होने पर मेटा-टाइल का रिटर्न साइज़, यानी यदि प्रयास किया गया मैच असफल के रूप में चिह्नित नहीं किया गया था।

उपयोग किए गए टेस्ट कोड:

#include <stdio.h>

extern int t(char* s);

int main()
{
    printf("%d\n", t(
        "a\n"
    ));
    printf("%d\n", t(
        " aaaa\n"
        "aaa  \n"
        "a    \n"
    ));
    printf("%d\n", t(
        "aabaab\n"
        "abaa  \n"
        "aaba  \n"
    ));
    printf("%d\n", t(
        "aabaab\n"
        "a  a a\n"
        "aabab \n"
    ));
    printf("%d\n", t(
        "ba  \n"
        "aaab\n"
    ));
    printf("%d\n", t(
        " aaaa\n"
        "ababb\n"
        "aaaa \n"
    ));
    printf("%d\n", t(
        " a aa\n"
        "ab ba\n"
        " aba \n"
    ));
    printf("%d\n", t(
        " aaaa\n"
        "abab \n"
        "aaaa \n"
    ));
    printf("%d\n", t(
        "ba \n"
        " ba\n"
        "  b\n"
    ));
    printf("%d\n", t(
        "baa\n"
        "aba\n"
        "aab\n"
    ));
    printf("%d\n", t(
        " aaaa\n"
        "aabaa\n"
        "aaaa \n"
    ));
    return 0;
}

आउटपुट:

— रेटो कोराडी
स्रोत