^{Questo è il primo di una serie di sfide Island Golf. Prossima sfida}

Data un'isola nell'arte ASCII, crea un percorso ottimale per circumnavigarla.

Ingresso

Il tuo input sarà una griglia rettangolare composta da due caratteri, che rappresentano terra e acqua. Negli esempi seguenti, la terra è #e l'acqua è ., ma puoi sostituire due caratteri distinti che desideri.

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

Ci sarà sempre almeno una tessera terra. Le tessere terra saranno tutte contigue (cioè c'è solo un'isola). Le tessere dell'acqua saranno anche contigue (cioè non ci sono laghi). Il bordo esterno della griglia sarà costituito da piastrelle d'acqua. Le tessere terra non saranno collegate in diagonale: cioè non vedrai mai qualcosa di simile

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

Produzione

Il codice deve generare la stessa griglia, con una circumnavigazione più breve disegnata su di essa. Negli esempi seguenti, viene tracciato il percorso di circumnavigazione o, ma puoi sostituire qualsiasi personaggio purché sia ​​distinto dai tuoi personaggi di terra e acqua.

Una circumnavigazione è una semplice curva chiusa, disegnata interamente su tessere d'acqua, che circonda completamente tutte le tessere di terra sulla griglia. Sono consentite connessioni diagonali . Ad esempio, questa è una circumnavigazione dell'isola sopra (ma non una più breve):

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

La lunghezza di una circumnavigazione viene calcolata come segue: per ogni coppia di tessere adiacenti sul percorso, se sono collegate in orizzontale o in verticale, aggiungi 1; se sono collegati in diagonale, aggiungi √2. La lunghezza del percorso sopra è 22 + 7√2 (≈ 31.9).

Una circumnavigazione più breve è una circumnavigazione con la lunghezza più breve possibile. Il programma dovrebbe generare un percorso qualsiasi che soddisfi questa condizione. Per la maggior parte delle isole, ci saranno più soluzioni possibili. Ecco una soluzione per l'isola sopra, con lunghezza 10 + 13√2 (≈ 28,4):

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

Dettagli

La tua soluzione può essere un programma completo o una funzione . Qualsiasi metodo di input e output predefinito è accettabile.

L'input e l'output possono essere una stringa multilinea o un elenco di stringhe. Se la tua lingua ha un tipo di carattere distinto dalle stringhe a carattere singolo, puoi sostituire "elenco di caratteri" con "stringa" nella frase precedente. Se la tua lingua deve inserire l'altezza e / o la larghezza della griglia, puoi farlo. L'output potrebbe (facoltativamente) avere una sola riga finale nuova. Come accennato in precedenza, è possibile utilizzare tre caratteri distinti al posto di #.o(specificare nella presentazione quali caratteri si stanno utilizzando).

Casi test

A. Isole con circumnavigazioni più brevi uniche:

...
.#.
...

.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.

B. Esempio di isola con molteplici possibili soluzioni:

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

Possibili uscite:

....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...

C. Caso di prova di grandi dimensioni come sostanza

Questo è code-golf : vince il codice più corto in ogni lingua.

Mathematica (versione 9), 165 byte

La simpatica e breve ConvexHullMeshfunzione usata da Greg Martin è stata introdotta solo in Mathematica versione 10, quindi ho pensato di fare un tentativo senza di essa, usando la mia antica Mathematica versione 9. Sono riuscito a renderlo leggermente più breve, però! E 'una funzione che prende e restituisce una lista di stringhe (con ., #e ocome i simboli).

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

Spiegazione:

