Te dan una cuadrícula hexagonal de los personajes .y #, así:

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

Su tarea es llenar todo el cuadro delimitador alineado con el eje #con #:

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

El cuadro delimitador alineado con el eje es la forma hexagonal convexa más pequeña que contiene todo #. Tenga en cuenta que en el caso de la cuadrícula hexagonal, hay tres ejes a considerar (W / E, SW / NE, NW / SE):

Aquí hay otro ejemplo para mostrar que en algunos casos, uno o más lados contendrán solo uno #:

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

Puede verlos como hexágonos con lados degenerados, o puede dibujar el cuadro delimitador alrededor de ellos, como he hecho anteriormente, en cuyo caso todavía son hexágonos:

¿Demasiado duro? ¡Prueba la parte I!

Reglas

Puede usar cualquiera de los dos caracteres ASCII imprimibles distintos de espacio (0x21 a 0x7E, inclusive), en lugar de #y .. Sin embargo , continuaré refiriéndome a ellos como #y .para el resto de la especificación.

La entrada y la salida pueden ser una sola cadena separada por salto de línea o una lista de cadenas (una para cada línea), pero el formato debe ser coherente.

Puede suponer que la entrada contiene al menos una #y todas las líneas tienen la misma longitud. Tenga en cuenta que hay dos "tipos" diferentes de líneas (comenzando con un espacio o un no-espacio) - es posible que no se asuma que la entrada se inicia siempre con el mismo tipo. Puede suponer que el cuadro delimitador siempre cabe dentro de la cuadrícula que se le proporciona.

Puede escribir un programa o una función y utilizar cualquiera de nuestros métodos estándar para recibir entradas y proporcionar salidas.

Puede usar cualquier lenguaje de programación , pero tenga en cuenta que estas lagunas están prohibidas de forma predeterminada.

Este es el código de golf , por lo que gana la respuesta válida más corta, medida en bytes .

Casos de prueba

Cada caso de prueba tiene entrada y salida una al lado de la otra.

#    #

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

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

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

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

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

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

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

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

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

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

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

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

Pyth , 82 71 bytes

L, hbebMqH @ S + GH1KhMyJs.e, Lkfq \ # @ bTUb.zA, ySm-FdJySsMJj.es.eXW && gKkgG-kYgH + kYZ \. \ # Bz
MqH @ S [hGHeG) 1j.es.eXW && ghMJs.e, Lkfq \ # @ bTUb.zkgSm-FdJ-kYgSsMJ + kYZ \. \ # Bz

Pruébalo en línea!

Explicación

• Sea A el punto con la coordenada y más baja y B el punto con la coordenada y más alta.

• Sea C el punto con el más bajo (valor x menos el valor y) y D el punto con el más alto.

• Sea E el punto con el valor más bajo (valor x más valor y) y F el punto con el valor más alto.

Entonces es equivalente a encontrar las coordenadas en las que la coordenada y está entre A y B, el valor x menos el valor y está entre C y D, y el valor x más el valor y está entre E y F.

Haskell, 256 254 243 bytes

import Data.List
f=z(\l->(,).(,))[0..]l)[0..]
q l=m(m(\e->min(snd e).(".#"!!).fromEnum.and.z($)(m(\x y->y>=minimum x&&y<=maximum x).transpose.m b.filter((==)'#'.snd).concat$l)$b e))l
b=(m uncurry[const,(-),(+)]<*>).pure.fst
z=zipWith
m=map
q.f

¡Gracias @Damien por jugar al golf f!

La entrada se toma como una lista de caracteres, la salida se proporciona de la misma manera.

Así que esta era una bestia para escribir. Se basa en la idea de LeakyNun utilizando un filtrado basado en máximo y mínimo en las coordenadas de los elementos.

Estoy realmente sorprendido por el hecho de que m=maprealmente ahorra bytes, ya que parece muy costoso.

Explicación:

Aquí hay una versión ligeramente menos descuartizada (énfasis en ligeramente ):

import Data.List
f=zipWith(\y l->zipWith(\x e->((y,x),e))[0..]l)[0..]
p=map(\x y->y>=minimum x&&y<=maximum x).transpose.map b.filter((==)'#'.snd).concat
q l=map(map(\e->min(snd e).(".#"!!).fromEnum.and.zipWith($)(p$l)$b e))l
b=(map uncurry[const,(-),(+)]<*>).pure.fst

