Défi Hexplosif ASCII-art

20

Dans le jeu de stratégie "Hexplode" , les joueurs placent à tour de rôle des jetons sur un plateau hexagonal. Une fois que le nombre de jetons est égal au nombre de tuiles adjacentes, cette tuile hexode et déplace tous les jetons sur elle vers les voisins environnants. Vous pouvez jouer au jeu en ligne ici .

J'aime ce jeu, mais il est parfois difficile de savoir exactement combien de jetons vont sur une tuile spécifique; Je compte toujours le nombre de voisins. Ce serait vraiment pratique si j'avais un art ASCII pour m'aider à me souvenir du nombre de jetons sur chaque tuile.

Vous devez écrire un programme ou une fonction qui prend un entier positif en entrée, et produit cette représentation ASCII de l' hexagone de taille N . Chaque tuile sera le nombre de voisins que la tuile a. Étant donné que 1 est un cas d'angle étrange avec zéro voisin, vous n'avez qu'à gérer des entrées supérieures à 1.

Vous pouvez prendre ce nombre dans n'importe quel format raisonnable, tel que STDIN, arguments de fonction, arguments de ligne de commande, à partir d'un fichier, etc. La sortie peut également être dans n'importe quel format raisonnable, comme imprimer sur STDOUT, écrire dans un fichier, retourner une liste de chaînes, une chaîne séparée par des sauts de ligne, etc.

Voici quelques exemples de sortie pour les 5 premières entrées:

2)

 3 3
3 6 3
 3 3


3)

  3 4 3
 4 6 6 4
3 6 6 6 3
 4 6 6 4
  3 4 3


4)

   3 4 4 3
  4 6 6 6 4
 4 6 6 6 6 4
3 6 6 6 6 6 3
 4 6 6 6 6 4
  4 6 6 6 4
   3 4 4 3

5)

    3 4 4 4 3
   4 6 6 6 6 4
  4 6 6 6 6 6 4
 4 6 6 6 6 6 6 4
3 6 6 6 6 6 6 6 3
 4 6 6 6 6 6 6 4
  4 6 6 6 6 6 4
   4 6 6 6 6 4
    3 4 4 4 3

6)

     3 4 4 4 4 3
    4 6 6 6 6 6 4
   4 6 6 6 6 6 6 4
  4 6 6 6 6 6 6 6 4
 4 6 6 6 6 6 6 6 6 4
3 6 6 6 6 6 6 6 6 6 3
 4 6 6 6 6 6 6 6 6 4
  4 6 6 6 6 6 6 6 4
   4 6 6 6 6 6 6 4
    4 6 6 6 6 6 4
     3 4 4 4 4 3

Et le schéma se poursuit d'une manière similaire. Comme d'habitude, les lacunes standard s'appliquent et la réponse avec le nombre d'octets le plus bas sera couronnée gagnante!

Classements

Voici un extrait de pile pour générer à la fois un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse apparaît, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les rayant. Par exemple:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou que vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

# Perl, 43 + 2 (-p flag) = 45 bytes

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Afficher l'extrait de code

code-golf  ascii-art  hexagonal-grid 
— DJMcMayhem
source
1
Connexes (mais en demandant le processus plutôt que le nombre de voisins).
— trichoplax
1
Je suis tenté d'apprendre l'hexagonie juste pour ce défi. ;)
— Kevin Cruijssen

Réponses:

11

MATL , 39 37 octets

4*3-:!G:+o~YRtP*!tPw4LY)vtI5&lZ+47+*c

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

Explication

Je peux à nouveau utiliser la convolution!

Tenez compte des commentaires n = 3. Le code construit d'abord une matrice de taille 4*n-3× nen ajoutant le vecteur colonne au vecteur [1; 2; ...; 9]ligne [1, 2, 3]avec diffusion. Cela signifie calculer un tableau matriciel 2D de tous les ajouts par paire:

 2  3  4
 3  4  5
 4  5  6
 5  6  7
 6  7  8
 7  8  9
 8  9 10
 9 10 11
10 11 12

Le remplacement des nombres pairs par 1et des nombres impairs 0donne le motif en damier

1 0 1
0 1 0
1 0 1
0 1 0
1 0 1
0 1 0
1 0 1
0 1 0
1 0 1

Il sera utilisé pour générer (une partie de) la grille hexagonale. Les uns représenteront les points de la grille et les zéros représenteront les espaces.

Le coin supérieur droit est supprimé en mettant à zéro toutes les entrées au-dessus de la "diagonale" principale de la matrice: 

