Pourriez-vous me faire un hexagone s'il vous plaît?

53

Aujourd'hui, nous allons créer un hexagone ASCII. Vous devez écrire un programme ou une fonction prenant un entier positif n et générant une grille hexagonale de taille n , composée d'astérisques. Par exemple, un hexagone de taille 2 ressemble à ceci:

 * *
* * *
 * *

Alors qu’un hexagone de taille 3 ressemble à ceci:

  * * *
 * * * *
* * * * *
 * * * *
  * * *

Vous pouvez utiliser n’importe laquelle des méthodes d’entrée et de sortie par défaut , par exemple STDIO / STDOUT, les arguments de fonction et les valeurs de retour ou lire / écrire un fichier.

Vous pouvez supposer que la saisie est toujours valide, donc si ce n'est pas un entier positif, votre programme peut faire ce que vous voulez. Vous ne devez cependant traiter le cas particulier d'une taille 1 hexagone, qui se trouve être un astérisque:

*

Les espaces de début et de fin sont autorisés tant que la sortie est visuellement identique.

Exemples:

1:
*

2:
 * *
* * *
 * *

3:
  * * *
 * * * *
* * * * *
 * * * *
  * * *

4:
   * * * *
  * * * * *
 * * * * * *
* * * * * * *
 * * * * * *
  * * * * *
   * * * *

5:
    * * * * *
   * * * * * *
  * * * * * * *
 * * * * * * * *
* * * * * * * * *
 * * * * * * * *
  * * * * * * *
   * * * * * *
    * * * * *

6:
     * * * * * *
    * * * * * * *
   * * * * * * * *
  * * * * * * * * *
 * * * * * * * * * *
* * * * * * * * * * *
 * * * * * * * * * *
  * * * * * * * * *
   * * * * * * * *
    * * * * * * *
     * * * * * *

12:
           * * * * * * * * * * * *
          * * * * * * * * * * * * *
         * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * *
 * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * *
 * * * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * *
         * * * * * * * * * * * * * *
          * * * * * * * * * * * * *
           * * * * * * * * * * * *

Comme d'habitude, c'est du , donc les échappatoires standard s'appliquent , et vous devriez essayer d'écrire le programme le plus court possible mesuré en octets. Bien sûr, certaines langues sont intrinsèquement plus courtes ou plus longues que d’autres, rappelez-vous donc que l’objectif n’est pas nécessairement d’avoir le plus petit nombre total d’octets, mais de battre les soumissions dans les mêmes langues ou dans des langues similaires.

Que le meilleur golfeur gagne!

DJMcMayhem
la source
15
Pourquoi avons-nous même une balise hexagonal-grid?
Pavel
13
En outre, quelqu'un doit écrire une solution hexagone.
Pavel
Si quelqu'un veut profiter de la prime, vous pouvez probablement réutiliser la boucle de sortie de ma réponse Hexagony ici .
Martin Ender le
6
"Pourriez-vous me faire un hexagone s'il vous plaît?" - bien sûr, vous êtes ici: i.imgur.com/1emYIia.png
aditsu
@Pavel parce que beaucoup d'opérations sur une grille hexagonale sont distinctes de la grille carrée plus standard et portables entre les solutions à des problèmes différents. Des opérations telles que la manipulation des coordonnées, la rotation, la présentation en sortie, etc.
Sparr le

Réponses:

37

Hexagony + Bash Coreutils, 0 + 3 + 8 = 11 octets

Inclut +3 pour le -gdrapeau et +8 pour |tr . \*l'appel non standard (voir cette méta publication )


L'entrée est donnée sous forme d'argument à Hexagony. Lorsque l'interpréteur Hexagony est appelé avec l' -g Noption, il affiche un hexagone de .s. Nous utilisons ensuite tr pour remplacer ceux par *s.

Riley
la source
2
Wow, c'est le génie. Et vous battez toutes les langues du golf!
DJMcMayhem
6
Je n'appellerais pas cela en utilisant le langage Hexagony, mais plutôt comme utiliser bash (ou un autre shell) avec l'interpréteur Hexagony comme l'une des commandes. Ce serait par exemple hexagony -g $1|tr . \*, en supposant que l'interprète hexagone soit nommé ainsi.
Paŭlo Ebermann
3
Cela bénéficierait d'une commande réelle
exécutable
1
@ jpmc26 Pour une longueur de 5 hex vous courriezruby ./interpreter.rb -g 5|tr . \*
Riley
3
@OlivierDulac Le "programme" est zéro octet. Tout le travail est fait par les "drapeaux".
Riley
20