• fes una función que asigna a cada carácter un índice (y-index, x-index)mientras preserva la estructura original de la lista.

• b: Dado un elemento de la lista indexada, bcomputa [y-index, y - x, y + x].

• p: Dado el campo indexado, devuelve 3 funciones Int -> Bool, la primera de las cuales es la verificación del índice y, la segunda de la diferencia y la tercera de la suma. min(snd e)cuida los espacios (un espacio es más pequeño que ambos). Esta función está incorporada en el código de golf.

• qdado el campo indexado, cambie todo lo necesario .para #verificar si ese campo específico vuelve Truea cada función de prueba.

La solución final es entonces la composición de qy f.

Python 3, 380 378 348 346 bytes

Tenga en cuenta que la sangría es con pestañas, no espacios.

Versión de golf:

def s(i):
    L=i.splitlines();E=enumerate;A=lambda x,y:(y,x+y,x-y);N=(2**64,)*3;X=(-2**64,)*3
    for y,l in E(L):
        for x,c in E(l):
            if c=='#':p=A(x,y);X=tuple(map(max,X,p));N=tuple(map(min,N,p))
    R=''
    for y,l in E(L):
        for x,c in E(l):
            if c!='.':R+=c
            else:p=A(x,y);f=all(N[j]<=p[j]<=X[j]for j in range(0,3));R+='.#'[f]
        R+='\n'
    return R

Pruébalo en Ideone

Explicación (para la versión no golfizada a continuación):

Todo el procesamiento se realiza sin ninguna conversión, los caracteres de espacio simplemente se omiten.
La función axes_poscalcula 3-tuplas de coordenadas imaginarias "3D", se acumulan en (mínimo en elementos) 3-tuplas máximas ( bmin, bmax) para todos los #caracteres.

Las coordenadas se calculan en def axes_pos(x, y): return y, x + y, lc - y + x;
donde X cuenta de 0 a derecha e Y cuenta de 0 a abajo (de la primera línea a la última).
La primera coordenada imaginaria es básicamente Y, porque es obvio por qué. Su hacha es ortogonal a los límites verdes (en las imágenes del OP). La
segunda es ortogonal a los límites rojos, y la tercera es ortogonal a los límites azules.

En la segunda pasada, el reemplazo se realiza para todos los .caracteres cuyas coordenadas "3D" caen dentro de bmin... bmaxrango, elemento inteligente: esto se verifica en esta expresión all(bmin[j] <= p[j] <= bmax[j] for j in range(0, 3)).

Versión sin golf con pruebas, también en Ideone :

def solve(i):
    ls = i.splitlines()
    lc = len(ls)

    def axes_pos(x, y):
        return y, x + y, lc - y + x

    I = 2 ** 64
    bmin = (I, I, I)
    bmax = (0, 0, 0)

    for y, line in enumerate(ls):
        for x, char in enumerate(line):
            if char != '#': continue
            p = axes_pos(x, y)
            bmax = tuple(map(max, bmax, p))
            bmin = tuple(map(min, bmin, p))

    result = ''
    for y, line in enumerate(ls):
        for x, char in enumerate(line):
            if char != '.':
                result += char
            else:
                p = axes_pos(x, y)
                f = all(bmin[j] <= p[j] <= bmax[j] for j in range(0, 3))
                result += '#' if f else char
        result += '\n'

    return result


def run_test(a, b):
    result = solve(a)
    if result != b:
        raise AssertionError('\n' + result + '\n\nshould be equal to\n\n' + b)


