क्या आप मुझे एक षट्भुज बना सकते हैं?

Question

आज, हम एक ASCII षट्भुज बनाने जा रहे हैं। आपको एक प्रोग्राम या फ़ंक्शन लिखना होगा जो एक सकारात्मक पूर्णांक n लेता है , और आकार n की एक षट्भुज ग्रिड को आउटपुट करता है , जो तारांकन से बना होता है। उदाहरण के लिए, आकार 2 का एक षट्भुज इस तरह दिखता है:

 * *
* * *
 * *

जबकि आकार 3 का एक षट्भुज इस तरह दिखता है:

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

आप डिफ़ॉल्ट इनपुट और आउटपुट विधियों में से किसी का भी उपयोग कर सकते हैं , उदाहरण के लिए STDIO / STDOUT, फ़ंक्शन तर्क और रिटर्न मान या फ़ाइल पढ़ना / लिखना।

आप मान सकते हैं कि इनपुट हमेशा मान्य है, इसलिए यदि यह एक सकारात्मक पूर्णांक नहीं है, तो आपका प्रोग्राम जो चाहे कर सकता है। आप करते हैं लेकिन एक आकार 1 षट्भुज, जो एक भी तारा चिह्न होने के विशेष मामले को संभालने के लिए है:

*

जब तक आउटपुट नेत्रहीन समान है तब तक अग्रणी और अनुगामी व्हाट्सएप की अनुमति है।

उदाहरण:

1:
*

2:
 * *
* * *
 * *

3:
  * * *
 * * * *
* * * * *
 * * * *
  * * *

4:
   * * * *
  * * * * *
 * * * * * *
* * * * * * *
 * * * * * *
  * * * * *
   * * * *

5:
    * * * * *
   * * * * * *
  * * * * * * *
 * * * * * * * *
* * * * * * * * *
 * * * * * * * *
  * * * * * * *
   * * * * * *
    * * * * *

6:
     * * * * * *
    * * * * * * *
   * * * * * * * *
  * * * * * * * * *
 * * * * * * * * * *
* * * * * * * * * * *
 * * * * * * * * * *
  * * * * * * * * *
   * * * * * * * *
    * * * * * * *
     * * * * * *

12:
           * * * * * * * * * * * *
          * * * * * * * * * * * * *
         * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * *
 * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * *
 * * * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * *
         * * * * * * * * * * * * * *
          * * * * * * * * * * * * *
           * * * * * * * * * * * *

हमेशा की तरह, यह कोड-गोल्फ है , इसलिए मानक कमियां लागू होती हैं , और आपको बाइट्स में मापा गया सबसे कम संभव प्रोग्राम लिखने की कोशिश करनी चाहिए। बेशक, कुछ भाषाएँ स्वाभाविक रूप से छोटी या दूसरों की तुलना में लंबी होती हैं, इसलिए याद रखें कि लक्ष्य के लिए आवश्यक नहीं कि सबसे छोटी बाइट काउंट हो, लेकिन समान या समान भाषाओं में सबमिशन को हराया जाए।

सर्वश्रेष्ठ गोल्फर जीत सकते हैं!

Comments

हमारे पास हेक्सागोनल-ग्रिड टैग भी क्यों है?

— पावेल

साथ ही, किसी को हेक्सागोनी समाधान लिखना होगा।

— पावेल

अगर किसी को इनाम के लिए जाना है, तो आप शायद यहाँ पर मेरे हेक्सागोनी उत्तर के आउटपुट लूप का पुन: उपयोग कर सकते हैं ।

— मार्टिन एंडर

"क्या आप मुझे एक षट्भुज बना सकते हैं?" - यकीन है, यहाँ तुम जाओ: i.imgur.com/1emYIia.png

— aditsu

@ हेवेल क्योंकि हेक्सागोनल ग्रिड पर बहुत सारे ऑपरेशन अधिक मानक वर्ग ग्रिड से भिन्न होते हैं, और विभिन्न समस्याओं के समाधान के बीच पोर्टेबल होते हैं। समन्वयन हेरफेर, रोटेशन, आउटपुट लेआउट आदि के रूप में इस तरह के संचालन

— शुक्राणु

Answer 1

हेक्सागोनी + बैश कोरुटिल्स, 0 + 3 + 8 = 11 बाइट्स

-gध्वज के लिए +3 और |tr . \*गैर-मानक आह्वान के लिए +8 शामिल हैं (यह मेटा पोस्ट देखें )

हेक्सागोनी के तर्क के रूप में इनपुट दिया गया है। जब हेक्सागोनी दुभाषिया को -g Nविकल्प के साथ बुलाया जाता है तो वह .एस के षट्भुज को प्रिंट करता है । हम तो *s के साथ बदलने के लिए tr का उपयोग करते हैं ।

Comments

वाह, यह प्रतिभा है। और आप सभी गोल्फ भाषाओं को हरा रहे हैं!

— DJMcMayhem

