แรงบันดาลใจจากงานเขียนโปรแกรม 101 อีกครั้งเป็นความท้าทายอีกประการหนึ่ง

การป้อนข้อมูล:

• n >= 3เป็นจำนวนเต็มบวก (ต้องเป็นเลขคี่)

เอาท์พุท:

• nบรรทัดของเครื่องหมายดอกจันที่บรรทัดแรกมีnเครื่องหมายดอกจันและทุกบรรทัดใหม่มีเครื่องหมายดอกจันสองตัวน้อยกว่าบรรทัดก่อนหน้า จนกว่าจะกดปุ่มดอกจัน 1 อัน จากนั้นทุกบรรทัดใหม่จะมีเครื่องหมายดอกจันมากกว่าสองบรรทัดก่อนหน้าจนกว่าจะกลับสู่nเครื่องหมายดอกจัน ช่องว่างหรือบางสิ่งบางอย่างเช่นช่องว่างจำเป็นต้องใช้เพื่อจัดตำแหน่งเครื่องหมายดอกจันเพื่อให้ดูเหมือนกับนาฬิกาทรายจริงๆ

กฎทั่วไป:

• ขึ้นบรรทัดใหม่ที่ได้รับอนุญาต แต่ไม่จำเป็นต้องใช้
• การเยื้องเป็นสิ่งที่ต้องทำ
• นี่คือ code-golf ดังนั้นคำตอบที่สั้นที่สุดในจำนวนไบต์ชนะ
• เนื่องจากหลักสูตรได้รับการสอนใน C ++ ฉันกระตือรือร้นที่จะเห็นวิธีแก้ปัญหาใน C ++

กรณีทดสอบ (n = 5):

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

ถ่าน 6 ไบต์

Ｇ↘←↗Ｎ*

ง่ายตาย วาดโพลีGบน*โดยมีความยาวด้านที่ถ่ายจากอินพุตN เบอร์ที่ด้านข้างเลื่อนไปทางซ้ายและขวาในแนวนอนและขึ้นไปทางขวา:

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

จากนั้นเติมโครงร่างอัตโนมัติและเติมให้สมบูรณ์

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

ลองออนไลน์!

Python 2, 57 ไบต์

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

โปรแกรมเต็มรูปแบบ ไปทีละบรรทัดโดยพิมพ์จำนวนเครื่องหมายดอกจันที่อยู่ตรงกลาง

ฟังก์ชั่นวนซ้ำมีความยาว (67 ไบต์):

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

หรือ

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

V , 12 ไบต์

Àé*hòl3Äjxx>

ลองออนไลน์!

ฉันชอบความท้าทายเช่นนี้เพราะฉันได้แสดงให้เห็นถึงข้อดีของธรรมชาติ 2 มิติของ V คำอธิบาย อันดับแรกเราต้องสร้างสตริงของnเครื่องหมายดอกจัน ดังนั้นเราทำสิ่งนี้:

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

ในฐานะที่เป็นบันทึกด้านนี้จะเทียบเท่าโดยตรง@ai*<esc>ในที่เป็นกลุ่มและการลงทะเบียน@aจะเริ่มต้นได้ล่วงหน้าเพื่อ "arg1" สิ่งนี้ทำให้การป้อนข้อมูลตัวเลขสะดวกยิ่งขึ้น

hจากนั้นเราจะย้ายตัวละครไปทางขวาด้วย นี่คือส่วนที่สนุก:

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

ตอนนี้ทางเทคนิคส่วนสุดท้ายนี้คือ

òl3Äjxx>>ò

>>เพราะคำสั่งเยื้องเป็นจริง V สมมติว่าคำสั่งที่ไม่สมบูรณ์นำไปใช้กับบรรทัดปัจจุบันได้อย่างสะดวกและยังเติมโดยอัตโนมัติในòอักขระตัวที่สองสำหรับการวนซ้ำ

เทมเพลต C ++, 186 ไบต์

ด้วยสูตรที่ชัดเจนจากคำตอบ C ของฉัน 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="";}; 

การใช้งาน:

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

ไม่ใช่การแข่งขัน

เพื่อความสนุกสนาน:

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

การใช้งาน:

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

PowerShell v2 +, 54 ไบต์

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

จะเข้า$n(รับประกันเป็นเลขคี่) สร้างสองช่วงด้วย$n..1และ2..$nและ concatenates พวกเขาร่วมกันแล้วใช้เพื่อเลือกเฉพาะคนแปลกด้วยWhere-Object |?{$_%2}สิ่งเหล่านั้นจะถูกป้อนเข้าสู่วงจร การวนซ้ำแต่ละครั้งเราสร้างจำนวนช่องว่างที่เหมาะสมโดยมีการต่อสตริงเข้ากับจำนวนเครื่องหมายดอกจันที่เหมาะสม สตริงเหล่านั้นจะถูกทิ้งไว้ที่ไพพ์ไลน์และเอาต์พุตผ่านทางWrite-Outputแทรกบรรทัดใหม่โดยนัยระหว่างพวกเขาเมื่อโปรแกรมเสร็จสมบูรณ์

ตัวอย่าง

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

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

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

Python ขนาด 78 ไบต์

ดังนั้นด้วยการเยื้อง:

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

การใช้งาน:

print f(5)

C, 114 109 ไบต์

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

