Ti viene data una griglia esagonale dei personaggi .e #, in questo modo:

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

Il tuo compito è riempire ulteriormente il riquadro di delimitazione allineato agli assi #con #:

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

Il riquadro di delimitazione allineato all'asse è la forma esagonale convessa più piccola che contiene tutto il #. Si noti che nel caso della griglia esagonale, ci sono tre assi da considerare (W / E, SW / NE, NW / SE):

Ecco un altro esempio per mostrare che in alcuni casi, uno o più lati conterranno solo uno #:

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

Puoi vederli come esagoni con lati degeneri, oppure puoi disegnare il riquadro di delimitazione attorno a loro, come ho fatto sopra, nel qual caso sono ancora esagoni:

Troppo difficile? Prova la parte I!

Regole

È possibile utilizzare due caratteri ASCII stampabili non spaziali distinti (da 0x21 a 0x7E, inclusi), al posto di #e .. Continuerò a fare riferimento a loro come #e .per il resto delle specifiche.

L'input e l'output possono essere una stringa separata da un singolo avanzamento riga o un elenco di stringhe (una per ogni riga), ma il formato deve essere coerente.

Si può presumere che l'input contenga almeno una #e tutte le linee abbiano la stessa lunghezza. Nota che ci sono due diversi "tipi" di linee (che iniziano con uno spazio o un non-spazio) - si può non dare per scontato che l'ingresso inizia sempre con lo stesso tipo. Puoi presumere che il rettangolo di selezione si adatti sempre alla griglia che ti viene data.

È possibile scrivere un programma o una funzione e utilizzare uno qualsiasi dei nostri metodi standard per ricevere input e fornire output.

È possibile utilizzare qualsiasi linguaggio di programmazione , ma si noti che queste scappatoie sono vietate per impostazione predefinita.

Questo è code-golf , quindi la risposta valida più breve - misurata in byte - vince.

Casi test

Ogni test case ha input e output uno accanto all'altro.

#    #

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

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

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

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

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

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

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

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

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

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

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

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

Pyth , 82 71 byte

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

Provalo online!

Spiegazione

• Sia A il punto con la coordinata y più bassa e B il punto con la coordinata y più alta.

• Sia C il punto con il valore più basso (valore x meno il valore y) e D il punto con il valore più alto.

• Sia E il punto con il valore più basso (valore x più valore y) e F il punto con il valore più alto.

Quindi equivale a trovare le coordinate in cui la coordinata y è tra A e B, il valore x meno il valore y è compreso tra C e D e il valore x più il valore y è compreso tra E e F.

Haskell, 256254 243 byte

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

Grazie @Damien per il golf f!

L'input viene considerato come un elenco di elenchi di caratteri, l'output viene fornito allo stesso modo.

Quindi questa era una bestia da scrivere. Si basa sull'idea di LeakyNun che utilizza un filtro basato su massimo e minimo sulle coordinate degli oggetti.

Sono davvero sorpreso dal fatto che in m=maprealtà salva byte poiché sembra così costoso.

Spiegazione:

Ecco una versione leggermente meno macellata (enfasi su leggermente ):

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

• fè una funzione che assegna a ciascun carattere un indice (y-index, x-index)preservando la struttura originale dell'elenco.

• b: Dato un elemento dell'elenco indicizzato, bcalcola [y-index, y - x, y + x].

• p: Dato il campo indicizzato, restituisce 3 funzioni Int -> Bool, la prima delle quali è il controllo dell'indice y, la seconda della differenza e la terza della somma. min(snd e)si occupa degli spazi (uno spazio è più piccolo di entrambi). Questa funzione è inclusa nel codice golf.

• qdato il campo indicizzato, cambiare tutto necessario .per #verificando se quel campo specifico di ritorno Trueper ogni funzione test.

La soluzione finale è quindi la composizione di qe f.

Python 3, 380 378 348 346 byte

Si noti che il rientro è con schede, non spazi.

Versione golfizzata:

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

Provalo su Ideone

Spiegazione (per la versione non golf di seguito):

Tutta l'elaborazione viene eseguita senza alcuna conversione, i caratteri dello spazio vengono semplicemente ignorati.
La funzione axes_poscalcola 3 tuple di coordinate "3D" immaginarie, che vengono accumulate in 3 tuple ( bmin, bmax) minime e massime (elemento ) per tutti i #personaggi.

