एक स्थान को भरने के लिए मनमानी आयतों की व्यवस्था करना

Question

क्या ये आयतें एक आयताकार जगह भर सकती हैं?

आयतों के एक समूह को देखते हुए, आपसे पूछा जाता है कि क्या उन्हें एक आयताकार स्थान को भरने के लिए व्यवस्थित किया जा सकता है या नहीं।

चश्मा

मनमानी m x nआयतों का एक गुच्छा दिया ; 0 <= m, n <= 1000, यह निर्धारित करें कि क्या उन्हें व्यवस्थित करना संभव है या नहीं, ताकि वे बिना किसी छेद या ओवरलैप के ठीक एक आयताकार क्षेत्र को कवर कर सकें। आयतों को घुमाया नहीं जा सकता है, और प्रत्येक आयत को केवल एक बार रखा जा सकता है।

इनपुट

इसके लिए इनपुट बहुत लचीला है, जब तक इनपुट 2-स्पेस आयामों की सूची देता है। उदाहरण के लिए, निम्नलिखित दोनों मान्य हैं:

स्पेस, रिटर्न द्वारा अलग किया गया

1 2
1 5
4 5
3 6

आयामों की सूची

[[1, 2], [1, 5], [4, 5], [3, 6]]

उत्पादन

किसी भी प्रकार के सच्चे / झूठे मान जैसे सच्चे / झूठे, 0/1, T / F, सच्चे / झूठे, आदि यदि आप एक आउटपुट विधि का उपयोग करने जा रहे हैं जो बहुत स्पष्ट नहीं है, तो कृपया अपने उत्तर में निर्दिष्ट करें।

उदाहरण

टेस्ट केस 1

इनपुट:

1 1
1 5
2 6

आउटपुट: true(या कुछ इसी तरह)
इसे कैसे व्यवस्थित करें:

XYYYYY
ZZZZZZ
ZZZZZZ

टेस्ट केस 2

इनपुट:

1 1
2 2

आउटपुट: false(या कुछ समान)
स्पष्टीकरण: यह स्पष्ट हो जाता है कि आप विभिन्न आकारों के दो वर्गों की व्यवस्था नहीं कर सकते हैं और उनके किनारों को पंक्तिबद्ध कर सकते हैं।

टेस्ट केस 3

इनपुट:

1 1
1 2
1 2
2 1
2 1

आउटपुट: true(या कुछ इसी तरह) इसे कैसे व्यवस्थित करें:

AAB
DEB
DCC

जैसा कि @ETHProductions ने बताया, अन्य सभी परीक्षण मामलों के लिए, आप आयतों को एक सामान्य किनारे की लंबाई के साथ जोड़ सकते हैं, जब तक कि आपके पास केवल एक आयत न हो, इसलिए यह परीक्षण मामला केवल इस विचार का उपयोग करने वाले किसी भी कोड को तोड़ने के लिए है।

टेस्ट केस 4

इनपुट:

3 2
4 1
2 1
4 1
2 1
5 2
3 2
1 4
3 2
2 1
2 1
1 1
5 1

आउटपुट: true(या कुछ इसी तरह)
इसे कैसे व्यवस्थित करें:

AAABBBBEE
AAACCDDDD
FFFFFGGGH
FFFFFGGGH
IIIJJKKLH
IIIMMMMMH

नोट : आपको यह बताने की आवश्यकता नहीं है कि इसे कैसे व्यवस्थित करना है, आपको केवल यह निर्धारित करने की आवश्यकता है कि क्या यह व्यवस्थित नहीं किया जा सकता है।

यह कोड गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा जवाब है! मैं 14 जनवरी तक सबसे छोटा जवाब स्वीकार करूंगा, लेकिन बाद में जवाब देने के लिए स्वतंत्र महसूस करूंगा क्योंकि मैं अभी भी हार मान सकता हूं! :)

हैप्पी गोल्फिंग!

~ एएल

PS यदि आप जानते हैं कि इस समस्या के लिए कौन सा टैग लागू किया जाना चाहिए, तो कृपया इसे जोड़ें, मुझे बिल्कुल पता नहीं है कि कोड-गोल्फ के अलावा टैग के रूप में क्या रखा जाए।

संपादित करें : आपका कार्यक्रम एक सभ्य कंप्यूटर पर अधिकतम 10 सेकंड में (मैं इस नियम पर काफी लचीला हो जाएगा) तक 25 आयतों को संसाधित करने में सक्षम होना चाहिए।

