স্থান পূরণের জন্য যথেচ্ছ আয়তক্ষেত্রগুলি সাজানো

এই আয়তক্ষেত্রগুলি কি একটি আয়তক্ষেত্রাকার স্থান পূরণ করতে পারে?

একগুচ্ছ আয়তক্ষেত্র দেওয়া, আপনাকে জিজ্ঞাসা করা হয় যে তারা একটি আয়তক্ষেত্রাকার স্থান পূরণ করার ব্যবস্থা করা যায় কিনা।

চশমা

একগুচ্ছ স্বেচ্ছাসেবী m x nআয়তক্ষেত্র দেওয়া; 0 <= m, n <= 1000, এগুলি সজ্জিত করা সম্ভব কিনা তা নির্ধারণ করুন যাতে তারা কোনও গর্ত বা ওভারল্যাপ ছাড়াই ঠিক একটি আয়তক্ষেত্রাকার অঞ্চলটি কভার করে। আয়তক্ষেত্রগুলি ঘোরানো যায় না এবং প্রতিটি আয়তক্ষেত্র কেবল একবারে স্থাপন করা যেতে পারে।

ইনপুট

এর জন্য ইনপুটটি খুব নমনীয়, যতক্ষণ ইনপুটটি 2-স্পেসের মাত্রাগুলির তালিকা দেয়। উদাহরণস্বরূপ, নিম্নলিখিত উভয়টি বৈধ:

স্পেস দ্বারা পৃথক, ফিরে

মাত্রা তালিকা

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

আউটপুট

সত্য / মিথ্যা, 0/1, টি / এফ, সত্য / মিথ্যা ইত্যাদির মতো যেকোন ধরণের সত্য / মিথ্যা মানগুলি যদি আপনি কোনও আউটপুট পদ্ধতি ব্যবহার করতে যাচ্ছেন যা খুব স্পষ্ট নয়, দয়া করে আপনার উত্তরে উল্লেখ করুন।

উদাহরণ

পরীক্ষার মামলা ১

ইনপুট:

1 1
1 5
2 6

আউটপুট: true(বা অনুরূপ কিছু) এটি
কীভাবে সাজানো যায়:

XYYYYY
ZZZZZZ
ZZZZZZ

পরীক্ষার মামলা 2

ইনপুট:

1 1
2 2

আউটপুট: false(বা অনুরূপ কিছু)
ব্যাখ্যা: এটি স্পষ্ট হয়ে যায় যে আপনি বিভিন্ন আকারের দুটি স্কোয়ারের ব্যবস্থা করতে পারবেন না এবং তাদের প্রান্তগুলি সারিবদ্ধ করতে পারবেন না।

পরীক্ষার মামলা 3

ইনপুট:

আউটপুট: true(বা অনুরূপ কিছু) এটি কীভাবে সাজানো যায়:

AAB
DEB
DCC

@ETHProductions যেমন নির্দেশ করেছে, অন্য সমস্ত পরীক্ষার ক্ষেত্রে, আপনার কেবলমাত্র একটি আয়তক্ষেত্র না হওয়া পর্যন্ত আপনি একটি সাধারণ প্রান্ত দৈর্ঘ্যের সাথে আয়তক্ষেত্রগুলির সংমিশ্রণ রাখতে পারেন, সুতরাং এই পরীক্ষার কেসটি এই ধারণাটি ব্যবহার করে এমন কোনও কোড ভাঙার জন্য।

টেস্ট কেস 4

ইনপুট:

আউটপুট: true(বা অনুরূপ কিছু) এটি
কীভাবে সাজানো যায়:

AAABBBBEE
AAACCDDDD
FFFFFGGGH
FFFFFGGGH
IIIJJKKLH
IIIMMMMMH

দ্রষ্টব্য : এটি কীভাবে সজ্জিত করা যায় তা আপনাকে জানানোর দরকার নেই, আপনাকে কেবল এটি সাজানো যায় কিনা তা নির্ধারণ করতে হবে।

এটি কোড গল্ফ, তাই বাইটের মধ্যে সংক্ষিপ্ত উত্তর! আমি 14 ই জানুয়ারী হিসাবে সংক্ষিপ্ত উত্তরটি গ্রহণ করব, তবে এর চেয়ে উত্তরগুলি নির্দ্বিধায় বোধ করতে পারছি যেহেতু আমি এখনও আপত্তি জানাতে পারি! :)

শুভ গল্ফিং!

~ AL

পিএস যদি আপনি জানেন যে এই সমস্যায় কোন ট্যাগ প্রয়োগ করা উচিত, দয়া করে এটি যুক্ত করুন, কোড-গল্ফ ব্যতীত কোনও ট্যাগ হিসাবে কী রাখবেন তা সম্পর্কে আমার কোনও ধারণা নেই।

