Limpia el pez cuartata fangoso

Este desafío es en honor a los ganadores de la categoría Novato del año de Best of PPCG 2015 : muddyfish (¡porque no soy el idioma que estás buscando! ) Y quartata (por Implementar una máquina de la verdad ). ¡Felicidades!

Fondo

En las trincheras más profundas del océano, vive un raro y esquivo pez de forma cuadrada llamado quartata-fish . Parece el planeador del autómata celular Game of Life. Aquí hay dos peces quartata de diferentes tamaños:

-o-
--o
ooo

--oo--
--oo--
----oo
----oo
oooooo
oooooo

Has logrado tomar una foto del pez quartata, pero el pez es bastante difícil de ver ya que está cubierto de barro. Ahora tendrá que escribir un programa para limpiar la foto.

Entrada

Su entrada es una cuadrícula 2D rectangular de los caracteres .-o#, dada como una cadena separada por una nueva línea. Si lo desea, puede usar tuberías en |lugar de líneas nuevas como separadores, y puede suponer un separador final y / o anterior.

La entrada contendrá exactamente un pez quartata de cierta longitud lateral 3*n, donde n ≥ 1es un número entero positivo, rodeado de períodos .que representan el fondo del océano. El pez siempre estará en la orientación representada arriba. Superpuesto en esta cuadrícula, habrá exactamente una región rectangular de hashes no vacía #, que representa una gota de lodo. La gota puede cubrir al pez quartata parcial o totalmente. Un ejemplo de entrada sería

............
..--oo--....
..--oo--....
..---#####..
..---#####..
..ooo#####..
..oooooo....

Salida

Su salida se generará a partir de la entrada reemplazando todos los hashes con los caracteres .-o, de modo que la cuadrícula contenga exactamente un pez quartata. Siempre habrá una forma única de realizar este reemplazo correctamente; en particular, la gota de lodo cubrirá completamente a los peces solo si su tamaño es de 3 × 3. La salida utilizará el mismo separador que la entrada. Para la entrada anterior, la salida correcta sería

............
..--oo--....
..--oo--....
..----oo....
..----oo....
..oooooo....
..oooooo....

Reglas y puntaje

Puede escribir un programa completo o una función. El conteo de bytes más bajo gana, y las lagunas estándar no se permiten. No hay límites de tiempo: si su envío eventualmente detendría el tiempo y los recursos ilimitados, está bien.

Casos de prueba

Input:
.......
...-o-.
...--o.
##.ooo.
##.....
Output:
.......
...-o-.
...--o.
...ooo.
.......

Input:
...-o-.
...-#o.
...ooo.
.......
Output:
...-o-.
...--o.
...ooo.
.......

Input:
.........
.###.....
.###.....
.ooo.....
Output:
.........
.-o-.....
.--o.....
.ooo.....

Input:
.....
.###.
.###.
.###.
Output:
.....
.-o-.
.--o.
.ooo.

Input:
......
......
......
...###
...###
...###
Output:
......
......
......
...-o-
...--o
...ooo

Input:
###o--....
###o--....
###-oo....
###-oo....
###ooo....
###ooo....
###.......
Output:
--oo--....
--oo--....
----oo....
----oo....
oooooo....
oooooo....
..........

Input:
............
..--oo--....
..--oo--....
..---#####..
..---#####..
..ooo#####..
..oooooo....
Output:
............
..--oo--....
..--oo--....
..----oo....
..----oo....
..oooooo....
..oooooo....

Input:
...--oo--....
.#########...
.#########...
.#########...
...oooooo....
...oooooo....
.............
.............
Output:
...--oo--....
...--oo--....
...----oo....
...----oo....
...oooooo....
...oooooo....
.............
.............

Input:
..............
..............
.########.....
.########.....
.########-....
.########-....
.########o....
.########o....
.########o....
.########o....
.########.....
..............
Output:
..............
..............
..............
..............
....--oo--....
....--oo--....
....----oo....
....----oo....
....oooooo....
....oooooo....
..............
..............

Input:
.................
.................
..---ooo---......
..--#########....
..--#########....
..--#########....
..--#########....
..--#########....
..oo#########....
..oo#########....
..oo#########....
....#########....
Output:
.................
.................
..---ooo---......
..---ooo---......
..---ooo---......
..------ooo......
..------ooo......
..------ooo......
..ooooooooo......
..ooooooooo......
..ooooooooo......
.................

Input:
.........................
.........................
....----oooo----.........
....----########.........
....----########.........
....----########.........
....----########.........
....----########.........
....----########.........
....----########.........
....oooo########.........
....oooo########.........
....oooooooooooo.........
....oooooooooooo.........
.........................
Output:
.........................
.........................
....----oooo----.........
....----oooo----.........
....----oooo----.........
....----oooo----.........
....--------oooo.........
....--------oooo.........
....--------oooo.........
....--------oooo.........
....oooooooooooo.........
....oooooooooooo.........
....oooooooooooo.........
....oooooooooooo.........
.........................

code-golf ascii-art grid

— Zgarb
fuente

¿Está bien si la entrada tiene una probabilidad de que no termine (mala aleatoriedad) a pesar de que las posibilidades son extremadamente bajas? ¿También se le permite cambiar los caracteres que no sean la tubería nueva?

— Azul