संपादित करें : मैंने वर्ष के अंतिम दिन तक सबमिशन स्वीकृति की समय सीमा बढ़ा दी है, लेकिन मुझे संदेह है कि मुझे तब तक उत्तर मिल जाएगा ...

संपादित करें : मैंने सबमिशन स्वीकृति की समय सीमा 2 सप्ताह बढ़ा दी है, इसलिए यदि कोई और जवाब नहीं आता है, तो वर्तमान सी उत्तर स्वीकार कर लिया जाएगा! :)

Comments

मैं इसे प्रत्येक इनपुट आयत का उपयोग केवल एक बार करता हूं?

— xnor

एक समय सीमा क्यों है? आप कह सकते हैं कि आप उस समय एक उत्तर स्वीकार करेंगे, लेकिन चुनौतियाँ अनिश्चित काल तक खुली रहनी चाहिए :)

— नाथन मेरिल

क्या आयतों को घुमाया जा सकता है?

— xnor

ठीक है, आपकी समस्या एक निर्णायक समस्या है: "क्या इन उन्मुख आयतों को 0 कचरे के साथ एक और आयत बनाने के लिए व्यवस्थित किया जा सकता है", जो एक एनपी-पूर्ण समस्या है ( कोरफ , 2003: pdfs.semanticscholar.org/90a5 ( ...... ))। कोरफ का एल्गोरिथ्म अनिवार्य रूप से कुछ समाधान के साथ कुछ अनुकूलन के साथ कुछ अनुकूलन के साथ एक क्रूर-बल है जो बिना किसी समाधान के कॉन्फ़िगरेशन को समाप्त करता है। मुझे संदेह है कि इसका एक गोल्फ अधिकांश भाषाओं में 250 वर्णों से नीचे होगा।

— गैब्रियल बेनामी

आसान मार्ग यह निर्धारित करना होगा कि क्या आप बार-बार एक ही चौड़ाई या ऊंचाई के दो आयतों को मिला सकते हैं जब तक कि आपके पास 1 आयत न बचे। यह एल्गोरिथ्म सभी मौजूदा टेस्टकेस के लिए काम करता है; हालाँकि, यह [[1, 2], [2, 1], [1, 1], [1, 2], [2, 1]](जो व्यवस्थित किया जा सकता है ABB ACD EED) के लिए विफल रहता है । आप इस साधारण परीक्षण मामले को जोड़ना चाह सकते हैं।

— अक्टूबर को ETHproductions

Answer 1

सी, 1135 1158 1231 1598 बाइट्स

ठीक है, यह बताई गई समय सीमा से अधिक है, लेकिन यह देखते हुए कि अभी तक कोई जवाब नहीं है, यहां सी में एक (थोड़ा लंबा) है।

यह दिखाता है:

• 0 (शून्य) विफलता पर (फिट नहीं)
• सफलता पर पूर्ण फिटिंग मैट्रिक्स

---

अद्यतन करें:

मूल कोड कुछ मैट्रिसेस पर अटक सकता है, अनुमत 10s से अधिक समय ले रहा है। वर्तमान संशोधन 1 वर्ष से कम आयु के सभी मेट्रिक्स को पूरा करना चाहिए। यह 1 द्वारा पूरा किया जाता है) इनपुट आयतों को क्रमबद्ध करना और 2) फिटिंग करते समय दोहराया आकारों को छोड़ देना।

golfed:

#define R r[i]
#define Z return
#define _(B,D,E) for(int B=E;B<D;B++)
struct{int x,y,u,p;}r[25],*S;int A,M,N,U,V,X,Y;char *P;T(x,y,w,h){_(I,x+w,x)_(J,y+h,y)if(I/U|J/V|P[J*U+I])Z 0;Z 1;}L(x,y,w,h,c){_(I,x+w,x)_(J,y+h,y)P[J*U+I]=c;}F(){int x=0,y;while(++x<A)if(!P[x])break;if(x/A){_(i,V,0)printf("%*.*s\n",U,U,P+i*U);exit(0);}y=x/U;x-=y*U;_(i,N,0)if(!R.u&T(x,y,R.x,R.y))R.u=1,L(x,y,R.x,R.y,'A'+i),F(),R.u=0,L(x,y,R.x,R.y,0);}O(i,y){if(!R.u){if(!T(0,y,R.x,R.y))Z;R.u=1;R.p=0;L(0,y,R.x,R.y,'A'+i);y+=R.y;}if(y-V||F())_(j,N,0)if(j-i&!r[j].u){O(j,y);while(r[j].x-r[j+1].x|r[j].y-r[j+1].y)j++;}R.u=0;L(R.p,(y-=R.y),R.x,R.y,0);}Q(i,x){if(!R.u){if(R.x>U-x)Z;R.u=1;R.p=x;L(x,0,R.x,R.y,'A'+i);x+=R.x;}if(x-U||O(i,1))_(j,N,0)if(j-i&!r[j].u)Q(j,x);L(x-=R.x,0,R.x,R.y,0);R.u=0;}C(int*a,int*b){Z*a-*b?*a-*b:a[1]-b[1];}main(){_(i,25,0)if(++N&scanf("%d%d\n",&R.x,&R.y)-2)break;_(i,N,0){A+=R.x*R.y;if(R.x>X)X=R.x;if(R.y>Y)Y=R.y;}_(i,A+1,1)if(!(A%i)){if(i<Y|A/i<X)continue;M++;S=realloc(S,M*16);S[M-1].y=i;S[M-1].x=A/i;}qsort(S,M,16,C);P=calloc(A+1,1);_(j,M,0){U=S[j].x;V=S[j].y;_(i,N,0)R.u=1,L(0,0,R.x,R.y,'A'+i),Q(i,R.x),R.u=0;}printf("0\n");exit(1);}

