Sie erhalten ein hexagonales Raster der Zeichen .und #wie folgt:

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

Ihre Aufgabe ist es, den gesamten achsenbündigen Begrenzungsrahmen des #mit weiter zu füllen #:

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

Der achsenausgerichtete Begrenzungsrahmen ist die kleinste konvexe sechseckige Form, die alle enthält #. Beachten Sie, dass beim hexagonalen Gitter drei Achsen zu berücksichtigen sind (W / E, SW / NE, NW / SE):

Hier ist ein weiteres Beispiel, um zu zeigen, dass in einigen Fällen eine oder mehrere Seiten nur eine Seite enthalten #:

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

Sie können diese entweder als Sechsecke mit entarteten Seiten anzeigen oder wie oben beschrieben den Begrenzungsrahmen um sie herum zeichnen. In diesem Fall handelt es sich immer noch um Sechsecke:

Zu schwer? Probiere Teil I aus!

Regeln

Sie können anstelle von und zwei verschiedene nicht durch Leerzeichen druckbare ASCII-Zeichen (0x21 bis 0x7E, einschließlich) verwenden . Ich werde sie jedoch weiterhin als und für den Rest der Spezifikation bezeichnen.#.#.

Eingabe und Ausgabe können entweder eine durch Zeilenvorschub getrennte Zeichenfolge oder eine Liste von Zeichenfolgen sein (eine für jede Zeile), das Format muss jedoch konsistent sein.

Sie können davon ausgehen, dass die Eingabe mindestens eine #und alle Zeilen gleich lang sind. Beachten Sie, dass es zwei verschiedene "Arten" von Zeilen gibt (beginnend mit einem Leerzeichen oder einem Nicht-Leerzeichen) - Sie können nicht davon ausgehen, dass die Eingabe immer mit demselben Typ beginnt. Sie können davon ausgehen, dass der Begrenzungsrahmen immer in das angegebene Raster passt.

Sie können ein Programm oder eine Funktion schreiben und eine unserer Standardmethoden zum Empfangen und Bereitstellen von Eingaben verwenden.

Sie können jede Programmiersprache verwenden , beachten Sie jedoch, dass diese Lücken standardmäßig verboten sind.

Das ist Code-Golf , also gewinnt die kürzeste gültige Antwort - gemessen in Bytes .

Testfälle

Jeder Testfall hat Ein- und Ausgänge nebeneinander.

#    #

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

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

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

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

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

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

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

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

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

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

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

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

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

Probieren Sie es online!

Erläuterung

• Sei A der Punkt mit der niedrigsten y-Koordinate und B der Punkt mit der höchsten y-Koordinate.

• Sei C der Punkt mit dem niedrigsten (x-Wert minus y-Wert) und D der Punkt mit dem höchsten.

• Sei E der Punkt mit dem niedrigsten (x-Wert plus y-Wert) und F der Punkt mit dem höchsten.

Dann ist es äquivalent, die Koordinaten zu finden, bei denen die y-Koordinate zwischen A und B liegt, der x-Wert minus y-Wert zwischen C und D liegt und der x-Wert plus y-Wert zwischen E und 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

Danke @Damien fürs Golfen f!

Die Eingabe erfolgt als Liste der Zeichen, die Ausgabe erfolgt auf die gleiche Weise.

Also das war ein Biest zum Schreiben. Es basiert auf der Idee von LeakyNun und verwendet eine maximale und minimale Filterung anhand der Koordinaten der Elemente.

Ich bin wirklich überrascht von der Tatsache, dass m=maptatsächlich Bytes gespart werden, da es so teuer zu sein scheint.

Erläuterung:

Hier ist eine etwas weniger geschlachtete Version (Schwerpunkt auf etwas ):

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

• fist eine Funktion, die jedem Zeichen einen Index zuweist (y-index, x-index)und dabei die ursprüngliche Struktur der Liste beibehält.

• b: bBerechnet bei einem Element der indizierten Liste [y-index, y - x, y + x].

• p: Bei gegebenem indizierten Feld werden 3 Funktionen zurückgegeben Int -> Bool, von denen die erste die Überprüfung des y-Index, die zweite der Differenz und die dritte der Summe ist. min(snd e)kümmert sich um die Leerzeichen (ein Leerzeichen ist kleiner als beide). Diese Funktion ist im Golfcode vermerkt.

• qÄndern Sie angesichts des indizierten Felds alle erforderlichen Einstellungen .in, #indem Sie prüfen, ob dieses bestimmte Feld Truezu jeder Testfunktion zurückkehrt.

Die endgültige Lösung ist dann die Zusammensetzung von qund f.

Python 3, 380 378 348 346 Bytes

Beachten Sie, dass der Einzug Tabulatoren und keine Leerzeichen enthält.

Golf Version:

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

Teste es auf Ideone

Erklärung (für ungolfed Version unten):