1 0 0
0 1 0
1 0 1
0 1 0
1 0 1
0 1 0
1 0 1
0 1 0
1 0 1

La multiplication par élément de cette matrice par une version inversée verticalement d'elle-même supprime également le coin inférieur droit. Transposer donne alors

1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
0 0 1 0 1 0 1 0 0

Cela commence à ressembler à un hexagone. En utilisant la symétrie, la grille est étendue pour produire la moitié supérieure:

0 0 1 0 1 0 1 0 0
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
0 0 1 0 1 0 1 0 0

Maintenant, nous devons remplacer chaque entrée égale à une par le nombre de voisins. Pour cela, nous utilisons la convolution avec un voisinage 3 × 5 (c'est-à-dire que le noyau est une matrice de 3 × 5). Le résultat,

2 3 4 5 5 5 4 3 2
4 5 7 7 8 7 7 5 4
4 6 7 8 7 8 7 6 4
4 5 7 7 8 7 7 5 4
2 3 4 5 5 5 4 3 2

a deux problèmes (qui seront résolus plus tard):

  1. Les valeurs ont été calculées pour toutes les positions, alors que nous n'en avons besoin qu'aux positions de celles de la grille zéro-un.
  2. Pour chacune de ces positions, le nombre de voisins inclut le point lui-même, il est donc hors tension 1.

Le code ajoute maintenant 47à chaque valeur calculée. Cela correspond à la soustraction 1pour résoudre le problème (2) et à l'ajout 48(ASCII pour '0'), qui convertit chaque nombre au point de code de son caractère correspondant.

La matrice résultante est ensuite multipliée par une copie de la grille zéro-un. Cela résout le problème (1) ci-dessus, ce qui rend les points qui ne font pas partie de la grille hexagonale égaux à zéro:

 0  0 51  0 52  0 51  0  0
 0 52  0 54  0 54  0 52  0
51  0 54  0 54  0 54  0 51
 0 52  0 54  0 54  0 52  0
 0  0 51  0 52  0 51  0  0

Enfin, ce tableau de nombres est converti en un tableau de caractères. Aucun caractère n'est affiché sous forme d'espace, ce qui donne le résultat final:

  3 4 3  
 4 6 6 4 
3 6 6 6 3
 4 6 6 4 
  3 4 3
— Luis Mendo
source
15

JavaScript (ES6), 118 117 octets

n=>[...Array(m=n+--n)].map((_,i,a)=>a.map((_,j)=>(k=j-(i>n?i-n:n-i))<0?``:k&&++j<m?i/2%n?6:4:3+!i%n).join` `).join`\n`

Où \nreprésente un caractère de nouvelle ligne littéral. Explication: Supposons n=4. Nous commençons par le carré de chiffres séparé par un espace suivant:

0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0

Les premiers |n-i| 0s sont supprimés, mais les espaces restent:

   0 0 0 0
  0 0 0 0 0
 0 0 0 0 0 0
0 0 0 0 0 0 0
 0 0 0 0 0 0
  0 0 0 0 0
   0 0 0 0

Hexagone instantané! Il suffit alors de calculer la valeur appropriée à la place de chacun 0en vérifiant si nous sommes sur la première ou la dernière ligne et / ou colonne. Edit: 1 octet enregistré grâce à @Arnauld.

— Neil
source
En utilisant une partie de votre formule, je suis arrivé à une version de 107 octets avec for / console.log ():n=>{for(i=n+--n;i--;)console.log(' '.repeat(l=i>n?i-n:n-i)+(j=3+!l%n)+` ${l-n?6:4}`.repeat(2*n-l-1)+' '+j)}
— Arnauld
@Arnauld j'aime ça 3+!i%n!
— Neil
7

Python 2, 125 123 octets

def h(n):m=n-1;t=[' '*(m-r)+' '.join(('46'[r>0]*(r+m-1)).join('34'[r%m>0]*2))for r in range(n)];print'\n'.join(t+t[-2::-1])

Les tests sont sur idéone

Fonctionne du haut vers les rangées du milieu for r in range(n), construisant des chaînes:
- faisant deux coins ou deux bords '34'[r%m>0]*2,;
- remplissage en les joignant à répétition '6'ou '4', '46'[r>0]*(r+m-1);
- joindre les coins et les bords avec ' ';
- préfixer avec des espaces, ' '*(m-r);

Imprime ensuite ceci et c'est la réflexion dans la rangée du milieu rejoint par de nouvelles lignes, print'\n'.join(t+t[-2::-1])

— Jonathan Allan
source
4

Python 2, 96 octets

n=input();m=n-1
while n+m:n-=1;j=abs(n);c='34'[0<j<m];print' '*j+c+' '+'46  '[j<m::2]*(2*m+~j)+c

Cela semble assez désordonné et quelque peu golfable ...

— Sp3000
source
3

Java, 375 363 361 339 329 317 293 octets

interface J{static void main(String[]r){int i=0,k,h=Integer.decode(r[0]),a=1,l,n=0;for(;i++<h*2-1;n+=a){if(n==h-1)a=-1;String s="";for(k=0;k<n+h;k++,s+=" ")s+=n==0?k==0||k==n+h-1?3:4:k!=0&&k!=n+h-1?6:n==h-1?3:4;l=(h*4-3-s.trim().length())/2;System.out.printf((l==0?"%":"%"+l)+"s%s\n","",s);}}}

Non golfé

interface J {
    static void main(String[] r) {
        int i = 0, k, h = Integer.decode(r[0]), a = 1, l, n = 0;
        for (; i++ < h * 2 - 1; n += a) {
            if (n == h - 1) {
                a = -1;
            }
            String s = "";
            for (k = 0; k < n + h; k++, s += " ") {
                s += n == 0 ? k == 0 || k == n + h - 1 ? 3 : 4 : k != 0 && k != n + h - 1 ? 6 : n == h - 1 ? 3 : 4;
            }
            l = (h * 4 - 3 - s.trim().length()) / 2;
            System.out.printf((l == 0 ? "%" : "%" + l) + "s%s\n", "", s);
        }
    }
}

Utilisation :

$ java J 5
    3 4 4 4 3     
   4 6 6 6 6 4    
  4 6 6 6 6 6 4   
 4 6 6 6 6 6 6 4  
3 6 6 6 6 6 6 6 3 
 4 6 6 6 6 6 6 4  
  4 6 6 6 6 6 4   
   4 6 6 6 6 4    
    3 4 4 4 3

Je suis sûr que l'horrible bloc imbriqué if-else peut être réécrit pour être plus petit, mais je ne peux pas le comprendre pour le moment. Toutes les suggestions sont les bienvenues :-)

Mise à jour

  • Suivi de la suggestion de Kevin Cruijssen et utilisé le décodage au lieu de parseInt.
  • Réécriture de certains ifs à l'aide de l'opérateur ternaire.
  • Plus d'opérateurs ternaires.
  • Opérateurs ternaires Moar! Je pense avoir créé un monstre!
  • Réécriture du bloc if-else concernant l'impression.
— Master_ex
source
1
Je n'ai pas examiné de si près la méthode que vous utilisez elle-même, mais quelques petits conseils de golf pour votre code actuel: Integer.parseIntpeut être joué au golf Integer.decode. l=(h*4-3-s.trim().length())/2;if(l==0)peut être joué au golf if((l=(h*4-3-s.trim().length())/2)==0). En outre, il est tout à fait acceptable de simplement publier une méthode sans classe (sauf indication contraire de la question), donc void f(int i){...use i...}au lieu de cela interface J{static void main(String[]r){...i=Integer.decode(r[0])...use i...}, cela devrait vous faire économiser quelques octets également. Quand j'aurai plus de temps, je regarderai plus loin.
— Kevin Cruijssen
@KevinCruijssen: Merci pour vos suggestions. l=(h*4-3-s.trim().length())/2;if(l==0)est en fait la même longueur avec if((l=(h*4-3-s.trim().length())/2)==0).
— Master_ex
2

05AB1E , 44 octets

FN_i4ë6}ð«¹ÍN+×ðìN_N¹<Q~i3ë4}.ø¹<N-ð×ì})¦«»

