एक घंटा खींचो

Question

फिर से प्रोग्रामिंग 101 के लिए एक कार्य से प्रेरित होकर यहां एक और चुनौती है।

इनपुट:

• एक सकारात्मक पूर्णांक n >= 3। (विषम होना चाहिए)

आउटपुट:

• nतारांकन रेखाएँ, जहाँ पहली पंक्ति में nतारांकन होते हैं और हर नई पंक्ति में पहले की तुलना में दो तारांकन कम होते हैं। 1 तारांकन तक मार। वहां से हर नई लाइन में तारांकन से वापस आने तक पहले की रेखा से दो तारांकन अधिक होते हैं n। रिक्त स्थान या स्पेस जैसी चीज़ों का उपयोग तारांकन को संरेखित करने के लिए किया जाता है ताकि यह वास्तव में एक घंटे के चश्मे की तरह दिखाई दे।

सामान्य नियम:

• अनुगामी newlines की अनुमति है, लेकिन इसका उपयोग करने की आवश्यकता नहीं है।
• इंडेंटेशन बहुत जरूरी है।
• यह कोड-गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
• चूंकि पाठ्यक्रम C ++ में पढ़ाया जाता है, मैं C ++ में समाधान देखने के लिए उत्सुक हूं।

टेस्ट केस (n = 5):

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

Comments

तदनुसार संपादित, धन्यवाद :-)

— सिकोबॉय

ड्रा तारांकन त्रिकोण के

— ओलिवर नी

@ ओलिवर ओपिनिंग पर विचार करते हुए ओपी ने लिखा है "एक तारांकन त्रिकोण बनाएं", मुझे पूरी तरह से यकीन नहीं है कि इस चुनौती को डुप्लीकेट कहना उचित है। यह निश्चित रूप से संबंधित है, हालांकि।

— शर्लक

चूंकि यहां हर कोई पूर्ण संदर्भ नहीं जानता है, इसलिए ओपी ने मूल रूप से "एक तारांकन त्रिकोण बनाएं" और इस चुनौती को एक अतिरिक्त चुनौती के रूप में संपादित किया। हमने उन्हें उस हिस्से को हटाने और इसे एक अलग चुनौती बनाने के लिए कहा (जो उन्होंने किया)। यह चुनौती कोई नकल नहीं है। ओपी कई उच्च प्रतिनिधि उपयोगकर्ताओं को कर रहा है , और यहां तक ​​कि कुछ मॉड्स ने भी सिफारिश की है।

— DJMcMayhem

@ जेडडीएल: नहीं, आप क्यों करेंगे? आह, अब मुझे समझ में आया कि आप वर्ग से क्या मतलब रखते हैं ...:

— सिकबॉय

Answer 1

चारकोल , 6 बाइट्स

Ｇ↘←↗Ｎ*

मृत सरल। एक पाली ड्रा जी के पर *, एक इनपुट से लिया ओर लंबाई के साथ एन भूरा रंग, जहां पक्षों जाना नीचे और सही, क्षैतिज छोड़ दिया, और उतार-सही:

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

फिर रूपरेखा को स्वतः पूर्ण करें और भरें।

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

इसे ऑनलाइन आज़माएं!

Comments

हह, यह बहुत अच्छा है!

— CT14.IT

यह भाषा बहुत ही रोचक है! मैं इसे अभी से बहुत करीब से देख रहा हूँ: p

— अदनान

पहले इस भाषा को नहीं देखा ... दिलचस्प लगता है! मुझे आश्चर्य है कि अगर आप इसे जेली के साथ किसी भी तरह से जोड़ देंगे तो क्या मिलेगा ...

— फल

Answer 2

पायथन 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)

Comments

मैं maxएक के साथ बदलने की कोशिश करने का सुझाव देना चाहता था abs, लेकिन मुझे सब मिल गया है abs(n-1)+1, जो बदतर है क्योंकि इसके अलावा कोष्ठक की आवश्यकता है

— njzk2

@ njzk2 आप पार्न्स को काट कर कर सकते हैं '*'*-~abs(n-1), लेकिन तब यह लंबाई के समान है '*'*max(n,2-n)।

— xnor

