द्वीपों का नक्शा (और एक नदी)

20

परिचय

कई शताब्दियों तक, एक निश्चित नदी रही है जो कभी भी मैप नहीं की गई है। गिल्ड ऑफ कार्टोग्राफर नदी के नक्शे का निर्माण करना चाहते हैं, हालांकि, वे कभी भी सफल नहीं हो पाए हैं - किसी कारण से, नदी के नक्शे पर भेजे जाने वाले सभी मानचित्रकारों को क्षेत्र में जंगली जानवरों द्वारा खाया गया है। एक अलग दृष्टिकोण की आवश्यकता है।

इनपुट विवरण

क्षेत्र लंबाई mऔर चौड़ाई की कोशिकाओं का एक आयताकार ग्रिड है n। नीचे बाईं ओर कक्ष होगा 0,0, और ऊपर दाईं ओर कक्ष होगा m-1,n-1। mऔर nइनपुट में एक टपल के रूप में प्रदान किया जाता है m,n।

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

7,7 2,0,0 2,3,1 2,6,1 2,4,3 2,2,4 8,0,6 1,2,6 3,4,6

अधिक स्पष्ट रूप से समझाने के लिए, यहाँ एक ग्राफ पर इनपुट है:

 y 6|8 1 3
   5|
   4|  2
   3|    2
   2|
   1|   2  2
   0|2  
     =======
     0123456
     x

आउटपुट विवरण

क्षेत्र के भागों का प्रतिनिधित्व करने के लिए ASCII वर्णों का उपयोग करके एक मानचित्र का उत्पादन करें प्रत्येक कोशिका या तो #(भूमि) या .(जल) होगी। मानचित्र को इन नियमों का पालन करना चाहिए:

  1. परिभाषा। एक द्वीप भूमि कोशिकाओं का एक orthogonally सन्निहित समूह है जो पूरी तरह से नदी की कोशिकाओं और / या क्षेत्र की सीमा से घिरा है।
  2. परिभाषा। एक नदी पानी की कोशिकाओं का एक orthogonally सन्निहित समूह है जो पूरी तरह से भूमि कोशिकाओं और / या क्षेत्र की सीमा से घिरा हुआ है, और इसमें "झीलें" (2x2 जल क्षेत्र) शामिल नहीं हैं।
  3. नियम । नक्शे में ठीक एक नदी होगी।
  4. नियम । इनपुट में प्रत्येक क्रमांकित सेल एक द्वीप का हिस्सा होगा जिसमें बिल्कुल sकोशिकाएं होंगी ।
  5. नियम । मानचित्र के प्रत्येक द्वीप में इनपुट में गिने कोशिकाओं में से एक होगा।
  6. नियम । हर इनपुट के लिए एक ही अनोखा नक्शा मौजूद है।

यहाँ उदाहरण इनपुट का आउटपुट है:

#.#.##.
#....#.
#.##...
##..##.
###....
...##.#
##....#

यहाँ एक और इनपुट और आउटपुट है।

इनपुट:

5,5 3,0,1 1,4,1 2,0,4 2,2,4 2,4,4

आउटपुट:

#.#.#
#.#.#
.....
###.#
.....
code-golf  graph-theory 
— चिरायता
स्रोत
3
नोट: यह एक नूरिकेबे सॉल्वर के समान प्रश्न है ।
— अनुपम
1
क्या हम किसी भी सुविधाजनक प्रारूप में इनपुट ले सकते हैं, या हमें प्रश्न में एक से रहना चाहिए?
— आउटगोल्फ
1
— ngn
@ng कब से "पोस्ट क्रिप्टोग्राफिक हैश" है ... हमेशा की तरह? (लेकिन मुझे लगता है कि यह अनुमति दी जाती है जब एक चुनौती स्पष्ट रूप से अनुमति देती है)
— user202729
1
यहां पहेली-nurikabe.com के लिए एक बुकमार्कलेट है - यह वर्तमान पहेली को इस चुनौती के लिए एक वैध इनपुट में परिवर्तित करता है और बोर्ड के ठीक नीचे लाल रंग में दिखाता है:javascript:(_=>{var t=Game.nurikabe().task,m=t.length,n=t[0].length,s=[m,n];for(var i=0;i<m;i++)for(var j=0;j<n;j++)if(t[i][j]>=0)s+=' '+[t[i][j],i,j];puzzleContainerDiv.insertAdjacentHTML('beforeend','<hr><tt style=color:red>'+s+'</tt><hr>')})();void(0)
— ngn

