^{यह द्वीप गोल्फ चुनौतियों की एक श्रृंखला में पहला है। अगली चुनौती}

ASCII- कला में एक द्वीप को देखते हुए, इसे परिचालित करने के लिए एक इष्टतम पथ का उत्पादन।

इनपुट

आपका इनपुट एक आयताकार ग्रिड होगा जिसमें दो वर्ण होंगे, जो भूमि और पानी का प्रतिनिधित्व करेंगे। नीचे दिए गए उदाहरणों में, भूमि है #और पानी है ., लेकिन आप अपनी इच्छानुसार किसी भी दो अलग-अलग पात्रों को स्थानापन्न कर सकते हैं।

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

हमेशा कम से कम एक भूमि टाइल होगी। भूमि की टाइलें सभी सन्निहित होंगी (यानी केवल एक द्वीप है)। पानी की टाइलें भी सन्निहित होंगी (यानी झीलें नहीं हैं)। ग्रिड की बाहरी सीमा सभी में पानी की टाइलें होंगी। जमीन की टाइलें तिरछे नहीं जुड़ी होंगी : यानी, आपको कभी ऐसा कुछ दिखाई नहीं देगा

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

उत्पादन

आपके कोड को उसी ग्रिड को आउटपुट करना होगा, जिस पर कम से कम सर्कुलेशन हो। नीचे दिए गए उदाहरणों में, परिच्छेद पथ के साथ खींचा गया है o, लेकिन आप किसी भी वर्ण को तब तक स्थानापन्न कर सकते हैं जब तक कि वह आपकी भूमि और जल के पात्रों से अलग हो।

एक परिच्छेद एक साधारण बंद वक्र है, जो पूरी तरह से पानी की टाइलों पर खींचा गया है, जो ग्रिड पर सभी भूमि टाइलों को पूरी तरह से घेरता है। विकर्ण कनेक्शन की अनुमति है। उदाहरण के लिए, यह उपर्युक्त द्वीप का एक परिमाण है (लेकिन सबसे छोटा नहीं):

.ooooo.....
o..##.oo...
o.#####.o..
o.#######o.
o#########o
ooo#######o
..o#####.#o
..oo####..o
....oooooo.

एक परिच्छेद की लंबाई की गणना निम्नानुसार की जाती है: पथ पर आसन्न टाइल्स के प्रत्येक जोड़े के लिए, यदि वे क्षैतिज या लंबवत रूप से जुड़े हुए हैं, तो 1 जोड़ें; यदि वे तिरछे जुड़े हुए हैं, तो are2 जोड़ें। उपरोक्त पथ की लंबाई 22 + 7√2 (path 31.9) है।

कम से कम संभव लंबाई के साथ एक सबसे बड़ा परिचालित दायित्व है। आपके कार्यक्रम को किसी भी एक पथ का उत्पादन करना चाहिए जो इस स्थिति को संतुष्ट करता है। अधिकांश द्वीपों के लिए, कई संभावित समाधान होंगे। यहाँ उपरोक्त द्वीप के लिए एक समाधान है, जिसकी लंबाई 10 + 13 (2 () 28.4) है:

...oo......
..o##oo....
.o#####oo..
.o#######o.
o#########o
.o.#######o
..o#####.#o
...o####.o.
....ooooo..

विवरण

आपका समाधान एक पूर्ण कार्यक्रम या फ़ंक्शन हो सकता है । का कोई भी डिफ़ॉल्ट इनपुट और आउटपुट तरीकों स्वीकार्य हैं।

आपका इनपुट और आउटपुट मल्टीलाइन स्ट्रिंग या स्ट्रिंग्स की सूची हो सकता है। यदि आपकी भाषा एकल-वर्ण स्ट्रिंग्स से भिन्न वर्ण प्रकार की है, तो आप पिछले वाक्य में "स्ट्रिंग" के लिए "वर्णों की सूची" स्थानापन्न कर सकते हैं। यदि आपकी भाषा को ग्रिड की ऊंचाई और / या चौड़ाई का इनपुट करने की आवश्यकता है, तो आप ऐसा कर सकते हैं। आपके आउटपुट (वैकल्पिक रूप से) में एक एकल अनुगामी न्यूलाइन हो सकती है। जैसा कि ऊपर उल्लेख किया गया है, आप के स्थान पर किसी भी तीन अलग-अलग वर्णों का उपयोग कर सकते हैं #.o(कृपया अपनी प्रविष्टि में निर्दिष्ट करें कि आप किन वर्णों का उपयोग कर रहे हैं)।

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