def f(n,s=''):r=s+'*'*n+'\n';return 1/n*r or r+f(n-2,s+' ')+r61 बाइट्स के लिए है, लेकिन यह अभी भी लंबा है। यहां तक ​​कि एक प्रमुख न्यूलाइन के साथ, def f(n,s='\n'):r=s+'*'*n;return 1/n*r or r+f(n-2,s+' ')+rअभी भी 58 बाइट्स हैं ...

— डेनिस

मुझे सिखाने के लिए +1 center। कभी नहीं पता था कि अब तक अस्तित्व में है।

— DLosc

Answer 3

वी , 12 बाइट्स

Àé*hòl3Äjxx>

इसे ऑनलाइन आज़माएं!

मुझे इस तरह की चुनौतियां पसंद हैं क्योंकि मुझे वी के 2 डी प्रकृति के फायदों के बारे में बताना है। स्पष्टीकरण। सबसे पहले, हमें एन तारांकन की एक स्ट्रिंग बनाने की आवश्यकता है । तो, हम यह करते हैं:

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

एक साइड नोट के रूप में, यह सीधे @ai*<esc>vim के बराबर है , और रजिस्टर @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 आसानी से मान लेता है कि अपूर्ण कमांड करंट लाइन पर लागू होती है, और साथ ही òलूपिंग के लिए दूसरे वर्ण में भी भर जाती है ।

Answer 4

सी ++ मेटाटैम्पलेट्स, 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;

Comments

पीएचपी को सी + + के सबसे लंबे समय तक चलने वाले हिस्से के साथ

— पीट के लिए

Answer 5

PowerShell v2 +, 54 बाइट्स

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

इनपुट लेता है $n(एक विषम पूर्णांक होने की गारंटी), के साथ दो पर्वतमाला निर्माण करती है $n..1और 2..$nऔर उन्हें एक साथ संयोजित करता है, तो का उपयोग करता है Where-Objectके साथ ही अजीब लोगों को चुनने के लिए |?{$_%2}। जिन्हें एक लूप में खिलाया जाता है। प्रत्येक पुनरावृत्ति, हम उपयुक्त संख्या में रिक्त स्थान का निर्माण करते हैं, तार-संघात उपयुक्त संख्या में होते हैं। उन तारों को पाइप लाइन पर छोड़ दिया जाता है, और निहितार्थ के माध्यम से आउटपुट Write-Outputप्रोग्राम पूरा होने के बीच उनके बीच नया संबंध बनाता है।

उदाहरण

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

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

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

Answer 6

पायथन, 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)

Answer 7

सी, 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);}

Answer 8

जावास्क्रिप्ट (ईएस 6), 66 बाइट्स

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

यहाँ विचार पिछले से प्रत्येक घंटे उत्पन्न करने के लिए है: हर पंक्ति की शुरुआत में एक स्थान जोड़ें, और nतारांकन दोनों को प्रेरित और जोड़ते हैं ।

Answer 9

05AB1E , 21 20 19 17 बाइट्स

सहेजे गए 2 बाइट्स कारुसोकोम्प्यूटिंग के लिए धन्यवाद

;ƒ'*¹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

Comments

Ir"*"×.pRû- अब तक इस बात का सामना करना पड़ा, जब मुझे एहसास हुआ कि मैं कितना दूर था, तो देखा कि आपने जवाब दे दिया था, अब इस उदाहरण का उपयोग करके इस भाषा में चलना सीखने की कोशिश करने जा रहा हूं। धन्यवाद!

— मैजिक ऑक्टोपस यूरिन

मैं वास्तव में एक बार के लिए मदद कर सकता हूं: ;ƒ'*¹N·-×Nð×ì})û»नए palindromize कमांड का उपयोग करें। -2 बाइट्स।

— मैजिक ऑक्टोपस Urn

@carusocomputing: धन्यवाद! मुझे पैलेंंड्रोमाइज़ कमांड के बारे में नहीं पता था (मैंने डॉक्स ताज़ा नहीं किया था)। बहुत उपयोगी। पहले कई बार इसकी आवश्यकता है :)

— Emigna