जवाबों:

10

सी + पिकोसेट , 2345 995 952 बाइट्स

#include<picosat.h>
#define f(i,a)for(i=a;i;i--)
#define g(a)picosat_add(E,a)
#define b calloc(z+1,sizeof z)
#define e(a,q)if(a)A[q]^A[p]?l[q]++||(j[++k]=q):s[q]||(i[q]=p,u(q));
z,F,v,k,n,h,p,q,r,C,*x,*A,*i,*l,*s,*j,*m;u(p){s[m[++n]=p]=1;e(p%F-1,p-1)e(p%F,p+1)e(p>F,p-F)e(p<=F*v-F,p+F)}t(){f(q,k)l[j[q]]=0;f(q,n)s[m[q]]=0;k=n=0;i[p]=-1;u(p);}main(){void*E=picosat_init();if(scanf("%d,%d",&F,&v)-2)abort();z=F*v;for(x=b;scanf("%d,%d,%d",&r,&p,&q)==3;g(p),g(0))x[p=F-p+q*F]=r;f(p,F*v-F)if(p%F)g(p),g(p+1),g(p+F),g(p+F+1),g(0);for(A=b,i=b,l=b,s=b,j=b,m=b;!C;){picosat_sat(E,C=h=-1);f(p,F*v)A[p]=picosat_deref(E,p)>0,i[p]=0;f(p,F*v)if(x[p])if(i[q=p]){for(g(-q);i[q]+1;)q=i[q],g(-q);g(C=0);}else if(t(),r=n-x[p]){f(q,r<0?k:n)g(r<0?j[q]:-m[q]);g(C=0);}f(p,F*v)if(!i[p])if(t(),A[p]){g(-++z);f(q,k)g(j[q]);g(C=0);f(q,n)g(-m[q]),g(z),g(0);}else{C&=h++;f(q,k)g(-j[q]);g(++z);g(++z);g(0);f(q,F*v)g(s[q]-z),g(q),g(0);}}f(p,F*v)putchar(A[p]?35:46),p%F-1||puts("");}

इसे ऑनलाइन आज़माएं!

(चेतावनी: यह TIO लिंक एक 30 किलोबाइट URL है जिसमें PicoSAT 965 की एक छोटी प्रतिलिपि शामिल है, इसलिए आप इसे कुछ ब्राउज़रों में लोड करने में सक्षम नहीं हो सकते हैं, लेकिन यह कम से कम फ़ायरफ़ॉक्स और क्रोम में लोड होता है।)

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

हम प्रत्येक सेल (भूमि या पानी) के लिए एक चर के साथ सैट सॉल्वर को आरंभीकृत करते हैं, और केवल निम्नलिखित बाधाएं हैं:

  1. हर नंबर सेल जमीन है।
  2. प्रत्येक 2 × 2 आयत में कम से कम एक भूमि होती है।