ए अद्वितीय कम से कम circumnavigations साथ आइलैंड्स:

...
.#.
...

.o.
o#o
.o.

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

.oooo.
o####o
.oooo.

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

......
..oo..
.o##o.
..o#o.
...o..
......

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

.ooooo.
o#####o
o..#..o
o..#..o
o#####o
.ooooo.

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

...o...
..o#o..
.o.#.o.
o#####o
.o.#.o.
..o#o..
...o...

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

.ooooo.
o#####o
o##..#o
.o#..#o
..oooo.

बी कई संभावित समाधान के साथ एक द्वीप का उदाहरण:

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

संभव आउटपुट:

....oo..
...o##o.
..o####o
.o###.o.
o#####o.
o#####o.
.o##oo..
..oo....

....oo..
...o##o.
..o####o
.o###.o.
o#####o.
o#####o.
.o##.o..
..ooo...

....oo..
...o##o.
..o####o
.o###..o
o#####.o
o#####o.
.o##oo..
..oo....

....oo..
...o##o.
..o####o
.o###..o
o#####.o
o#####o.
.o##.o..
..ooo...

सी। बड़े परीक्षण का मामला एक जिस्ट के रूप में

यह कोड-गोल्फ है : प्रत्येक भाषा में सबसे छोटा कोड जीतता है।

— DLosc
स्रोत

1

3rd टेस्ट केस के लिए सबसे छोटा सर्कुलेशन, कॉनवे के गेम ऑफ लाइफ में 'loaf' पैटर्न है!

— कॉमरेड स्पार्कलपनी

18

गणितज्ञ (संस्करण 9), 165 बाइट्स