मैं वास्तव में हेक्सागोनी भाषा का उपयोग करके इसे नहीं कहूंगा, जैसे कि हेक्सागोनी दुभाषिया के साथ बैश (या कुछ अन्य शेल) का उपयोग करना। यह hexagony -g $1|tr . \*माना जाएगा कि, हेक्सागोनी दुभाषिया को इस तरह नामित किया गया है।

— पाओलो एबरमन

यह एक वास्तविक, चल कमान से लाभान्वित होगा ...

— jpmc26

@ jpmc26 लंबाई 5 हेक्स के लिए आप चलाएंगेruby ./interpreter.rb -g 5|tr . \*

— रिले

@OlivierDulac "प्रोग्राम" शून्य बाइट्स है। सारा काम "झंडे" से हो रहा है।

— रिले

Answer 2

पायथन 2, 61 बाइट्स

i=n=input()
while~-n+i:i-=1;j=abs(i);print' '*j+'* '*(2*n+~j)

प्रत्येक पंक्ति के अंत में एक अनुगामी स्थान प्रिंट करता है।

बाइट बचाने के लिए एर्ग आउटफोलर को धन्यवाद।

Comments

इस से शुरू, यदि आप एक गैर PEP8 लेकिन 69 बाइट्स के साथ वैध अजगर 3 कोड व्युत्पन्न, द्वारा int(input())बजाय input()और हमेशा की तरह print(' '*j+'* '*(2*n+~j))जगह print' '*j+'* '*(2*n+~j)- शांत कोड btw ;-)

— Dilettant

यह कुछ गंभीरता से अच्छा कोड है!

— मटियास ब्रजलैंड

Answer 3

जावास्क्रिप्ट (ईएस 6), 77 81 84

@Upvoters: @ बाइट्स से जवाब याद नहीं है, कि 76 बाइट्स है

संपादित करें कल्पना में परिवर्तन के बाद, अनुगामी अंतरिक्ष अनुमति दी

सिर्फ टोपी के लिए ... हे! कोई टोपी नहीं?

f=(n,b='* '.repeat(n+n-1),o=b)=>--n?f(n,b=` ${b}`.slice(0,-2),b+`
${o}
`+b):o

परीक्षा

f=(n,b='* '.repeat(n+n-1),o=b)=>--n?f(n,b=` ${b}`.slice(0,-2),b+`
${o}
`+b):o


function update()
{
  O.textContent=f(+I.value)
}

update()

<input id=I type=number min=1 value=3 oninput='update()'>
<pre id=O></pre>

Answer 4

हेक्सागोनी , 91 87 86 बाइट्स

?{2'*=&~}=&}='P0</0P}|@..;>;'.\};0Q/..\&(<>"-_"&}=\?_&\/8.=-\<><;{M/.(.(/.-{><.{&'/_.\

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

अंत में किया।

प्रारंभ में (यह समझने से पहले कि महंगे लूप कैसे हैं) मुझे उम्मीद है कि यह साइड 5 लंबाई में फिट होने में सक्षम हो सकता है, लेकिन अब इसे साइड लंबाई 6 में फिट करने के लिए पर्याप्त कठिन है।

इसे पाने के लिए मुझे वास्तव में रैखिक कोड को थोड़ा संशोधित करना होगा। वास्तव में, इसे लिखने से मुझे रैखिक कोड को 1 2 बाइट से नीचे करने का एक तरीका पता चलता है ।

Answer 5

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

g=(n,s=`
*`+' *'.repeat(n*2-2),c=s,q=c.replace('*',''))=>--n?g(n,q+s+q,q):s

मैंने अपने आप से कहा कि मैं तब तक नहीं सोऊंगा जब तक कि मैंने अन्य उत्तरों को देखे बिना एक नया ईएस 6 रिकॉर्ड स्थापित नहीं किया, इसलिए यहां यह है ...

टेस्ट स्निपेट

g=(n,s=`
*`+' *'.repeat(n*2-2),c=s,q=c.replace('*',''))=>--n?g(n,q+s+q,q):s

for(var i = 1; i < 7; i++) console.log(g(i)) // joe

Answer 6

सी, 91 89 80 74 बाइट्स

w,y;f(s){for(y=-s;++y<s;)for(w=printf("\n%*s",y,"");++w<s*printf(" *"););}

मैं बहुत सही फार्मूले पाने के लिए चारों ओर tweaked, तो यह सब एक साथ मैश्ड।

fनंबर n के साथ कॉल करें , और यह षट्भुज को छोडने के लिए प्रिंट करेगा।

Ungolfed और समझाया (80-बाइट संस्करण):

w,y;
f(s) {
    // y iterates over [-s + 1 ; s - 1] (the number of rows)
    for(y = -s; ++y < s;)
        // w iterates over [abs(y) + 2 ; s * 2 - 1] (the number of stars on the row)
        for(
            // This prints a backspace character (ASCII 8)
            // padded with abs(y) + 2 spaces, effectively
            // printing abs(y) spaces to offset the row.
            // Also initializes w with abs(y) + 2.
            printf("\n%*c", w = abs(y) + 2, 8);

            // This is the for's condition. Makes use
            // of the 2 returned by printf, since we coïncidentally
            // need to double the upper bound for w.
            w++ < s * printf("* ");

            // Empty for increment
        )
            ; // Empty for body
}