Explication

Comme le haut et le bas de l'hexagone sont en miroir, il suffit de générer la partie supérieure.
Donc, pour une entrée de X, nous devons générer X lignes. C'est ce que fait la boucle principale.

F                                        }

Ensuite, nous faisons la partie centrale des rangées.
C'est 4 pour la première rangée et 6 pour le reste (car nous ne faisons que la partie supérieure).
Nous concaténons ce nombre avec un espace car le motif nécessitera un espacement entre les nombres.

N_i4ë6}ð«

Nous répétons ensuite cette chaîne X-2 + N fois, où N est la ligne actuelle indexée 0 et ajoutons un caractère espace sur le côté gauche.

¹ÍN+×ðì

Après cela, il est temps pour les virages. Ils seront 3 pour la première et la dernière rangée et 4 pour les rangées du milieu.

N_N¹<Q~i3ë4}.ø

Maintenant, nous devons nous assurer que les lignes sont alignées correctement en ajoutant des espaces au début de chaque ligne. Le nombre d'espaces ajoutés sera X-1-N .

¹<N-ð×ì

Maintenant que la partie supérieure de la grille est terminée, nous ajoutons les lignes à une liste, créons une copie inversée et supprimons le premier élément de cette copie (car nous n'avons besoin qu'une seule fois de la ligne centrale), puis fusionnons ces 2 listes et impression.

)¦«»