โซลูชันแบบเรียกซ้ำก่อนหน้า:

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 ไบต์

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

ความคิดที่นี่คือการสร้างแต่ละนาฬิกาทรายจากก่อนหน้านี้: เพิ่มช่องว่างที่จุดเริ่มต้นของทุกบรรทัดและทั้งเติมและผนวกnเครื่องหมายดอกจัน

05AB1E , 21 20 19 17 ไบต์

บันทึก 2 ไบต์ด้วยcarusocomputing

;ƒ'*¹N·-×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 ไบต์

Q2/Zv&<~42*c

ลองออนไลน์!

คำอธิบาย

สิ่งนี้ใช้ประโยชน์จากฟังก์ชันช่วงสมมาตรที่เพิ่งเพิ่ม

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 ไบต์

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

แทนที่จะเก็บแถวในอาร์เรย์แล้วส่งออกทุกอย่างสำหรับลูปจะลดลงจนถึง 1 จากนั้นกลับไปที่หมายเลขเดิม

C ++ 11, 93 ไบต์

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

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

การใช้งาน:

std::cout << f(5);

MATL , 20 ไบต์

XyY>t1X!*t2X!+ZS42*c

ลองออนไลน์!

R, 77 ไบต์

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

สร้างเมทริกซ์ของตัวละครซึ่งมันก็พิมพ์ออกทางcatกับfill=nการทำให้แน่ใจว่าเส้นที่จัดอย่างถูกต้อง โปรดทราบว่าองค์ประกอบจะถูกเก็บไว้ในคอลัมน์เมทริกซ์ - แรก (เช่นสององค์ประกอบแรกคือM[1,1]และM[2,1]ไม่ใช่M[1,2])

Java 7 170 165 164 ไบต์

ขอบคุณ @Hypino สำหรับการบันทึก 5 ไบต์
ขอบคุณเควินสำหรับการบันทึก 1 ไบต์

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 ไบต์

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

บันทึกไบต์โดยใช้บรรทัดใหม่จริงแทนการ "\r"

Pyth, 22 ไบต์

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

โปรแกรมที่รับอินพุตของจำนวนเต็มบน STDIN และพิมพ์ผลลัพธ์

ลองออนไลน์

มันทำงานอย่างไร

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 ไบต์

ควรตีกอล์ฟให้เล็กลงหน่อย

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

เราสามารถทดสอบได้ที่นี่บน ideone

C, 79 ไบต์

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

มันแยกตัวแปร countdown kออกเป็นดัชนีแถวและคอลัมน์ หากดัชนีคอลัมน์คือ 0 (อักขระสุดท้ายในแถว) ก็จะแสดงอักขระขึ้นบรรทัดใหม่ (10) จากนั้นจะปรับดัชนีแถวและคอลัมน์ให้อยู่รอบ ๆ เครื่องหมายดอกจันกึ่งกลาง จากนั้นabs(x) < abs(y)เป็นเงื่อนไขสั้น ๆ สำหรับการแสดงพื้นที่

Ruby, 55 54 ไบต์

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

Java 7, 156 ไบต์

ค่อนข้างง่าย ติดตามการทำงานของเส้นที่มีnดาวที่มีjช่องว่างด้วยและทิศทางด้วยs dฉันแค่อยากได้คำตอบ Java แบบ non-recursive บนกระดาน แต่ก็ไม่เจ็บเลยว่ามันสั้นกว่านี้ :)

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

ด้วยตัวแบ่งบรรทัด:

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 ไบต์

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

ทดสอบ:

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

คำอธิบาย:

                 ⎕   ⍝ 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 ไบต์

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

C (gcc) , 80 74 ไบต์

ขอขอบคุณแมวขนาด 6 ไบต์

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

ลองออนไลน์!

PowerShell , 54 50 ไบต์

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

ลองออนไลน์!

PHP ,104 88 ไบต์

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

ลองออนไลน์!

สิ่งนี้ไม่ได้ชนะคะแนนต่ำสุดของ PHP ในความท้าทายนี้ แต่มันบ้าเกินกว่าที่ฉันจะทิ้ง

เอาล่ะฉันได้เล่นกอล์ฟตอนนี้มันเป็นคะแนนต่ำสุด (ไม่นาน) สำหรับ PHP ในการท้าทายนี้ แต่ก็ไม่ได้เปลี่ยนความจริงที่ว่ามันยังบ้าอยู่

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

Groovy, 66 ไบต์

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

ทดลองใช้: https://groovyconsole.appspot.com/script/5145735624392704

อธิบาย:

((n..1)+(2..n)) - ย้อนกลับ palindromize เป็น n [n,..,1,..,n]

.each{if(it%2>0){...} - วนซ้ำผ่านองค์ประกอบที่แปลก

println(("*"*it).center(n)) - จัดกึ่งกลางดวงดาวและพิมพ์บนบรรทัดใหม่

PHP, 191 ไบต์

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

วิ่งเหมือน php -f golf_hourglass.php 15

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

แนวคิดเบื้องหลังคือการสร้างครึ่งบน (ส่วนที่อยู่ข้างหน้าเดียว*) จากนั้นเพียงแค่สะท้อนส่วนบนสุดสองครั้ง แต่ครั้งที่สองในลำดับที่กลับกัน

Pyke, 22 19 ไบต์

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

ลองที่นี่!

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 ไบต์

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