इसे कोलिरु पर लाइव देखें

टिप्पणियाँ:

• printfनकारात्मक गद्दी को संभाल सकता है, जिसके परिणामस्वरूप दाईं ओर गद्दी के साथ एक बाएं-संरेखित वर्ण होता है। इस प्रकार मैंने इसके प्रभाव के लिए कुछ करने की कोशिश की, w = printf("%*c*", y, ' ')यह पूर्ण मूल्य का ख्याल रखेगा, और मैं इसे इसके वापसी मूल्य से पुनः प्राप्त कर सकता हूं। दुर्भाग्य से, दोनों शून्य और एक पैडिंग चौड़ाई अपने आप ही चरित्र को प्रिंट करती है, इसलिए तीन केंद्र लाइनें समान थीं।
  अपडेट: जैसन ने एक चरित्र के बजाय एक खाली स्ट्रिंग को प्रिंट करके ऐसा करने का एक तरीका ढूंढ लिया है - 6 बाइट्स मुंडा!

• कॉलिरू द्वारा बैकस्पेस वर्ण को गलत तरीके से नियंत्रित किया जाता है - इस कोड को एक स्थानीय टर्मिनल पर निष्पादित करने से प्रत्येक पंक्ति पर अग्रणी स्थान को हटा दिया जाता है।

Comments

w=printf("\n%*s",abs(y),"");++w<s*printf(" *");

— जसन

@ जैसन मुझे विश्वास नहीं हो रहा है कि मैं चूक गया ... धन्यवाद!

— क्वेंटिन

Answer 7

05AB1E , 14 13 बाइट्स

कोड:

F¹N+„ *×})û.c

स्पष्टीकरण:

F       }        # Input times do (N = iteration number)
 ¹N+             #   Calculate input + N
    „ *×         #   Multiply by the string " *"
         )       # Wrap everything into an array
          û      # Palindromize the array
           .c    # Centralize

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

Comments

मुझे समझ में नहीं आता है कि "केंद्रीकृत" भाग क्या करता है। जब मैं इसे हटाता हूं, तो मुझे उपयुक्त स्थानों की संख्या के बिना तार की एक सरणी मिलती है।

— DJMcMayhem

@DJMcMayhem एक सरणी पर, आप इसे देख सकते हैं जैसे कि यह एक स्ट्रिंग है जो पाठ केंद्र के साथ newlines द्वारा जुड़ती है। यह वह है जो इनपुट पर करता है।

— अदनान

Answer 8

जेली , 24 बाइट्स

R+’µạṀx@€⁶żx@K¥€”*$F€ŒḄY

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

जेली को इस तथ्य पर शर्म आती है कि इसमें एक केंद्रीकरण परमाणु नहीं है, इसलिए इसे क्रमशः 05AB1E और V. द्वारा 11 और 7 बाइट्स द्वारा पीटा जाता है!

यदि आपको यह गोल्फ के लिए कोई रास्ता मिल जाए, तो कृपया टिप्पणी करें। किसी भी मदद की सराहना की है।

स्पष्टीकरण :

R+’µạṀx@€⁶żx@K¥€”*$F€ŒḄY Main link. Arguments: z.
R+’                      The sizes of the hexagon's rows. (implicit argument)
   µ                     Start a new monadic chain with the above argument.
    ȧṀx@€⁶               The spaces you must prepend to each row. (implicit argument)
           x@K¥€”*$      The stars (points) of each row, space-joined, as a single link. (implicit argument)
          ż        F€    Conjoin and merge the leading spaces with the stars appropriately.
                     ŒḄ  Create the second half of the hexagon without the middle row.
                       Y Join the rows with newlines. This makes the shape look like a hexagon.

बोनस: यह जानने के लिए कि षट्भुज में कितने तारे हैं, इसका उपयोग करें:

Ḷ×6S‘

Comments

भई, स्पष्टीकरण भारी था।

— को एग्री आउटफोलर

एक "केंद्रीकरण परमाणु" क्या करेगा?

— DJMcMayhem

@DJMcMayhem एक उदाहरण के लिए 05AB1E उत्तर देखें।

— से एग्री आउटलॉफर

Answer 9

ऑक्टेव, 62 58 बाइट्स

@(n)' *'(dilate(impad(1,2*--n,n),[k='01010'-48;~k;k],n)+1)

पिछला उत्तर:

@(n)' *'(dilate(impad(1,2*(m=n-1),m),[k='01010'-48;~k;k],m)+1)

जिसे कहा जा सकता है

(@(n)' *'(dilate(impad(1,2*(m=n-1),m),[k='01010'-48;~k;k],m)+1))(5)