@muddyfish Sí a la primera pregunta (eventualmente debe terminar con probabilidad 1, suponiendo una aleatoriedad perfecta, pero teóricamente puede correr para siempre), no a la segunda (los caracteres son fijos).

— Zgarb

entonces es una probabilidad de 0.9 recurrente ok?

— Azul

@muddyfish Si está generando cuadrículas aleatorias en un bucle hasta que encaje, está bien.

— Zgarb

Caso de prueba importante: ......|......|......|...###|...###|...###(en caso de que una solución intente todas las coordenadas posibles arriba a la izquierda e intente colocar un 6x6 sobre el área)

— Sp3000

Respuestas:

Python 2, 433 411 bytes

import re;i,o,l,j=input(),range,lambda s,r:s.replace(*r),"".join;i=l(l(l(i,".1"),"#."),"| ");s=o(len(i))
for x in s:
 for y in s:
    for q in s:
     r=map(list,l(l(i,"o."),"-.").split(" "))
     try:
        for v in o(q):r[x+v][y:y+q]=["".join(c*(q/3)for c in b)for b in["-o-","--o","ooo"]][3*v/q]
        m=re.match(i," ".join(j(i)for i in r))
     except:0
     if sum("-"in p for p in r)and m:print"|".join(l(j(i),"1.")for i in r);_

Salidas con a NameError. Toma la tubería de entrada separada.

Estoy mezclando pestañas y espacios aquí. SE no procesa las pestañas correctamente.

'###o--....|###o--....|###-oo....|###-oo....|###ooo....|###ooo....|###.......'
 --oo--....|--oo--....|----oo....|----oo....|oooooo....|oooooo....|..........

'.....|.###.|.###.|.###.'
 .....|.-o-.|.--o.|.ooo.

'...-o-.|...-#o.|...ooo.|.......'
 ...-o-.|...--o.|...ooo.|.......

(Tenga en cuenta que los espacios adicionales al inicio son solo para la belleza y no están realmente impresos)

— Azul
fuente

Puede deshacerse de las pestañas adicionales en su código y reemplazarlas con espacios individuales para reducir algunos bytes (es decir, si tuvo en cuenta el espacio en blanco al contar los bytes en su código).

— R. Kap

JavaScript (ES6), 291 bytes

g=>eval('w=g.search`\n`;h=g.length/w|0;for(n=(w<h?w:h)/3|0;s=n*3;n--)for(x=w+1-s;x--;)for(y=h+1-s;y--;[...g].every((c,i)=>c==o[i]|c=="#")?z=p:0)for(p="",i=h;i--;)p=(l=[,"-o-","--o","ooo"][(i-y)/n+1|0],l?"."[t="repeat"](x)+l.replace(/./g,c=>c[t](n))+"."[t](w-x-s):"."[t](w))+(p?`\n`:"")+p;z')

Explicación

Toma la cuadrícula de entrada como una cadena separada de nueva línea. No completamente golf, haré más cuando tenga tiempo.

Funciona por:

Obtener todas las posiciones y tamaños posibles de un pez en los límites de la cuadrícula de entrada.
Para cada posición / tamaño, construye una cadena de cuadrícula con un pez en esa posición.
Comprueba si esta es la salida correcta iterando sobre cada carácter. Si cada carácter coincide o es un hash, genera la cadena construida.

var solution =

g=>
  eval(`

    // Get size of input grid
    w=g.search\`\n\`;
    h=g.length/w|0;

    // Check every possible size (n) and position (x and y) of fish
    for(n=(w<h?w:h)/3|0;s=n*3;n--)
      for(x=w+1-s;x--;)
        for(y=h+1-s;y--;

          // Check if possible solution matches input grid
          [...g].every((c,i)=>c==p[i]|c=="#")?z=p:0
        )

          // Create possible solution grid
          for(p="",i=h;i--;)
            p=(
              l=[,"-o-","--o","ooo"][(i-y)/n+1|0],
              l?
                "."[t="repeat"](x)+
                l.replace(/./g,c=>c[t](n))+
                "."[t](w-x-s)
              :"."[t](w)
            )+(p?\`\n\`:"")+p;
    z
  `)

<textarea id="input" rows="6" cols="40">..............
..............
.########.....
.########.....
.########-....
.########-....
.########o....
.########o....
.########o....
.########o....
.########.....
..............</textarea><br />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

Expandir fragmento

— usuario81655
fuente

Python 2, 325 bytes

def f(s):
 s=map(list,s.split());R=range;L=len(s);M=len(s[0])
 for h in R(L/3*3,0,-3):
  for x in R(M-h+1):
   for y in R(L-h+1):
    if all(s[v%L][v/L]in".-#o #"[0<=v%L-y<h>v/L-x>=0::2]for v in R(L*M)):
     for k in R(h*h):s[y+k/h][x+k%h]="-o"[482>>k/h*3/h*3+k%h*3/h&1]
     return'\n'.join(map(''.join,s)).replace('#','.')

Una solución mal desarrollada por ahora: los for .. in range(...)s son un completo choque de trenes. Entradas / salidas de cadenas separadas por nueva línea.

El recuento de bytes actualmente asume solo sangrías de espacio: más adelante cambiaré a pestañas / espacios mixtos cuando termine de jugar al golf, si es necesario.

— Sp3000
fuente