Essayez-le en ligne!

Solution supplémentaire, également 44 octets:

ÍÅ10.øvN_i4ë6}ð«¹ÍN+×ðìyi4ë3}.ø¹<N-ð×ì})¦«»
— Emigna
source
2

Rubis, 87 octets

La fonction anonyme prend n comme argument et renvoie un tableau de chaînes.

->n{(1-n..n-=1).map{|i|j=i.abs
" "*j+(e=j%n>0?"4 ":"3 ")+["6 ","4 "][j/n]*(2*n-1-j)+e}}

Non testé dans le programme de test

Entrée via stdin. Écrit la forme entière sur stdout. Assez explicite.

f=->n{
  (1-n..n-=1).map{|i|            #reduce n by 1 and iterate i from -n to n
    j=i.abs;                     #absolute magnitude of i
    " "*j+                       #j spaces +
    (e=j%n>0?"4 ":"3 ")+         #start the string with 3 or 4 +
    ["6 ","4 "][j/n]*(2*n-1-j)+  #2*n-1-j 6's or 4`s as appropriate +
    e                            #end the string with another 3 or 4
  }
}

puts f[gets.to_i]
— Level River St
source
1

V , 60 octets

Àé x@aA4 xr3^.òhYpXa 6^òkyHç^/:m0
Pç 3.*6/^r4$.
òÍ6 4./6

Essayez-le en ligne!

C'est vraiment trop long. Voici un hexdump, car il contient des caractères non imprimables:

0000000: c0e9 2078 4061 4134 201b 7872 335e 2ef2  .. x@aA4 .xr3^..
0000010: 6859 7058 6120 361b 5ef2 6b79 48e7 5e2f  hYpXa 6.^.kyH.^/
0000020: 3a6d 300a 50e7 2033 2e2a 362f 5e72 3424  :m0.P. 3.*6/^r4$
0000030: 2e0a f2cd 3620 9334 852e 2f36            ....6 .4../6
— DJMcMayhem
source
1

Raquette, 487 octets

(λ(n c e o)(let((sp(append(range(- n 1)-1 -1)(reverse(range(- n 1)0 -1))))
(mm(append(range(- n 2)(-(+ n(- n 1))2))(range(-(+ n(- n 1))2)(-(- n 1)2)-1)))
(r""))(for((i sp)(j mm))(define str"")(for((ss i))(set! str(string-append str" ")))
(set! str(string-append str(if(or(= i 0)(= i(- n 1))(= i(* 2(- n 1))))c e)" "))
(for((jj j))(set! str(string-append str(if(= j(- n 2))e o)" ")))(set! r(if(or(= i 0)
(= i(- n 1))(= i(* 2(- n 1))))c e))(set! str(string-append str r))(displayln str))))

Essai: 

(f 4 "3" "4" "6") 

   3 4 4 3
  4 6 6 6 4
 4 6 6 6 6 4
3 6 6 6 6 6 3
 4 6 6 6 6 4
  4 6 6 6 4
   3 4 4 3

(f 5 "o" "*" "-") 

    o * * * o
   * - - - - *
  * - - - - - *
 * - - - - - - *
o - - - - - - - o
 * - - - - - - *
  * - - - - - *
   * - - - - *
    o * * * o

Version détaillée: 

(define(f1 n c e o)
  (let ((sp(append(range(sub1 n) -1 -1)
                  (reverse(range(sub1 n) 0 -1))))
        (mm(append(range(- n 2)(-(+ n(sub1 n)) 2))
                  (range(-(+ n(sub1 n)) 2)(-(sub1 n)2) -1) ))
        (r ""))
    (for((i sp)(j mm))
      (define str "")
      (for((ss i))(set! str(string-append str " ")))
      (set! str(string-append str
                              (if(or(= i 0)(= i(sub1 n))
                                    (= i(* 2(sub1 n)))) c e)
                              " "))
      (for((jj j))
        (set! str(string-append str
                                (if(= j(- n 2)) e o)
                                " ")))
      (set! r(if(or(= i 0)
                   (= i(sub1 n))
                   (= i(* 2(sub1 n)))) c e))
      (set! str(string-append str r))
      (displayln str))))
— rnso
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.