Encore une fois inspiré par une tâche de programmation 101, voici un autre défi.

Contribution:

• Un entier positif n >= 3. (doit être étrange)

Sortie:

• nlignes d'astérisques, où la première ligne a des nastérisques et chaque nouvelle ligne a deux astérisques de moins que la ligne précédente. Jusqu'à frapper 1 astérisque. De là, chaque nouvelle ligne a deux astérisques de plus que la ligne précédente jusqu'à ce qu'elle revienne aux nastérisques. Des espaces ou quelque chose comme des espaces doivent être utilisés pour aligner les astérisques afin qu'ils ressemblent vraiment à un sablier.

Règles générales:

• Les sauts de ligne sont autorisés mais ne doivent pas être utilisés.
• l'indentation est un must.
• C'est le code-golf, donc la réponse la plus courte en octets l'emporte.
• Puisque le cours est enseigné en C ++, je suis impatient de voir des solutions en C ++.

Cas de test (n = 5):

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

Charbon de bois , 6 octets

Ｇ↘←↗Ｎ*

Mort simple. Tracer une poly G sur de *, avec une longueur latérale prise à partir d' une entrée N ombre, où les côtés vont vers le bas et vers la droite, à l' horizontale à gauche, et vers le haut et à droite:

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

Remplissez ensuite automatiquement le plan et remplissez-le.

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

Essayez-le en ligne!

Python 2, 57 octets

N=n=input()
exec"print('*'*max(n,2-n)).center(N);n-=2;"*n

Un programme complet. Va ligne par ligne, imprimant le bon nombre d'astérisques centrés.

Une fonction récursive était plus longue (67 octets):

f=lambda n,p='':p+n*'*'+'\n'+(1%n*' 'and f(n-2,p+' ')+p+n*'*'+'\n')

ou

f=lambda n,p='':1/n*(p+'*\n')or f(n-2,p+' ').join([p+n*'*'+'\n']*2)

V , 12 octets

Àé*hòl3Äjxx>

Essayez-le en ligne!

J'aime les défis comme celui-ci parce que je peux montrer les avantages de la nature 2D de V. Explication. Tout d'abord, nous devons créer une chaîne de n astérisques. Donc, nous faisons ceci:

À           " Arg1 times:
 é          " Insert the following single character:
  *         " '*'

En remarque, ceci est directement équivalent à @ai*<esc>dans vim, et le registre @aest pré-initialisé à "arg1". Cela rend la saisie numérique beaucoup plus pratique.

Ensuite, on passe du caractère à droite avec h. Voici la partie amusante:

ò           " Until an error is thrown:
 l          "   Move one character to the right. This will throw an error on anyline with only one asterisk in it
  3Ä        "   Make 3 copies of this line
    j       "   Move down one line
     xx     "   Delete two characters
       >    "   Indent this line once.

Maintenant techniquement, cette dernière partie est

òl3Äjxx>>ò

Parce que la commande de retrait est en fait >>. V suppose que les commandes incomplètes s'appliquent à la ligne actuelle et remplit également implicitement le deuxième òcaractère pour la boucle.

Méta-modèles C ++, 186 octets

Avec la formule explicite de ma réponse C, les métatemplates sont en concurrence!

template<int N,int X=N*N+N-1>struct H{enum{I=X/(N+1)-N/2,J=X%(N+1)-N/2-1};S s{(J==-N/2-1?'\n':((I>=J&I>=-J)|(I<=J&I<=-J)?'*':' '))+H<N,X-1>().s};};template<int N>struct H<N,-1>{S s="";};

Ungolfed:

using S=std::string;

template <int N, int X=N*N+N-1>
struct H{
 enum{I=X/(N+1)-N/2,J=X%(N+1)-N/2-1};
 S s{(J==-N/2-1 ? '\n' : ( (I>=J&I>=-J)|(I<=J&I<=-J) ?'*':' '))+H<N,X-1>().s};
};

template <int N> struct H<N,-1> {S s="";}; 

usage:

std::cout << H<5>().s;

non compétitif

Juste pour le plaisir:

//T: Tuple of chars
template <char C, char...Tail> struct T { S r=S(1,C)+T<Tail...>().r; };

//specialization for single char
template <char C> struct T<C> { S r=S(1,C); };

//M: Repeated char
template <int N, char C> struct M { S r=S(N,C); };

//U: concatenates T and M
template <class Head, class...Tail> struct U { S r=Head().r+U<Tail...>().r; };

//specialization for Tail=M
template <int N, char C> struct U<M<N,C>> { S r{M<N,C>().r}; };

