Moi veux nid d'abeille

39

Ecrivez le programme le plus court qui imprime cette section d'art ASCII d'un carrelage hexagonal ou en nid d'abeille :

       __
    __/  \__
 __/  \__/  \__
/  \__/  \__/  \
\__/  \__/  \__/
/  \__/  \__/  \
\__/  \__/  \__/
/  \__/  \__/  \
\__/  \__/  \__/
   \__/  \__/
      \__/
  • Aucune entrée ne devrait être prise.
  • Sortie sur stdout ou l'alternative la plus proche de votre langue.
  • Au lieu d'un programme, vous pouvez écrire une fonction nommée qui ne prend aucun paramètre et affiche le résultat normalement ou le renvoie sous forme de chaîne.
  • La sortie peut avoir un nombre quelconque de nouvelles lignes en début et en fin de ligne et chaque ligne de la sortie peut comporter un nombre quelconque d'espaces en tête et / ou de fin (tant que le motif s'aligne correctement).
  • Le code le plus court en octets gagne.
code-golf  ascii-art  kolmogorov-complexity  tiling  hexagonal-grid 
— Les passe-temps de Calvin
source
13
Est-ce que tu joues beaucoup de Catan?
— user3490
@ user3490 En fait, je le fais ^^
— Calvin's Hobbies
2
La semaine prochaine sur PCG: écrire un générateur de cartes Catan?
— user3490
7
Il devrait avoir une entrée IMO, dans votre cas il devrait être 3.
— user3819867
3
@ user3819867 J'ai considéré cela, mais je l'ai préféré. Il est trop tard pour changer, mais pas trop tard pour permettre à quiconque de relever un défi connexe.
— Les passe-temps de Calvin

Réponses:

33

CJam, 45 43 42 41 40 octets

741e8 36+Ab"\__/  "38*21/.{G2$-<\S*.e<N}

Essayez-le en ligne dans l' interprète CJam .

Comment ça marche

"\__/  "38*21/

répète le motif \__/ 38 fois et le divise en morceaux de longueur 21 . Si les morceaux étaient séparés par des sauts de ligne, le résultat serait le suivant:

\__/  \__/  \__/  \__
/  \__/  \__/  \__/  
\__/  \__/  \__/  \__
/  \__/  \__/  \__/  
\__/  \__/  \__/  \__
/  \__/  \__/  \__/  
\__/  \__/  \__/  \__
/  \__/  \__/  \__/  
\__/  \__/  \__/  \__
/  \__/  \__/  \__/  
\__/  \__/  \__/

Cela contient clairement le nid d'abeille désiré. Tout ce qui reste à faire est de remplacer certains caractères par des espaces, d’en couper d’autres et d’introduire les sauts de ligne.

741e8 36+Ab

génère le nombre entier 74 100 000 036 et le convertit en tableau [7 4 1 0 0 0 0 0 0 3 6] . Chaque élément du tableau code le nombre de caractères de début de la ligne correspondante devant être remplacés par des espaces. En soustrayant ce nombre de 16 , nous obtenons également la longueur correcte pour cette ligne.

.{            } e# Execute for each pair of a digit D and a line L:
  G2$-<         e#   Chop off L after 16 - D characters.
       \S*      e#   Push a string of D spaces.
          .e<   e#   Compute the vectorized minimum.
             N  e#   Push a linefeed.

Puisqu'un espace a un point de code inférieur aux autres caractères de L et que les opérateurs vectorisés laissent les caractères de la chaîne la plus longue qui ne correspondent pas à l'un des plus courts, .e<remplace les premiers caractères D par des espaces.

— Dennis
source
2
C'est génial. Bon travail.
— Alex A.
28

Python 2, 73

i=0
exec"k=max(7-i,i-24,0);print' '*k+('\__/  '*9)[i:][k:16-k];i+=3;"*11

Voir le courir.

Pour chacune des 11 lignes de sortie, calcule le nombre d'espaces kde début sous la forme d'un maximum de trois fonctions linéaires formant l'enveloppe du côté gauche de l'hexagone. Étant donné que les lignes diagonales ont une pente 3et -3il est préférable d’indexer le numéro de ligne sous la forme i=0,3,...30.

Pour créer le maillage hexagonal, nous commençons par créer une mosaïque suffisante de l'unité '\__/ '. Ensuite, le décalage le [i:]réaligne de 3 pour les lignes impaires. Enfin, nous en prenons la partie nécessaire en [k:16-k]laissant une marge kà gauche et à droite.