बाकी बाधाओं को सीधे SAT में एनकोड करना मुश्किल है, इसलिए हम मॉडल प्राप्त करने के लिए सॉल्वर चलाते हैं, इस मॉडल के जुड़े क्षेत्रों को खोजने के लिए गहराई-पहली खोजों का एक क्रम चलाते हैं, और अतिरिक्त बाधाओं को इस प्रकार जोड़ते हैं:

  1. किसी भूमि क्षेत्र के प्रत्येक गिने हुए सेल के लिए जो बहुत बड़ा है, उस क्षेत्र में वर्तमान भूमि कोशिकाओं के बीच कम से कम एक जल कोशिका होनी चाहिए।
  2. किसी भूमि क्षेत्र के प्रत्येक गिने हुए सेल के लिए जो बहुत छोटा है, उस क्षेत्र में सीमावर्ती वर्तमान जल कोशिकाओं के बीच कम से कम एक भूमि सेल होना चाहिए।
  3. दूसरे नंबर की सेल के रूप में एक ही भूमि क्षेत्र में प्रत्येक गिने हुए सेल के लिए, एक बाधा जोड़ें कि उनके बीच वर्तमान भूमि कोशिकाओं के रास्ते में कम से कम एक पानी का सेल होना चाहिए (गहराई-पहली खोज से बचे हुए मूल बिंदुओं को चलते हुए पाया गया) )।
  4. बिना नंबर वाली कोशिकाओं सहित प्रत्येक भूमि क्षेत्र के लिए, या तो बाधाओं को जोड़ें
    • उन सभी वर्तमान भूमि कोशिकाओं में पानी होना चाहिए, या
    • उस क्षेत्र की सीमा वाली वर्तमान जल कोशिकाओं में से कम से कम एक भूमि होनी चाहिए।
  5. हर जल क्षेत्र के लिए, या तो बाधाओं को जोड़ें
    • उन सभी वर्तमान जल कोशिकाओं को भूमि होना चाहिए, या
    • उन वर्तमान जल कोशिकाओं के अलावा प्रत्येक कोशिका भूमि, या होनी चाहिए
    • उस क्षेत्र की सीमा वाली वर्तमान भूमि कोशिकाओं में से कम से कम एक पानी होनी चाहिए।

पिकोसेट लाइब्रेरी में वृद्धिशील इंटरफ़ेस का लाभ उठाते हुए, हम तुरंत सॉल्वर द्वारा जोड़े गए सभी अवरोधों को संरक्षित करते हुए, जोड़ा बाधाओं को हल कर सकते हैं। PicoSAT हमें एक नया मॉडल देता है, और हम उपरोक्त चरणों को तब तक जारी रखते हैं जब तक कि समाधान मान्य न हो।

यह उल्लेखनीय रूप से प्रभावी है; यह एक सेकंड के छोटे से हिस्से में 15 × 15 और 20 × 20 उदाहरणों को हल करता है।

( लोप्सी को धन्यवाद वृद्धिशील सैट सॉल्वर में कुछ समय पहले जुड़े क्षेत्रों को परस्पर जोड़ने के इस विचार के सुझाव कुछ समय पहले।)

से कुछ बड़े परीक्षण के मामले Puzzle-nurikabe.com

15 × 15 कठिन पहेलियों का एक यादृच्छिक पृष्ठ ( 5057541 , 5122197 , 5383030 , 6275294 , 6646970 , 6944232 ):