Python 2, 61 octets

i=n=input()
while~-n+i:i-=1;j=abs(i);print' '*j+'* '*(2*n+~j)

Imprime un espace de fin à la fin de chaque ligne.

Merci à Erik the Outgolfer pour avoir sauvegardé un octet.

Xnor
la source
À partir de là, vous dérivez un code Python 3 non valide mais valide avec 69 octets, par int(input())au lieu de input()et le print(' '*j+'* '*(2*n+~j))remplacement habituel print' '*j+'* '*(2*n+~j)- code froid d'ailleurs ;-)
Dilettant
C'est du code vraiment cool!
Matias Bjarland
13

JavaScript (ES6), 77 81 84

@Upvoters: ne manquez pas la réponse de @ETHproductions, soit 76 octets

Modifier Révisé après modification des spécifications, espace de fin autorisé

Juste pour le chapeau ... hé! Pas de chapeau?

f=(n,b='* '.repeat(n+n-1),o=b)=>--n?f(n,b=` ${b}`.slice(0,-2),b+`
${o}
`+b):o

Tester

f=(n,b='* '.repeat(n+n-1),o=b)=>--n?f(n,b=` ${b}`.slice(0,-2),b+`
${o}
`+b):o


function update()
{
  O.textContent=f(+I.value)
}

update()
<input id=I type=number min=1 value=3 oninput='update()'>
<pre id=O></pre>

edc65
la source
11

Hexagony , 91 87 86 octets

?{2'*=&~}=&}='P0</0P}|@..;>;'.\};0Q/..\&(<>"-_"&}=\?_&\/8.=-\<><;{M/.(.(/.-{><.{&'/_.\

Essayez-le en ligne!

Finalement l'a fait.

Initialement (avant de réaliser à quel point les boucles sont coûteuses), je suppose que cela pourra peut-être tenir dans la longueur de côté 5, mais maintenant, il est assez difficile de l’adapter à la longueur de côté 6.

Pour obtenir cela, je dois en fait modifier un peu le code linéaire. En fait, écrire ceci me permet de comprendre comment coder le code linéaire de 1 à 2 octets.

utilisateur202729
la source
10

JavaScript (ES6), 77 76 octets

g=(n,s=`
*`+' *'.repeat(n*2-2),c=s,q=c.replace('*',''))=>--n?g(n,q+s+q,q):s

Je me suis dit que je ne dormirais pas tant que je n'aurais pas établi un nouvel enregistrement ES6 sans regarder les autres réponses, alors voila ...

Extrait de test

g=(n,s=`
*`+' *'.repeat(n*2-2),c=s,q=c.replace('*',''))=>--n?g(n,q+s+q,q):s

for(var i = 1; i < 7; i++) console.log(g(i)) // joe

ETHproductions
la source
10

C, 91 89 80 74 octets

w,y;f(s){for(y=-s;++y<s;)for(w=printf("\n%*s",y,"");++w<s*printf(" *"););}

J'ai à peu près tordu pour obtenir les bonnes formules, puis j'ai tout mis en purée.

Appelez favec le numéro n , et l'hexagone sera imprimé sur la sortie standard.

Non golfé et expliqué (version 80 octets):

w,y;
f(s) {
    // y iterates over [-s + 1 ; s - 1] (the number of rows)
    for(y = -s; ++y < s;)
        // w iterates over [abs(y) + 2 ; s * 2 - 1] (the number of stars on the row)
        for(
            // This prints a backspace character (ASCII 8)
            // padded with abs(y) + 2 spaces, effectively
            // printing abs(y) spaces to offset the row.
            // Also initializes w with abs(y) + 2.
            printf("\n%*c", w = abs(y) + 2, 8);

            // This is the for's condition. Makes use
            // of the 2 returned by printf, since we coïncidentally
            // need to double the upper bound for w.
            w++ < s * printf("* ");

            // Empty for increment
        )
            ; // Empty for body
}

