Nettoyez le poisson-quartata boueux

Ce défi est en l'honneur des lauréats de la catégorie Recrue de l'année du Meilleur de PPCG 2015 : muddyfish (car je ne suis pas la langue que vous recherchez! ) Et quartata (pour Implémenter une machine à vérité ). Toutes nos félicitations!

Contexte

Dans les tranchées les plus profondes de l'océan, vit un poisson de forme carrée rare et insaisissable appelé poisson quartata . Il ressemble au planeur de l'automate cellulaire Game of Life. Voici deux poissons quartata de tailles différentes:

-o-
--o
ooo

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

Vous avez réussi à prendre une photo du poisson quartata, mais le poisson est assez difficile à voir car il est couvert de boue. Vous devrez maintenant écrire un programme pour nettoyer la photo.

Contribution

Votre entrée est une grille 2D rectangulaire des caractères .-o#, donnée sous forme de chaîne séparée par des sauts de ligne. Si vous le souhaitez, vous pouvez utiliser des tuyaux |au lieu de retours à la ligne comme séparateurs et vous pouvez supposer un séparateur de fin et / ou précédent.

L'entrée contiendra exactement un quartata-poisson d'une certaine longueur latérale 3*n, où n ≥ 1est un entier positif, entouré de périodes .qui représentent le fond de l'océan. Le poisson sera toujours dans l'orientation décrite ci-dessus. Superposé sur cette grille, il y aura exactement une région rectangulaire de hachage non vide #, qui représente une goutte de boue. La goutte peut couvrir partiellement ou entièrement le poisson quartata. Un exemple d'entrée serait

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

Sortie

Votre sortie doit être générée à partir de l'entrée en remplaçant tous les hachages par les caractères .-o, afin que la grille contienne exactement un quartata-fish. Il y aura toujours un moyen unique d'effectuer correctement ce remplacement; en particulier, la goutte de boue ne couvrira entièrement le poisson que si sa taille est de 3 × 3. La sortie doit utiliser le même séparateur que l'entrée. Pour l'entrée ci-dessus, la sortie correcte serait

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

Règles et notation

Vous pouvez écrire un programme complet ou une fonction. Le nombre d'octets le plus bas l'emporte et les failles standard sont interdites. Il n'y a pas de limite de temps: si votre soumission finissait par s'arrêter avec un temps et des ressources illimités, tout va bien.

Cas de 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
source

Est-ce correct si l'entrée a une probabilité qu'elle ne se termine pas (mauvais hasard) même si les chances sont extrêmement faibles? Êtes-vous également autorisé à modifier les caractères autres que le simple saut de ligne?

— Blue

@muddyfish Oui à la première question (elle doit finir par la probabilité 1, en supposant un hasard parfait, mais peut théoriquement fonctionner pour toujours), non à la seconde (les caractères sont fixes).

— Zgarb

est donc une probabilité de 0,9 récurrente ok?

— Blue

@muddyfish Si vous générez des grilles aléatoires dans une boucle jusqu'à ce qu'il y en ait une, c'est correct.

— Zgarb

Cas de test important: ......|......|......|...###|...###|...###(dans le cas où une solution essaie toutes les coordonnées possibles en haut à gauche et essaie d'ajuster un 6x6 sur la zone)

— Sp3000

Réponses:

Python 2, 433 411 octets

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

Quitte avec a NameError. Prend le tuyau d'entrée séparé.

Je mélange des tabulations et des espaces ici. SE ne rend pas les onglets correctement.

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

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

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

(Notez que les espaces supplémentaires au début sont réservés à la beauté et ne sont pas réellement imprimés)

— Bleu
source

Vous pouvez vous débarrasser des onglets supplémentaires dans votre code et les remplacer par des espaces simples pour réduire quelques octets (c'est-à-dire si vous avez pris en compte l'espace blanc lors du comptage des octets dans votre code).

— R. Kap

JavaScript (ES6), 291 octets

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

Explication

Prend la grille d'entrée comme une chaîne séparée par des sauts de ligne. Pas complètement golfé, fera plus quand j'aurai le temps.

Il fonctionne par:

Obtenir toutes les positions et tailles possibles d'un poisson dans les limites de la grille d'entrée.
Pour chaque position / taille, il construit une chaîne de grille avec un poisson dans cette position.
Vérifie s'il s'agit de la sortie correcte en itérant sur chaque caractère. Si chaque caractère correspond ou est un hachage, il génère la chaîne construite.

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>

Développer l'extrait

— user81655
source

Python 2, 325 octets

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

Une solution mal golfée pour l'instant - les for .. in range(...)s sont une épave de train totale. Entrées / sorties de chaînes séparées par une nouvelle ligne.

Le nombre d'octets suppose actuellement des retraits d'espace uniquement - je passerai plus tard à des onglets / espaces mixtes lorsque j'aurai fini de jouer au golf, si nécessaire.

— Sp3000
source