//specialization for Tail=T
template <char...C> struct U<T<C...>> { S r=T<C...>().r; };

//finally the Hourglass
template <int N, int I=0> struct H {
 S s=U<
       M<I,' '>,
       M<N,'*'>,
       T<'\n'>
      >().r;
 S r{s + H<N-2,I+1>().r + s};
};

//specialization for recursion end
template <int I> struct H<1,I> {
 S r=U<
       M<I,' '>,
       T<'*','\n'>
      >().r;
};

Usage:

std::cout << H<5>().r;

PowerShell v2 +, 54 octets

param($n)$n..1+2..$n|?{$_%2}|%{" "*(($n-$_)/2)+"*"*$_}

Prend l'entrée $n(garanti d'être un entier impair), construit deux plages avec $n..1et 2..$net les concatène ensemble, puis utilise Where-Objectpour sélectionner uniquement les impaires avec |?{$_%2}. Ceux-ci sont introduits dans une boucle. À chaque itération, nous construisons le nombre approprié d'espaces, concaténé en chaîne avec le nombre approprié d'astérisques. Ces chaînes sont laissées sur le pipeline et sorties via des Write-Outputinsertions implicites de nouvelles lignes entre elles à la fin du programme.

Exemples

PS C:\Tools\Scripts\golfing> 3,5,7|%{.\draw-an-hourglass.ps1 $_;""}
***
 *
***

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

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

Python, 78 octets

Donc seulement avec indentation:

f=lambda n,i=0:n>1and' '*i+'*'*n+'\n'+f(n-2,i+1)+' '*i+'*'*n+'\n'or' '*i+'*\n'

Usage:

print f(5)

C, 114 109 octets

i,j;k(n){for(i=-n/2;i<=n/2;++i)for(j=-n/2;j<=n/2+1;++j)putchar(j==n/2+1?10:(i>=j&i>=-j)|(i<=j&i<=-j)?42:32);}

ungolfed:

i,j;
k(n){
 for(i=-n/2;i<=n/2;++i)
  for(j=-n/2;j<=n/2+1;++j)
   putchar(j==n/2+1?10:(i>=j&i>=-j)|(i<=j&i<=-j)?42:32);
}

Solution récursive précédente:

p(a,c){while(a--)putchar(c);}
f(n,i){p(i,32);p(n,42);p(1,10);}
g(n,i){if(n>1)f(n,i),g(n-2,i+1);f(n,i);}
h(n){g(n,0);}

JavaScript (ES6), 66 octets

f=(n,s="*".repeat(n))=>n>1?s+`
`+f(n-2).replace(/^/gm," ")+`
`+s:s

L'idée ici est de générer chaque sablier à partir du précédent: ajoutez un espace au début de chaque ligne, et ajoutez à la fois des nastérisques et des préfixes .

05AB1E , 21 20 19 17 octets

Économisé 2 octets grâce à carusocomputing

;ƒ'*¹N·-×Nð×ì})û»

Essayez-le en ligne!

Explication

;ƒ                   # for N in [0 ... floor(input/2)+1]
  '*                 # push an asterisk
    ¹N·-×            # repeat the asterisk input-N*2 times
         Nð×ì        # prepend N spaces
             }       # end loop
              )      # wrap stack in a list
               û     # palendromize
                »    # join with newlines

MATL , 12 octets

Q2/Zv&<~42*c

Essayez-le en ligne!

Explication

Cela utilise la fonction de plage symétrique récemment ajoutée .

Q     % Input n implicitly. Add 1
      % STACK: 6
2/    % Divide by 2
      % STACK: 3
Zv    % Symmetric range
      % STACK: [1 2 3 2 1]
&<~   % Matrix of all pairwise "greater than or or equal to" comparisons
      % STACK: [1 1 1 1 1
                0 1 1 1 0
                0 0 1 0 0
                0 1 1 1 0
                1 1 1 1 1]
42*   % Multiply by 42 (ASCII code of '*')
      % STACK: [42 42 42 42 42
                 0 42 42 42  0
                 0  0 42  0  0
                 0 42 42 42  0
                42 42 42 42 42]
c     % Convert to char. Implicitly display, with char 0 shown as space
      % STACK: ['*****'
                ' *** '
                '  *  '
                ' *** '
                '*****']

PHP, 95 octets

for($c=str_pad,$m=$n=$argv[1];$n<=$m;$n+=$d=$d>0||$n<2?2:-2)echo$c($c('',$n,'*'),$m,' ',2)."
";

