Nuevamente inspirado por una tarea para la Programación 101, aquí hay otro desafío.

Entrada:

• Un entero positivo n >= 3. (tiene que ser extraño)

Salida:

• nlíneas de asteriscos, donde la primera línea tiene nasteriscos y cada nueva línea tiene dos asteriscos menos que la línea anterior. Hasta golpear 1 asterisco. A partir de ahí, cada nueva línea tiene dos asteriscos más que la línea anterior hasta volver a los nasteriscos. Los espacios o algo así como espacios deben usarse para alinear los asteriscos para que realmente se vea como un reloj de arena.

Reglas generales:

• Las nuevas líneas finales están permitidas pero no tienen que usarse.
• sangrado es imprescindible.
• Este es el código de golf, por lo que la respuesta más corta en bytes gana.
• Como el curso se imparte en C ++, estoy ansioso por ver soluciones en C ++.

Caso de prueba (n = 5):

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

Carbón de leña , 6 bytes

Ｇ↘←↗Ｎ*

Muy simple. Dibuje una poli G en de *, con longitud lateral tomada desde una entrada N umber, donde los lados bajan-y-derecha, horizontalmente a la izquierda y de arriba a la derecha:

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

Luego autocompletar el contorno y llenarlo.

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

Pruébalo en línea!

Python 2, 57 bytes

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

Un programa completo Va línea por línea, imprimiendo el número correcto de asteriscos centrados.

Una función recursiva era más larga (67 bytes):

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

o

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

V , 12 bytes

Àé*hòl3Äjxx>

Pruébalo en línea!

Me gustan los desafíos como este porque puedo mostrar las ventajas de la naturaleza 2D de V. Explicación. Primero, necesitamos crear una cadena de n asteriscos. Entonces, hacemos esto:

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

Como nota al margen, esto es directamente equivalente a @ai*<esc>in vim, y el registro @ase preinicializa a "arg1". Esto hace que la entrada numérica sea mucho más conveniente.

Luego, avanzamos el personaje a la derecha con h. Aquí está la parte divertida:

ò           " 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.

Ahora técnicamente, esta última parte es

òl3Äjxx>>ò

Porque el comando sangría es en realidad >>. V asume convenientemente que los comandos incompletos se aplican a la línea actual y también rellena implícitamente el segundo òcarácter para el bucle.

Plantillas de C ++, 186 bytes

¡Con la fórmula explícita de mi respuesta C, las Metatemplates están compitiendo!

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="";};

Sin golf:

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="";}; 

uso:

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

no competidor

Solo por diversión:

//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;
};

Uso:

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

PowerShell v2 +, 54 bytes

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

Toma información $n(se garantiza que es un número entero impar), construye dos rangos con $n..1y 2..$ny los concatena juntos, luego los usa Where-Objectpara seleccionar solo los impares con |?{$_%2}. Esos son alimentados en un bucle. En cada iteración, construimos el número apropiado de espacios, concatenado con cadenas con el número apropiado de asteriscos. Esas cadenas se dejan en la tubería y la salida a través de Write-Outputinserciones implícitas de nuevas líneas entre ellas al finalizar el programa.

Ejemplos

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

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

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

Python, 78 bytes

Entonces solo con sangría:

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

Uso:

print f(5)

C, 114 109 bytes

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);}

sin golf:

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);
}

Solución recursiva previa:

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 bytes

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

La idea aquí es generar cada reloj de arena a partir del anterior: agregue un espacio al comienzo de cada línea, y añada y agregue nasteriscos.

05AB1E , 21 20 19 17 bytes

Ahorro de 2 bytes gracias a carusocomputing

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

Pruébalo en línea!

Explicación

;ƒ                   # 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 bytes

Q2/Zv&<~42*c

Pruébalo en línea!

Explicación

Esto hace uso de la función de rango simétrico recientemente agregada .

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 bytes

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

En lugar de almacenar las filas en una matriz y luego generar todo, el ciclo for desciende hasta 1 y luego vuelve al número original.

C ++ 11, 93 bytes

#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;}

Ligeramente incólume:

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;
}

Uso:

std::cout << f(5);

MATL , 20 bytes

XyY>t1X!*t2X!+ZS42*c

Pruébalo en línea!

R, 77 bytes

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

Crea una matriz de caracteres, que luego imprime a través de cat, fill=nasegurándose de que las líneas se alineen correctamente. Tenga en cuenta que los elementos se almacenan en una columna de matriz primero (es decir, los dos primeros elementos son M[1,1]y M[2,1]no M[1,2]).

Java 7 170 165 164 bytes

Gracias a @Hypino por guardar 5 bytes.
Gracias a Kevin por guardar 1 byte.

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 bytes

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

Guardado un byte usando una nueva línea real en lugar de un "\r"

Pyth, 22 bytes

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

Un programa que toma la entrada de un número entero en STDIN e imprime el resultado.

Pruébalo en línea

Cómo funciona

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 Bytes

Debería jugar golf un poco más pequeño

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));}}

Podemos probarlo aquí en ideone

C, 79 bytes

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));}

Divide la variable de cuenta regresiva ken índices de fila y columna. Si el índice de la columna es 0 (último carácter en una fila), genera un carácter de nueva línea (10). Luego ajusta los índices de fila y columna para que estén alrededor del asterisco central. Entonces, abs(x) < abs(y)es una condición corta para generar un espacio.

Ruby, 55 54 bytes

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

Java 7, 156 bytes

Bastante simple. Realiza un seguimiento de las líneas con n, estrellas con j, espacios con sy dirección con d. Realmente solo quería una respuesta Java no recursiva en el tablero, pero no duele que también sea un poco más corta :)

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;}

Con saltos de línea:

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 bytes

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

Prueba:

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

Explicación:

                 ⎕   ⍝ 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 bytes

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

C (gcc) , 80 74 bytes

Gracias ceilingcat por 6 bytes

-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);}

Pruébalo en línea!

PowerShell , 54 50 bytes

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

Pruébalo en línea!

PHP ,104 88 bytes

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

Pruébalo en línea!

Esto no supera los puntajes más bajos para PHP en este desafío, pero es demasiado loco para tirarlo.

Bien, ahora lo he jugado para que sea el puntaje más bajo (no por mucho tiempo) para PHP en este desafío, pero no cambia el hecho de que todavía es una locura.

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

Groovy, 66 bytes

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

Pruébelo: https://groovyconsole.appspot.com/script/5145735624392704

Explicado:

((n..1)+(2..n)) - Invertir palindromizar a n [n,..,1,..,n]

.each{if(it%2>0){...} - Iterar a través de elementos extraños.

println(("*"*it).center(n)) - Centre n estrellas e imprima cada una en la nueva línea.

PHP, 191 bytes

$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));

Corre como php -f golf_hourglass.php 15

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

La idea detrás de esto es crear la mitad superior (la parte anterior al single *), luego hacer eco de la parte superior dos veces, pero la segunda vez en orden inverso.

Pyke, 22 19 bytes

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

Pruébalo aquí!

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 bytes

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);}}

Sin golf

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);
  }
}