UnGolfed:

#define R r[i]
#define Z return
#define _(B,D,E) for(int B=E;B<D;B++)
struct {
    int x,y,u,p;
} r[25],*S;
int A,M,N,U,V,X,Y;
char *P;

test_space(x,y,w,h) {
    _(I,x+w,x)
        _(J,y+h,y)
            if (    I >= U |
                    J >= V |
                    P[J*U+I]) Z 0;
    Z 1;
}
place_rect(x,y,w,h,c){
    _(I,x+w,x)
        _(J,y+h,y)P[J*U+I] = c;
}

fill_rest() {
    int x=0,y;
    while(++x<A) if (!P[x])break;
    if (x>=A) {
        _(i,V,0) printf("%*.*s\n", U,U, P+i*U);
        exit(0);
    }
    y = x / U; x -= y*U;

    _(i,N,0)
        if (!R.u & test_space(x, y, R.x, R.y))
                R.u = 1,
                place_rect(x, y, R.x, R.y, 'A'+i),
                fill_rest(),
                R.u = 0,
                place_rect(x, y, R.x, R.y, 0);

}

fill_y(i,y) {
    if (!R.u) {
        if (!test_space(0, y, R.x, R.y)) Z;
        R.u = 1;
        R.p = 0;
        place_rect(0, y, R.x, R.y, 'A'+i);
        y += R.y;
    }
    if (y == V) fill_rest();
    else _(j,N,0)
        if (j!=i && !r[j].u){ fill_y(j, y);
        while (r[j].x^r[j+1].x||r[j].y^r[j+1].y)j++;
        }
    R.u = 0;
    place_rect(R.p, (y -= R.y), R.x, R.y, 0);
}

fill_x(i,x) {
    if (!R.u) {
        if (R.x > U - x) Z;
        R.u = 1;
        R.p = x;
        place_rect(x, 0, R.x, R.y, 'A'+i);
        x += R.x;
    }
    if (x == U) fill_y(i, 1);
    else
        _(j,N,0)
            if (j!=i && !r[j].u) fill_x(j, x);
    place_rect((x -= R.x), 0, R.x, R.y, 0);
    R.u = 0;
}
C(int*a,int*b) {
    Z *a^*b?*a-*b:a[1]-b[1];
}


main() {
    _(i,25,0)
        if (++N&&scanf("%d %d\n", &R.x, &R.y)!=2) break;
    _(i,N,0){
        A+=R.x*R.y;
        if(R.x>X)X=R.x;
        if(R.y>Y)Y=R.y;
    }
    _(i,A+1,1)
        if (!(A%i)) {
            if (i < Y | A/i < X) continue;
            M++;
            S = realloc(S,M*16);
            S[M-1].y=i;
            S[M-1].x=A/i;
        }
    qsort(S, M, 16,C);
    P = calloc(A + 1,1);
    _(j,M,0){
        U = S[j].x; V = S[j].y;
        _(i,N,0)
            R.u = 1,
            place_rect(0, 0, R.x, R.y, 'A'+i),
            fill_x(i, R.x),
            R.u = 0;
    }
    printf("0\n");
    exit(1);
}

