On vous donne une grille hexagonale des personnages .et #, comme ceci:

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

Votre tâche consiste à remplir tout le cadre de délimitation aligné sur l'axe du #avec #:

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

La boîte englobante alignée sur l'axe est la plus petite forme hexagonale convexe qui contient tous les #. Notez que dans le cas de la grille hexagonale, il y a trois axes à considérer (W / E, SW / NE, NW / SE):

Voici un autre exemple pour montrer que dans certains cas, un ou plusieurs côtés n'en contiendront qu'un #:

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

Vous pouvez soit les voir comme des hexagones à côtés dégénérés, soit dessiner le cadre de délimitation autour d'eux, comme je l'ai fait ci-dessus, auquel cas ce sont toujours des hexagones:

Trop dur? Essayez la partie I!

Règles

Vous pouvez utiliser deux caractères ASCII imprimables non spatiaux distincts (0x21 à 0x7E, inclus), à la place de #et .. Je continuerai à me référer à eux au fur #et .à mesure du reste de la spécification.

L'entrée et la sortie peuvent être soit une chaîne séparée par un saut de ligne, soit une liste de chaînes (une pour chaque ligne), mais le format doit être cohérent.

Vous pouvez supposer que l'entrée contient au moins une #et que toutes les lignes ont la même longueur. Notez qu'il existe deux "types" de lignes (commençant par un espace ou un non-espace) - vous ne pouvez pas supposer que l'entrée commence toujours par le même type. Vous pouvez supposer que le cadre de sélection tient toujours à l'intérieur de la grille qui vous est donnée.

Vous pouvez écrire un programme ou une fonction et utiliser l'une de nos méthodes standard de réception d'entrée et de sortie.

Vous pouvez utiliser n'importe quel langage de programmation , mais notez que ces failles sont interdites par défaut.

Il s'agit de code-golf , donc la réponse valide la plus courte - mesurée en octets - l'emporte.

Cas de test

Chaque scénario de test a une entrée et une sortie côte à côte.

#    #

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

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

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

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

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

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

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

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

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

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

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

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

Pyth , 82 71 octets

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

Essayez-le en ligne!

Explication

• Soit A le point avec la coordonnée y la plus basse et B le point avec la coordonnée y la plus élevée.

• Soit C le point le plus bas (valeur x moins la valeur y) et D le point le plus haut.

• Soit E le point le plus bas (valeur x plus valeur y) et F le point le plus élevé.

Ensuite, cela revient à trouver les coordonnées dont la coordonnée y est entre A et B, la valeur x moins la valeur y est entre C et D, et la valeur x plus la valeur y est entre E et F.

Haskell, 256 254 243 octets

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

Merci @Damien pour le golf f!

L'entrée est considérée comme une liste de liste de caractères, la sortie est fournie de la même manière.

Donc c'était une bête à écrire. Il est basé sur l'idée de LeakyNun en utilisant un filtrage basé sur maximum et minimum sur les coordonnées des éléments.

Je suis vraiment surpris par le fait que cela m=mapéconomise des octets car cela semble si coûteux.

Explication:

Voici une version légèrement moins boucherie (accent sur légèrement ):

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

• fest une fonction qui attribue à chaque caractère un index (y-index, x-index)tout en préservant la structure d'origine de la liste.

• b: Étant donné un élément de la liste indexée, bcalcule [y-index, y - x, y + x].

• p: Étant donné le champ indexé, retournez 3 fonctions Int -> Bool, dont la première est la vérification de l'indice y, la seconde de la différence et la troisième de la somme. min(snd e)prend soin des espaces (un espace est plus petit que les deux). Cette fonction est intégrée dans le code du golf.

• qétant donné le champ indexé, changer tout le nécessaire .pour #en vérifiant si ce retour sur le terrain spécifique Trueà chaque fonction de test.

La solution finale est alors la composition de qet f.

Python 3, 380 378 348 346 octets

Notez que le retrait est avec des tabulations, pas des espaces.

Version golfée:

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

Testez-le sur Ideone

Explication (pour la version non golfée ci-dessous):

