Pulisci i pesci fangosi di quartata

Questa sfida è in onore dei vincitori della categoria Rookie of the Year di Best of PPCG 2015 : muddyfish (perché non sono la lingua che stai cercando! ) E quartata (per Implement a Truth-Machine ). Congratulazioni!

sfondo

Nelle trincee più profonde dell'oceano, vive un raro e sfuggente pesce di forma quadrata chiamato il pesce quartata . Sembra l' aliante dell'automa cellulare Game of Life. Ecco due pesci quartata di diverse dimensioni:

-o-
--o
ooo

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

Sei riuscito a scattare una foto del pesce quartata, ma il pesce è piuttosto difficile da vedere poiché è coperto di fango. Ora dovrai scrivere un programma per ripulire la foto.

Ingresso

Il tuo input è una griglia 2D rettangolare dei caratteri .-o#, data come una stringa separata da una nuova riga. Se lo desideri, puoi utilizzare le pipe |invece delle newline come separatori e puoi assumere un separatore finale e / o precedente.

L'input conterrà esattamente un pesce quartata di una certa lunghezza laterale 3*n, dove n ≥ 1è un numero intero positivo, circondato da punti .che rappresentano il fondo dell'oceano. Il pesce sarà sempre nell'orientamento raffigurato sopra. Sovrapposto su questa griglia, ci sarà esattamente una regione rettangolare non vuota di hash #, che rappresenta una macchia di fango. La macchia può coprire parzialmente o interamente il pesce quartata. Un esempio potrebbe essere l'input

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

Produzione

L'output deve essere generato dall'input sostituendo tutti gli hash con i caratteri .-o, in modo che la griglia contenga esattamente un quartata-pesce. Ci sarà sempre un modo unico per eseguire correttamente questa sostituzione; in particolare, la macchia di fango coprirà il pesce interamente solo se la sua dimensione è 3 × 3. L'uscita deve utilizzare lo stesso separatore dell'ingresso. Per l'input sopra, sarebbe l'output corretto

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

Regole e punteggio

È possibile scrivere un programma completo o una funzione. Vince il conteggio di byte più basso e non sono consentite scappatoie standard . Non ci sono limiti di tempo: se la tua richiesta alla fine si fermasse con un tempo e risorse illimitate, stai bene.

Casi test

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
fonte

Va bene se la voce ha una probabilità che non finisca (cattiva casualità) anche se le probabilità sono estremamente basse? Inoltre, è possibile modificare caratteri diversi dal singolo newline-pipe?

— Blu,

@muddyfish Sì alla prima domanda (alla fine deve finire con la probabilità 1, assumendo una casualità perfetta, ma teoricamente può funzionare per sempre), no al secondo (i personaggi sono fissi).

— Zgarb,

quindi una probabilità di 0,9 ricorrente è ok?

— Blu

@muddyfish Se stai generando griglie casuali in un ciclo fino a quando uno si adatta, va bene.

— Zgarb,

Caso di test importante: ......|......|......|...###|...###|...###(nel caso in cui una soluzione provi tutte le possibili coordinate in alto a sinistra e cerchi di adattare un 6x6 sull'area)

— Sp3000

Risposte:

Python 2, 433 411 byte

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);_

Esce con a NameError. Prende il tubo di input separato.

Sto mescolando schede e spazi qui. SE non esegue il rendering delle schede correttamente.

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

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

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

(Nota che gli spazi extra all'inizio sono solo per la bellezza e non sono effettivamente stampati)

— Blu
fonte

È possibile eliminare le schede aggiuntive nel codice e sostituirle con spazi singoli per ridurre alcuni byte (vale a dire, se si è preso in considerazione lo spazio bianco quando si contano i byte nel codice).

— R. Kap

JavaScript (ES6), 291 byte

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

Spiegazione

Accetta la griglia di input come stringa separata da una nuova riga. Non completamente golfato, farà di più quando avrò tempo.

Funziona da:

Ottenere ogni possibile posizione e dimensione di un pesce nei limiti della griglia di input.
Per ogni posizione / dimensione, costruisce una stringa di griglia con un pesce in quella posizione.
Verifica se questo è l'output corretto ripetendo ogni carattere. Se ogni carattere corrisponde o è un hash, genera la stringa creata.

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>

Espandi frammento

— user81655
fonte

Python 2, 325 byte

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('#','.')

Per ora una soluzione malamente giocata a golf: gli for .. in range(...)s sono un totale disastro ferroviario. Input / output stringhe separate newline.

Il conteggio dei byte attualmente presuppone solo i rientri di spazio: passerò a schede / spazi misti più tardi quando avrò finito di giocare a golf, se necessario.

— SP3000
fonte