^{Este es el primero de una serie de desafíos de Island Golf. Siguiente reto}

Dada una isla en el arte ASCII, genera una ruta óptima para circunnavegarla.

Entrada

Su entrada será una cuadrícula rectangular que consta de dos caracteres, que representan tierra y agua. En los ejemplos a continuación, la tierra es #y el agua es ., pero puede sustituir cualquiera de los dos caracteres distintos que desee.

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

Siempre habrá al menos una ficha de tierra. Todas las fichas de tierra serán contiguas (es decir, solo hay una isla). Las baldosas de agua también serán contiguas (es decir, no hay lagos). El borde exterior de la cuadrícula será de baldosas de agua. Las fichas de tierra no se conectarán en diagonal: es decir, nunca verás algo como

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

Salida

Su código debe generar la misma cuadrícula, con una circunnavegación más corta dibujada en ella. En los ejemplos a continuación, se dibuja la ruta de circunnavegación o, pero puede sustituir cualquier personaje siempre que sea distinto de sus caracteres de tierra y agua.

Una circunnavegación es una curva cerrada simple, dibujada completamente en baldosas de agua, que rodea completamente todas las baldosas terrestres en la cuadrícula. Se permiten conexiones diagonales . Por ejemplo, esta es una circunnavegación de la isla anterior (pero no la más corta):

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

La longitud de una circunnavegación se calcula de la siguiente manera: por cada par de mosaicos adyacentes en el camino, si están conectados horizontal o verticalmente, agregue 1; si están conectados en diagonal, agregue √2. La longitud de la ruta anterior es 22 + 7√2 (≈ 31.9).

Una circunnavegación más corta es una circunnavegación con la menor longitud posible. Su programa debe generar cualquier ruta que satisfaga esta condición. Para la mayoría de las islas, habrá múltiples soluciones posibles. Aquí hay una solución para la isla anterior, con longitud 10 + 13√2 (≈ 28.4):

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

Detalles

Su solución puede ser un programa completo o una función . Cualquiera de los métodos de entrada y salida predeterminados son aceptables.

Su entrada y salida puede ser una cadena multilínea o una lista de cadenas. Si su idioma tiene un tipo de caracteres distinto de las cadenas de un solo carácter, puede sustituir "lista de caracteres" por "cadena" en la oración anterior. Si su idioma necesita ingresar el alto y / o ancho de la cuadrícula, puede hacerlo. Su salida puede (opcionalmente) tener una nueva línea final. Como se mencionó anteriormente, puede usar tres caracteres distintos en lugar de #.o(especifique en su envío qué caracteres está usando).

Casos de prueba

A. Islas con circunnavegaciones más cortas y únicas:

...
.#.
...

.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. Ejemplo de una isla con múltiples soluciones posibles:

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

Salidas posibles:

....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. Gran caso de prueba como Gist

Este es el código de golf : gana el código más corto en cada idioma.

Mathematica (versión 9), 165 bytes