Au lieu de stocker les lignes dans un tableau, puis de tout générer, la boucle for descend jusqu'à 1, puis revient au numéro d'origine.

C ++ 11, 93 octets

#include<string>
using S=std::string;S f(int n,int i=0){S s=S(i,32)+S(n,42)+'\n';return n>1?s+f(n-2,i+1)+s:s;}

Légèrement non-golfé:

std::string f(int n,int i=0){
 auto s=std::string(i,' ') + std::string(n,'*') + '\n';
 return n>1 ? s+f(n-2,i+1)+s : s;
}

Usage:

std::cout << f(5);

MATL , 20 octets

XyY>t1X!*t2X!+ZS42*c

Essayez-le en ligne!

R, 77 octets

M=matrix(" ",n<-scan(),n);for(i in 1:n)M[i:(n-i+1),i]="*";cat(M,sep="",fill=n)

Crée une matrice de caractères, qu'elle imprime ensuite via cat, fill=nen s'assurant que les lignes s'alignent correctement. Notez que les éléments sont stockés dans une matrice colonne en premier (c'est-à-dire que les deux premiers éléments sont M[1,1]et M[2,1]non M[1,2].)

Java 7, 170 165 164 octets

Merci à @Hypino d'avoir économisé 5 octets.
Merci à Kevin d'avoir économisé 1 octet.

String c(int n,int x){String s,c,t=c=s=" ";int i=0;for(;i++<n;s+="*");for(i=x;i-->=0;c+=" ");for(i=x;i-->0;t+=" ");return(n=n-2)>=0?s+"\n"+c+c(n,++x)+"\n"+t+s:"*";} 

PHP - 95 octets

$c=2;for($i=$a=$argv[1];$i<=$a;$i-=$c*=$i<2?-1:1)echo str_pad(str_repeat("*",$i),$a," ",2)."
";

Enregistré un octet en utilisant une nouvelle ligne réelle au lieu d'un "\r"

Pyth, 22 octets

j+J.e+*dk*b\*_:1hQ2_PJ

Un programme qui prend l'entrée d'un entier sur STDIN et imprime le résultat.

Essayez-le en ligne

Comment ça marche

j+J.e+*dk*b\*_:1hQ2_PJ  Program. Input: Q
              :1hQ2     Range from 1 to Q+1 in steps of 2. Yields [1, 3, 5, ..., Q]
             _          Reverse
   .e                   Enumnerated map with b as elements and k as indices:
      *dk                 k spaces
         *b\*             b asterisks
     +                    Concatenate the spaces and asterisks
  J                     Store in J
                    PJ  All of J except the last element
                   _    Reverse
 +                      Concatenate J and its modified reverse
j                       Join on newlines
                        Implicitly print

C, 195 191 octets

Devrait jouer au golf un peu plus petit

x,y,i;f(n){for(i=0;i<n;i+=2,puts("")){for(y=n-i;y<n;y+=2,putchar(32));for(x=i;x++<n;putchar(42));}for(i=n-2;~i;i-=2,puts("")){for(y=n-i+2;y<n;y+=2,putchar(32));for(x=i-1;x++<n;putchar(42));}}

On peut le tester ici sur ideone

C, 79 octets

h(m,n,k){for(n=m++,k=n*m;--k;putchar(k%m?abs(k%m-m/2)>abs(k/m-n/2)?32:42:10));}

Il divise la variable de compte à rebours ken indices de ligne et de colonne. Si l'index de colonne est 0 (dernier caractère d'une ligne), il génère un caractère de nouvelle ligne (10). Ensuite, il ajuste les indices de ligne et de colonne autour de l'astérisque central. Ensuite, abs(x) < abs(y)c'est une condition courte pour sortir un espace.

Rubis, 55 54 octets

f=->n,s=0{puts a=' '*s+?**n;(f[n-2,s+1];puts a)if n>1}

Java 7, 156 octets

Assez simple. Permet de suivre les lignes avec n, les étoiles avec j, les espaces avec set la direction avec d. Je voulais vraiment juste une réponse Java non récursive sur le tableau, mais ça ne fait pas de mal qu'elle soit aussi un peu plus courte :)

String f(int n){String o="";int j=n,s=0,i,d=0;for(;n-->0;o+="\n"){for(i=0;i++<s;)o+=" ";for(i=0;i++<j;)o+="*";d+=j<2?1:0;j+=d<1?-2:2;s+=d<1?1:-1;}return o;}

Avec des sauts de ligne:

String f(int n){
    String o="";
    int j=n,s=0,i,d=0;
    for(;n-->0;o+="\n"){
        for(i=0;i++<s;)
            o+=" ";
        for(i=0;i++<j;)
            o+="*";
        d+=j<2?1:0;
        j+=d<1?-2:2;
        s+=d<1?1:-1;
    }
    return o;
}

APL, 19 octets

' *'[1+∘.≤⍨(⊢⌊⌽)⍳⎕]

Tester:

      ' *'[1+∘.≤⍨(⊢⌊⌽)⍳⎕]
⎕:
      5
*****
 *** 
  *  
 *** 
*****

Explication:

                 ⎕   ⍝ read number  
                ⍳    ⍝ 1..N
           ( ⌊ )     ⍝ at each position, minimum of
            ⊢        ⍝ 1..N
              ⌽      ⍝ and N..1 (this gives 1..N/2..1)
       ∘.≤⍨          ⍝ outer product with ≤
     1+              ⍝ add 1 to each value
' *'[             ]  ⍝ 1→space, 2→asterisk

Haskell, 84 octets

f n|l<-div n 2,k<-[-l..l]=putStr$unlines[[" *"!!(fromEnum$abs x<=abs y)|x<-k]|y<-k]

C (gcc) , 80 74 octets

Merci plafondcat pour 6 octets

-Du(x,k)=for(x=~n;x+=2,x<n;putchar(k))

i;j;f(n){u(i,10)u(j,i*i<j*j?32:42);}

Essayez-le en ligne!

PowerShell , 54 50 octets

filter f{if($_-1){'*'*$_;($_-2)|f|%{" $_"}}'*'*$_}

Essayez-le en ligne!

PHP ,104 88 octets

for(;$i++<$argn;$a.='**',$i++>1?$o=$s.$o:1)$o.=$s=str_pad("*$a",$argn,' ',2)."
";echo$o;

Essayez-le en ligne!

Cela ne bat pas les scores les plus bas pour PHP sur ce défi, mais c'est tout simplement trop fou pour moi de le jeter.

D'accord, j'ai donc joué maintenant pour que ce soit le score le plus bas (pas pour longtemps) pour PHP sur ce défi, mais cela ne change pas le fait qu'il est toujours fou.

$ echo 7|php -nF hour.php
*******
 *****
  ***
   *
  ***
 *****
*******

Groovy, 66 octets

{n->((n..1)+(2..n)).each{if(it%2>0){println(("*"*it).center(n))}}}

Essayez-le: https://groovyconsole.appspot.com/script/5145735624392704

A expliqué:

((n..1)+(2..n)) - Palindromiser inverse à n [n,..,1,..,n]

.each{if(it%2>0){...} - Itérer à travers des éléments impairs.

println(("*"*it).center(n)) - Centrez n étoiles et imprimez chacune sur la nouvelle ligne.

PHP, 191 octets

$b=[];for($i=$a=$argv[1]+1;$i>0;$i--){$i--;if($i<=1){$c=str_pad("*",$a," ",2)."\n";break;}$b[]=str_pad(str_repeat("*",$i),$a," ",2)."\n";}echo implode("",$b).$c.implode("",array_reverse($b));

Courir comme php -f golf_hourglass.php 15

# php -f golf_hourglass.php 15
***************
 *************
  ***********
   *********
    *******
     *****
      ***
       *
      ***
     *****
    *******
   *********
  ***********
 *************
***************

L'idée derrière cela est de créer la moitié supérieure (la partie avant le single *), puis de répéter simplement la partie supérieure deux fois, mais la deuxième fois dans l'ordre inverse.

Pyke, 22 19 octets

F-ed*ih\**+)2%'X_OX

Essayez-le ici!

F          )        -    for i in range(input)
 -                  -        Q-i
  e                 -       floor(^/2)
   d*               -      ^*" "
          +         -     ^+V
     ih             -       i+1
       \**          -      ^*"*"
            2%      -   ^[::2]
              'X_   - splat(^),
                       reversed(^)
                 OX - splat(^[:-1])

C, 117 octets

void p(c,n){while(n--)putchar(c);}void h(n){for(int i=n;i>=-n;i-=i==1?4:2){p(32,(n-abs(i))/2);p(42,abs(i));p(10,1);}}

Ungolfed

void printNum(c, n) {
  while (n--)
    putchar(c);
}

void hourGlass(n) {
  for (int i = n; i >= -n; i-=i==1?4:2) {
    printNum(32, (n - abs(i)) / 2);
    printNum(42, abs(i));
    printNum(10, 1);
  }
}