Voir en direct sur Coliru

Remarques:

  • printfpeut gérer le remplissage négatif, ce qui donne un caractère aligné à gauche avec le remplissage à droite. J'ai donc essayé quelque chose qui aurait pour effet de w = printf("%*c*", y, ' ')prendre en compte la valeur absolue et de la récupérer à partir de sa valeur de retour. Malheureusement, les largeurs de remplissage zéro et une impriment le caractère seul, de sorte que les trois lignes centrales sont identiques.
    Mise à jour: Jasen a trouvé un moyen de faire exactement cela en imprimant une chaîne vide au lieu d'un caractère - 6 octets supprimés!

  • Coliru ne gère pas correctement le caractère de retour arrière. L'exécution de ce code sur un terminal local supprime l'espace de début sur chaque ligne.

Quentin
la source
w=printf("\n%*s",abs(y),"");++w<s*printf(" *");
Jasen
@Jasen Je ne peux pas croire que j'ai raté ça ... Merci!
Quentin
9

05AB1E , 14 à 13 octets

Code:

F¹N+„ *×})û.c

Explication:

F       }        # Input times do (N = iteration number)
 ¹N+             #   Calculate input + N
    „ *×         #   Multiply by the string " *"
         )       # Wrap everything into an array
          û      # Palindromize the array
           .c    # Centralize

Utilise le codage CP-1252 . Essayez-le en ligne!

Adnan
la source
1
Je ne comprends pas ce que fait la partie "centralisée". Lorsque je le supprime, j'obtiens un tableau de chaînes sans le nombre approprié d'espaces de début.
DJMcMayhem
1
@DJMcMayhem Sur un tableau, vous pouvez le voir comme s'il s'agissait d'une chaîne jointe par des nouvelles lignes avec le texte aligné au centre. C'est ce qu'il fait en entrée.
Adnan
8

Gelée , 24 octets

R+’µạṀx@€⁶żx@K¥€”*$F€ŒḄY

Essayez-le en ligne!

Jelly a honte du fait qu’il n’a pas d’atome de centralisation, c’est donc battu de 05AB1E et V. De 11 et 7 octets respectivement!

Si vous trouvez un moyen de jouer au golf, veuillez commenter. Toute aide est appréciée.

Explication :

R+’µạṀx@€⁶żx@K¥€”*$F€ŒḄY Main link. Arguments: z.
R+’                      The sizes of the hexagon's rows. (implicit argument)
   µ                     Start a new monadic chain with the above argument.
    ȧṀx@€⁶               The spaces you must prepend to each row. (implicit argument)
           x@K¥€”*$      The stars (points) of each row, space-joined, as a single link. (implicit argument)
          ż        F€    Conjoin and merge the leading spaces with the stars appropriately.
                     ŒḄ  Create the second half of the hexagon without the middle row.
                       Y Join the rows with newlines. This makes the shape look like a hexagon.

Bonus: pour trouver le nombre d'étoiles dans un hexagone, utilisez ceci:

Ḷ×6S‘
Erik l'Outgolfeur
la source
2
Ouf, l'explication était accablante.
Erik l'Outgolfer
Que ferait un "atome de centralisation"?
DJMcMayhem
@DJMcMayhem Voir la réponse 05AB1E pour un exemple.
Erik the Outgolfer
7

Octave, 62 58 octets

@(n)' *'(dilate(impad(1,2*--n,n),[k='01010'-48;~k;k],n)+1)

Réponse précédente:

@(n)' *'(dilate(impad(1,2*(m=n-1),m),[k='01010'-48;~k;k],m)+1)

qui peut être appelé comme

(@(n)' *'(dilate(impad(1,2*(m=n-1),m),[k='01010'-48;~k;k],m)+1))(5)

Essayez-le (coller) sur Octave Online

Par exemple, l'image de base pour n=5est

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

qui peut être créé avec

impad(1,2*(n-1),n-1)

Le dilation morphological operatorappliqué 4 fois sur l'image en utilisant le masque voisin suivant:

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

qui peut être créé avec [k='01010'-48;~k;k]

résultat de la dilatation:

0 0 0 0 1 0 1 0 1 0 1 0 1 0 0 0 0
0 0 0 1 0 1 0 1 0 1 0 1 0 1 0 0 0
0 0 1 0 1 0 1 0 1 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 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 1 0 1 0 1 0 1 0 0
0 0 0 1 0 1 0 1 0 1 0 1 0 1 0 0 0
0 0 0 0 1 0 1 0 1 0 1 0 1 0 0 0 0

puis remplacez 0 et 1 par '' et '*' respectivement

    * * * * *
   * * * * * *
  * * * * * * *
 * * * * * * * *
* * * * * * * * *
 * * * * * * * *
  * * * * * * *
   * * * * * *
    * * * * *
rahnema1
la source
6

postgresql9.6, 290 octets

do language plpgsql $$ declare s constant smallint:=4;declare n smallint;declare a constant int[]:=array(select generate_series(1,s));begin foreach n in array a||array(select unnest(a)t order by t desc offset 1)loop raise info'%',concat(repeat(' ',s-n),repeat(' *',s+(n-1)));end loop;end;$$

sql formaté est ici:

do language plpgsql $$
declare s constant smallint := 4;
declare n smallint;
declare a constant int[] := array(select generate_series(1, s));
begin
foreach n in array a || array(select unnest(a)t order by t desc offset 1) loop
    raise info '%', concat(repeat(' ', s - n), repeat(' *', s + (n - 1)));
end loop;
end;
$$;

sortie:

INFO:      * * * *
INFO:     * * * * *
INFO:    * * * * * *
INFO:   * * * * * * *
INFO:    * * * * * *
INFO:     * * * * *
INFO:      * * * *
Andryk
la source
lpadpeut être en mesure de vous sauver quelques octets. J'appellerais aussi le langage pl / pgsql, mais cela soulève des questions quant à savoir s'il faut compter le nombre de fois do language plpgsql $$et le temps de fermeture $$;. Ceux-ci seraient mieux traités par la méta, s'ils ne sont pas venus avant.
jpmc26
Aussi, pourquoi avez-vous besoin de plusieurs DECLAREs? Un seul ne fonctionnerait-il pas?
jpmc26
6

V , 17 octets