La ConvexHullMeshfunción corta y agradable que usó Greg Martin solo se introdujo en la versión 10 de Mathematica, así que pensé en intentarlo sin ella, usando mi antigua versión 9. de Mathematica. Es una función que toma y devuelve una lista de cadenas (con ., #y oque los símbolos).

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

Explicación:

• Primero, Characters@# /. {"."->0, "#"->1}convierte la entrada en una matriz de 0sy 1s.
• "o"MorphologicalTransform[MorphologicalComponents[#,Method->"ConvexHull"],Max[#(1-#[[2,2]])CrossMatrix@1]&]+"#"#luego usa las poderosas capacidades de procesamiento de imágenes de Mathematica (pero extremadamente pesadas en bytes ...) para llenar primero el casco convexo de la isla (que es la forma que obtendría si estirara un trozo de cuerda a su alrededor), y luego tome su límite. Luego multiplicamos esta matriz por la cadena "o"para obtener una matriz de 0sys "o"(gracias a la impresionante adaptabilidad de Mathematica sobre los tipos), y agregamos esto a "#"veces la matriz de la isla.
• Finalmente, ""<>#& /@ (... /. {0->"."})convierte esta matriz de "o"s, "#"sy 0s en una matriz de "o"s, "#"sy "."s, y une cada fila en una cadena.

Cuando probamos esto en el ejemplo B , obtenemos la salida

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

[Editar, gracias a Greg Martin:] Si se nos permite usar matrices de caracteres en lugar de listas de cadenas, podemos reducir esto a 144 bytes:

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

(Pero vota la solución de Notatree , ¡es mejor!)

Mathematica, 168 bytes

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

Función pura que toma una matriz 2D de caracteres como entrada y devuelve una matriz 2D de caracteres. Una versión más fácil de leer:

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 línea 1 define una función nque produce la distancia (más pequeña) entre un punto xen el plano y un conjunto yde otros puntos. La línea 2 inicializa la variable ia la entrada, tanto para resolver una ambigüedad curry más tarde como para poder modificarla para producir la salida final; La línea 2 también define una función pque devuelve las coordenadas de todas las ocurrencias de su entrada i.

En la línea 3, p["#" | "."]representa cada coordenada del mapa de entrada (ya que todos sus caracteres son "#"o "."), por lo que tes una función que selecciona solo aquellas coordenadas que satisfacen una propiedad aún no especificada. En la línea 4, i~Part~## = "o"va a cambiar un montón de entradas del ipersonaje "o"; esos caracteres se seleccionarán del conjunto de coordenadas posibles de acuerdo con las cosas en las líneas 5-8. Y la línea 9 solo devuelve la respuesta una vez que se calcula.

Bien, infraestructura hecha, ahora a la computación real. ConvexHullMeshes la función integrada de Mathematica para calcular el casco convexo de un conjunto de puntos (el polígono convexo más pequeño que contiene esos puntos). Hablando moralmente, esto debería "completar" las calas y los fiordos de la isla (que es s = p@"#"), para descartarlos de nuestra navegación en bicicleta. Hay un pequeño problema con ConvexHullMeshcuando ese conjunto de puntos está todo en una línea (gracias, caso de prueba # 2), que resolvemos agregando una versión ligeramente desplazada de ssí mismo en la línea 7. Esta salida es un polígono, por lo que las líneas 7 -9 (t[...~RegionMember~# &]) produce una lista de los puntos con coordenadas enteras en ese polígono. Finalmente, la línea 5 y el final de la línea 9 calculan todos los puntos que están a una distancia exactamente 1 (por lo tanto, no 0) de este conjunto de puntos enteros; ese conjunto se convierte en el camino de circunnavegación.

A continuación se muestra la salida para el caso de prueba grande en el enlace del OP. Observe en la esquina superior izquierda, las elecciones inusuales de cuándo ir al oeste versus suroeste insinúan el hecho de que está sombreando una línea invisible de pendiente -2/3 entre dos penínsulas (dicho segmento de línea es parte del límite del casco convexo).

........................
.............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 bytes (sangría con pestañas)

Este es todo el programa. Lee la entrada de stdin y la imprime en stdout. Stdin debe terminar con EOF. Ejemplo ejecutado con la entrada grande: 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))

La idea es simple: calcula los límites octogonales más pequeños y dibuja celdas que están dentro de todos los límites calculados e intersectan al menos uno de los bordes.

JavaScript (ES6), 369343 bytes

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

Explicación: La cadena se divide en una matriz de caracteres (no estoy claro si la entrada de la matriz de caracteres es aceptable). La matriz se repite y se ubican las posiciones de todos los cuadrados de tierra. Las líneas que limitan dadas por las ecuaciones x - y = o, x = p, x + y = q, y = r, y - x = t, -x = u, -x - y = v, -y = wse determinan de tal manera que el parámetro máximo posible se elige donde todas mentiras la tierra más allá de la línea. Esto tiene el efecto de encerrar la isla en un octágono. Las coordenadas de las esquinas del octágono se calculan fácilmente a partir de los parámetros y las celdas en su borde se rellenan. La matriz se vuelve a unir en una cadena. La razón por la que es suficiente un octágono es la siguiente:

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

Considere una esquina del octágono. En algún punto a lo largo de los dos bordes, el camino estará limitado por la tierra porque construimos el octágono para tocar la tierra lo más cerca posible. Si no hay tierra en la esquina, el camino podría tomar las rutas alternativas como se muestra a la derecha, pero sigue siendo el mismo número de pasos ortogonales y diagonales, por lo que la distancia no cambia.

Python 3.5, 224, 263, 234 218 bytes

Aprovechó otros 16 bytes eliminando la función anidada y convirtiéndola en una sola línea.

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]

Golfed de 29 bytes:

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)

La entrada es una sola cadena que usa '~' para el océano, 'X' para la tierra y 'o' para el límite. (El uso de 'X' guarda un byte para '>' en lugar de '==')

Versión menos golfista con comentarios:

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 bytes

Editar : cambió a 1D looping, informática iy jsobre la marcha

Editar : cambió el método de entrada, contrajo la tabla de búsqueda y cambió a límites iniciales bien definidos ... y eliminó el espacio sin sentido en el último for-loop externo

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

Pruébalo en línea

Programa completo, toma la entrada en el estándar, lo imprime a cabo estándar, usos #, .y o. Para cada celda, calcula un 'perfil' (que es la distancia sobre 8 direcciones (parece calcular una novena por conveniencia, pero esto es siempre 0), y registra un máximo de cada una de ellas. Luego escribe todo el mapa nuevamente, y reemplaza cualquier celda que esté en un límite y no fuera de ninguna con una 'o'. El código comentado a continuación explica cómo funciona todo.

Según mi respuesta a Save the Geese from Extinction , esto produce el octágono más pequeño (circunnavegación válida con el área más grande) que limita la isla.

Nota : que por una vez en mi vida estoy usando algo de la década actual, y este código requiere C # 7 para compilar. Si no tiene C # 7, hay una línea que deberá reemplazarse, que está claramente marcada en el código.

Ejemplo de uso y salida:

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

Código formateado y comentado:

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