• In primo luogo, Characters@# /. {"."->0, "#"->1}si trasforma l'input in una matrice di 0s e 1s.
• "o"MorphologicalTransform[MorphologicalComponents[#,Method->"ConvexHull"],Max[#(1-#[[2,2]])CrossMatrix@1]&]+"#"#utilizza quindi le potenti (ma estremamente pesanti byte ...) capacità di elaborazione delle immagini di Mathematica per riempire prima lo scafo convesso dell'isola (che è la forma che otterresti se allungassi un pezzo di corda attorno ad esso), e quindi ne prende il confine. Quindi moltiplichiamo questa matrice per la stringa "o"per ottenere una matrice di 0s "o"(grazie all'impressionante adattabilità di Mathematica sui tipi) e la aggiungiamo a "#"volte la matrice dell'isola.
• Infine, ""<>#& /@ (... /. {0->"."})trasforma questa matrice di "o"s, "#"s e 0s in una matrice di "o"s, "#"s e "."s e unisce ogni riga in una stringa.

Quando lo testiamo sull'esempio B , otteniamo l'output

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

[Modifica, grazie a Greg Martin:] Se ci è permesso usare matrici di caratteri anziché elenchi di stringhe, possiamo ridurlo a 144 byte:

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

(Ma vota la soluzione di Notatree , è meglio!)

Mathematica, 168 byte

(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)&

Funzione pura che accetta una matrice 2D di caratteri come input e restituisce una matrice 2D di caratteri. Una versione più facile da leggere:

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) &

La linea 1 definisce una funzione nche produce la (minima) distanza tra un punto xnel piano e una serie ydi altri punti. La riga 2 inizializza la variabile isull'input, sia per risolvere un'ambiguità di curry in seguito sia per essere in grado di modificarla per produrre l'output finale; la linea 2 definisce anche una funzione pche restituisce le coordinate di tutte le occorrenze del suo input i.

Nella riga 3, p["#" | "."]rappresenta ogni singola coordinata dalla mappa di input (poiché tutti i suoi caratteri sono o "#"o "."), quindi tè una funzione che seleziona solo quelle coordinate che soddisfano una proprietà non ancora specificata. Alla riga 4, i~Part~## = "o"cambierà un sacco di voci del ipersonaggio "o"; quei personaggi saranno selezionati dall'insieme di possibili coordinate secondo le cose sulle righe 5-8. E la riga 9 restituisce la risposta una volta calcolata.

Bene, infrastruttura fatta, ora al calcolo effettivo. ConvexHullMeshè il modulo integrato di Mathematica per il calcolo dello scafo convesso di una serie di punti (il poligono convesso più piccolo contenente quei punti). Sul piano morale, questo dovrebbe "riempire" le insenature e i fiordi dell'isola (che è s = p@"#"), per escluderle dalla nostra cicrumnavigazione. C'è un piccolo problema con ConvexHullMeshquando l'insieme di punti è tutto in una riga (grazie, caso di test n. 2), che risolviamo aggiungendo una versione leggermente sfalsata di sse stesso nella riga 7. Questo output è un poligono, quindi le righe 7 -9 (t[...~RegionMember~# &]) produce un elenco di punti con coordinate intere in quel poligono. Infine, la linea 5 e la fine della linea 9 calcolano tutti i punti che si trovano a una distanza esattamente 1 (quindi non 0) da questa serie di punti interi; quell'insieme diventa il percorso circumnavigante.

Di seguito è riportato l'output del caso di test di grandi dimensioni sul collegamento dell'OP. Notare in alto a sinistra, le insolite scelte su quando andare a ovest contro sud-ovest suggeriscono che sta oscurando una linea invisibile di pendenza -2/3 tra due penisole (detto segmento di linea fa parte del confine dello scafo convesso).

........................
.............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................

Python 3, 779 byte (rientro con schede)

Questo è l'intero programma. Legge l'input da stdin e lo stampa su stdout. Stdin deve terminare con EOF. Esempio eseguito con il grande input: 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))

L'idea è semplice: calcola i più piccoli limiti ottagonali e disegna celle che si trovano all'interno di tutti i limiti calcolati e si intersecano almeno uno dei bordi.

JavaScript (ES6), 369 343 byte

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`
`)

Spiegazione: La stringa è divisa in una matrice di caratteri (non sono chiaro se l'input della matrice di caratteri sia accettabile). L'array viene quindi ripetuto e si trovano le posizioni di tutti i quadrati di terra. Le linee che delimitano date dalle equazioni x - y = o, x = p, x + y = q, y = r, y - x = t, -x = u, -x - y = v, -y = wsono determinati in modo tale che il parametro massimo possibile è scelto dove tutti si trova la terra oltre la linea. Ciò ha l'effetto di racchiudere l'isola in un ottagono. Le coordinate degli angoli dell'ottagono vengono prontamente calcolate dai parametri e le celle sul suo bordo vengono riempite. L'array viene quindi ricollegato in una stringa. La ragione per cui è sufficiente un ottagono è la seguente:

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

Considera un angolo dell'ottagono. Ad un certo punto lungo i due bordi il percorso sarà limitato dalla terra perché abbiamo costruito l'ottagono per toccare la terra il più vicino possibile. Se non c'è terra all'angolo stesso, il percorso potrebbe prendere percorsi alternativi come mostrato a destra, ma questo è sempre lo stesso numero di passi ortogonali e diagonali, quindi la distanza rimane invariata.

Python 3.5, 224, 263, 234 218 byte

Ha golfato altri 16 byte eliminando la funzione nidificata e rendendola una linea.

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]

Golfato fuori 29 byte:

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)

L'input è una singola stringa che usa '~' per ocean, 'X' per land e 'o' per il confine. (Usando 'X' si salva un byte per '>' invece di '==')

Versione meno giocata a golf con commenti:

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)

C # 7 - 414 369 327 byte

Modifica : passa al loop 1D, al calcolo ie jal volo

Modifica : metodo di input modificato, tabella di ricerca compressa e passaggio a limiti iniziali ben definiti ... e rimosso lo spazio inutile nell'ultimo ciclo esterno

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;}}

Provalo online

Il programma completo, riceve l'input alla norma, lo stampa fuori norma, usi #, .e o. Per ogni cella, calcola un 'profilo' (che è la distanza su 8 direzioni (sembra calcolare un nono per comodità, ma questo è sempre 0) e registra un massimo di ciascuno di essi. Quindi scrive l'intera mappa di nuovo, e sostituisce qualsiasi cella che si trova sia su un confine che non al di fuori di qualsiasi con una "o". Il codice commentato di seguito spiega come funziona tutto.

Secondo la mia risposta a Save the Geese from Extinction , questo produce il più piccolo ottagono (circumnavigazione valida con la più grande area) che delimita l'isola.

Nota : per una volta nella mia vita sto usando qualcosa del decennio in corso, e questo codice richiede C # 7 per la compilazione. Se non si dispone di C # 7, è necessario sostituire una riga, che è chiaramente indicata nel codice.

Esempio di utilizzo e output:

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.......

Codice formattato e commentato:

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)
    }
}