ConvexHullMeshग्रेग मार्टिन द्वारा इस्तेमाल किया गया अच्छा, छोटा फंक्शन केवल मैथमेटिका संस्करण 10 में पेश किया गया था, इसलिए मैंने सोचा कि मैं इसके बिना एक प्रयास करूंगा, अपने प्राचीन मैथमैटिक संस्करण 9 का उपयोग करके। मैं इसे थोड़ा कम पाने में कामयाब रहा, हालांकि! यह एक ऐसा फ़ंक्शन है जो स्ट्रिंग्स की सूची (और ., #और oप्रतीकों के रूप में) लेता है ।

""<>#&/@("o"MorphologicalTransform[MorphologicalComponents[#,Method->"ConvexHull"],Max[#(1-#[[2,2]])CrossMatrix@1]&]+"#"#/.{0->"."})&[Characters@#/.{"."->0,"#"->1}]&

स्पष्टीकरण:

सबसे पहले, Characters@# /. {"."->0, "#"->1}इनपुट को 0s और 1s के मैट्रिक्स में बदलता है ।
"o"MorphologicalTransform[MorphologicalComponents[#,Method->"ConvexHull"],Max[#(1-#[[2,2]])CrossMatrix@1]&]+"#"#इसके बाद मैथेमेटिका के शक्तिशाली (लेकिन बेहद बाइट-हैवी ...) इमेज प्रोसेसिंग क्षमताओं का उपयोग करता है ताकि पहले द्वीप के उत्तल पतवार (जो आकार आपको मिल सके, अगर आप उसके चारों ओर स्ट्रिंग का एक टुकड़ा फैलाएंगे), और फिर उसकी सीमा ले लें। हम तब एस और एस के "o"एक मैट्रिक्स को प्राप्त करने के लिए स्ट्रिंग द्वारा इस मैट्रिक्स को गुणा करते हैं (प्रकारों के बारे में मैथमेटिका के प्रभावशाली अनुकूलनशीलता के लिए धन्यवाद), और द्वीप के मैट्रिक्स के समय में इसे जोड़ते हैं ।0"o""#"
अंत में, ""<>#& /@ (... /. {0->"."})के इस मैट्रिक्स बदल जाता है "o", रों "#"है और 0के एक मैट्रिक्स में एस "o"एस, "#"है और "."है, और एक स्ट्रिंग में प्रत्येक पंक्ति मिलती है।

जब हम इस उदाहरण B पर परीक्षण करते हैं , तो हमें आउटपुट मिलता है

{"....oo..",
 "...o##o.",
 "..o####o",
 ".o###..o",
 "o#####o.",
 "o#####o.",
 ".o##oo..",
 "..oo...."}

[संपादित करें, ग्रेग मार्टिन के लिए धन्यवाद:] अगर हमें स्ट्रिंग्स की सूची के बजाय वर्णों के सरणियों का उपयोग करने की अनुमति दी जाती है, तो हम इसे 144 बाइट्स तक ट्रिम कर सकते हैं:

"o"MorphologicalTransform[MorphologicalComponents[#,Method->"ConvexHull"],Max[#(1-#[[2,2]])CrossMatrix@1]&]+"#"#/.{0->"."}&[#/.{"."->0,"#"->1}]&

— पेड़ नहीं
स्रोत

1

अच्छी तरह से किया! मुझे इसके बारे में कभी नहीं पता था MorphologicalComponents[#, Method->"ConvexHull"] :) आप यह मानकर और भी अधिक बाइट्स बचा सकते हैं कि इनपुट पहले से ही वर्णों में विभाजित है, और साथ ही वर्णों के 2 डी सरणी को वापस करके।

— ग्रेग मार्टिन

@GregMartin, मैं MorphologicalComponentsआज तक या तो उस उपयोग के बारे में नहीं जानता था!

— पेड़ नहीं

यहां गणितज्ञ नौसिखिया: मुझे इस फ़ंक्शन को कैसे कॉल करना चाहिए? मैंने कोशिश की f[{"...",".#.","..."}]और कुछ त्रुटियां मिलीं।

— DLosc

@ डल, फंक्शन पूरी चीज है, न कि सिर्फ f। (ठीक है, सख्ती से बोल रहा है कि यह अर्धविराम के बाद सामान है।) फ़ंक्शन को कॉल करने के लिए, पूरी चीज़ को एक मैथेमेटिका विंडो में टाइप करें, इसके बाद [, आपका इनपुट और ], इसलिए इसे कुछ ऐसा दिखना चाहिए f@m_:=m(1-m[[2,2]]) . . . #/.{"."->0,"#"->1}]&[{"...", ".#.", "..."}](अंतरिक्ष के लिए निरस्त)।

— पेड़ नहीं

@DLosc खैर, ऐसा इसलिए है क्योंकि कोड टूट गया है। मुझे लगता है कि मैंने इसे अभी तय कर लिया है, हालांकि! (मुझे पता नहीं है कि वहाँ क्या हुआ था? क्षमा करें ...)

— पेड़ नहीं

11

(लेकिन नोटाट्री के समाधान को आगे बढ़ाएं , यह बेहतर है!)

मैथेमेटिका, 168 बाइट्स

(x_~n~y_:=Min[Norm[x-#]&/@y];i=#;p=i~Position~#&;t=p["#"|"."]~Select~#&;(i~Part~##="o")&@@@t[#~n~t[ConvexHullMesh[Join[s=p@"#",#+{.1,.1}&/@s]]~RegionMember~#&]==1&];i)&

शुद्ध फ़ंक्शन इनपुट के रूप में वर्णों का 2D सरणी ले रहा है और वर्णों का 2D सरणी लौटा रहा है। एक आसानी से पढ़ा जाने वाला संस्करण:

1  (x_~n~y_ := Min[Norm[x - #] & /@ y];
2  i = #; p = i~Position~# &; 
3  t = p["#" | "."]~Select~# &;
4  (i~Part~## = "o") & @@@ 
5    t[#~n~
6      t[ConvexHullMesh[
7        Join[s = p@"#", # + {.1, .1} & /@ s]]
8      ~RegionMember~# &] == 1 &];
9  i) &

लाइन 1 एक फ़ंक्शन को परिभाषित करता है nजो xविमान में एक बिंदु और yअन्य बिंदुओं के एक सेट के बीच (सबसे छोटी) दूरी पैदा करता है । लाइन 2 iइनपुट के लिए चर को इनिशियलाइज़ करता है , दोनों बाद में एक करी अस्पष्टता को हल करने के लिए और अंतिम आउटपुट के उत्पादन के लिए इसे संशोधित करने में सक्षम होने के लिए; पंक्ति 2 एक फ़ंक्शन को भी परिभाषित करता है pजो इसके इनपुट की सभी घटनाओं के निर्देशांक को वापस करता है i।

लाइन 3 पर, p["#" | "."]इनपुट मैप से हर एक निर्देशांक का प्रतिनिधित्व करता है (क्योंकि इसके सभी वर्ण "#"या तो हैं "."), इसलिए tएक फ़ंक्शन है जो केवल उन निर्देशांक का चयन करता है जो अभी तक अनिर्दिष्ट संपत्ति को संतुष्ट करते हैं। लाइन 4 पर, चरित्र i~Part~## = "o"की प्रविष्टियों का एक गुच्छा बदलने जा रहा है ; उन पात्रों को 5-8 लाइनों पर सामान के अनुसार संभव निर्देशांक के सेट से चुना जाएगा। और लाइन 9 बस एक बार जवाब देने के बाद गणना करता है।i"o"

ठीक है, बुनियादी ढाँचा, अब वास्तविक गणना के लिए। ConvexHullMeshMathematica का बनाया गया है जिसमें अंकों के एक सेट के उत्तल पतवार की गणना के लिए (उन बिंदुओं में सबसे छोटा उत्तल बहुभुज है)। नैतिक रूप से, यह s = p@"#"हमारे cicrumnavigation से बाहर शासन करने के लिए द्वीप (जो है ) के coves और fjords में "भरना" चाहिए । उस समय के साथ थोड़ी समस्या होती है ConvexHullMeshजब बिंदुओं का वह सेट एक लाइन में होता है (धन्यवाद, टेस्ट केस # 2), जिसे हम sलाइन 7 में खुद से थोड़ा ऑफसेट संस्करण जोड़कर हल करते हैं । यह आउटपुट एक बहुभुज है, इसलिए लाइनें 7 - (t[...~RegionMember~# &]) उस बहुभुज में पूर्णांक निर्देशांक के साथ अंकों की एक सूची तैयार करता है। अंत में, पंक्ति 5 और पंक्ति 9 के अंत में उन सभी बिंदुओं की गणना करें जो पूर्णांक बिंदुओं के इस सेट से ठीक 1 (इसलिए 0 नहीं) हैं; वह सेट सर्कुलेटिव मार्ग बन जाता है।

नीचे ओपी के लिंक पर बड़े परीक्षण मामले के लिए आउटपुट है। ऊपरी बाईं ओर ध्यान दें, जब पश्चिम बनाम दक्षिण-पश्चिम की ओर जाने के असामान्य विकल्प इस तथ्य पर हैं कि यह दो प्रायद्वीपों के बीच ढलान -2/3 की एक अदृश्य रेखा को छायांकित कर रहा है (कहा जाता है कि खंड खंड उत्तल पतवार की सीमा का हिस्सा है)।

........................
.............o..........
...........oo#ooooooo...
..........o#.#.##...#o..
........oo.#.#.###.##o..
.......o..########.##o..
.....oo...############o.
...oo#....############o.
..o#.###.##############o
.o##.##################o
.o####################o.
.o.##################.o.
.o##################..o.
.o..################..o.
o###################..o.
o#####################o.
o.##################.o..
o####################o..
o#...##############.o...
o##...#############o....
o#.....###....#oooo.....
.oooooo#ooooooo.........
.......o................

— ग्रेग मार्टिन
स्रोत

क्या Mathematica आमतौर पर वर्णों के 1D सरणियों के रूप में तारों का प्रतिनिधित्व करता है? यदि नहीं, तो आपको स्ट्रिंग्स के बजाय 1D सरणी लेने / वापस करने की आवश्यकता होगी। (इसके अलावा, स्पष्टीकरण के लिए आगे देख! मुझे नहीं लगता कि मैं गणितज्ञ, अधिकार के बिना इसे चलाने में सक्षम

— होऊंगा

Mathematica में एक स्ट्रिंग डेटा प्रकार है, लेकिन ऐसा लगता है कि इस साइट के उद्देश्यों के लिए वर्णों का एक सरणी भी मान्य है (यानी, जब मैंने PPCG पर शुरू किया था, तब मैंने इसे सीखा था, लेकिन मैं क्यों की वैधता भूल जाता हूं)। हां, दुर्भाग्य से, गणितज्ञ गैर-मुक्त है और इस प्रकार कई लोगों के लिए सुलभ नहीं है :(

— ग्रेग मार्टिन

1

@GregMartin मैं हमेशा से बाहर मेथेमेटिका समाधान की कोशिश sandbox.open.wolframcloud.com

— OVS

वर्तमान सर्वसम्मति कहती है कि एक स्ट्रिंग के स्थान पर एकल-वर्ण स्ट्रिंग्स की सूची का उपयोग नहीं किया जा सकता है। जहाँ तक मैं बता सकता हूँ, गणितज्ञों में "वर्ण" केवल एकल वर्ण के तार हैं, जैसे कि पायथन में। जावा जैसी भाषा में स्थिति अलग है, जिसमें एक अलग charप्रकार है; उस स्थिति में, charस्ट्रिंग के स्थान पर एक सरणी का उपयोग किया जा सकता है।

— DLosc

1

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

— DLosc

10

पायथन 3, 779 बाइट्स (टैब के साथ इंडेंटिंग)

यह पूरा कार्यक्रम है। यह स्टड से इनपुट पढ़ता है और इसे स्टडआउट में प्रिंट करता है। स्टेप ईओएफ के साथ समाप्त होना चाहिए। उदाहरण बड़े इनपुट के साथ चलते हैं: https://ideone.com/XIfYY0

import itertools,sys
L=list
C=itertools.count
d=L(map(L,filter(None,sys.stdin.read().split('\n'))))
X=len(d[0])
Y=len(d)
R=range
def P(r):return all(d[y][x]=='.'for x,y in r)
def S(f):
    for n in C(0):
        if P(f(n)):l=n
        else:break
    for n in C(l+1):
        if P(f(n)):return l,n
def f(V,a,*b):return L(eval('lambda '+a+':('+i+')',V)for i in b)
V=locals()
def D(n):
    y=min(n,Y-1);x=n-y
    while y>=0and x<X:yield(x,y);x+=1;y-=1
def E(n):
    x=max(0,n-Y);y=x+Y-n
    while y<Y and x<X:yield(x,y);x+=1;y+=1
F=f(V,'p','(p,y)for y in R(0,Y)','(x,p)for x in R(0,X)')+[D,E]
r=f(V,'x,y','x','y','x+y','x-y+Y')
B=L(map(S,F))
for x in R(0,X):
    for y in R(0,Y):
        z=L(zip(r,B))
        if all(g(x,y)in R(a,b+1)for g,(a,b)in z)and any(g(x,y)in e for g,e in z):d[y][x]='o'
print('\n'.join(''.join(x)for x in d))

यह विचार सरल है: यह छोटी से छोटी अष्टकोणीय सीमाओं की गणना करता है, और उन कोशिकाओं को खींचता है जो सभी संगणित सीमा के अंदर होती हैं और किनारों में से कम से कम एक को काटती हैं।

— Lera
स्रोत

1

आपको वास्तव sys.stdinमें इनपुट के रूप में उपयोग करने की आवश्यकता नहीं है । input(), बहुभाषी होने से काम चलेगा और लागत कम बाइट्स होगी

— डेड पॉसम

2

मई के R(0,x)साथ बदलने में सक्षम हो सकता हैR(x)

— छत

बिल्ट-इन का उपयोग नहीं करने के लिए +1।

— रॉबर्ट फ्रेज़र

1

अच्छा! कुछ और गोल्फ टिप्स: परिभाषित Pऔर करने के लिए lambdas का उपयोग करके प्रत्येक को 5 बाइट बचाएं f; L(generator expression)=> [generator expression]; F, rऔर Bकेवल एक बार उपयोग किए जाने वाले प्रतीत होते हैं और इस प्रकार इनलेट हो सकते हैं।

— DL23

8

जावास्क्रिप्ट (ईएस 6), 369 343 बाइट्स

f=s=>(a=s.split`
`.map(s=>[...s]),m=Array(8),a.map((b,i)=>b.map((c,j)=>c>'#'||[i-j,i,j+i,j,j-i,-i,-i-j,-j].map((d,k)=>d>m[k]||(m[k]=d-1)))),[o,p,q,r,t,u,v,w]=m,g=(i,j,k,l,...p)=>i-k|j-l?a[i][j]=g(i+(k>i)-(k<i),j+(l>j)-(l<j),k,l,...p):1/p[0]?g(k,l,...p):'o',g(p,p-o,p,q-p,q-r,r,r-t,r,-u,t-u,-u,u-v,w-v,-w,o-w,-w,p,p-o),a.map(b=>b.join``).join`
`)

स्पष्टीकरण: स्ट्रिंग को चरित्र सरणी में विभाजित किया गया है (मैं स्पष्ट नहीं हूं कि क्या चरित्र सरणी इनपुट स्वीकार्य है)। इसके बाद सरणी को पुनरावृत्त किया जाता है और सभी भूमि वर्गों की स्थिति स्थित होती है। समीकरण द्वारा दिए गए बाउंडिंग लाइनों x - y = o, x = p, x + y = q, y = r, y - x = t, -x = u, -x - y = v, -y = wइस तरह के निर्धारित कर रहे हैं कि अधिक से अधिक संभव पैरामीटर चुना जाता है रेखा के पार जहां सारे देश निहित है। यह एक अष्टकोना में द्वीप को घेरने का प्रभाव है। अष्टकोना के कोनों के निर्देशांक को मापदंडों से आसानी से गणना की जाती है और इसके किनारे की कोशिकाओं को भर दिया जाता है। सरणी फिर वापस एक स्ट्रिंग में शामिल हो जाती है। एक अष्टकोणीय कारण निम्नानुसार है:

   /o#     /o#     /o#
 |/o #   |/o #   |/ o#
 *o###   * o #   *  o#
/|o #   /|o #   /| o#
 |o#     |o#     |o#

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

— नील
स्रोत

´ ... p´ क्या करता है?

— रॉबर्ट फ्रेजर

@RobertFraser तकनीकी नाम सरणी विनाशकारी है। इस मामले में, यह सिर्फ एक rest of argumentsपैरामीटर के रूप में कार्य करता है ।

— नील

@ नील वास्तव में, तकनीकी नाम बाकी पैरामीटर है । एक ही सिंटैक्स का उपयोग प्रसार ऑपरेटर के लिए किया जाता है । (आप दोनों का उपयोग ...pअलग-अलग जगहों पर करते हैं।) विनाशकारी कुछ और है (हालांकि प्रसार ऑपरेटर को विनाशकारी रूप में इस्तेमाल किया जा सकता है)।

— बजे ब्रायन मैककिनटन

@BrianMcCutchon आप सही कह रहे हैं, मेरा मतलब था कि फैलता हुआ ऑपरेटर, लेकिन तर्क सूचियों में विनाशकारी कार्य वैसे भी होते हैं।

— नील

6

पायथन 3.5, 224, 263, 234 218 बाइट्स

नेस्टेड फ़ंक्शन से छुटकारा पाने और इसे एक-लाइनर बनाने के लिए एक और 16 बाइट्स से गोल्फिंग की।

def h(s,k=0,i=0):w=s.find('\n')+1;x=s.find('X')-w;k=k or x;d=[1,w+1,w,w-1,-1,-w-1,-w,-w+1]*2;u=s[:k]+'o'+s[k+1:];return['X'>s[k]and i<8and(h(u,k+d[i+2],i+2)or h(u,k+d[i+1],i+1)or h(u,k+d[i],i))or'',s][s[k]>'X'and k==x]

29 बाइट्स से दूर:

def f(s):
 w=s.find('\n')+1;x=s.find('X')-w;d=[1,w+1,w,w-1,-1,-w-1,-w,-w+1]*2
 def h(s,k,i):u=s[:k]+'o'+s[k+1:];return['X'>s[k]and i<8and(h(u,k+d[i+2],i+2)or h(u,k+d[i+1],i+1)or h(u,k+d[i],i))or'',s][s[k]>'X'and k==x]
 return h(s,x,0)

इनपुट महासागर के लिए '~', भूमि के लिए 'X' और सीमा के लिए 'o' का उपयोग करते हुए एक एकल स्ट्रिंग है। ('X' का प्रयोग '==' के बजाय '>' के लिए बाइट बचाता है)

टिप्पणियों के साथ कम गोल्फ वाला संस्करण:

def f(s):
    w=s.find('\n')+1                         # width of one row
    x=s.find('X')-w                          # starting point
    d=[1,w+1,w,w-1,-1,-w-1,-w,-w+1]*2        # delta to add to current index to move in 
                                             # the 8 directions: E, SE, S, SW, W, NW, 
                                             # N, NE. Make it long to avoid
                                             # lots of modulo operations in 
                                             #    the recursive calls

    def h(s,k,i):                            # s is the island string, k the current
                                             # position, i the direction index
        if s[k]>'X'and k==x:                 # if back at the begining,
            return s                         #   return the map

        elif 'X'>s[k] and i<8:               # if there is water here, and haven't
                                             #  looped around,
            u=s[:k]+'o'+s[k+1:]              #  make a new map with an 'o' in the 
                                             #  current spot

            r = h(u,k+d[i+2],i+2)            # try a 90 degree right turn
            if r: return r

            r = h(u,k+d[i+1],i+1)            # try a 45 degree turn
            if r: return r

            r= h(u,k+d[i],i)                 # try straight ahead
            if r: return r

        return ''                            # this path failed

    return h(s,x,0)

— RootTwo
स्रोत

@ डल तय। (क्या मुझे पुराना उत्तर हटाना चाहिए?)

— रूटट्वो

अच्छा! (हां, आपको पुराने उत्तर को हटा देना चाहिए - यदि कोई इसे देखना चाहता है, तो वे पोस्ट के संशोधन इतिहास को देख सकते हैं।)

— DLosc

5

सी # 7 - 414 369 327 बाइट्स

संपादित करें : 1D लूपिंग, कंप्यूटिंग iऔर jफ्लाई पर स्विच किया गया

संपादित करें : परिवर्तित इनपुट विधि, ध्वस्त लुकअप टेबल, और अच्छी तरह से परिभाषित प्रारंभिक सीमा पर स्विच किया गया ... और पिछले बाहरी लूप के लिए व्यर्थ स्थान को हटा दिया

using C=System.Console;class P{static void Main(){var D=C.In.ReadToEnd().Replace("\r","");int W=D.IndexOf('\n')+1,H=D.Length,z=H,k,q,c;int P()=>z%W*(k%3-1)+z/W*(k/3-1)+H;var B=new int[9];for(;z-->0;)for(k=9;k-->0&D[z]%7<1;)if(B[k]<=P())B[k]=P()+1;for(;++z<H;C.Write(q>9?'o':D[z]))for(q=k=9;k-->0;)q*=(c=P()-B[k])>0?0:c<0?1:2;}}

यह ऑनलाइन की कोशिश करो

पूरा कार्यक्रम, इनपुट को मानक में लेता है, इसे मानक से प्रिंट करता है #, उपयोग करता है ., और o। प्रत्येक सेल के लिए, यह एक 'प्रोफाइल' की गणना करता है (जो कि 8 दिशाओं से दूरी है (यह सुविधा के लिए एक नौवें की गणना करता है, लेकिन यह हमेशा होता है 0), और इनमें से प्रत्येक को अधिकतम रिकॉर्ड करता है। फिर यह पूरा नक्शा लिखता है। फिर से, और किसी भी सेल की जगह लेता है जो दोनों एक सीमा पर है और किसी 'ओ' के साथ बाहर नहीं है। नीचे टिप्पणी कोड यह बताता है कि यह सब कैसे काम करता है।

विलुप्त होने से गीज़ को बचाने के लिए मेरे जवाब के अनुसार , यह सबसे छोटा अष्टकोण (सबसे बड़े क्षेत्र के साथ वैध परिमाण) का उत्पादन करता है जो द्वीप को बांधता है।

नोट : कि मेरे जीवन में एक बार मैं वर्तमान दशक से कुछ का उपयोग कर रहा हूं, और इस कोड को संकलन करने के लिए C # 7 की आवश्यकता है। यदि आपके पास C # 7 नहीं है, तो एक पंक्ति है जिसे प्रतिस्थापित करने की आवश्यकता होगी, जो कोड में स्पष्ट रूप से चिह्नित है।

उदाहरण उपयोग और आउटपुट:

type t7.txt | IslandGolf1.exe

.........ooooooooooo....
........o....#......o...
.......o...#.#.##...#o..
......o....#.#.###.##.o.
.....o....########.##..o
....o.....############.o
...o.#....############.o
..o#.###.##############o
.o##.##################o
o.####################.o
o..##################..o
o.##################...o
o...################...o
o###################...o
o#####################.o
o.##################..o.
o####################o..
o#...##############.o...
o##...#############o....
o#.....###....#...o.....
.o.....#.........o......
..ooooooooooooooo.......

प्रारूपित और टिप्पणी की गई कोड:

using C=System.Console;

class P
{
    static void Main()
    {
        // \n 10
        // # 35
        // . 46
        // o 111


        var D=C.In.ReadToEnd().Replace("\r",""); // map

        int W=D.IndexOf('\n')+1, // width
            H=D.Length, // length
            z=H, // position in map (decomposed into i and j by and for P)
            k, // bound index
            q, // bound distance, and later cell condition (0 -> outside, 8 -> inside, >8 -> on boudary)
            c; // (free), comparison store

        // 'indexes' into a profile for the point z at index k
        // effectively {i=z%W,j=z/W,-i,-j,i+j,j-i,-i-j,i-j,0}[k] (inside order is a bit different) (0 const is always treated as 'inside bounds')
        // each non-zero-const entry describes the distance in one of the 8 directions: we want to maximise these to find the 'outer bounds'
        // the non-zero-const bounds describe 8 lines, together an octogen
        int P()=>z%W*(k%3-1)+z/W*(k/3-1)+H; // new C#7 local method syntax (if you don't have C#7, you can test this code with the line below instead)
        //k=0;System.Func<int>P=()=>z%W*(k%3-1)+z/W*(k/3-1)+H; // old lambda syntax (must pre-assign k to make static checker happy)

        var B=new int[9]; // our current bounds, each is initially null (must only call P() when on a #)
        // B[k] starts off a 0, P() has a +H term, and W+(H/W)<H for W >= 3, so B[k] is assigned the first time we compare it (H-i-j always > 0)

        for(;z-->0;) // for each cell
            for(k=9;k-->0& // for each bound
                D[z]%7<1;) // if this cell is #
                if(B[k]<=P())B[k]=P()+1; // update bound if necessary (add one so that we define the bound _outside_ the hashes)
        // z=-1
        for(;++z<H; // for each cell
                C.Write(q>9?'o':D[z])) // print the cell (if q > 9, then we are on the bounds, otherwise, spit out whatever we were before)
            // check we are not 'outside' any of the bounds, and that we are 'on' atleast one of them
            for(q=k=9;k-->0;) // for each bound
                q*=(c=P()-B[k])>0?0: // outside bound (q=0)    (??0 is cheaper than (int) or .Value)
                    c<0?1: // inside (preserve q)
                    2; // on bound (if q != 0, then q becomes > 9)
    }
}

— VisualMelon
स्रोत

सबसे बड़ा अष्टकोना? या सबसे छोटा?

— सर्ज बोर्स्च

@ सर्जबॉर्स धन्यवाद, पाठ को ठीक किया।

— विजुअलमेल

द्वीप गोल्फ # 1: पूर्वनिर्धारण

इनपुट

उत्पादन

विवरण

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

गणितज्ञ (संस्करण 9), 165 बाइट्स

मैथेमेटिका, 168 बाइट्स

पायथन 3, 779 बाइट्स (टैब के साथ इंडेंटिंग)

जावास्क्रिप्ट (ईएस 6), 369 343 बाइट्स

पायथन 3.5, 224, 263, 234 218 बाइट्स

सी # 7 - 414 369 327 बाइट्स