def run_tests():
    run_test(
        "#\n",

        "#\n")

    run_test(
        " . . \n"
        "# . #\n"
        " . . \n",

        " . . \n"
        "# # #\n"
        " . . \n")

    run_test(
        " . # \n"
        ". . .\n"
        " # . \n",

        " . # \n"
        ". # .\n"
        " # . \n")

    run_test(
        " # . \n"
        ". . .\n"
        " . # \n",

        " # . \n"
        ". # .\n"
        " . # \n")

    run_test(
        " # . \n"
        "# . .\n"
        " . # \n",

        " # . \n"
        "# # .\n"
        " # # \n")

    run_test(
        " . # \n"
        "# . .\n"
        " . # \n",

        " # # \n"
        "# # #\n"
        " # # \n")

    run_test(
        ". . . . . . . . \n"
        " . . # . # . . .\n"
        ". . . . . . . . \n"
        " . . . # . . . .\n",

        ". . . . . . . . \n"
        " . . # # # . . .\n"
        ". . . # # . . . \n"
        " . . . # . . . .\n")

    run_test(
        ". . . . . . . . \n"
        " . . # . . . # .\n"
        ". . . . . . . . \n"
        " . . . # . . . .\n",

        ". . . . . . . . \n"
        " . . # # # # # .\n"
        ". . . # # # # . \n"
        " . . . # # # . .\n")

    run_test(
        ". . . . . . . . \n"
        " . # . . . . . .\n"
        ". . . . . # . . \n"
        " . . . . . . . .\n",

        ". . . . . . . . \n"
        " . # # # # . . .\n"
        ". . # # # # . . \n"
        " . . . . . . . .\n")

    run_test(
        ". . . . . . . . \n"
        " . # . . . . . .\n"
        ". . . . . # . . \n"
        " . . # . . . . .\n",

        ". . . . . . . . \n"
        " . # # # # . . .\n"
        ". . # # # # . . \n"
        " . . # # # . . .\n")

    run_test(
        ". . . . # . . . \n"
        " . # . . . # . .\n"
        ". . . # . . . . \n"
        " . . . . . # . .\n",

        ". . # # # # . . \n"
        " . # # # # # . .\n"
        ". . # # # # # . \n"
        " . . # # # # . .\n")


if __name__ == '__main__':
    run_tests()

Eliminado innecesario -1para la tercera coordenada imaginaria, porque no cambia nada

Mejoras parcialmente implementadas sugeridas por Leaky Nun+ my own también.

Gelatina , 45 35 ₁₃ 42 41 bytes

Ṁ€»\
ṚÇṚ«Çṁ"
ŒDṙZL$ÇṙL’$ŒḌ«Ç
ṚÇṚ«Ç
n⁶aÇo⁶

Esta es una lista de enlaces; el último tiene que ser llamado en la entrada para producir la salida.

I / O está en forma de matrices de cadenas, donde .indica vacío e @indica lleno.

Pruébalo en línea! o verificar todos los casos de prueba .

Fondo

Consideremos el siguiente ejemplo.

. . . . . . . . 
 . @ . . . . . .
. . . . . @ . . 
 . . @ . . . . .

Al dibujar un par o líneas paralelas, el par más cercano que encierra todas las posiciones rellenas, en cada una de las tres direcciones, podemos determinar el cuadro de límite hexagonal.

En la implementación, reemplazamos todos los caracteres entre esas dos líneas con @, y todo lo que esté fuera de estas líneas ., con la posible excepción de diagonales que solo contienen espacios).

Para el eje horizontal, esto da

................
@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@

para el eje diagonal descendente, da

..@@@@@@@......
...@@@@@@@......
....@@@@@@@.....
 ....@@@@@@@....

y para el eje diagonal de elevación, da

....@@@@@@@@@...
...@@@@@@@@@....
..@@@@@@@@@....
.@@@@@@@@@.... .

Al tomar el mínimo en cuanto a carácter de los tres, ya que .< @, obtenemos

...............
...@@@@@@@......
....@@@@@@@....
 ....@@@@@.... .

Todo lo que queda por hacer es restaurar los espacios.

Cómo funciona

n⁶aÇo⁶           Main link. Argument: A (array of strings)

n⁶               Not-equal space; yield 0 for spaces, 1 otherwise.
  aÇ             Take the logical AND with the result the 4th helper link.
                 This will replace 1's (corresponding to non-space characters) with
                 the corresponding character that result from calling the link.
    o⁶           Logical OR with space; replaces the 0's with spaces.

ṚÇṚ«Ç            4th helper link. Argument: A

Ṛ                Reverse the order of the strings in A.
 Ç               Call the 3rd helper link.
  Ṛ              Reverse the order of the strings in the resulting array.
    Ç            Call the 3rd helper link with argument A (unmodified).
   «             Take the character-wise minimum of both results.