ऑक्टेव ऑनलाइन पर इसे आज़माएं (पेस्ट करें)

उदाहरण के लिए आधार छवि n=5है

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

के साथ बनाया जा सकता है

impad(1,2*(n-1),n-1)

dilation morphological operatorनिम्नलिखित पड़ोसी मुखौटा का उपयोग कर छवि पर लागू 4 बार:

0 1 0 1 0
1 0 1 0 1
0 1 0 1 0

के साथ बनाया जा सकता है [k='01010'-48;~k;k]

फैलाव का परिणाम:

0 0 0 0 1 0 1 0 1 0 1 0 1 0 0 0 0
0 0 0 1 0 1 0 1 0 1 0 1 0 1 0 0 0
0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0
0 0 0 1 0 1 0 1 0 1 0 1 0 1 0 0 0
0 0 0 0 1 0 1 0 1 0 1 0 1 0 0 0 0

फिर क्रमशः 0 और 1 को '' और '*' से बदलें

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

Answer 10

postgresql9.6, 290 बाइट्स

do language plpgsql $$ declare s constant smallint:=4;declare n smallint;declare a constant int[]:=array(select generate_series(1,s));begin foreach n in array a||array(select unnest(a)t order by t desc offset 1)loop raise info'%',concat(repeat(' ',s-n),repeat(' *',s+(n-1)));end loop;end;$$

स्वरूपित sql यहाँ है:

do language plpgsql $$
declare s constant smallint := 4;
declare n smallint;
declare a constant int[] := array(select generate_series(1, s));
begin
foreach n in array a || array(select unnest(a)t order by t desc offset 1) loop
    raise info '%', concat(repeat(' ', s - n), repeat(' *', s + (n - 1)));
end loop;
end;
$$;

उत्पादन:

INFO:      * * * *
INFO:     * * * * *
INFO:    * * * * * *
INFO:   * * * * * * *
INFO:    * * * * * *
INFO:     * * * * *
INFO:      * * * *

Comments

lpadआपको कुछ बाइट्स बचाने में सक्षम हो सकता है। मैं भाषा को pl / pgsql भी कहूँगा, लेकिन यह सवाल उठाता है कि क्या आपको do language plpgsql $$और समापन की गिनती करनी है $$;। यदि वे पहले नहीं आए हैं, तो उन्हें मेटा पर सबसे अच्छा संबोधित किया जाएगा।

— jpmc26

इसके अलावा, आपको कई DECLAREएस की आवश्यकता क्यों है ? एक काम नहीं होगा?

— jpmc26

Answer 11

वी , 17 बाइट्स