সম্পাদনা : আপনার প্রোগ্রামটি একটি শালীন কম্পিউটারে সর্বাধিক 10 সেকেন্ডে 25 টি আয়তক্ষেত্র পর্যন্ত প্রক্রিয়া করতে সক্ষম হওয়া উচিত (আমি এই নিয়মটিতে বেশ নমনীয় হব)।

সম্পাদনা : আমি জমা গ্রহণের সময়সীমা বছরের শেষ দিন পর্যন্ত প্রসারিত করেছি, তবে আমি সন্দেহ করি ততক্ষণে আমি একটি উত্তর পেয়ে যাব ...

সম্পাদনা : আমি সাবমিশন গ্রহণের সময়সীমা ২ সপ্তাহ বাড়িয়েছি, সুতরাং যদি এর মধ্যে আরও উত্তর না আসে তবে বর্তমান সি উত্তর গৃহীত হবে! :)

— HyperNeutrino
সূত্র

আমি কি প্রতিটি ইনপুট আয়তক্ষেত্রটি একবার ব্যবহার করতে পারি?

— xnor

কেন একটি সময়সীমা আছে? আপনি বলতে পারেন যে আপনি সেই সময়ে একটি উত্তর গ্রহণ করবেন, তবে চ্যালেঞ্জগুলি অনির্দিষ্টকালের জন্য উন্মুক্ত হওয়া উচিত :)

— নাথান মেরিল

আয়তক্ষেত্রগুলি ঘোরানো যায়?

— xnor

ঠিক আছে, আপনার সমস্যাটি একটি ক্ষয়িষ্ণু সমস্যা: "এই ওরিয়েন্টেড আয়তক্ষেত্রগুলিকে 0 টি বর্জ্য দিয়ে অন্য একটি আয়তক্ষেত্র গঠনের ব্যবস্থা করা যেতে পারে", এটি এনপি-সম্পূর্ণ সমস্যা ( করফ , 2003: pdfs.semanticscholar.org/90a5/… )। কার্ফের অ্যালগরিদম মূলত কিছু সমাধানের সাথে কনফিগারেশনগুলি আরও দক্ষতার সাথে মুছে ফেলার জন্য কিছু অপ্টিমাইজেশন সহ একটি জোর-শক্তি। আমি সন্দেহ করি এর একটি গল্ফ বেশিরভাগ ভাষায় 250 টি অক্ষরের নীচে below

— গ্যাব্রিয়েল বেনামি

সহজ রুটটি হ'ল এটি নির্ধারণ করা হবে যে আপনি 1 টি আয়তক্ষেত্র বাম না হওয়া পর্যন্ত আপনি বার বার একই প্রস্থ বা উচ্চতার দুটি আয়তক্ষেত্র একত্রিত করতে পারেন কিনা। এই অ্যালগরিদম বর্তমান টেস্টকেসের সমস্তটির জন্য কাজ করে; তবে এটি ব্যর্থ হয় [[1, 2], [2, 1], [1, 1], [1, 2], [2, 1]](যা সাজানো যায় ABB ACD EED)। আপনি এই সাধারণ পরীক্ষার কেসটি যুক্ত করতে চাইতে পারেন।

— ইটিএইচ প্রোডাকশনস

উত্তর:

সি, 1135 1158 1231 1598 বাইট

ঠিক আছে, এটি নির্ধারিত সময়সীমার অতীত হয়েছে, তবে কীভাবে এখনও কোনও উত্তর নেই তা দেখে, এখানে সি-তে একটি (কিছুটা দীর্ঘ) রয়েছে's

রিটার্নস:

0 (শূন্য) ব্যর্থতার (ফিট না)
সাফল্যের উপর সম্পূর্ণ ফিটিং ম্যাট্রিক্স

হালনাগাদ:

মুল কোডটি কিছু ম্যাট্রিকগুলিতে আটকে যেতে পারে, অনুমোদিত 10 এর চেয়ে বেশি সময় নেয়। বর্তমানের পুনর্বিবেচনায় 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 ঠ আউটপুট বাফারের মধ্যে একটি আয়তক্ষেত্র গুলি বা, অথবা এটি মুছে একে সরিয়ে ফেলা হয়। Oএবং Qযথাক্রমে বাম এবং শীর্ষ প্রাচীরগুলো আবার গড়ে তুলবে এবং F চ পুনরাবৃত্ত অনুসন্ধানে আয়তক্ষেত্র বাকি দুর্ভাগ্য।

যদিও মূল অনুসন্ধানটি পুনরাবৃত্তিযোগ্য, আমরা প্রথমে মাস্টার আয়তক্ষেত্রের জন্য প্রস্থ এবং উচ্চতার অনুমোদিত সংমিশ্রণগুলি তৈরি করে এবং তারপরে অসম্ভব কনফিগারেশনগুলি মুছে ফেলার মাধ্যমে সম্ভাব্য সন্ধানের বিশাল সংখ্যককে অপসারণ করি। কেন্দ্রটি পূরণের পূর্বে নীচের এবং ডান দেয়ালগুলি নির্ধারণ করে বৃহত আয়তক্ষেত্রগুলিতে অতিরিক্ত গতি অর্জন করা যেতে পারে তবে 25 অভ্যন্তরের আয়তক্ষেত্রগুলিকে সীমাবদ্ধ করার সময় শালীন গতির জন্য এটির প্রয়োজন হয় না।