— Xnor
source
22

CJam, 65 56 55 octets

"Ý6TNð*¯5"303b4b["/\_")"_ "4*S]f=sB/z{_W%"\/"_W%erN}/

Essayez-le en ligne dans l' interprète CJam .

Idée

La moitié droite de chaque ligne est une copie inversée de la moitié gauche avec les barres obliques et les barres obliques inversées échangées. Par conséquent, il suffit de coder la moitié gauche du nid d'abeilles:

       _
    __/ 
 __/  \_
/  \__/ 
\__/  \_
/  \__/ 
\__/  \_
/  \__/ 
\__/  \_
   \__/ 
      \_

Plutôt que d’analyser ce modèle ligne par ligne, nous pouvons l’analyser colonne par colonne:

   /\/\/\  
  _ _ _ _  
  _ _ _ _  
  /\/\/\/\ 
 _ _ _ _ _ 
 _ _ _ _ _ 
 /\/\/\/\/\
_ _ _ _ _ _

Des modèles évidents émergent:

  • La chaîne _ _ _ _se produit cinq fois.
  • Chaque /est suivi d'un \.

En remplaçant tous /\, _, _ _ _ _et dans l' espace avec un nombre de 0 à 3, on peut convertir le tableau résultant d'une base 4 numéro à une base plus élevée et stocker le modèle complet de façon compacte.

Code

"Ý6TNð*¯5"303b4b  e# Convert the string from base 303 to base 4.
["/\_")"_ "4*S]f= e# Replace each resulting digit by the corresponding item of the array
                  e# ["/\" "_" "_ _ _ _ " " "].
sB/               e# Split into strings of length 11.
z                 e# Zip: transpose rows with columns.
{             }/  e# For each string:
 _W%              e#     Push a reversed copy.
    "\/"_W%er     e#     Swap slashes and backslashes.
             N    e#     Push a linefeed.
— Dennis
source
10

C, 148 144 140 octets

k,r,c,d,p;f(){for(;k<187;k++){r=k/17;c=k%17;d=c+r%2*3;p=3*r+c-7<33u&3*r-c+8<33u;putchar(c==16?10:p&(d+5)%6<2?95:p&d%6==3?47:!p|d%6?32:92);}}

Avec des espaces, sans les avertissements du compilateur, et avant quelques ajustements de code pour sauvegarder quelques octets:

#include <stdio.h>

int k, r, c, d, p;

void f() {
    for ( ; k < 187; k++) {
        r = k / 17;
        c = k % 17;
        d = c + 3 * (r % 2);
        p = 3 * r + c - 7 < 33u && 3 * r - c + 8 < 33u;
        putchar(
            c == 16 ? 10 :
            p && (d + 5) % 6 < 2 ? 95 :
            p && d % 6 == 3 ? 47 :
            p && d % 6 == 0 ? 92 :
            32);
    }
}

Cette approche n'utilise aucune table de caractères / chaînes. Il parcourt les 187 (11 rangées, 17 colonnes incluant les nouvelles lignes) et détermine le caractère à imprimer pour chaque position, en fonction d'une combinaison de conditions.

Les conditions incluent un test pour être à l'intérieur / à l'extérieur des 4 coins, en utilisant des équations à 4 lignes, avec le résultat stocké dans une variable p. Le reste se répète généralement tous les 6 caractères, les lignes impaires étant décalées de 3 caractères par rapport aux lignes paires.

— Reto Koradi
source
2
Pour le golfé, vous pouvez utiliser implicit-int et laisser tomber le fichier int .
— luser droog
Quelques micro-améliorations:k;f(r,c,d,p){for(;k<187;putchar(c>15?10:p&d<2&p?95:p&d<3?47:!p|d-5?32:92))r=k/17,c=k++%17,d=(5+c+r%2*3)%6,p=3*r+c-7<33u&3*r-c+8<33u;}
— Dennis
7

Ruby - 78 octets

(-5..5).map{|i|puts' '*(j=[i.abs*3-i/6-9,0].max)+('/  \__'*4)[j+i%2*3,16-j*2]}

Une transcription de la solution de xnor (69 octets):

11.times{|i|puts' '*(j=[7-i*=3,i-24,0].max)+('\__/  '*9)[i+j,16-j*2]}
— primo
source
1
11.timessauve 2 octets
— Mitch Schwartz
6

JavaScript (ES6), 129 130