ŒDṙZL$ÇṙL’$ŒḌ«Ç  3rd helper link. Argument: L (array of strings)

ŒD               Yield all falling diagonals of L. This is a reversible operation,
                 so it begins with the main diagonal.
   ZL$           Yield the length of the transpose (number of columns).
  ṙ              Shift the array of diagonals that many units to the left.
                 This puts the diagonals in their natural order.
      Ç          Call the helper link on the result.
        L’$      Yield the decremented length (number of columns) of L.
       ṙ         Shift the result that many units to the left.
                 This puts the changed diagonals in their original order.
           ŒḌ    Undiagonal; reconstruct the string array.
              Ç  Call the 2nd helper link with argument L (unmodified).
             «   Take the character-wise minimum of both results.

ṚÇṚ«Çṁ"          2nd helper link. Argument: M (array)

Ṛ                Reverse the rows of M.
 Ç               Call the 1st helper link on the result.
  Ṛ              Reverse the rows of the result.
    Ç            Call the 1nd helper link with argument M (unmodified).
   «             Take the minimum of both results.
     ṁ"          Mold zipwith; repeat each character in the result to the left
                 as many times as needed to fill the corresponding row of M.

Ṁ€»\             1st helper link. Argument: N (array)

Ṁ€               Take the maximum of each row of N.
  »\             Take the cumulative maxima of the resulting characters.

Python, 237 230 bytes

7 bytes gracias a Dennis.

def f(a):i=range(len(a[0]));j=range(len(a));b,c,d=map(sorted,zip(*[[x,x+y,x-y]for y in i for x in j if"?"<a[x][y]]));return[[[a[x][y],"#"][(a[x][y]>" ")*(b[0]<=x<=b[-1])*(c[0]<=x+y<=c[-1])*(d[0]<=x-y<=d[-1])]for y in i]for x in j]

Puerto de mi respuesta en Pyth .

Toma una matriz de líneas como entrada, emite una matriz 2D de caracteres.

• Python 2: ¡ Ideónalo!
• Python 3: ¡ Ideónalo!

Perl, 128 126 bytes

Incluye +6 para -0F\n

Ejecutar con entrada en STDIN. Uso 1para lleno, 0para vacío. Las líneas no tienen que rellenarse con espacios al final:

perl -M5.010 hexafill.pl
 0 0 0 0 0 0 0 0
0 0 1 1 1 1 0 0 
 0 1 1 1 1 1 0 0
0 0 1 1 1 1 1 0 
 0 0 1 1 1 1 0 0
0 0 0 0 0 0 0 0 
^D

hexafill.pl

#!/usr/bin/perl -0F\n
$-=map{s%$=%$=^!map{/$/;grep{pos=$`;$=?$_|="!"x$`.1:!/\b.*\G./}${--$@}}@F-$-+pos,$-+pos,$-%eeg;--$-;$=||say}@F while$=--

Utiliza coordenadas de cubo. Determine el máximo y el mínimo durante el $= == 1ciclo y complete las coordenadas entre estos límites durante el $= == 0ciclo. Los primeros 58 bucles no tienen sentido y solo están allí para llenar $-con el número de líneas

TSQL, 768 bytes

Escribí una consulta para resolver esto, que encontré bastante difícil. No puede competir con todas las excelentes respuestas más cortas. Pero quería publicarlo de todos modos para aquellos interesados. Perdón por la longitud de la respuesta: esperar que codegolf también se trate de enfoques diferentes.

Golfizado:

DECLARE @ varchar(max)=
'
. . . . # . . . 
 . # . . . # . .
. . . # . . . . 
 . . . . . # . .
. . . . . . . . 
'

