Wieder inspiriert von einer Aufgabe zum Programmieren 101 ist hier eine weitere Herausforderung.

Eingang:

• Eine positive ganze Zahl n >= 3. (muss ungerade sein)

Ausgabe:

• nZeilen mit Sternchen, wobei die erste Zeile nSternchen enthält und jede neue Zeile zwei Sternchen weniger als die vorherige Zeile enthält. Bis du 1 Sternchen triffst. Von da an hat jede neue Zeile zwei Sternchen mehr als die vorherige Zeile, bis wieder nSternchen angezeigt werden. Leerzeichen oder ähnliches müssen verwendet werden, um die Sternchen so auszurichten, dass sie wirklich wie eine Sanduhr aussehen.

Allgemeine Regeln:

• Nachgestellte Zeilenumbrüche sind erlaubt, müssen aber nicht verwendet werden.
• Einrückung ist ein Muss.
• Das ist Code-Golf, also gewinnt die kürzeste Antwort in Bytes.
• Da der Kurs in C ++ unterrichtet wird, bin ich gespannt auf Lösungen in C ++.

Testfall (n = 5):

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

Holzkohle , 6 Bytes

Ｇ↘←↗Ｎ*

Ganz einfach. Zeichnet ein poly G auf dem *, mit der Seitenlänge von einer Eingang entnommen N umber, wobei die Seiten nach unten gehen und rechts, horizontal nach links und nach oben und rechts:

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

Vervollständigen Sie dann den Umriss automatisch und füllen Sie ihn aus.

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

Probieren Sie es online!

Python 2, 57 Bytes

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

Ein volles Programm. Geht Zeile für Zeile und druckt die richtige Anzahl von zentrierten Sternchen.

Eine rekursive Funktion war länger (67 Bytes):

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

oder

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

V , 12 Bytes

Àé*hòl3Äjxx>

Probieren Sie es online!

Ich mag Herausforderungen wie diese, weil ich die Vorteile von Vs 2D-Charakter zeigen kann. Erläuterung. Zuerst müssen wir eine Folge von n Sternchen erstellen . Also machen wir das:

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

Als Randnotiz ist dies direkt äquivalent zu @ai*<esc>in vim und register@a ist auf "arg1" vorinitialisiert. Dies erleichtert die numerische Eingabe erheblich.

Dann bewegen wir uns mit der Figur nach rechts h. Hier ist der lustige Teil:

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

Technisch gesehen ist dies der letzte Teil

òl3Äjxx>>ò

Weil der Einrückbefehl tatsächlich ist >>. V geht zweckmäßigerweise davon aus, dass unvollständige Befehle für die aktuelle Zeile gelten, und füllt implizit auch das zweite òZeichen für die Schleife aus.

C ++ - Metatemplates, 186 Byte

Mit der expliziten Formel aus meiner C-Antwort konkurrieren die Metatemplates!

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

Verwendung:

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

nicht konkurrierend

Nur zum Spaß:

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

Verwendung:

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

PowerShell v2 +, 54 Byte

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

Übernimmt die Eingabe $n(garantiert eine ungerade Ganzzahl), konstruiert zwei Bereiche mit $n..1und2..$n und verknüpft sie miteinander und Where-Objectwählt dann nur die ungeraden mit aus |?{$_%2}. Diese werden in eine Schleife eingespeist. Bei jeder Iteration erstellen wir die entsprechende Anzahl von Leerzeichen, die mit der entsprechenden Anzahl von Sternchen verkettet sind. Diese Zeichenfolgen Write-Outputverbleiben in der Pipeline und werden nach Abschluss des Programms durch implizite Einfügungen von Zeilenumbrüchen zwischen ihnen ausgegeben .

Beispiele

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

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

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

Python, 78 Bytes

Also nur mit Einrückung:

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

Verwendung:

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

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

Bisherige rekursive Lösung:

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 Byte

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

Die Idee dabei ist, jede Sanduhr aus der vorherigen zu generieren: Fügen Sie am Anfang jeder Zeile ein Leerzeichen ein und stellen Sie nSternchen voran und fügen Sie sie hinzu .