Tout le traitement est effectué sans aucune conversion, les caractères d'espace sont simplement ignorés.
La fonction axes_poscalcule 3-tuple de coordonnées "3D" imaginaires, elles sont accumulées en (élément par élément) minimum et maximum 3-tuples ( bmin, bmax) pour tous les #caractères.

Les coordonnées sont calculées en def axes_pos(x, y): return y, x + y, lc - y + x;
où X compte de 0 à droite et Y compte de 0 à bas (de la première ligne à la dernière).
La première coordonnée imaginaire est essentiellement Y, car il est évident pourquoi. Sa hache est orthogonale aux limites vertes (dans les images de l'OP). La
seconde est orthogonale aux limites rouges et la troisième est orthogonale aux limites bleues.

Dans la deuxième passe, le remplacement est effectué pour tous les .caractères dans lesquels les coordonnées "3D" entrent dans la plage bmin.. bmaxélément par élément - ceci est vérifié dans cette expression all(bmin[j] <= p[j] <= bmax[j] for j in range(0, 3)).

Version non golfée avec tests, également sur 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()

Supprimé inutile -1pour la troisième coordonnée imaginaire, car cela ne change rien

Améliorations partiellement mises en œuvre suggérées par le Leaky Nunmien

Gelée , 45 35 ₁₃ 42 41 octets

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

Ceci est une liste de liens; le dernier doit être appelé sur l'entrée pour produire la sortie.

Les E / S se présentent sous la forme de tableaux de chaînes, où .indique vide et @indique rempli.

Essayez-le en ligne! ou vérifiez tous les cas de test .

Contexte

Prenons l'exemple suivant.

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

En dessinant une paire ou des lignes parallèles - la paire la plus proche qui englobe toutes les positions remplies - dans chacune des trois directions, nous pouvons déterminer le cadre de délimitation hexagonal.

Dans l'implémentation, nous remplaçons tous les caractères entre ces deux lignes par @, et tout en dehors de ces lignes par ., à l'exception possible des diagonales qui ne contiennent que des espaces).

Pour l'axe horizontal, cela donne

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

pour l'axe diagonal descendant, il donne

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

et pour l'axe diagonal en élévation, il donne

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

En prenant le minimum en caractères des trois, puisque .< @, nous obtenons

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

Il ne reste plus qu'à restaurer les espaces.

Comment ça marche

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 octets

7 octets grâce à 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 de ma réponse en Pyth .

Prend un tableau de lignes en entrée, génère un tableau 2D de caractères.

• Python 2: Ideone it!
• Python 3: Ideone it!

Perl, 128 126 octets

Comprend +6 pour -0F\n

Exécuter avec entrée sur STDIN. Utilisez 1pour rempli, 0pour vide. Il n'est pas nécessaire de remplir les lignes avec des espaces à la fin:

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

Utilise les coordonnées du cube. Déterminez le maximum et le minimum pendant la $= == 1boucle et remplissez les coordonnées entre ces limites pendant la $= == 0boucle. Les 58 premières boucles sont inutiles et ne sont là que pour remplir $-le nombre de lignes

TSQL, 768 octets

J'ai écrit une requête pour résoudre ce problème - ce que j'ai trouvé assez difficile. Il n'est pas en mesure de rivaliser avec toutes les excellentes réponses plus courtes. Mais je voulais quand même le poster pour les personnes intéressées. Désolé pour la longueur de la réponse - en espérant que codegolf concerne également différentes approches.

Golfé:

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 @

Non 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 @

Violon non golfé

GNU Octave, 212 , 196 octets

Peut-être pas vraiment la langue préférée des golfeurs, mais c'est ce qui fait le défi, n'est-ce pas? En supposant que m est considéré comme une matrice de caractères: 178 octets autonomes et 196 s'ils sont insérés dans une fonction .

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: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

non 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

Explication : nous construisons un système de coordonnées, 3 axes - orthogonal aux côtés des hexagones, trouvons max et min de chaque coordonnée, puis construisons un masque logique commençant par 1 partout et logiquement et: ing chaque coordonnée max et min contrainte, enfin réinitialisant chaque position "vraie" restante au caractère "#".

Si vous voulez le tester, vous pouvez simplement créer une matrice m comme ceci:

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

puis appelez f (m) et comparez avec m en construisant une matrice avec les deux dans:

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