;WITH c as(SELECT cast(0as varchar(max))a,x=0,y=1,z=0UNION ALL SELECT SUBSTRING(@,z,1),IIF(SUBSTRING(@,z,1)=CHAR(10),1,x+1),IIF(SUBSTRING(@,z,1)=CHAR(10),y+1,y),z+1FROM c WHERE LEN(@)>z)SELECT @=stuff(@,z-1,1,'#')FROM c b WHERE((exists(SELECT*FROM c WHERE b.y=y and'#'=a)or exists(SELECT*FROM c WHERE b.y<y and'#'=a)and exists(SELECT*FROM c WHERE b.y>y and'#'=a))and a='.')and(exists(SELECT*FROM c WHERE b.x<=x-ABS(y-b.y)and'#'=a)or exists(SELECT*FROM c WHERE b.x<=x+y-b.y and a='#'and b.y<y)and exists(SELECT*FROM c WHERE b.x<=x+b.y-y and a='#'and b.y>y))and(exists(SELECT*FROM c WHERE b.x>=x+ABS(y-b.y)and'#'=a)or exists(SELECT*FROM c WHERE b.x>=x-y+b.y and b.y<y and'#'=a)and exists(SELECT*FROM c WHERE b.x>=x-b.y+y and a='#'and b.y>y))OPTION(MAXRECURSION 0)PRINT @

Sin golf:

DECLARE @ varchar(max)=
'
. . . . # . . . 
 . # . . . # . .
. . . # . . . . 
 . . . . . # . .
. . . . . . . . 
'
;WITH c as
(
  SELECT 
    cast(0as varchar(max))a,x=0,y=1,z=0
  UNION ALL
  SELECT
    SUBSTRING(@,z,1),IIF(SUBSTRING(@,z,1)=CHAR(10),1,x+1),
    IIF(SUBSTRING(@,z,1)=CHAR(10),y+1,y),
    z+1
  FROM c
  WHERE LEN(@)>z
)
SELECT @=stuff(@,z-1,1,'#')FROM c b
WHERE((exists(SELECT*FROM c WHERE b.y=y and'#'=a)
or exists(SELECT*FROM c WHERE b.y<y and'#'=a)
and exists(SELECT*FROM c WHERE b.y>y and'#'=a)
)and a='.')
and 
(exists(SELECT*FROM c WHERE b.x<=x-ABS(y-b.y)and'#'=a)
or exists(SELECT*FROM c WHERE b.x<=x+y-b.y and a='#'and b.y<y)
and exists(SELECT*FROM c WHERE b.x<=x+b.y-y and a='#'and b.y>y))
and(exists(SELECT*FROM c WHERE b.x>=x+ABS(y-b.y)and'#'=a)
or exists(SELECT*FROM c WHERE b.x>=x-y+b.y and b.y<y and'#'=a)
and exists(SELECT*FROM c WHERE b.x>=x-b.y+y and a='#'and b.y>y))
OPTION(MAXRECURSION 0) 
PRINT @

Violín sin golf

Octava GNU, 212 , 196 bytes

Tal vez no sea el idioma de elección favorito de un golfista, pero eso es lo que hace el desafío, ¿no? Suponiendo que m se toma como una matriz de caracteres: 178 bytes independientes y 196 si se introducen en una función .

golfizado:

function k=f(m)[a,b]=size(m);[y,x]=ndgrid(1:a,1:b);t={y,y+x,x-y};k=m;s=x>0;for j=1:3l{j}=unique(sort(vec(t{j}.*(m==['#']))))([2,end]);s&=(l{j}(1)<=t{j})&(l{j}(2)>=t{j});endk(s&mod(x+y,2))=['#']end

sin golf:

function k=f(m)
[a,b]=size(m);[y,x]=ndgrid(1:a,1:b);t={y,y+x,x-y};k=m;s=x>0;
for j=1:3
  l{j}=unique(sort(vec(t{j}.*(m==['#']))))([2,end]);
  s&=(l{j}(1)<=t{j})&(l{j}(2)>=t{j});
end
k(s&mod(x+y,2))=['#']
end

Explicación : construimos un sistema de coordenadas, 3 ejes, ortogonales a los lados de los hexágonos, encontramos el máximo y el mínimo de cada coordenada, luego construimos una máscara lógica que comienza con 1 en todas partes y lógicamente y: ajustando cada coordenada máxima y mínima, finalmente restableciendo cada posición "verdadera" restante a "#" char.

Si quieres probarlo, puedes crear una matriz m como esta:

m = [' . . . . . . . .. . . . # . . .  . # . . . # . .. . . # . . . .  . . . . . # . .. . . . . . . . ']; m = reshape(m,[numel(m)/6,6])';

y luego llame a f (m) y compare con m construyendo una matriz con ambos en:

['     before           after      ';m,ones(6,1)*'|',f(m)]