स्पष्टीकरण: हम 6 कार्यों: main, O, Q, F, Lऔर T। T टी यह देखने के लिए कि क्या किसी दिए गए स्थान पर आयत के लिए जगह है। Lfil l s आउटपुट बफ़र में एक आयत है या, बारी-बारी से इसे हटाकर एक हटा देता है। Oऔर Qक्रमशः छोड़ दिया और शीर्ष दीवारों का निर्माण, और F च पुनरावृत्ति खोज द्वारा आयत के शेष ills।

हालांकि मूल खोज पुनरावृत्त है, हम मास्टर खोज के लिए चौड़ाई और ऊंचाई के अनुमत संयोजनों के निर्माण और फिर असंभव कॉन्फ़िगरेशन को समाप्त करके, संभव खोज वैक्टरों के विशाल बहुमत को समाप्त करते हैं। केंद्र को भरने से पहले नीचे और सही दीवारों का निर्धारण करके बड़ी आयतों में अतिरिक्त गति प्राप्त की जा सकती है लेकिन 25 आंतरिक आयतों को सीमित करते समय सभ्य गति की आवश्यकता नहीं होती है।

Comments

अच्छी नौकरी! यह कार्य करता प्रतीत होता है ... हालाँकि, क्या आप अपना आउटपुट स्वरूप निर्दिष्ट कर सकते हैं? ऐसा प्रतीत होता है कि अगर यह काम करता है और दुर्घटनाग्रस्त हो रहा है, तो यह मुद्रण सामग्री है, जो कि मैं अनुमति देता हूं, क्योंकि यह एकमात्र उत्तर वैसे भी है। इसके अलावा, आप "हर कोई फिट बैठता है" के बजाय "1" प्रिंट करके काफी कुछ बाइट्स बचा सकता है! (क्योंकि इसकी अनुमति है), और यह भी कि वे कैसे व्यवस्थित हैं, यह नहीं छापकर कुछ बाइट्स। यह अच्छा है कि इसे मुद्रित किया गया है, लेकिन यह अनावश्यक बाइट्स का उपयोग करता है, और इसका उद्देश्य उस पर बचत करना है। नहीं तो अच्छी नौकरी! मैं समय सीमा को आधे महीने तक बढ़ा रहा हूं, लेकिन अभी के लिए, एक उत्थान है। :)

— हाइपरनेट्रिनो 16

धन्यवाद। मैंने प्रारूप को निर्दिष्ट करने के लिए अद्यतन किया और क्रैश को ठीक किया (जो कि अनजाने में था)। मैंने मैट्रिक्स आउटपुट (+ 30bytes) को छोड़ दिया क्योंकि यह निफ्टी है और अगर कोई अन्य व्यक्ति गोल्फ-भाषा समाधान पोस्ट करता है, तो वे सिर्फ 30 :) तक मेरी पिटाई नहीं करेंगे

— सेठ

-367 बाइट्स ... संभवतः सबसे बड़ा गोल्फ? :-)

— हाइपरएनुट्रीनो

:-) खैर, यह एक हैक-वाई शुरुआती बिंदु होने में मदद करता है।

— सेठ

सुनिश्चित करते हैं! मेरे सबसे बड़े गोल्फ में कई एडिट्स पर जावा में 337 अक्षर थे, और मैंने कुछ बहुत ही भयानक विचारों के साथ शुरुआत की (ओह, अच्छे पुराने दिन जब मैं 50 मिलियन चर बनाऊंगा और केवल 2 की आवश्यकता होगी ...)। वैसे भी, मैं जवाबों का इंतजार करता रहूंगा, लेकिन ऐसा लग रहा है कि यह केवल काम करने वाला हो सकता है!

— हाइपरन्यूट्रिनो

Answer 2

हास्केल, 226 बाइट्स

((y,z):l)&(w,x)|x*y<1=(w+y,x+z):l
(q:l)&p=p:q:l
(p@(u,v):r@(y,z):l)%q@(w,x)=[((y-w,z):l)&q&(u,v-x)|w<=y,x<=v]++[p:m|m<-(r:l)%q]
_%_=[]
g m(p:n)l=any(g[]$m++n)(l%p)||g(p:m)n l
g[]_[_,_,_]=0<1
g _[]_=0<0
($[(0,9^9),(9^9,0)]).g[]

Ideone पर इसे आज़माएं

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

यह सभी आंशिक झुकावों की खोज करता है, जिनकी आकृति एक यंग आरेख है , जो एक समय में एक आयत जोड़ते हैं, और यह जांचते हैं कि क्या कोई अंतिम परिणाम आयताकार हैं।

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

Comments

अच्छा है! यह शानदार है। बहुत बढ़िया! :)

— हाइपरएनुट्रीनो