é*À­ñ>{MÄpXA *Î.

Essayez-le en ligne!

Comme d'habitude, voici un hexdump, puisqu'il contient des caractères non imprimables:

00000000: e92a c0ad f13e 7b4d c470 5841 202a 1bce  .*...>{M.pXA *..
00000010: 2e                                       .
DJMcMayhem
la source
6

APL (Dyalog Unicode) , 40 36 35 33 27 25 octets

(⍉⊖⍪1↓⊢)⍣2∘↑⍳↓¨∘⊂'* '⍴⍨+⍨

Suppose ⎕IO←0, c'est-à-dire une indexation basée sur zéro La sortie contient un espace de début et un espace de fin sur chaque ligne.

Un grand merci à @FrownyFrog et @ngn pour beaucoup de golf.

Essayez-le en ligne!

Comment ça fonctionne

(⍉⊖⍪1↓⊢)⍣2∘↑⍳↓¨∘⊂'* '⍴⍨+⍨   Main function train
                 '* '⍴⍨+⍨     Repeat '* ' up to length 2×⍵
            ⍳↓¨∘⊂             Generate lower-right corner of the hexagon
          ∘↑                  Convert to matrix
(⍉⊖⍪1↓⊢)                      Palindromize vertically and transpose
        2                    ... twice
Barboteur
la source
5

JavaScript (ES6), 83 81 octets

Ceci est ma première réponse (code golf). J'espère que j'ai tout formaté correctement.

a=>{for(b=c=2*a-1;c;)console.log(" ".repeat(d=Math.abs(a-c--))+"* ".repeat(b-d))}

Contrairement aux 2 réponses ES6 actuelles, je n’appelle pas de manière récursive et j’utilise la console pour la sortie.

Luke
la source
Pourriez-vous utiliser alertsi vous spécifiez le navigateur js?
FlipTack
@ FlipTack, pas vraiment, car j'ai progressivement construit la chaîne (ligne par ligne). Si je le faisais alert, cela alerterait ligne par ligne, et pas le tout.
Luke
5

Haskell, 99 97 79 octets

h n=mapM_(putStrLn.(\k->([k..n]>>" ")++([2..n+k]>>"* ")))([1..n-1]++[n,n-1..1])

Explication: Ce programme est basé sur l'observation que chaque ligne d'un n-hexagone contient des espaces (nk) suivis par des astérisques (n + k-1), pour certains k dépendant du numéro de ligne.

h n=                                             h is a function of type Int -> IO ()
  mapM_                                          mapM_ executes a function returning 
                                                 monadic actions on all objects 
                                                 in a list, in order. Then it executes 
                                                 these actions, in order. For this code, it 
                                                 transforms each value in the list into a 
                                                 monadic action that prints 
                                                 the corresponding line

      (                                          the function consists of two components
        putStrLn                                 the second part is printing the result of 
                                                 the first part to stdout 

        .                                        concatenating both components

        (\k->                                    the first parts first prints (n-k) spaces 
                                                 and then (n+k-1) asterisks

          ([k..n]>>" ")                          create the list of the integers from 
                                                 k to n (That is actually one more entry
                                                 than necessary, but just results in a
                                                 leading whitespace per line, while
                                                 saving 2 bytes compared to [1..n-k]).
                                                 Then create a new list where 
                                                 each element of that first list is 
                                                 replaced with the string " " and 
                                                 concatenate that result into one string

          ++                                     concatenate both lists

          ([2..n+k]>>"* ")                       create the list of the integers 
                                                 from 2 to n+k (of length n+k-1). 
                                                 Then create a new list where each 
                                                 element of that first list is replaced 
                                                 with the string "* " and concatenate 
                                                 that result into one big string
        ) 

      )         
      ([1..n-1]++[n,n-1..1])                     the list simply goes from 1 to n and 
                                                 back, supplying the k 

Edit: Basculé sur mapM_. Je ne savais pas qu'il était disponible sans l'aide de l'importation

Sacchan
la source
5

Python 2 , 100 97 89 88 87 81 79 octets

-1 de @ Flp.Tkc

-6 à nouveau de @Flp

-2 avec merci à @ nedla2004. J'essayais de trouver comment me débarrasser de la deuxième tranche mais je n'y pensais pas :)

i=input()
a=[" "*(i-x)+"* "*(i+x)for x in range(i)]
print'\n'.join(a+a[-2::-1])

Essayez-le en ligne!

Crée un tableau pour la moitié supérieure puis ajoute le tableau inversé moins la ligne médiane, puis s'imprime. Imprime exactement "en l’état", sauf pour les 1impressions avec un espace de début (je suppose que cela est autorisé car *est visuellement identique au *avec ou sans espace de début).

ElPedro
la source
1
Cela donne une mauvaise solution pour 1 - "*". Je pense que cela devrait être un astérisque sans espace devant?
Андрей Ломакин
@ Андрейомакин - De l'OP: "Les espaces de début et de fin sont autorisés tant que la sortie est visuellement identique." Une seule étoile est visuellement la même chose qu'une seule étoile avec un espace devant elle ou du moins c'était mon interprétation ;-)
ElPedro
Mais vous avez en fait raison de dire que je contredisais ce que je viens de dire dans ma réponse. J'ai mis à jour la réponse pour clarifier. Mieux maintenant? BTW, bon travail pour trouver une vieille réponse et repérer une erreur potentielle. Le respect.
ElPedro
1
J'essayais ce défi moi-même, et je ne pouvais rien trouver de mieux, étudiais le vôtre pour l'inspirer.
Андрей Ломакин
J'espère que mon humble effort vous a aidé. Bien sûr, nous aurons du plaisir à jouer ensemble au golf à l'avenir. Profitez de PPCG. Je suis sûr de faire ça
ElPedro
4

Lot, 161 octets

@echo off
set s=*
set l=for /l %%i in (2,1,%1)do call 
%l%set s= %%s%% *
%l%echo %%s%%&call set s=%%s:~1%% *
echo %s%
%l%set s= %%s:~0,-2%%&call echo %%s%%

Remarque: espace de fin sur la ligne 2. Ungolfed:

@echo off
set s=*
rem build up the leading spaces and stars for the first row
for /l %%i in (2,1,%1) do call :s
rem output the top half of the hexagon
for /l %%i in (2,1,%1) do call :t
rem middle (or only) row
echo %s%
rem output the bottom half of the hexagon
for /l %%i in (2,1,%1) do call :b
exit/b
:s
set s= %s% *
exit/b
:t
echo %s%
rem for the top half remove a space and add a star to each row
set s=%s:~1% *
exit/b
:b
rem for the bottom half add a space and remove a star from each row
set s= %s:~0,-2%
echo %s%
exit/b
Neil
la source
4

JavaScript (ES6), 83 octets

f=
n=>[...Array(n+--n)].map((_,i,a)=>a.map((_,j)=>j<n-i|j<i-n?``:`*`).join` `).join`
`
<input type=number min=1 oninput=o.textContent=f(+this.value)><pre id=o>

Neil
la source
4

Toile , 9 octets

╷⁸+* ×]/─