9 बाइट्स , यहां तक ​​कि विरासत में भी। हालांकि मुझे पूरा यकीन है कि जब आप इसे पोस्ट करते हैं, तो शायद यह बिल्‍डिंग ÅÉऔर .cसंभवत: अभी तक उपलब्‍ध नहीं है। :)

— केविन क्रूज़सेन

Answer 10

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: ['*****'
                ' *** '
                '  *  '
                ' *** '
                '*****']

Comments

अच्छा! यह एक अच्छी सुविधा है। यह एकमात्र उत्तर है जो मेरे वी उत्तर के करीब आया है, इसलिए अब मैं एक या दो बाइट्स लेने के लिए जुनूनी हूं। : डी

— DJMcMayhem

@DJMcMayhem हेह, मुझे नहीं लगता कि मैं इस एक पर बाइट की संख्या को कम कर पाऊंगा

— लुइस मेंडो

हाँ, मुझे नहीं लगता कि मैं भी कर सकता हूँ। शायद hahaha ..., वैसे भी कुछ मिनट में एक 4-बाइट जेली जवाब हो जाएगा

— DJMcMayhem

Answer 11

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 तक नीचे चला जाता है, और फिर मूल संख्या तक वापस चला जाता है।

Answer 12

सी ++ 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;}

थोड़ा अपराजित:

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

Comments

अच्छा! एक बाइट को ASCII मानकर और :) के '\n'साथ प्रतिस्थापित करके बचाया जा सकता है10

— क्वेंटिन

Answer 13

MATL , 20 बाइट्स

XyY>t1X!*t2X!+ZS42*c

इसे ऑनलाइन आज़माएं!

Comments

आप हाल ही में शुरू की गई सममित रेंज फ़ंक्शन के साथ कुछ बाइट्स बचा सकते हैं: Q2 / Zv & <~ 42 * c

— लुइस

@LuisMendo यह अच्छा है! चूंकि यह पूरी तरह से अलग दृष्टिकोण है, इसलिए मैं आपको इसके पास होने दूंगा।

— DJMcMayhem

ठीक है, मैं इसे पोस्ट करूँगा!

— लुइस मेंडू

Answer 14

आर, 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]) में संग्रहित हैं ।

Answer 15

जावा 7, 170 165 164 बाइट्स

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:"*";} 

Comments

आप को हटाने के द्वारा 2 बाइट्स बचा सकता s=से s=s+"\n"बदलकर और 2 अधिक बाइट्स return(n=--n-1)करने के लिए return(n=n-2)4 बाइट के लिए कुल।

— 23

नमस्ते। आप कर सकते हैं गोल्फ दो भागों: String s="",c="",t="";करने के लिए String s,c,t=s=c="";( -2 बाइट्स ), और return(n=n-2)>=0?s+"\n"+c+c(n,++x)+करने के लिए return n-1>0?s+"\n"+c+c(n-2,++x)+( -2 बाइट्स फिर से)

— केविन Cruijssen

लेकिन @KevinCruijssen पैटर्न बदलने के बाद अपेक्षित नहीं n=n-2-> n-1>0क्योंकि n का उपयोग किसी फ़ंक्शन के अन्य तर्क में किया जाना चाहिए।

— नंबरनॉट

@Numberknot मुझे पता है, लेकिन मैं भी उस हिस्से में बदल nगया n-2। return(n=n-2)>=0 ... nबदला जा रहा return n-1>0 ... n-2है अभी भी कम है। पुनश्च: आपने मुझे बाइट्स बचाने के लिए धन्यवाद दिया है, लेकिन अपने संपादन में अपना कोड नहीं बदला है। ;)

— केविन क्रूज़सेन

@Numberknot उम्म .. आप अभी भी मेरी दूसरी टिप भूल गए। वैसे भी, यहाँ एक छोटा संस्करण है: ( आइडोन परीक्षण केString c(int n,int x){String s,c=s="";int i=0;for(;i++<n;s+="*");for(i=x;i-->0;c+=" ");return n>1?s+"\n "+c+c(n-2,x+1)+"\n"+c+s:"*";} बिना - 133 बाइट्स )t

— केविन क्रूज़सेन

Answer 16

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"

Answer 17

पायथ, 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

Answer 18

सी, 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));}}

हम इसे इदेओन पर यहाँ परीक्षण कर सकते हैं