é*À­ñ>{MÄpXA *Î.

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

हमेशा की तरह, यहाँ एक हेक्सडंप है, क्योंकि इसमें अनपेक्षित वर्ण हैं:

00000000: e92a c0ad f13e 7b4d c470 5841 202a 1bce  .*...>{M.pXA *..
00000010: 2e                                       .

Answer 12

APL (Dyalog Unicode) , 40 36 35 33 27 25 बाइट्स

(⍉⊖⍪1↓⊢)⍣2∘↑⍳↓¨∘⊂'* '⍴⍨+⍨

मान लेता है ⎕IO←0, अर्थात शून्य-आधारित अनुक्रमण। आउटपुट में प्रत्येक पंक्ति पर एक अग्रणी और एक अनुगामी स्थान होता है।

कई गोल्फ के लिए @FrownyFrog और @ngn के लिए बहुत धन्यवाद।

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

यह काम किस प्रकार करता है

(⍉⊖⍪1↓⊢)⍣2∘↑⍳↓¨∘⊂'* '⍴⍨+⍨  ⍝ Main function train
                 '* '⍴⍨+⍨  ⍝   Repeat '* ' up to length 2×⍵
            ⍳↓¨∘⊂          ⍝   Generate lower-right corner of the hexagon
          ∘↑               ⍝   Convert to matrix
(⍉⊖⍪1↓⊢)                   ⍝   Palindromize vertically and transpose
        ⍣2                 ⍝   ... twice

Answer 13

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

यह मेरा पहला (कोड गोल्फ) उत्तर है। मुझे उम्मीद है कि मैंने सब कुछ सही ढंग से स्वरूपित किया।

a=>{for(b=c=2*a-1;c;)console.log(" ".repeat(d=Math.abs(a-c--))+"* ".repeat(b-d))}

2 वर्तमान ईएस 6 उत्तरों के विपरीत, मैं पुनरावर्ती रूप से एक फ़ंक्शन नहीं कह रहा हूं और मैं आउटपुट के लिए कंसोल का उपयोग कर रहा हूं।

Comments

alertयदि आप ब्राउज़र js निर्दिष्ट करते हैं तो क्या आप इसका उपयोग कर सकते हैं ?

— फ्लिपकैक

@FlipTack, वास्तव में नहीं, क्योंकि मैं धीरे-धीरे स्ट्रिंग (लाइन द्वारा लाइन) का निर्माण करता हूं। अगर मैं alertइसे एड करता हूं , तो यह लाइन से लाइन को अलर्ट करता है, न कि पूरी चीज को।

— ल्यूक

Answer 14

हास्केल, 99 97 79 बाइट्स

h n=mapM_(putStrLn.(\k->([k..n]>>" ")++([2..n+k]>>"* ")))([1..n-1]++[n,n-1..1])

व्याख्या: यह कार्यक्रम इस अवलोकन पर आधारित है कि n-Hexagon की प्रत्येक पंक्ति में (n +) रिक्त स्थान होते हैं (n + k-1) तारांकन, कुछ k संख्या रेखा पर निर्भर के लिए।

h n=                                             h is a function of type Int -> IO ()
  mapM_                                          mapM_ executes a function returning 
                                                 monadic actions on all objects 
                                                 in a list, in order. Then it executes 
                                                 these actions, in order. For this code, it 
                                                 transforms each value in the list into a 
                                                 monadic action that prints 
                                                 the corresponding line

      (                                          the function consists of two components
        putStrLn                                 the second part is printing the result of 
                                                 the first part to stdout 

        .                                        concatenating both components

        (\k->                                    the first parts first prints (n-k) spaces 
                                                 and then (n+k-1) asterisks

          ([k..n]>>" ")                          create the list of the integers from 
                                                 k to n (That is actually one more entry
                                                 than necessary, but just results in a
                                                 leading whitespace per line, while
                                                 saving 2 bytes compared to [1..n-k]).
                                                 Then create a new list where 
                                                 each element of that first list is 
                                                 replaced with the string " " and 
                                                 concatenate that result into one string

          ++                                     concatenate both lists

          ([2..n+k]>>"* ")                       create the list of the integers 
                                                 from 2 to n+k (of length n+k-1). 
                                                 Then create a new list where each 
                                                 element of that first list is replaced 
                                                 with the string "* " and concatenate 
                                                 that result into one big string
        ) 

      )         
      ([1..n-1]++[n,n-1..1])                     the list simply goes from 1 to n and 
                                                 back, supplying the k 

संपादित करें: mapM_ पर स्विच किया गया। मुझे पता नहीं था कि आयात का उपयोग किए बिना उपलब्ध था

Answer 15

पायथन 2 , 100 97 89 88 87 81 79 बाइट्स

-1 @ Flp.Tkc से

-6 फिर से @ एफएलपी

-2 @ nedla2004 के साथ धन्यवाद। मैं खोजने की कोशिश कर रहा था कि दूसरी स्लाइस से कैसे छुटकारा पाऊं लेकिन उस एक के बारे में नहीं सोचा था :)

i=input()
a=[" "*(i-x)+"* "*(i+x)for x in range(i)]
print'\n'.join(a+a[-2::-1])

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

शीर्ष आधे के लिए एक सरणी बनाता है फिर उलटी सरणी को जोड़ता है मध्य रेखा फिर प्रिंट करता है। प्रिंट बिल्कुल "जैसा है" से अलग है1 एक प्रमुख स्थान के साथ प्रिंट करता है (मुझे लगता है कि अनुमति दी गई है *कि नेत्रहीन *एक अग्रणी स्थान के साथ या बिना समान है)।

Comments

यह 1 - "*" के लिए गलत समाधान देता है। मुझे लगता है कि यह सामने अंतरिक्ष के बिना तारांकन होना चाहिए?

— Андрей Ломакин

@ АндрейЛомакин - ओपी से: "जब तक आउटपुट नेत्रहीन समान है तब तक अग्रणी और अनुगामी व्हाट्सएप की अनुमति है।" एक एकल तारा नेत्रहीन एक एकल तारा है जिसके सामने एक स्थान है या कम से कम मेरी व्याख्या है

— ;;

लेकिन आप वास्तव में सही हैं कि मैंने अपने जवाब में जो कहा है, उसका खंडन किया है। मैंने स्पष्ट करने के उत्तर को अपडेट कर दिया है। अब बेहतर है? BTW, एक पुराने उत्तर को खोजने और संभावित त्रुटि का पता लगाने पर अच्छा काम। आदर करना।

— एलपेड्रो

मैं खुद इस चुनौती का प्रयास कर रहा था, और कुछ भी बेहतर नहीं कर सकता था, प्रेरणा के लिए आपका अध्ययन कर रहा था।

— फरवरी को Андрей Ломакин

मुझे उम्मीद है कि मेरे विनम्र प्रयास ने आपकी मदद की है। यकीन है कि हम भविष्य में एक साथ कुछ मजेदार गोल्फिंग करेंगे। PPCG का आनंद लें। मुझे यकीन है कि

— P

Answer 16

बैच, 161 बाइट्स

@echo off
set s=*
set l=for /l %%i in (2,1,%1)do call 
%l%set s= %%s%% *
%l%echo %%s%%&call set s=%%s:~1%% *
echo %s%
%l%set s= %%s:~0,-2%%&call echo %%s%%

नोट: पंक्ति 2 पर पीछे की जगह

@echo off
set s=*
rem build up the leading spaces and stars for the first row
for /l %%i in (2,1,%1) do call :s
rem output the top half of the hexagon
for /l %%i in (2,1,%1) do call :t
rem middle (or only) row
echo %s%
rem output the bottom half of the hexagon
for /l %%i in (2,1,%1) do call :b
exit/b
:s
set s= %s% *
exit/b
:t
echo %s%
rem for the top half remove a space and add a star to each row
set s=%s:~1% *
exit/b
:b
rem for the bottom half add a space and remove a star from each row
set s= %s:~0,-2%
echo %s%
exit/b

Answer 17

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

f=
n=>[...Array(n+--n)].map((_,i,a)=>a.map((_,j)=>j<n-i|j<i-n?``:`*`).join` `).join`
`

<input type=number min=1 oninput=o.textContent=f(+this.value)><pre id=o>

Answer 18

कैनवस , 9 बाइट्स

╷⁸＋* ×］／─

यहाँ यह कोशिश करो!

अंतर्निहित बीटिंग: डी

स्पष्टीकरण:

{╷⁸+* ×]/─  implicit "{"
{      ]    map over 1..input
 ╷            decrement: 0..input-1
  ⁸+          add the input: input..(input*2-1)
    * ×       repeat "* " that many times
        /   diagonalify that - pad each line with 1 less space than the previous
         ─  palindromize vertically

_{पता नहीं क्यों वहाँ बहुत बड़ा पैडिंग है, लेकिन इसकी अनुमति है और मैं जल्द ही इसे ठीक कर रहा हूं। ™ तय? आशा है कि मैंने सामान नहीं तोड़ा}

Answer 19

पर्ल 6 , 49 बाइट्स

->\n{say " "x n*2-1-$_~"*"xx$_ for n...n*2-1...n}

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

यह काम किस प्रकार करता है

->\n{                                           }  # Lambda accepting edge size (e.g. 3)
                               for n...n*2-1...n   # For each row-size (e.g. 3,4,5,4,3):
                       "*"xx$_                     # List of stars     (e.g. "*","*","*")
         " "x n*2-1-$_                             # Spaces to prepend (e.g. "  ")
                      ~                            # Concatenate.      (e.g. "  * * *")
     say                                           # Print

Answer 20

पॉवर्सशेल, 91 89 78 68 63 52 48 बाइट्स

param($n)$n..1+1..$n|gu|%{' '*$_+'* '*(2*$n-$_)}

टेस्ट स्क्रिप्ट:

$script = {
param($n)$n..1+1..$n|gu|%{' '*$_+'* '*(2*$n-$_)}
}

12,6,5,4,3,2,1 |%{
    $_
    . $script $_
}

आउटपुट (अतिरिक्त अग्रणी स्थान):

12
            * * * * * * * * * * * *
           * * * * * * * * * * * * *
          * * * * * * * * * * * * * *
         * * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * * *
 * * * * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * * *
         * * * * * * * * * * * * * * *
          * * * * * * * * * * * * * *
           * * * * * * * * * * * * *
            * * * * * * * * * * * *
6
      * * * * * *
     * * * * * * *
    * * * * * * * *
   * * * * * * * * *
  * * * * * * * * * *
 * * * * * * * * * * *
  * * * * * * * * * *
   * * * * * * * * *
    * * * * * * * *
     * * * * * * *
      * * * * * *
5
     * * * * *
    * * * * * *
   * * * * * * *
  * * * * * * * *
 * * * * * * * * *
  * * * * * * * *
   * * * * * * *
    * * * * * *
     * * * * *
4
    * * * *
   * * * * *
  * * * * * *
 * * * * * * *
  * * * * * *
   * * * * *
    * * * *
3
   * * *
  * * * *
 * * * * *
  * * * *
   * * *
2
  * *
 * * *
  * *
1
 *

स्पष्टीकरण:

param($n)           # define script parameter
$n..1+              # int range from n to 1 step -1; append
1..$n|              # int range from 1 to n
gu|                 # alias for Get-unique eliminates equal neighbors - here is 1,1 -> 1
%{                  # for each int from [n, n-1, n-2, ... 2, 1, 2, ... n-2, n-1, n]
    ' '*$_+         # string (' ' have repeated $_ times) append
    '* '*(2*$n-$_)  # string ('* ' have repeated 2*n-$_ times)
}

Comments

का अच्छा उपयोग gu।

— AdmBorkBork

Answer 21

PHP, 83 79 बाइट्स

for($p=str_pad;++$y<2*$n=$argn;)echo$p($p("
",1+$k=abs($n-$y)),4*$n-$k-2,"* ");

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

---

यह कोडोस के उत्तर के करीब है ; लेकिन गोल्फ str_padसे str_repeatभी छोटा है ।
और ++लूप सिर में कुछ और बचाता है।

Answer 22

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

->n{(1-n..n-1).map{|j|i=j.abs;' '*i+'* '*(n*2+~i)}*$/}

lambda फ़ंक्शन तर्क के रूप में n लेता है और नए सिरे से अलग किए गए एक स्ट्रिंग को लौटाता है। ($/ एक डिफॉल्ट लाइन सेपरेटर वाला चर है।)

परीक्षण कार्यक्रम में

f=->n{(1-n..n-1).map{|j|i=j.abs;' '*i+'* '*(n*2+~i)}*$/}

puts f[gets.to_i]

Comments

3 डॉट्स

— GB

लगता है कि सर्वसम्मति से आउटपुट putsगिनती (यानी ) को चार गिनती में शामिल करना है। लेकिन परिभाषा को फिर से पढ़ना यह कहता है कि आपके फ़ंक्शन को परिणाम "आउटपुट" करना चाहिए जिसे परिणाम "रिटर्न" के रूप में पढ़ा जा सकता है। शांत समाधान।

— मटियास ब्रजलैंड

@MatiasBjarland meta.codegolf.stackexchange.com/a/2456/15599

— लेवल रिवर सेंट

Answer 23

चार्ली, 125 बाइट्स

let i="".promptn()let o=0let j=0let w=write loop{w(" "*(i-1-o),"* "*(i+o))w("
")if j<i-1{o+=1}else{o-=1}if o<0{break}j+=1}

चार्ली गिटहब पेज: https://github.com/KCreate/charly-lang

Answer 24

स्माइलबासिक, 74 बाइट्स

FOR I=0TO N-1P
NEXT
FOR I=N-2TO.STEP-1P
NEXT
DEF P?" "*(N-I);"* "*(N+I)END

एक अग्रणी और अनुगामी स्थान जोड़ता है।

ये "हेक्सागोन" भयानक दिखते हैं जब पात्रों की चौड़ाई और ऊंचाई समान होती है ...

Answer 25

रैकेट / योजना

(define (f n)
  (define (s t n)
    (if (= n 0) t (s (~a t "* ") (- n 1))))
  (define (h t p a i)
    (if (= i 0)
        (display t)
        (let ((x (~a t (make-string p #\space) (s "" a) "\n"))
              (q (if (> i n) (- p 1) (+ p 1)))
              (b (if (> i n) (+ a 1) (- a 1))))
          (h x q b (- i 1)))))
  (h "" (- n 1) n (- (* 2 n) 1)))

परिक्षण:

(f 1)
*

(f 4)
   * * * *
  * * * * *
 * * * * * *
* * * * * * *
 * * * * * *
  * * * * *
   * * * *

Comments

साइट पर आपका स्वागत है! यह एक कोड-गोल्फ प्रतियोगिता है, इसलिए आपको अपनी बाइट की गिनती शामिल करनी चाहिए। साथ ही आप इस उत्तर में मौजूद बहुत से व्हाट्सएप को छोटा करने के लिए निकाल सकते हैं।

— गेहूं जादूगर

आपके इनपुट के लिए धन्यवाद, कैट विजार्ड। मैं कोड गोल्फिंग के लिए नया हूं, और मुझे लगता है कि योजना इसके लिए सबसे अच्छी भाषा नहीं है, लेकिन मैं इसे छोटा करने की कोशिश करूंगा, व्हॉट्सएप को खत्म कर दूंगा और मेरी अगली प्रविष्टि पर एक बाइट की गिनती जोड़ूंगा।

— केविन

Answer 26

पायथन 2, 111 बाइट्स

n=input()
l=range(n,2*n-1)
S=l+[2*n-1]+l[::-1]
W=range(1,n)
for w in W[::-1]+[0]+W:print" "*w+"* "*S[0];S=S[1:]

एक उबाऊ, सीधा कार्यान्वयन (और एक पूर्ण कार्यक्रम)। प्रत्येक पंक्ति में एक अनुगामी व्हाट्सएप को आउटपुट करता है।

परीक्षण के मामलों:

1:
*

2:
 * * 
* * * 
 * * 

3:
  * * * 
 * * * * 
* * * * * 
 * * * * 
  * * * 

4:
   * * * * 
  * * * * * 
 * * * * * * 
* * * * * * * 
 * * * * * * 
  * * * * * 
   * * * * 

Answer 27

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

यह अंत में क्रिसमस ब्रेक (मेरी क्रिसमस!) है, इसलिए मेरे पास गोल्फ के लिए कुछ समय है।
और लड़के को थोड़ी देर हो गई है - इसलिए बड़ी बाइट गिनती है।
यहाँ जाता हैं:

c=[];a=a=>{for(i=0;i<a;i++){c.push(" ".repeat(a-i-1)+"* ".repeat(i+a-1)+"*")}for(j=c.length-2;j>-1;j--)c.push(c[j]);return a==1?"*":c.join`\n`}
console.log(a(3));

Comments

कुछ सुधार: के for(j=c.length-2;j>-1;j--)c.push(c[j])रूप में लिखा जा सकता है for(j=a-1;j;c.push(c[--j]))और for(i=0;i<a;i++){c.push(" ".repeat(a-i-1)+"* ".repeat(i+a-1)+"*")}हो सकता है for(i=0;i<a;c.push(" ".repeat(a-i-1)+"* ".repeat(a-1+i++));। वापसी विवरण को छोटा किया जा सकता है return a-1?c.join\ n :"*"कुल मिलाकर, ये परिवर्तन 18B (11 + 7 + 1) को बचाते हैं।

— ल्यूक

Answer 28

जावा, 157 149 129 127 बाइट्स

s->{for(int j=~--s,t;++j<=s;p(s-~s-t,"* "),p(1,"\n"))p(t=j<0?-j:j," ");};<T>void p(int j,T s){for(;j-->0;)System.out.print(s);}

• जोनाथन फ्रेच द्वारा हटाए गए 8 बाइट्स।
• केविन क्रूज़सेन द्वारा हटाए गए 20 बाइट्स।
• केविन क्रूज़सेन द्वारा हटाए गए 2 बाइट्स।

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

Comments

149 बाइट्स ।

— जोनाथन फ्रीच

94 बाइट्स। नोट: जावा 11 में है String#repeat(int), लेकिन TIO अभी भी JDK 10 है, इसलिए उत्सर्जित repeat(String,int)विधि (उसी बाइट-काउंट के साथ)। जावा 11 में वास्तविक कोड होगा:s->{for(int j=~--s,t;++j<=s;System.out.println(" ".repeat(t)+"* ".repeat(s-~s-t)))t=j<0?-j:j;}

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

@ यूजीन श्योर। :) उस मामले में वर्तमान जावा संस्करण में गोल्फ के लिए कुछ चीजें (8+) अभी के लिए: 129 बाइट्स ।

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

@ केविनक्रूजसेन यहाँ काफी भारी गोल्फ है, इसे अद्यतन किया, धन्यवाद।

— यूजीन

मैं फिर से। -2 बाइट्स के लिए गोल्फ में एक और चीज मिली। 127 बाइट्स इसका उपयोग ऊपर दिए गए जावा 11 सॉल्यूशन में 1 बाइट गोल्फ के लिए भी किया जा सकता है ।

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

Answer 29

हेक्सागोनी (रैखिक), 128 127 126 बाइट्स

ध्यान दें कि यह हेक्सागोनी नहीं है , बस एक (मेटा-) भाषा टिम्वी एसोटेरिक आईडीई में समर्थित है, इसलिए यह है नहीं है इनाम के लिए योग्य ।

हालाँकि इसे हेक्सागोनी समाधान में परिवर्तित किया जा सकता है (और मुझे लगता है कि यह इस समाधान से छोटा होगा) मैं बाद में ऐसा कर सकता हूं। यह अधिक प्रयास लेता है मैंने इसे यहां पर किया था ।

प्रारंभिक ❢3 बाइट्स ( e2 9d a2) लेता है । प्रत्येक नई पंक्ति में 1 बाइट ( 0a) होती है।

❢?{2'*=(
A
if > 0
 "-"&}=&~}=&}=?&
 B
 if > 0
  }P0;'(
  goto B
 &{&'-{=-(
 C
 if > 0
  'P0;Q0;}(
  goto C
 {M8;{(
 goto A
@

कोई ऑनलाइन कोशिश करो!। इस केवल एसोटेरिक आईडीई में काम करता है।

एनोटेट कोड:

❢?        # read input n
[n]
{2'*=(     # x = 2n-1
[x]
A
if > 0    # loop (x) from 2n-1 to 1
 "-      # a = x - n
 [a]
 "&}=&~}=&    # a = abs(a). Let K be this amount
 }=?&
 B
 if > 0       # print ' ' (a) times
  }P0;'(
  goto B
 &        # current cell = a (= K)
 {&       # a = n if K>0 else x
          # Note that K=abs(x-n). So if K==0 then x==n.
          # Therefore after this step a is always equal to n.
 '-{=-    # compute n-(K-n) = 2n+K
 (        # decrement, get 2n+K-1
 C
 if > 0   # print ' *' this many times
  'P0;Q0;}(
  goto C
 {M8;{    # print a newline, goto x
 (        # x -= 1
 goto A
@

Answer 30

जाप -R, ११ 10 बाइट्स

Æ°çSi*Ãû ê

यह कोशिश करो (या TIO का उपयोग करें कई परीक्षण चलाने के का )

---

व्याख्या

               :Implicit input of integer U
Æ              :Map the range [0,U)
 °             :  Postfix increment U
  ç            :  Repeat
   S           :    Space
    i*         :    Prepend asterisk
      Ã        :End map
       û       :Centre pad each string with spaces to the length of the longest string
         ê     :Palindromise
               :Implicitly join with newlines and output