Die gesamte Verarbeitung erfolgt ohne Konvertierung, Leerzeichen werden einfach übersprungen.
Die Funktion axes_posberechnet 3-Tupel der imaginären "3D" -Koordinaten und summiert sie für alle Zeichen zu (elementweisen) minimalen und maximalen 3-Tupeln ( bmin, bmax) #.

Koordinaten werden berechnet in def axes_pos(x, y): return y, x + y, lc - y + x;
Dabei zählt X von 0 nach rechts und Y von 0 nach unten (von der ersten bis zur letzten Zeile).
Die erste imaginäre Koordinate ist im Grunde Y, weil es offensichtlich ist, warum. Seine Axt ist orthogonal zu grünen Grenzen (in den Bildern des OP).
Zweitens ist orthogonal zu roten Grenzen und drittens ist orthogonal zu blauen Grenzen.

Im zweiten Durchgang werden alle .Zeichen ersetzt, deren "3D" -Koordinaten elementweise in den Bereich fallen bmin. bmaxDies wird in diesem Ausdruck überprüft all(bmin[j] <= p[j] <= bmax[j] for j in range(0, 3)).

Ungolfed-Version mit Tests, auch auf 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()

-1Für die dritte imaginäre Koordinate unnötig entfernt , da sie nichts ändert

Teilweise implementierte Verbesserungen, die auch von Leaky Nunmir vorgeschlagen wurden .

Jelly , 45 35 ₁₃ 42 41 Bytes

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

Dies ist eine Liste von Links; Der letzte muss am Eingang aufgerufen werden, um den Ausgang zu erzeugen.

I / O ist in Form von String-Arrays, wobei .leer und @gefüllt angezeigt wird.

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Hintergrund

Betrachten wir das folgende Beispiel.

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

Durch Zeichnen eines Paares oder paralleler Linien - das nächste Paar, das alle ausgefüllten Positionen einschließt - in jede der drei Richtungen können wir den hexagonalen Begrenzungsrahmen bestimmen.

In der Implementierung ersetzen wir alle Zeichen zwischen diesen beiden Zeilen mit @und alle Zeichen außerhalb dieser Zeilen mit .(mit der möglichen Ausnahme von Diagonalen, die nur Leerzeichen enthalten).

Für die horizontale Achse ergibt sich

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

für die fallende diagonale achse gibt es

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

und für die ansteigende diagonale Achse gibt es

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

Wenn wir das zeichenweise Minimum aller drei nehmen , erhalten wir .<@

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

Alles was zu tun bleibt, ist die Wiederherstellung der Räume.

Wie es funktioniert

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 dank 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]

Port meiner Antwort in Pyth .

Nimmt ein Array von Zeilen als Eingabe und gibt ein 2D-Array von Zeichen aus.

• Python 2: Ideone es!
• Python 3: Ideone es!

Perl, 128 126 Bytes

Beinhaltet +6 für -0F\n

Mit Eingabe auf STDIN ausführen. Verwenden Sie 1für gefüllt, 0leer. Zeilen müssen am Ende nicht mit Leerzeichen aufgefüllt werden:

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

Verwendet Würfelkoordinaten. Bestimmen Sie Maximum und Minimum während der $= == 1Schleife und füllen Sie die Koordinaten zwischen diesen Grenzen während der $= == 0Schleife. Die ersten 58 Schleifen sind sinnlos und nur dazu da, um $-die Anzahl der Zeilen zu füllen

TSQL, 768 Bytes

Ich schrieb eine Anfrage, um dies zu lösen - was mir ziemlich schwer fiel. Es ist nicht in der Lage, mit all den hervorragenden kürzeren Antworten mithalten zu können. Wollte es aber trotzdem für Interessierte posten. Entschuldigen Sie die Länge der Antwort - in der Hoffnung, dass es bei Codegolf auch um unterschiedliche Ansätze geht.

Golf gespielt:

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 @

Geige ungolfed

GNU Octave, 212 , 196 Bytes

Vielleicht nicht wirklich die Lieblingssprache eines Golfspielers, aber genau das macht die Herausforderung aus, nicht wahr? Angenommen, m wird als eine Zeichenmatrix genommen: 178 Bytes stehen alleine und 196, wenn sie in eine Funktion gestopft sind .

Golf gespielt:

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

Erklärung : Wir bauen ein Koordinatensystem auf, 3 Achsen - senkrecht zu den Sechseckseiten, finden Max und Min jeder Koordinate, bauen dann eine logische Maske auf, die überall mit 1 beginnt und logisch ist jede verbleibende "wahre" Position auf "#" Zeichen.

Wenn Sie es testen möchten, können Sie einfach eine m-Matrix wie folgt erstellen:

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

und rufen Sie dann das f (m) auf und vergleichen Sie mit m, indem Sie eine Matrix mit beiden in:

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