Essayez-le ici!

Battre l'intégré: D

Explication:

{╷⁸+* ×]/─  implicit "{"
{      ]    map over 1..input
 ╷            decrement: 0..input-1
  ⁸+          add the input: input..(input*2-1)
    * ×       repeat "* " that many times
        /   diagonalify that - pad each line with 1 less space than the previous
         ─  palindromize vertically

Je ne sais pas pourquoi il y a un si grand rembourrage, mais c'est autorisé et je répare ce problème bientôt ™. fixé? J'espère que je n'ai pas casser des trucs

dzaima
la source
3

Perl 6 , 49 octets

->\n{say " "x n*2-1-$_~"*"xx$_ for n...n*2-1...n}

Essayez-le en ligne!

Comment ça fonctionne

->\n{                                           }  # Lambda accepting edge size (e.g. 3)
                               for n...n*2-1...n   # For each row-size (e.g. 3,4,5,4,3):
                       "*"xx$_                     # List of stars     (e.g. "*","*","*")
         " "x n*2-1-$_                             # Spaces to prepend (e.g. "  ")
                      ~                            # Concatenate.      (e.g. "  * * *")
     say                                           # Print
smls
la source
3

Powershell, 91 89 78 68 63 52 48 octets

param($n)$n..1+1..$n|gu|%{' '*$_+'* '*(2*$n-$_)}

Script de test:

$script = {
param($n)$n..1+1..$n|gu|%{' '*$_+'* '*(2*$n-$_)}
}

12,6,5,4,3,2,1 |%{
    $_
    . $script $_
}

Sortie (espace de début supplémentaire):

12
            * * * * * * * * * * * *
           * * * * * * * * * * * * *
          * * * * * * * * * * * * * *
         * * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * * *
 * * * * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * * *
         * * * * * * * * * * * * * * *
          * * * * * * * * * * * * * *
           * * * * * * * * * * * * *
            * * * * * * * * * * * *
6
      * * * * * *
     * * * * * * *
    * * * * * * * *
   * * * * * * * * *
  * * * * * * * * * *
 * * * * * * * * * * *
  * * * * * * * * * *
   * * * * * * * * *
    * * * * * * * *
     * * * * * * *
      * * * * * *
5
     * * * * *
    * * * * * *
   * * * * * * *
  * * * * * * * *
 * * * * * * * * *
  * * * * * * * *
   * * * * * * *
    * * * * * *
     * * * * *
4
    * * * *
   * * * * *
  * * * * * *
 * * * * * * *
  * * * * * *
   * * * * *
    * * * *
3
   * * *
  * * * *
 * * * * *
  * * * *
   * * *
2
  * *
 * * *
  * *
1
 *

Explication:

param($n)           # define script parameter
$n..1+              # int range from n to 1 step -1; append
1..$n|              # int range from 1 to n
gu|                 # alias for Get-unique eliminates equal neighbors - here is 1,1 -> 1
%{                  # for each int from [n, n-1, n-2, ... 2, 1, 2, ... n-2, n-1, n]
    ' '*$_+         # string (' ' have repeated $_ times) append
    '* '*(2*$n-$_)  # string ('* ' have repeated 2*n-$_ times)
}
mazzy
la source
1
Belle utilisation de gu.
AdmBorkBork
3

PHP, 83 79 octets