C'est une chaîne pure remplacer / remplacer / remplacer ... ne tirant pas parti d'une propriété géométrique.

À l'aide de chaînes de modèle, toutes les nouvelles lignes sont importantes et comptent.

Exécuter un extrait de code dans Firefox pour tester

f=_=>`70
405
 055
9992 3051
6301`[R='replace'](/9/g,`55123
30551
`)[R](/5/g,1230)[R](/\d/g,n=>['__','/',,'\\'][n]||' '.repeat(n))

// TEST

O.innerHTML = f()
<pre id=O></pre>
Développer l'extrait

— edc65
source
6

PHP - 139 137 107 101 91 87 octets

Je ne sais pas si c'est la meilleure façon de jouer au golf, mais voici mon essai:

30 36 46 -50 bytes grâce à Ismael Miguel

Testez-le en ligne ici

<?='       __
    __',$a='/  \__',"
 __$a$a
",$c="$a$a/  \
\__$a$a/
","$c$c   \__$a/
      \__/";


<script src="http://ideone.com/e.js/WHWEZS" type="text/javascript" ></script>
Développer l'extrait

ancien code:

<?php $a="/  \\__";$c=$a.$a."/  \\\n\__".$a.$a."/\n";echo "       __\n    __".$a."\n __".$a,$a."\n".$c,$c,$c."   \\__".$a."/\n      \\__/";
— Timo
source
Bienvenue dans Programmation Puzzles et Code Golf. Votre code PHP peut être réduit beaucoup plus. Vous pouvez utiliser à la <?place de <?phppour sauvegarder 3 octets. Au lieu de $c=$a.$a."/ \\\n\__".$a.$a."/\n";, vous pouvez écrire $c="$a$a/ \\\n\__.$a$a/\n";(puisque PHP développe les variables dans des chaînes). Vous pouvez appliquer la même logique à la echopour réduire davantage sa longueur. En outre, vous n'avez pas besoin d'espace entre le echoet la chaîne.
— Ismael Miguel
1
Merci, j'apprends quelque chose de nouveau chaque fois que j'essaie de jouer au golf hehe.
— Timo
Je vous en prie. Voici une solution longue de 99 octets: ideone.com/WHWEZS . Cela semble un désordre, mais c'est beaucoup plus court. Au lieu d'utiliser \n, vous pouvez mettre une vraie ligne et économiser 1 octet par ligne.
— Ismael Miguel
En attendant, je l'ai réduit de 2 octets. Maintenant, il a 97 octets.
— Ismael Miguel
1
Voici une seule ligne: <?="\t __\n\t__",$a='/ \__',"\n __$a$a\n",$c="$a$a/ \\\n\__$a$a/\n","$c$c \__$a/\n\t \__/";. Rappelez-vous de remplacer le \tavec un caractère de tabulation et \npar une vraie nouvelle ligne.
— Ismael Miguel
4

Lua 146

T="       __\n    __/  \\__\n __/  \\__/  \\__\n"
S="/  \\__/  \\__/  \\\n\\__/  \\__/  \\__/\n"
B="   \\__/  \\__/\n      \\__/"
io.write(T,S,S,S,B)

(nouvelles lignes ajoutées pour plus de clarté)

— Kyle Kanos
source
1
Ce code n'est-il pas plus long que la sortie souhaitée, car il ne contient que la sortie plus les fonctions d'échappement et de gestion des chaînes?
— Caleb
6
@Caleb: Je suppose que vous n'avez pas réellement compté et simplement deviné en faisant ce commentaire. Selon mon éditeur de texte, il y a 165 caractères dans le réseau (nouvelles lignes incluses). J'ai 19 moins de caractères en raison de répéter Strois fois.
— Kyle Kanos,
2
Mais vous avez raison de dire que les échappées et les retours à la ligne limitent la capacité de mon code à rivaliser dans ce jeu en particulier. Mais gagner n’est pas la raison pour laquelle je fais cela, c’est pour le plaisir et l’apprentissage.
— Kyle Kanos
3

Dart - 113

main({r:"/  \\__"}){print("       __\n    __$r\n __$r$r\n${"$r$r/  \\\n\\__$r$r/\n"*3}   \\__$r/\n      \\__/");}

Solution d’interpolation de cordes pure, rien d’extraordinaire. Les opérations sur les chaînes telles que "sous-chaîne" sont trop détaillées pour être mises en concurrence.

Exécutez-le sur DartPad .

— lrn
source
3