15,15 1,5,1 3,9,1 5,4,2 1,6,2 2,11,2 2,2,3 3,9,3 2,4,4 1,10,4 5,12,4 3,1,5 1,3,5 3,8,5 1,13,5 5,5,6 1,12,6 1,2,8 2,9,8 1,1,9 2,6,9 6,11,9 3,13,9 5,2,10 2,4,10 4,10,10 1,5,11 2,12,11 2,3,12 2,8,12 5,10,12 1,5,13 1,9,13 1,6,14 1,8,14
15,15 4,2,0 2,5,0 1,3,1 2,14,2 1,3,3 2,11,3 1,13,3 1,5,4 11,7,4 1,9,4 1,4,5 1,8,5 2,10,5 12,14,5 3,5,6 1,4,7 2,10,7 3,9,8 4,0,9 1,4,9 1,6,9 3,10,9 1,5,10 1,7,10 8,9,10 1,1,11 10,3,11 2,11,11 6,0,12 1,11,13 2,9,14 1,12,14
15,15 2,2,0 8,10,0 2,3,1 2,14,2 2,3,3 3,5,3 3,9,3 2,11,3 5,13,3 6,0,4 3,7,4 3,3,5 2,11,5 2,6,6 1,8,6 1,4,7 2,10,7 1,6,8 2,8,8 5,3,9 2,11,9 2,7,10 7,14,10 2,1,11 4,3,11 2,5,11 1,9,11 2,11,11 2,0,12 4,6,13 1,11,13 3,4,14 1,12,14
15,15 2,0,0 2,4,0 3,6,1 2,10,1 1,13,1 2,5,2 2,12,2 3,0,3 2,2,3 4,7,3 2,9,3 1,14,3 1,4,4 1,8,4 2,12,5 4,2,6 3,4,6 1,14,6 7,7,7 1,10,8 2,12,8 3,2,9 2,14,9 2,0,10 2,6,10 1,10,10 2,5,11 4,7,11 2,12,11 1,14,11 3,2,12 3,9,12 1,1,13 2,4,13 3,8,13 2,10,14 5,14,14
15,15 1,3,0 1,14,0 3,7,1 3,10,1 2,13,1 3,1,2 4,5,2 2,12,3 3,3,4 1,8,4 1,1,5 3,5,5 1,9,5 5,13,5 3,3,6 1,8,6 2,2,7 2,12,7 1,6,8 1,8,8 2,11,8 2,1,9 4,5,9 2,9,9 2,13,9 2,6,10 4,11,10 1,2,11 3,9,12 2,13,12 3,1,13 2,4,13 3,7,13 1,0,14
15,15 2,8,0 2,4,1 2,7,1 1,10,1 6,4,3 1,1,4 12,5,4 3,11,4 5,13,4 3,10,5 3,0,6 1,6,6 2,8,6 4,13,7 2,3,8 1,6,8 3,8,8 2,14,8 2,4,9 5,1,10 4,3,10 1,9,10 6,13,10 3,8,11 1,10,11 3,4,13 2,7,13 3,10,13 1,6,14 1,14,14

20 × 20 सामान्य पहेलियों का एक यादृच्छिक पृष्ठ ( 536628 , 3757659 ):

20,20 1,0,0 3,2,0 2,6,0 1,13,0 3,9,1 3,15,1 2,7,2 3,13,2 3,0,3 2,3,3 3,18,3 3,5,4 2,9,4 2,11,4 2,16,4 1,0,5 2,7,5 1,10,5 1,19,5 3,2,6 1,11,6 2,17,6 2,0,7 3,4,7 5,6,7 2,9,7 4,13,7 3,15,7 1,3,8 1,10,8 1,14,9 2,18,9 3,1,10 2,4,10 1,8,10 1,10,10 3,12,10 3,16,10 1,9,11 1,17,11 2,19,11 2,0,12 2,2,12 1,4,12 4,6,12 2,13,12 2,15,12 1,14,13 2,17,13 1,3,14 2,5,14 4,7,14 2,15,14 3,0,15 1,2,15 2,13,15 3,18,15 3,7,16 7,10,16 1,17,16 2,0,17 2,3,17 2,5,17 3,11,17 3,15,17 1,0,19 1,2,19 1,4,19 2,6,19 5,8,19 1,11,19 1,13,19 3,15,19 2,18,19
20,20 1,0,0 1,4,0 5,8,0 1,17,0 1,19,0 2,17,2 3,6,3 2,10,3 2,12,3 4,14,3 6,0,4 3,4,4 4,7,4 1,11,4 1,18,4 1,6,5 3,12,5 4,15,5 4,4,6 2,16,6 2,19,6 6,0,7 3,10,7 2,12,8 2,17,8 3,3,9 2,5,9 4,8,9 2,10,9 3,0,10 1,2,10 5,14,10 2,16,10 2,19,10 7,7,11 3,12,12 2,17,12 2,2,13 4,4,13 3,6,13 4,14,13 3,0,14 1,3,14 1,5,14 3,16,14 1,2,15 1,9,15 2,11,15 5,13,15 3,19,15 1,4,16 3,6,16 1,3,17 1,12,17 1,14,17 1,16,17 6,0,19 2,2,19 3,5,19 2,7,19 5,9,19 1,11,19 2,13,19 1,15,19 4,17,19
— एंडर्स कसीगोर
स्रोत
3