Le coordinate sono calcolate in def axes_pos(x, y): return y, x + y, lc - y + x;
dove X conta da 0 a destra e Y conta da 0 a fondo (dalla prima all'ultima riga).
La prima coordinata immaginaria è sostanzialmente Y, perché è ovvio il perché. La sua ascia è ortogonale ai limiti verdi (nelle immagini dell'OP) Il
secondo è ortogonale ai limiti rossi e il terzo è ortogonale ai limiti blu.

Nel secondo passaggio, la sostituzione viene eseguita per tutti i .caratteri le cui coordinate "3D" rientrano nell'intervallo bmin.. bmax, per quanto riguarda l'elemento - questo viene verificato in questa espressione all(bmin[j] <= p[j] <= bmax[j] for j in range(0, 3)).

Versione non golfata con test, anche su 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()

Rimosso non necessario -1per la terza coordinata immaginaria, perché non cambia nulla

Miglioramenti parzialmente implementati suggeriti da Leaky Nun+ anche il mio.

Gelatina , 45 35 ₁₃ 42 41 byte

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

Questo è un elenco di collegamenti; l'ultimo deve essere chiamato sull'input per produrre l'output.

L'I / O è in forma di array di stringhe, dove .indica vuoto e @indica riempito.

Provalo online! o verifica tutti i casi di test .

sfondo

Consideriamo il seguente esempio.

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

Tracciando una coppia o linee parallele - la coppia più vicina che racchiude tutte le posizioni riempite - in ciascuna delle tre direzioni, possiamo determinare il rettangolo di selezione esagonale.

Nell'implementazione, sostituiamo tutti i caratteri tra quelle due linee con @, e tutto al di fuori di queste linee con ., con la possibile eccezione delle diagonali che contengono solo spazi).

Per l'asse orizzontale, questo dà

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

per l'asse diagonale che cade, dà

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

e per l'asse sollevante diagonale, dà

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

Prendendo il minimo saggio di tutti e tre, poiché .< @, otteniamo

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

Tutto quello che resta da fare è ripristinare gli spazi.

Come funziona

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 byte

7 byte grazie 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]

Porta della mia risposta in Pyth .

Accetta array di linee come input, genera array 2D di caratteri.

• Python 2: Ideone esso!
• Python 3: Ideone esso!

Perl, 128 126 byte

Include +6 per -0F\n

Esegui con input su STDIN. Utilizzare 1per riempito, 0per vuoto. Le linee non devono essere riempite con spazi alla fine:

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$=--

Utilizza le coordinate del cubo. Determina il massimo e il minimo durante il $= == 1loop e riempie le coordinate tra questi limiti durante il $= == 0loop. I primi 58 loop sono inutili e sono lì solo per riempire $-con il numero di righe

TSQL, 768 byte

Ho scritto una domanda per risolvere questo problema, che ho trovato piuttosto difficile. Non è in grado di competere con tutte le eccellenti risposte più brevi. Ma volevo pubblicarlo comunque per chi fosse interessato. Mi dispiace per la lunghezza della risposta - sperando che codegolf riguardi anche approcci diversi.

golfed:

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 @

Ungolfed:

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 @

Fiddle ungolfed

GNU Octave, 212 , 196 byte

Forse non è davvero la lingua preferita dai golfisti, ma è questo che rende la sfida, no? Supponendo che m sia considerato una matrice di caratteri: 178 byte sono indipendenti e 196 se inseriti in una funzione .

golfed:

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

ungolfed:

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

Spiegazione : costruiamo un sistema di coordinate, 3 assi - ortogonali ai lati degli esagoni, troviamo il massimo e il minimo di ciascuna coordinata, quindi costruiamo una maschera logica che inizia con 1 ovunque e logicamente e: ing ogni vincolo massimo e minimo di coordinate, infine reimpostazione ogni posizione "vera" rimanente al carattere "#".

Se vuoi provarlo, puoi semplicemente creare una matrice m in questo modo:

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

e quindi chiama f (m) e confronta con m costruendo una matrice con entrambi in:

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