— শেঠ
সূত্র

সুন্দর কাজ! এটি কাজ করছে বলে মনে হচ্ছে ... তবে, আপনি কি নিজের আউটপুট ফর্ম্যাটটি নির্দিষ্ট করতে পারবেন? এটি প্রদর্শিত হয় যে এটি কাজ করে যদি এটি মুদ্রণ করে এবং যদি এটি না ঘটে তবে ক্র্যাশ হয়, যা আমি অনুমতি দেব কারণ এটি যাইহোক একমাত্র উত্তর। এছাড়াও, "প্রত্যেকের ফিট!" এর পরিবর্তে "1" মুদ্রণ করে আপনি বেশ কয়েকটি বাইট সংরক্ষণ করতে পারেন! (কারণ এটি অনুমোদিত) এবং এগুলি কীভাবে সাজানো হয়েছে তা মুদ্রণ না করে বেশ কয়েকটি বাইট এটি মুদ্রিত হওয়া ভাল, তবে এটি অপ্রয়োজনীয় বাইট ব্যবহার করে এবং উদ্দেশ্যটি এটি সংরক্ষণ করা। অন্যথায়, ভাল কাজ! আমি সময়সীমাটি অর্ধ মাস বাড়িয়ে দিচ্ছি, তবে আপাতত একটি উত্সাহ দেওয়া উচিত। :)

— হাইপারনিউটারিনো

ধন্যবাদ। আমি ফর্ম্যাটটি নির্দিষ্ট করতে আপডেট করেছি এবং ক্রাশটি ঠিক করেছিলাম (তা অনিচ্ছাকৃত ছিল)। আমি ম্যাট্রিক্স আউটপুট (+ 30 বাইটস) রেখেছি কারণ এটি নিফটি এবং অন্য কেউ যদি গল্ফ-ভাষা সমাধান পোস্ট করে তবে তারা কেবল 30 দ্বারা আমাকে মারবে না

— শেঠ

-367 বাইট ... সম্ভবত সবচেয়ে বড় গল্ফ? :-)

— হাইপার নিউট্রিনো

:-) ঠিক আছে, এটি হ্যাক-ওয়াই পয়েন্ট করতে সহায়তা করে।

— শেঠ

অবশ্যই! আমার বৃহত্তম গল্ফটি বেশ কয়েকটি সম্পাদনার সময়ে জাভাতে 337 অক্ষর ছিল এবং আমি বেশ কয়েকটি ভয়ঙ্কর ধারণার সাথে শুরু করেছিলাম (ওহ, খুব ভাল দিনগুলি যখন আমি 50 মিলিয়ন ভেরিয়েবল তৈরি করব এবং কেবল 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[]

আইডিয়নে চেষ্টা করে দেখুন

কিভাবে এটা কাজ করে

এটি পুনরাবৃত্তভাবে সমস্ত আংশিক টিলিংয়ের সন্ধান করে যার আকারটি একটি ইয়ং ডায়াগ্রাম , একবারে একটি আয়তক্ষেত্র যুক্ত করে এবং চূড়ান্ত ফলাফলগুলির কোনও আয়তক্ষেত্র কিনা তা পরীক্ষা করে।

যে কোনও আয়তক্ষেত্রের টাইলিংটি এভাবে নির্মিত যেতে পারে তা দেখতে: কোনও অল্প বয়স্ক ইয়ং ডায়াগ্রামের যেকোন টাইলিংয়ে আর এর দক্ষিণ-পশ্চিম কোণটি অন্য কোনও আয়তক্ষেত্রের স্পর্শ না করে এমন টাইলিংয়ের আয়তক্ষেত্রগুলির সেট হয়ে উঠুক। যেহেতু ইয়ং ডায়াগ্রামের প্রতিটি অবতল প্রান্তটি R এর সর্বাধিক একটি আয়তক্ষেত্রের সাথে সংলগ্ন (নিছক কোণে-সংলগ্ন নয়), এবং এই অবতল কোণের সংখ্যাটি আর-তে আয়তক্ষেত্রের সংখ্যার চেয়ে কম, সুতরাং অবশ্যই কমপক্ষে থাকতে হবে আর এর একটি আয়তক্ষেত্র যা এই অবতল কোণে কোনওটির সাথে প্রান্ত-সংলগ্ন। এটিকে সরিয়ে ফেলার ফলে আরও একটি তরুণ চিত্র পাওয়া যায়, তাই আমরা অন্তর্ভুক্তিতে এগিয়ে যেতে পারি।

— অ্যান্ডারস ক্যাসরগ
সূত্র

সুন্দর! এটি চমৎকার. ভাল করেছ! :)

— হাইপারনিউটারিনো