GLPK , (गैर-प्रतिस्पर्धात्मक) 2197 बाइट्स

यह एक गैर-प्रतिस्पर्धी प्रविष्टि है, जैसा कि

  • मैं इनपुट डेटा प्रारूप का पालन नहीं करता हूं (चूंकि GLPK केवल फाइलों से इनपुट डेटा पढ़ सकता है) और
  • लगता है GLPK RIO पर उपलब्ध नहीं है।

मैं यहाँ अभी भी एक ungolfed, अभी तक कार्यात्मक संस्करण बचा सकता हूँ। प्रतिक्रिया के आधार पर, मैं इसे छोटा करने की कोशिश कर सकता हूं। अब तक, बाधा नाम इन-प्लेस डॉक्स के रूप में काम करते हैं।

मुख्य विचार "संरक्षित द्वीपों" की बाधा को एक संरक्षित प्रवाह चर को पेश करके सांकेतिक शब्दों में बदलना है, जो संकेत स्थान पर पूर्व-निर्दिष्ट स्रोत है। निर्णय चर is_islandतब अपराजेय डूब की भूमिका निभाता है। इस प्रवाह के कुल योग को कम करके, द्वीपों को इष्टतम में जुड़े रहने के लिए मजबूर किया जाता है। अन्य बाधाएं सीधे विभिन्न नियमों को लागू करती हैं। मुझे कौन सी पहेलियां हैं जिनकी मुझे अभी भी जरूरत है island_fields_have_at_least_one_neighbor।

इस सूत्रीकरण का प्रदर्शन महान नहीं है, हालाँकि। बड़ी मात्रा में बाधाओं के साथ सभी जटिलता को सीधे खाने से, सॉल्वर 15 x 15 उदाहरण के लिए 15 सेकंड के करीब लेता है।

कोड (अभी भी अपुष्ट)

# SETS
param M > 0, integer; # length
param N > 0, integer; # width
param P > 0, integer; # no. of islands

set X := 0..N-1;  # set of x coords
set Y := 0..M-1;  # set of y coords
set Z := 0..P-1;  # set of islands

set V := X cross Y;
set E within V cross V := setof{
  (sx, sy) in V, (tx, ty) in V :

  ((abs(sx - tx) = 1) and (sy = ty)) or 
  ((sx = tx) and (abs(sy - ty) = 1))
} 
  (sx, sy, tx, ty);


# PARAMETERS
param islands{x in X, y in Y, z in Z}, integer, default 0;
param island_area{z in Z} := sum{x in X, y in Y} islands[x, y, z];

# VARIABLES
var is_river{x in X, y in Y}, binary;
var is_island{x in X, y in Y, z in Z}, binary;
var flow{(sx, sy, tx, ty) in E, z in Z} >= 0;

# OBJECTIVE
minimize obj: sum{(sx, sy, tx, ty) in E, z in Z} flow[sx, sy, tx, ty, z];

# CONSTRAINTS
s.t. islands_are_connected{(x, y) in V, z in Z}:

    islands[x, y, z] 
  - is_island[x, y, z]
  + sum{(sx, sy, tx, ty) in E: x = tx and y = ty} flow[sx, sy, x, y, z]
  - sum{(sx, sy, tx, ty) in E: x = sx and y = sy} flow[x, y, tx, ty, z]
  = 0;