Javascript ( ES7 Draft ), 96 94 93 octets

Inspiration tirée de quelques solutions ici ...

Edit: -1 à partir de edc65

f=z=>[for(x of[741e6]+36)' '.repeat(x)+'/  \\__'.repeat(4,z^=3).slice(+x+z,16-x+z)].join(`
`)

// For snippet demo:
document.write('<pre>'+f()+'</pre>');
Développer l'extrait

Commenté:

f=z=>[                                 
        for(x of [741e6] + 36)        // for each character "x" in "74100000036"
            ' '.repeat(x) +           // x spaces
            '/  \\__'.repeat(4,       // build pattern string
            z ^= 3).                  // toggle z offset (3) for even lines
            slice(+x + z, 16 - x + z) // get appropriate substring
    ].join(`                          // join with newlines
    `)
— Nderscore
source
Joli. .substr(+x+z,16-x-x)-> .slice(+x+z,16-x+z)-1
— edc65
@ edc65 belle prise!
— nderscore
Question rapide: pourquoi est-ce +xau lieu de juste x?
— Fonds de la poursuite de Monica
1
@QPaysTaxes C'est pour convertir xun nombre. Sans cela, cela concaténeraitz
— nderscore
2

Python 3, 100 87 octets

n=0x85208e08e08dd445
while n:l=n>>2&15;print(' '*(8-l)+('\__/  '*4)[n&3:n&3|l*2]);n>>=6

Et une version lisible du code ci-dessous. L'idée est de coder en dur les intervalles (début, longueur), puis de compléter avec la quantité correcte d'espaces pour centrer l'intervalle.

hexagon_string = '\__/  ' * 4
for i in range(11):
    # Pick the begin and length of the i-th interval using hardcoded numbers
    b = (0x00030303111 >> 4*i) & 3   # n is a combination of these two numbers
    l = (0x25888888741 >> 4*i) & 15  #
    # Print the interval with appropriate whitespace in front of it
    spaces = ' ' * (8-l)
    print(spaces + hexagon_string[b : b+l*2])
— Matty
source
2

Retina , 66 octets

<empty line>
sss __<LF>ssa__<LF> aa__<LF>lll dau<LF>ssdu
l
/daa<LF>\aau<LF>
a
ud
u
__/
d
s\
s

Chaque ligne doit aller dans son propre fichier et <LF>signifie nouvelle ligne réelle dans le fichier. 1 octet par fichier supplémentaire ajouté au nombre d'octets.

Vous pouvez exécuter le code en tant que fichier unique avec le -s indicateur, en conservant les <LF>marqueurs et en les modifiant éventuellement en traits nouveaux dans la sortie, par souci de lisibilité, si vous le souhaitez.

L'algorithme consiste en 5 étapes simples de substitution (changer le contenu de la ligne impaire en contenu de la ligne égale) en partant d'une chaîne d'entrée vide. Les résultats après chaque étape sont (délimités par ='s):

sss __
ssa__
 aa__
lll dau
ssdu
============
sss __
ssa__
 aa__
/daa
\aau
/daa
\aau
/daa
\aau
 dau
ssdu
============
sss __
ssud__
 udud__
/dudud
\ududu
/dudud
\ududu
/dudud
\ududu
 dudu
ssdu
============
sss __
ss__/d__
 __/d__/d__
/d__/d__/d
\__/d__/d__/
/d__/d__/d
\__/d__/d__/
/d__/d__/d
\__/d__/d__/
 d__/d__/
ssd__/
============
sss __
ss__/s\__
 __/s\__/s\__
/s\__/s\__/s\
\__/s\__/s\__/
/s\__/s\__/s\
\__/s\__/s\__/
/s\__/s\__/s\
\__/s\__/s\__/
 s\__/s\__/
sss\__/
============
       __
    __/  \__
 __/  \__/  \__
/  \__/  \__/  \
\__/  \__/  \__/
/  \__/  \__/  \
\__/  \__/  \__/
/  \__/  \__/  \
\__/  \__/  \__/
   \__/  \__/
      \__/
— randomra
source
1

Javascript, 154 151 octets

b="\n",c="\t",d="/  \\",f="__",g="\\",h="/",a=f+d,j=a+a,i=d+j+b+g+j+f+h+b,k="   ";console.log(c+k+f+b+c+a+f+b+" "+j+f+b+i+i+i+k+g+a+f+h+b+c+"  "+g+f+h)
— SuperJedi224
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.