Answer 19

सी, 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));}

यह उलटी गिनती चर kपंक्ति और स्तंभ सूचकांकों में विभाजित करता है । यदि कॉलम इंडेक्स 0 है (पंक्ति में अंतिम वर्ण), तो यह एक नई लाइन वर्ण (10) को आउटपुट करता है। फिर यह केंद्र तारांकन के आसपास होने वाली पंक्ति और स्तंभ सूचक को समायोजित करता है। फिर, abs(x) < abs(y)एक स्पेस आउटपुट के लिए एक छोटी शर्त है।

Answer 20

रूबी, 55 54 बाइट्स

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

Comments

?**nकाम करता है; आपको वहां जगह की जरूरत नहीं है।

— वैल्यू इंक

Answer 21

जावा 7, 156 बाइट्स

काफी सरल। के साथ लाइनों के साथ नज़र रखता है n, सितारों के साथ j, रिक्त स्थान sऔर साथ दिशा d। मैं वास्तव में बोर्ड पर एक गैर-पुनरावर्ती जावा उत्तर चाहता था, लेकिन यह चोट नहीं करता है कि यह थोड़ा छोटा है :)

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

Answer 22

एपीएल, 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

Comments

बस 1+एक एपीएल को हटा दें और उसका उपयोग करें ⎕IO←0।

— Adám

Answer 23

हास्केल, 84 बाइट्स

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

Comments

अच्छा समाधान! लेकिन मुझे पूरा यकीन है कि आपको इसकी आवश्यकता नहीं है putStrऔर आप इसfromEnum तरह से छुटकारा पा सकते हैं ।

— ბიმო

Answer 24

सी (जीसीसी) , 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);}

इसे ऑनलाइन आज़माएं!

Answer 25

पॉवरशेल , 54 50 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 26

पीएचपी ,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
*******
 *****
  ***
   *
  ***
 *****
*******

Comments

83? हुह भी, php के पास नंगे पासवर्ड भी हैं, हालाँकि यह यहाँ उपयोगी नहीं है

— ASCII-only

@ ASCII- केवल चूहों! लगता है कि मुझे कुछ और काम करना है! lol

— 640KB

82? वैकल्पिक 82

— एएससीआईआई-केवल

उचित झंडे के साथ: दुख की बात है, यह लंबा है

— ASCII- केवल

@ ASCII- केवल हां, अच्छी तरह से किया! यह सुनिश्चित करने के लिए सही दृष्टिकोण है!

— 640KB

Answer 27

ग्रूवी, 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 to n [n,..,1,..,n]

.each{if(it%2>0){...} - मैं विषम तत्वों से गुजरता हूं।

println(("*"*it).center(n)) - केंद्र एन सितारों और प्रत्येक newline पर मुद्रित करें।

Comments

.eachका कोड ब्लॉक हो सकता है {it%2&&println(("*"*it).center(n))}।

— मैनावर्क

Answer 28

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

इसके पीछे का विचार शीर्ष आधा (एकल से पहले वाला हिस्सा *) बनाना है, फिर शीर्ष भाग को दो बार गूंजना है, लेकिन दूसरी बार रिवर्स ऑर्डर में।

Comments

मुझे लगता है कि यह इस कार्य के लिए एक बेहतर शुरुआत हैfor(;$i<$a=$argv[1];$i+=2){$t=str_pad(str_pad("",$i+1,"*"),$a," ",2)."\n";$i?$s.=$t:$r=$t;}echo strrev($s)."\n".$r.$s;

— जोर्ग हल्सरमैन

for(;$i<$a=$argv[1];$i++){$t=str_pad(str_pad("",$i+1+$i%2,"*"),$a," ",2)."\n";$i%2?$s.=$t:$s=$t.$s;}echo$s;यह बेहतर है

— Jörg Hülsermann

6 बाइट्स को बचाने के लिए () के साथ जुड़ाव बदलें।

— एलेक्स हॉवान्स्की

\nएक बाइट को बचाने के लिए एक वास्तविक नई लाइन के साथ बदलें ।

— एलेक्स हॉवान्स्की

Answer 29

पाइके, 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])

Answer 30

सी, 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);
  }
}