s.t. island_contains_hint_location{(x, y) in V, z in Z}:

    is_island[x, y, z] >= if islands[x, y, z] > 0 then 1 else 0;


s.t. each_square_is_river_or_island{(x, y) in V}:

    is_river[x, y] + sum{z in Z} is_island[x, y, z] = 1;


s.t. islands_match_hint_area{z in Z}:

    sum{(x, y) in V} is_island[x, y, z] = island_area[z];


s.t. river_has_no_lakes{(x,y) in V: x > 0 and y > 0}:

  3 >= is_river[x, y] + is_river[x - 1, y - 1]
     + is_river[x - 1, y] + is_river[x, y - 1];


s.t. river_squares_have_at_least_one_neighbor{(x, y) in V}:

    sum{(sx, sy, tx, ty) in E: x = tx and y = ty} is_river[sx, sy] 
 >= is_river[x, y];


s.t. island_fields_have_at_least_one_neighbor{(x, y) in V, z in Z: island_area[z] > 1}:

    sum{(sx, sy, tx, ty) in E: x = tx and y = ty} is_island[sx, sy, z]
 >= is_island[x, y, z];


s.t. islands_are_separated_by_water{(x, y) in V, z in Z}:

    sum{(sx, sy, tx, ty) in E, oz in Z: x = sx and y = sy and z != oz} is_island[tx, ty, oz]
 <= 4 * P * (1 - is_island[x, y, z]);

solve;

for{y in M-1..0 by -1}
{
    for {x in X} 
    {
        printf "%s", if is_river[x, y] = 1 then "." else "#";
    }
    printf "\n";
}

समस्या डेटा

५ x ५

data;
param M := 5;
param N := 5;
param P := 5;
param islands :=
# x,y,z,area
  0,1,0,3
  4,1,1,1
  0,4,2,2
  2,4,3,2
  4,4,4,2;
end;

X 7

data;
param M := 7;
param N := 7;
param P := 8;
param islands :=
# x,y,z,area
  0,0,0,2 
  3,1,1,2 
  6,1,2,2 
  4,3,3,2 
  2,4,4,2 
  0,6,5,8 
  2,6,6,1 
  4,6,7,3;
end;

15 x 15

data;
param M := 15;
param N := 15;
param P := 34;
param islands :=
# x,y,   z,area
5,  1,   0, 1
9,  1,   1, 3
4,  2,   2, 5
6,  2,   3, 1
11, 2,   4, 2
2,  3,   5, 2
9,  3,   6, 3
4,  4,   7, 2
10, 4,   8, 1
12, 4,   9, 5
1,  5,  10, 3
3,  5,  11, 1
8,  5,  12, 3
13, 5,  13, 1
5,  6,  14, 5
12, 6,  15, 1
2,  8,  16, 1
9,  8,  17, 2
1,  9,  18, 1
6,  9,  19, 2
11, 9,  20, 6
13, 9,  21, 3
2,  10, 22, 5
4,  10, 23, 2
10, 10, 24, 4
5,  11, 25, 1
12, 11, 26, 2
3,  12, 27, 2
8,  12, 28, 2
10, 12, 29, 5
5,  13, 30, 1
9,  13, 31, 1
6,  14, 32, 1
8,  14  33, 1;
end;

प्रयोग

है glpsolएक फ़ाइल (जैसे के रूप में स्थापित किया है, मॉडल river.mod), अलग फाइल (रों) (जैसे में इनपुट डेटा 7x7.mod)। फिर:

glpsol -m river.mod -d 7x7.mod

यह प्लस कुछ धैर्य निर्दिष्ट आउटपुट प्रारूप ("कुछ" नैदानिक ​​आउटपुट के साथ) में समाधान प्रिंट करेगा।