for($p=str_pad;++$y<2*$n=$argn;)echo$p($p("
",1+$k=abs($n-$y)),4*$n-$k-2,"* ");

Exécuter en pipe -nRou essayer en ligne .


C'est proche de la réponse de Kodos ; mais str_padest plus courte que str_repeatmême quand on joue au golf.
Et la ++tête dans la boucle enregistre encore plus.

Titus
la source
2

Ruby, 54 octets

->n{(1-n..n-1).map{|j|i=j.abs;' '*i+'* '*(n*2+~i)}*$/}

La fonction lambda prend n en argument et renvoie une chaîne séparée par des nouvelles lignes. ( $/est une variable contenant le séparateur de ligne par défaut.)

dans le programme de test

f=->n{(1-n..n-1).map{|j|i=j.abs;' '*i+'* '*(n*2+~i)}*$/}

puts f[gets.to_i]
Level River St
la source
Vous pouvez économiser 1 octet en utilisant (1-n ... n) avec 3 points
GB
Le consensus semble consister à inclure le code de sortie (c'est-à-dire puts) dans le nombre de caractères. Mais en relisant la définition, il est seulement indiqué que votre fonction doit "afficher" le résultat qui pourrait être lu comme "renvoyer" le résultat. Solution cool.
Matias Bjarland
@MatiasBjarland meta.codegolf.stackexchange.com/a/2456/15599
Level River St
2

SmileBASIC, 74 octets

FOR I=0TO N-1P
NEXT
FOR I=N-2TO.STEP-1P
NEXT
DEF P?" "*(N-I);"* "*(N+I)END

Ajoute un espace de début et de fin.

Ces "hexagones" ont l’air horrible quand les personnages ont la même largeur et la même hauteur ...

12Me21
la source
2

raquette / schéma

(define (f n)
  (define (s t n)
    (if (= n 0) t (s (~a t "* ") (- n 1))))
  (define (h t p a i)
    (if (= i 0)
        (display t)
        (let ((x (~a t (make-string p #\space) (s "" a) "\n"))
              (q (if (> i n) (- p 1) (+ p 1)))
              (b (if (> i n) (+ a 1) (- a 1))))
          (h x q b (- i 1)))))
  (h "" (- n 1) n (- (* 2 n) 1)))

essai:

(f 1)
*

(f 4)
   * * * *
  * * * * *
 * * * * * *
* * * * * * *
 * * * * * *
  * * * * *
   * * * *
Kevin
la source
3
Bienvenue sur le site! Ceci est une compétition de code-golf, vous devez donc inclure votre nombre d'octets. En outre, vous pouvez supprimer une grande partie des espaces présents dans cette réponse pour la raccourcir.
Wheat Wizard
Merci pour votre contribution, Cat Wizard. Je suis nouveau dans le domaine du golf, et je suppose que les schémas ne sont pas le langage le mieux adapté, mais je vais essayer de le raccourcir, d’éliminer les espaces, et d’ajouter un nombre d’octets lors de ma prochaine entrée.
Kevin
2

Python 2, 111 octets

n=input()
l=range(n,2*n-1)
S=l+[2*n-1]+l[::-1]
W=range(1,n)
for w in W[::-1]+[0]+W:print" "*w+"* "*S[0];S=S[1:]

Une mise en œuvre simple et ennuyeuse (et un programme complet). Affiche un espace de fin à chaque ligne.

Cas de test:

1:
*

2:
 * * 
* * * 
 * * 

3:
  * * * 
 * * * * 
* * * * * 
 * * * * 
  * * * 

4:
   * * * * 
  * * * * * 
 * * * * * * 
* * * * * * * 
 * * * * * * 
  * * * * * 
   * * * * 
Yytsi
la source
2

Javascript (ES6), 143 octets

C'est enfin la pause de Noël (joyeux Noël!), J'ai donc un peu de temps pour jouer au golf.
Et ça fait un bout de temps, d'où le grand nombre d'octets.
Voici:

c=[];a=a=>{for(i=0;i<a;i++){c.push(" ".repeat(a-i-1)+"* ".repeat(i+a-1)+"*")}for(j=c.length-2;j>-1;j--)c.push(c[j]);return a==1?"*":c.join`\n`}
console.log(a(3));

Bantha Chauve
la source
2
Quelques améliorations: for(j=c.length-2;j>-1;j--)c.push(c[j])peuvent être écrites comme for(j=a-1;j;c.push(c[--j]))et for(i=0;i<a;i++){c.push(" ".repeat(a-i-1)+"* ".repeat(i+a-1)+"*")}pourraient être for(i=0;i<a;c.push(" ".repeat(a-i-1)+"* ".repeat(a-1+i++));. L’instruction return pourrait être abrégée en return a-1?c.join\ n. :"*"Au total, ces modifications permettent d’économiser 18B (11 + 7 + 1).
Luke
2

Java, 157 149 129 127 octets

s->{for(int j=~--s,t;++j<=s;p(s-~s-t,"* "),p(1,"\n"))p(t=j<0?-j:j," ");};<T>void p(int j,T s){for(;j-->0;)System.out.print(s);}
  • 8 octets supprimés par Jonathan Frech.
  • 20 octets supprimés par Kevin Cruijssen.
  • 2 octets supprimés par Kevin Cruijssen.

Essayez-le en ligne!

Eugene
la source
1
149 octets .
Jonathan Frech
1
94 octets. REMARQUE: Java 11 a String#repeat(int), mais TIO reste JDK 10, d’où la repeat(String,int)méthode émulée (avec le même nombre d’octets). Le code actuel dans Java 11 serait:s->{for(int j=~--s,t;++j<=s;System.out.println(" ".repeat(t)+"* ".repeat(s-~s-t)))t=j<0?-j:j;}
Kevin Cruijssen le
1
@Eugene Bien sûr. :) Dans ce cas, quelques éléments pour jouer au golf dans la version actuelle de Java (8+) pour le moment: 129 octets .
Kevin Cruijssen
1
@KevinCruijssen C'est un golf assez lourd ici, mis à jour, merci.
Eugene
1
Moi encore. Trouvé une dernière chose à jouer au golf pour -2 octets. 127 octets Cela peut également être utilisé pour jouer au golf 1 octet dans la solution Java 11 ci-dessus .
Kevin Cruijssen
2

Hexagone (linéaire), 128 127 126 octets

Notez qu'il ne s'agit pas d' Hexagony, mais simplement d'un (méta-) langage Timwi pris en charge dans Esoteric IDE. Ce n'est donc pas éligible à la prime.

Cependant, cela peut être converti en une solution Hexagony (et je pense que ce sera plus petit que cette solution), je pourrai le faire plus tard. Cela prend plus d'effort que je l'ai fait ici .

L'initiale prend 3 octets ( e2 9d a2). Chaque nouvelle ligne prend 1 octet ( 0a).

❢?{2'*=(
A
if > 0
 "-"&}=&~}=&}=?&
 B
 if > 0
  }P0;'(
  goto B
 &{&'-{=-(
 C
 if > 0
  'P0;Q0;}(
  goto C
 {M8;{(
 goto A
@

Non Essayez-le en ligne !. Cela ne fonctionne que dans l'IDE Esoteric.

Code annoté:

❢?        # read input n
[n]
{2'*=(     # x = 2n-1
[x]
A
if > 0    # loop (x) from 2n-1 to 1
 "-      # a = x - n
 [a]
 "&}=&~}=&    # a = abs(a). Let K be this amount
 }=?&
 B
 if > 0       # print ' ' (a) times
  }P0;'(
  goto B
 &        # current cell = a (= K)
 {&       # a = n if K>0 else x
          # Note that K=abs(x-n). So if K==0 then x==n.
          # Therefore after this step a is always equal to n.
 '-{=-    # compute n-(K-n) = 2n+K
 (        # decrement, get 2n+K-1
 C
 if > 0   # print ' *' this many times
  'P0;Q0;}(
  goto C
 {M8;{    # print a newline, goto x
 (        # x -= 1
 goto A
@
utilisateur202729
la source
2

Japt -R, 11 à 10 octets

Æ°çSi*Ãû ê

Essayez-le (ou utilisez TIO pour exécuter plusieurs tests)


Explication

               :Implicit input of integer U
Æ              :Map the range [0,U)
 °             :  Postfix increment U
  ç            :  Repeat
   S           :    Space
    i*         :    Prepend asterisk
      Ã        :End map
       û       :Centre pad each string with spaces to the length of the longest string
         ê     :Palindromise
               :Implicitly join with newlines and output
Hirsute
la source