05AB1E , 21 20 19 17 Bytes

2 Bytes dank Carusocomputing gespart

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Erläuterung

Dies nutzt die kürzlich hinzugefügte Symmetric Range- Funktion.

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)."
";

Anstatt die Zeilen in einem Array zu speichern und dann alles auszugeben, geht die for-Schleife bis auf 1 zurück und kehrt dann zur ursprünglichen Nummer zurück.

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

Leicht ungolfed:

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

Verwendung:

std::cout << f(5);

MATL , 20 Bytes

XyY>t1X!*t2X!+ZS42*c

Probieren Sie es online!

R, 77 Bytes

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

Erstellt eine Zeichenmatrix, die dann gedruckt wird cat, fill=nwobei sichergestellt wird, dass die Linien richtig ausgerichtet sind. Beachten Sie, dass Elemente in einer Matrix spaltenweise gespeichert werden (dh die ersten beiden Elemente sind M[1,1]und M[2,1]nicht M[1,2].)

Java 7, 170 165 164 Bytes

Vielen Dank an @Hypino für das Speichern von 5 Bytes.
Vielen Dank an Kevin für das Speichern von 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)."
";

Ein Byte wurde gespeichert, indem eine aktuelle neue Zeile anstelle von "" verwendet wurde "\r"

Pyth, 22 Bytes

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

Ein Programm, das eine Ganzzahl in STDIN eingibt und das Ergebnis ausgibt.

Probieren Sie es online aus

Wie es funktioniert

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

Sollte etwas kleiner golfen

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

Wir können es hier auf ideone testen

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

Die Countdown-Variable wird kin Zeilen- und Spaltenindizes aufgeteilt. Wenn der Spaltenindex 0 ist (letztes Zeichen in einer Zeile), wird ein Zeilenumbruchzeichen (10) ausgegeben. Dann werden die Zeilen- und Spaltenindizes so angepasst, dass sie sich um den mittleren Stern befinden. Dann abs(x) < abs(y)ist eine kurze Bedingung für die Ausgabe eines Leerzeichens.

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

Relativ einfach. Verfolgt Linien mit n, Sterne mit j, Leerzeichen mit sund Richtung mit d. Ich wollte eigentlich nur eine nicht-rekursive Java-Antwort im Forum haben, aber es tut nicht weh, dass sie auch etwas kürzer ist :)

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

Mit Zeilenumbrüchen:

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+∘.≤⍨(⊢⌊⌽)⍳⎕]

Prüfung:

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

Erläuterung:

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

Ich danke ceilingcat für 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);}

Probieren Sie es online!

PowerShell , 54 50 Byte

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

Probieren Sie es online!

PHP ,104 88 Bytes

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

Probieren Sie es online!

Dies übertrifft nicht die niedrigsten Werte für PHP bei dieser Herausforderung, aber es ist einfach zu verrückt für mich, um es wegzuwerfen.

Okay, also habe ich jetzt Golf gespielt, um die (nicht lange) niedrigste Punktzahl für PHP bei dieser Herausforderung zu sein, aber es ändert nichts an der Tatsache, dass es immer noch verrückt ist.

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

Groovy, 66 Bytes

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

Probieren Sie es aus: https://groovyconsole.appspot.com/script/5145735624392704

Erklärt:

((n..1)+(2..n)) - Umgekehrte Palindromisierung zu n [n,..,1,..,n]

.each{if(it%2>0){...} - Durch ungerade Elemente iterieren.

println(("*"*it).center(n)) - N Sterne zentrieren und jeweils auf Newline drucken.

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

Laufen wie php -f golf_hourglass.php 15

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

Die Idee dahinter ist, die obere Hälfte (den Teil vor der Single *) zu erstellen und dann den oberen Teil zweimal, aber das zweite Mal in umgekehrter Reihenfolge, wiederzugeben.

Pyke, 22 19 Bytes

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

Probieren Sie es hier aus!

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

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