— ojdo
स्रोत
2
मुझे लगता है कि इस जवाब को प्रतिस्पर्धा माना जाना चाहिए क्योंकि अन्य लोगों के लिए यह सत्यापित करना संभव है कि यह काम करता है। IO प्रारूप के अंतर को इस धारणा के द्वारा कवर किया जाना चाहिए कि किसी भी उचित IO प्रारूप को स्वीकार किया जाना चाहिए।
— f --n 21tɪk
2
@ f @nəˈtɪk सहमत। यह ngn के इनाम के लिए योग्य नहीं था कि बस समाप्त हो गया, जिसे विशेष रूप से TIO पर जवाब देने योग्य जवाब की आवश्यकता थी, लेकिन यह स्वयं प्रश्न की आवश्यकता नहीं है।
— एंडर्स कासोर्ग
यह देखते हुए कि मैंने इसे गोल्फ शुरू नहीं किया है, मैं इसे प्रतिस्पर्धा (अभी तक) नहीं मानूंगा। एक बार मुझे यकीन है कि मैंने सभी अनावश्यक बाधाओं को दूर कर दिया है, मैं सभी घोषणाओं को एक-चार कर दूँगा।
— ओजडो
3

पायथन 3 , 1295 बाइट्स

यह एक अजगर केवल समाधान है। यह कोई पुस्तकालयों का उपयोग नहीं करता है और मानक इनपुट के माध्यम से बोर्ड को लोड करता है। आगे की व्याख्या। इतने बड़े गोल्फ में यह मेरा पहला प्रयास है। नीचे टिप्पणी की गई और कोई नहीं-गोल्फ कोड का एक लिंक है। 

L,S,O,R,F=len,set,None,range,frozenset
U,N,J,D,I=S.update,F.union,F.isdisjoint,F.difference,F.intersection
def r(n,a,c):
 U(c,P)
 if L(I(N(Q[n],C[n]),a))<2:return 1
 w=D(P,N(a,[n]));e=S();u=S([next(iter(w))])
 while u:n=I(Q[u.pop()],w);U(u,D(n,e));U(e,n)
 return L(e)==L(w)
def T(a,o,i,c,k):
 s,p,m=a
 for _ in o:
  t=s,p,N(m,[_]);e=D(o,[_])
  if t[2] in c:o=e;continue
  c.add(t[2]);n=D(Q[_],m);U(k,n)
  if not J(i,n)or not r(_,N(m,i),k):o=e
  elif s==L(t[2]):yield t
  else:yield from T(t,N(e,n),i,c,k)
s,*p=input().split()
X,Y=eval(s)
A=[]
l=1,-1,0,0
P=F((x,y)for y in R(Y)for x in R(X))
exec("Q%sl,l[::-1]%s;C%s(1,1,-1,-1),l[:2]*2%s"%(('={(x,y):F((x+i,y+j)for i,j in zip(',')if X>x+i>-1<y+j<Y)for x,y in P}')*2))
for a in p:a,x,y=eval(a);k=x,y;A+=[(a,k,F([k]))]
A.sort(reverse=1)
k=F(a[1]for a in A)
p=[O]*L([a for a in A if a[0]!=1])
g,h=p[:],p[:]
i=0
while 1:
 if g[i]is O:h[i]=S();f=O;g[i]=T(A[i],Q[A[i][1]],D(N(k,*p[:i]),[A[i][1]]),S(),h[i])
 try:p[i]=g[i].send(f)[2]
 except:
  f=I(N(k,*p[:i]),h[i]);g[i]=p[i]=O;i-=1
  while J(p[i],f):g[i]=p[i]=O;i-=1
 else:
  i+=1
  if i==L(p):
   z=N(k,*p)
   if not any(J(z,F(zip([x,x+1]*2,[y,y,y+1,y+1])))for x in R(X-1)for y in R(Y-1)):break
   for c in h:U(c,z)
b=[X*['.']for i in R(Y)]
for x,y in z:b[y][x]='#'
for l in b[::-1]:print(''.join(l))

इसे ऑनलाइन आज़माएं!

को देखो अन-golfed कोड ।

— द मैट
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.