मुसीबत

पिछली चुनौती से प्रेरित होकर कुछ ऐसा ही कर रहे हैं

सकारात्मक पूर्णांक इनपुट nआउटपुट को एक आकार देता है जो इस पैटर्न का अनुसरण करता है:

इनपुट n=1:

* *
 *
* *

इनपुट n=2:

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

इनपुट n=3:

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

और इसी तरह...

इसके ये गुण हैं:

n*2+1 लंबी लाइनें

"हथियार" nव्यापक होते हैं सिवाय जब वे विलय करते हैं

केंद्र रेखा nचौड़ी है

अगर nकेंद्र के ऊपर और नीचे की रेखाएँ n*2चौड़ी हैं

यदि nविषम है तो केंद्र के ऊपर और नीचे की रेखाएँ n*2-1चौड़ी हैं

नियम

अनुगामी newlines स्वीकार किए जाते हैं
मानक खामियां लागू होती हैं
सबसे कम बाइट्स जीतते हैं
आउटपुट प्रिंट आउट या स्ट्रिंग या अरेंज ऑफ़ स्ट्रिंग्स हो सकता है

संपादित करता

n=0 को संभालने की जरूरत नहीं है
ट्रेलिंग रिक्त स्थान की अनुमति दी

code-golf string ascii-art

— LiefdeWen
स्रोत

2

यह ठीक है आउटपुट है, तो 1बजाय *और 0अंतरिक्ष के बजाय?

— जंगहवान मिन

क्या हमारे पैटर्न 0-अनुक्रमित हो सकते हैं?

— लीक नयन

@JungHwanMin मैं इसे अनुमति दूंगा, लेकिन तब आपको जीतने की अनुमति नहीं है, यदि आप सबसे अधिक अपवित्र हैं, तो इसे बहाया जा सकता है।

— LiefdeWen

@LeakyNun 0 अनुक्रमित ठीक है

— LiefdeWen

9

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

एक बाइट के लिए @ErikTheOutgolfer को धन्यवाद

ＦＮ«ＰX⁺*×*Ｉθ→

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

यह मेरा पहला चारकोल उत्तर है, और मुझे पूरा यकीन है कि यह गोल्फ के साथ-साथ नहीं हो सकता है, लेकिन मुझे लगा कि मैं कहीं शुरू करूंगा।

 ＦＮ«            # For input() (i in range(0,input()))
     Ｐ           # Print
       X          # In an 'X' shape
        ⁺*×*Ｉθ   # '*'+'*'*int(first_input)
               →  # Move the cursor right one

— nmjcman101
स्रोत

आप Ｉ-1 के लिए उपयोग कर सकते हैं ।

— आउटगोल्फ

@EriktheOutgolfer मुझे पता था कि ऐसा करने का एक तरीका होना चाहिए था! धन्यवाद!

— nmjcman101

और हाँ यह वास्तव में ऐसा लगता है जैसे यह हो सकता है।

— अगस्त को आउटगोल्फर

@EriktheOutgolfer वैसे भी आपके साथ आने से पहले ऐसा नहीं था :)

— nmjcman101

1

@thomasrutter चारकोल में 256 बाइट्स के साथ स्वयं का कस्टम कोड-पेज है , जहां उन पात्रों में से प्रत्येक 1 बाइट है। इसलिए यह ASCII में एनकोडेड नहीं है, जहां इनमें से कुछ अक्षर वास्तव में कई बाइट्स होंगे। nmjcman101 +1 btw। कल के रूप में मेरे पहले चारकोल जवाब की कोशिश कर रहा था, लेकिन काम से घर जाने से पहले कुछ मिनटों में यह वास्तव में काम नहीं करता था। इसलिए आपने मुझे हरा दिया है। मैंने आपके उत्तर से कुछ चीजें सीखीं, इसलिए इसके लिए धन्यवाद।

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

13

MATL , 16 बाइट्स

EQXyG:Y+tP+g42*c

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

व्याख्या

2उदाहरण के रूप में इनपुट पर विचार करें । स्टैक सामग्री को नीचे हाल के लोगों के साथ दिखाया गया है।

EQ    % Implicitly input n. Push 2*n+1
      %   STACK: 5
Xy    % Identity matrix of that size
      %   STACK: [1 0 0 0 0;
                  0 1 0 0 0;
                  0 0 1 0 0;
                  0 0 0 1 0;
                  0 0 0 0 1]
G:    % Push [1 2 ... n]
      %   STACK: [1 0 0 0 0;
                  0 1 0 0 0;
                  0 0 1 0 0;
                  0 0 0 1 0;
                  0 0 0 0 1],
                 [1 2]
Y+    % 2D convolution, extending size
      %   STACK: [1 2 0 0 0 0;
                  0 1 2 0 0 0;
                  0 0 1 2 0 0;
                  0 0 0 1 2 0;
                  0 0 0 0 1 2]
tP+   % Duplicate, flip vertically, add
      %   STACK: [1 2 0 0 2 1;
                  0 1 2 1 2 0;
                  0 0 1 4 0 0;
                  0 1 2 1 2 0;
                  1 2 0 0 1 2]
g     % Convert to logical
      %   STACK: [1 1 0 0 1 1;
                  0 1 1 1 1 0;
                  0 0 1 1 0 0;
                  0 1 1 1 1 0;
                  1 1 0 0 1 1]
42*   % Multiply by 42.
      %   STACK: [42 42  0  0 42 42;
                   0 42 42 42 42  0;
                   0  0 42 42  0  0;
                   0 42 42 42 42  0;
                  42 42  0  0 42 42]
c     % Convert to char. Char 42 is '*'. Char 0 is displayed as space
      %   STACK: ['**  **';
                  ' **** ';
                  '  **  ';
                  ' **** ';
                  '**  **']

— लुइस मेंडो
स्रोत

तुम मुझसे ज्यादा तेज हो ...

— Leaky Nun

@LeakyNun शायद ही कभी :-)

— लुइस

काश, जेली का 2 डी कायल होता ... मुझे हर पंक्ति में 0 अपेंड करना होता और फिर सदिश राशि लागू होती ...

— लीक नून

1

@LeakyNun आप जानते हैं कि वे

— लुइस मेंडू

1

@LuisMendo मेरे दिल में आप दृढ़ संकल्प का उपयोग करने के लिए विजेता हैं, इस तरह की अच्छी यादों को वापस लाता है।

— LiefdeWen

9

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

Ḥ‘Ḷ⁶ẋ;€”*ẋ$»Ṛ$Y

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

— आउटग्रॉफर को एरिक करें
स्रोत

बहुत अच्छा। 8 बाइट्स मुझसे कम।

— लीक नून

@LeakyNun सीधा तरीका काफी मदद करता है।

— आउटगोल्फ

एक बहुत अच्छा दृष्टिकोण

— जोनाथन एलन

@JonathanAllan हाँ, विशेष रूप से tfw आप वेक्टर सीखते हैं »...

— एरिक द आउटगलर

1

मुझे वास्तव में आपका उपयोगकर्ता नाम पसंद है! लेकिन मेरी इच्छा है कि आप इसके बजाय "vi" या "विम" का उपयोग करते हैं, इसलिए आप "एरिक द वी किंग" चुन सकते हैं ... (मोंटी पाइथन प्रशंसक यहाँ ...)

— ओलिवियर दुलक

4

वी , 18 17 बाइट्स

@ DJMcMayhem की इनपुट ट्रिक के लिए एक बाइट धन्यवाद दिया गया।

Àé*ÄJÀälÀñ2ÙÀl2x>

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

व्याख्या

Àé*ÄJÀäl

यह सम्मिलित करता है [n]*'*'+[n]*' '+[n]*'*'

        Àñ        ' [arg] times
          2Ù      ' Duplicate the current line down twice
            Àl    ' Move right [arg] times
              2x  ' Delete two characters
                > ' Indent this line one space

लूप का प्रत्येक पुनरावृत्ति बफर से जाता है

|**   ***

सेवा

***   ***
 |** ***
***   ***

इसके नीचे |कर्सर कहां है*

— nmjcman101
स्रोत

वाह। आप waaay मुझे outgolfed। बहुत बढ़िया! कुछ सुझाव: आप Àé*ÄJÀälइसके बजाय Àá*Àá Àá*कर सकते हैं, और आप कर सकते हैं <M-c>, यानी ã(mnemonic: केंद्र ) लाइन के मध्य में जाने के लिए, जो कि बाइट से छोटी है Àl। इसे ऑनलाइन आज़माएं!

— DJMcMayhem

@DJMcMayhem मैं विभिन्न स्थानों के एक समूह में आपसे बात करने की कोशिश कर रहा हूं। मैं पहला सुझाव चोरी करने जा रहा हूं जो मुझे लगता है, लेकिन <M-c>उच्च संख्या के लिए ब्रेक

— nmjcman101

3

05AB1E , 18 बाइट्स

Å4bS{I·ƒDÂ~„ *èJ,À

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

व्याख्या

के लिए उदाहरण n=2

Å4                   # push a list of 4s with length as the input
                     # STACK: [4,4]
  b                  # convert each to binary
                     # STACK: [100, 100]
   S{                # split into digit list and sort
                     # STACK: [0, 0, 0, 0, 1, 1]
     I·ƒ             # input*2+1 times do
        D            # duplicate top of stack
                     # 1st iteration: [0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 1, 1]
                     # 2nd iteration: [0, 0, 0, 1, 1, 0], [0, 0, 0, 1, 1, 0]
                     # 3rd iteration: [0, 0, 1, 1, 0, 0], [0, 0, 1, 1, 0, 0]
         Â~          # or each item in the duplicate with its reverse
                     # 1st iteration: [0, 0, 0, 0, 1, 1], [1, 1, 0, 0, 1, 1]
                     # 2nd iteration: [0, 0, 0, 1, 1, 0], [0, 1, 1, 1, 1, 0]
                     # 3rd iteration: [0, 0, 1, 1, 0, 0], [0, 0, 1, 1, 0, 0]
           „ *èJ     # use the resulting binary list to index into the string " *"
                     # 1st iteration: [0, 0, 0, 0, 1, 1], "**  **"
                     # 2nd iteration: [0, 0, 0, 1, 1, 0], " **** "
                     # 3rd iteration: [0, 0, 1, 1, 0, 0], "  **  "
                ,    # print
                 À   # rotate list left

— Emigna
स्रोत

3

वी , 23 बाइट्स

Àé*ÄJÀälÀñÙãlxx>ñyHæGVp

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

Hexdump:

00000000: c0e9 2ac4 4ac0 e46c c0f1 d9e3 6c78 783e  ..*.J..l....lxx>
00000010: f179 48e6 4756 70                        .yH.GVp

जो भी कारण हो, यह चुनौती पिछले एक की तुलना में वी में काफी कठिन है। N समय के हमारे सामान्य दृष्टिकोण के बाद से , एक 'x' विकसित करें यहां काम नहीं करेगा, हम इसके बजाय X के शीर्ष का निर्माण करेंगे, इसे कॉपी करेंगे और इसे फ्लिप करेंगे, फिर दोनों भागों को एक साथ जोड़ेंगे।

स्पष्टीकरण:

Àé*ÄJÀäl                " Insert ('*' * n) + (' ' * n) + ('*' * n) 
                        " The obvious way would be 'Àé*ÀÁ ÀÁ*', but this 
                        " non-obvious way saves us a byte
        Àñ      ñ       " 'n' times:
          Ù             "   Duplicate this line (below us)
           ãl           "   Move to the center of this line
             xx         "   Delete two characters
               >        "   And indent this line with one space.

लूप के अंत में इंडेंट करना , हमें अंतर्निहित अंत का लाभ उठाने की अनुमति देता है । यह आसानी से n + 1 लाइनें भी बनाता है , जो 'X' के शीर्ष आधे भाग में है। मान लीजिए कि इनपुट 4 था। तब इस बिंदु पर, बफर इस तरह दिखता है:

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

और हम अंतिम पंक्ति पर हैं। तो हम:

                yH      " Copy the whole buffer and move to the first line
                  æG    " Reverse every line
                    Vp  " And paste what we just copied *over* the current
                        " line, deleting it in the process

— DJMcMayhem
स्रोत

मैंने ãxxपहली बार में भी बात की थी, लेकिन मुझे लगता है कि यह उदाहरण के लिए तोड़ता है n = 8?

— nmjcman101

@ nmjcman101 आह, आप सही कह रहे हैं। यह ठीक है अगर आप करते हैं ãl, या यदि आप हालांकि केंद्रित करने से पहले संकेत देते हैं, लेकिन यह वास्तव में किसी भी बाइट को नहीं बचाता है। मुझे समझ नहीं आता कि यह छोटी संख्या के लिए क्यों काम करता है।

— डीजेमेक्मे

3

सी #, 139 130 115 बाइट्स

-1 बाइट एक स्ट्रिंग और कॉल करके WriteLine, इस प्रकार नई लाइन के लिए चेक की बचत होती है।
केविन और उनके गुरु गोल्फ तकनीक के लिए -6 बाइट्स धन्यवाद!
के n*3-nसाथ प्रतिस्थापित करके -2 बाइट्स n*2।
-15 बाइट्स के बाद केविन ने मुझे सही दिशा में इशारा किया: मैं इसे प्रिंट करने के बजाय स्ट्रिंग वापस कर सकता हूं, इस प्रकार कॉल को सहेजना System.Console.WriteLine()। और कुछ अन्य टिप्स भी ...

n=>{var s="";for(int i,j=0;j<=n*2;j++,s+='\n')for(i=0;i<n*3;)s+=i>=j&i<j+n|i<=n*3-j-1&i++>=n*2-j?'*':' ';return s;}

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

Ungolfed:

class Program
{
    static void Main(string[] args)
    {
        System.Func<int, string> g = n =>
        {
            var s = "";
            for (int i, j = 0; j <= n*2; j++, s += '\n')
                for (i = 0; i < n*3;)
                    s += i >= j & i < j+n | i <= n*3-j-1 & i++ >= n*2-j ? '*' : ' ';
            return s;
        };

        System.Console.Write(f(1));
        System.Console.Write(f(2));
        System.Console.Write(f(3));
        System.Console.Write(f(5));
        System.Console.Write(f(8));

        System.Console.ReadKey();
    }
}

यह सिर्फ बड़े X को प्रिंट करने के लिए आवश्यक स्थान की पंक्तियों और स्तंभों के साथ पुनरावृत्त करता है और '*'या तो ' 'शर्त के आधार पर प्रिंट करता है।

— चार्ली
स्रोत

1

+1! गोल्फ के लिए कुछ छोटी चीजें। सभी इस मामले में हो &&सकते हैं &और ||हो सकते हैं |। for(int j=0;हो सकता है for(int j=0,i;और तब आप आंतरिक पाश int में सामने को हटा सकते हैं i। इसके अलावा, के पहले परिवर्तन के बाद &और |, आप भी हटा सकते हैं i++के लिए लूप, और परिवर्तन के अंदर i==n*3-1?...करने के लिए i++==n*3-1?...।

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

@KevinCruijssen आपको बहुत बहुत धन्यवाद! मैंने आंतरिक लूप को बदल दिया और अब मैं एक स्ट्रिंग बनाता हूं ताकि मैं कॉल कर सकूं WriteLine, सिर्फ 1 बाइट बचाया। तो अब मुझे यकीन नहीं है कि आपकी आखिरी सलाह का क्या करना है।

— चार्ली

1

Btw, क्यों System.Console.WriteLine? स्ट्रिंग वापस करना: n=>{string s="";for(int i,j=0;j<n*2+1;j++,s+="\n")for(i=0;i<n*3;)s+=i>=j&i<j+n|i<=n*3-j-1&i++>n*2-j-1?'*':' ';return s;}छोटा है [ 120 बाइट्स ] (और फॉर-लूप के अंदर सब कुछ डालकर कोष्ठक से छुटकारा भी मिलता है। यह काम करने के लिए एक TIO- लिंक है। इसके अलावा, इसे या (अपने खुद के) जोड़ने के लिए स्वतंत्र महसूस करें। अपने उत्तर के लिए

— TIO-

1

@KevinCruijssen मुझे नहीं पता था कि TIO C # कोड को संभाल सकता है! मैंने WriteLineकोड में जोड़ा क्योंकि ओपी ने बड़े एक्स को आउटपुट करने के लिए कहा , न कि केवल इसे वापस करने के लिए, इसलिए मुझे लगा कि एक्स के आउटपुट ( WriteLineविधि को कॉल करके ) कोड का हिस्सा होना चाहिए। फिर भी, मुझे अभी भी कोड-गोल्फ के नियमों का उपयोग नहीं किया गया है, और मुझे नहीं पता कि कोड लिखते समय मैं क्या लाइसेंस ले सकता हूं। मैंने अभी देखा है कि यहां कुछ अन्य उत्तर कोड में एक्स प्रिंट करते हैं, और कुछ अन्य इसे पाद लेख में प्रिंट करते हैं। इस मामले में वैध दृष्टिकोण क्या है?

— चार्ली

1

आमतौर पर एक स्ट्रिंग का उपयोग करने के साथ-साथ एक कार्यक्रम के बजाय एक फ़ंक्शन का उपयोग करके डिफ़ॉल्ट रूप से अनुमति दी जाती है, जब तक कि अन्यथा न कहा जाए। इसके अलावा, प्रश्न में यह कहा गया है कि " आउटपुट प्रिंट आउट या स्ट्रिंग या अरेंज ऑफ स्ट्रिंग्स हो सकता है ", इसलिए एक स्ट्रिंग वापस करने की अनुमति है। :) ओह, और एक आखिरी चीज जो आप गोल्फ कर सकते हैं: j<n*2+1हो सकती है j<=n*2। मैंने आपके उत्तर का जावा 8 पोर्ट भी उसी बाइट-काउंट के साथ बनाया है, जो आपके अद्भुत उत्तर को निश्चित रूप से श्रेय देता है।

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

3

हास्केल , 88 87 86 बाइट्स

-1 @ लिकोनी को धन्यवाद

(!)=replicate
x n=[zipWith max(reverse m)m|m<-[i!' '++n!'*'++(n*2-i)!' '|i<-[0..n*2]]]

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

— bartavelle
स्रोत

1

zipWith max m(reverse m)को छोटा किया जा सकता है zipWith max(reverse m)m। यह जैसा है zipWith max=<<reverse$m, और फिर mइनलाइन हो सकता है: इसे ऑनलाइन आज़माएं!

— लकोनी

2

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

Ḥ‘Ḷ⁸+þṬ+Ṛ$a”*o⁶Y

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

— लीक नन
स्रोत

2

MATLAB, 153 126 बाइट्स (17.6% 126)

@ लुइसमेडो की टिप्पणी के लिए धन्यवाद, फ़ंक्शन disp()एकल उद्धरणों के बिना वर्णों का उत्पादन कर सकता है, इस प्रकार मैं कुछ बाइट्स के fprintfसाथ उपयोग करने से रोक सकता हूं formats। इसके अलावा, उनकी टिप्पणी मुझे याद दिलाती है कि मुझे (अशक्त) के char(32)बजाय एक स्थान प्रस्तुत करने के लिए उपयोग की आवश्यकता है char(0)।

n=input('')
r=2*n+1
c=3*n
a=0
for i=0:n-1
a=a+[zeros(r,i),diag(1:r),zeros(r,c-r-i)];
end
a((a+flipud(a))>0)=10
disp([a+32 ''])

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

MATLAB, 153 बाइट्स

n=input('')
r=2*n+1
c=3*n
a=0
for i=0:n-1 
a=a+[zeros(r,i),diag(1:r),zeros(r,c-r-i)];
end
a((a+flipud(a))>0)=42
fprintf([repmat('%c',1,c),'\n'],char(a)')

परिणाम उदाहरण: n = 10

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

— गौयांग किन
स्रोत

2

पायथन 2 , 93 90 89 83 बाइट्स

^{-3 बाइट्स का शुक्रिया}^Leaky^Nun
^{-1 बाइट}^{की बदौलत}^{Zachary T}
^{-6 बाइट्स के लिए शुक्रिया xnor}

n=input()
x=n*'*'+n*'  '
exec"print`map(max,x,x[::-1])`[2::5];x=' '+x[:-1];"*(n-~n)

[इसे ऑनलाइन आज़माएं!] [TIO-j3xwsktf]

प्रत्येक स्थिति के लिए रिक्त स्थान चुनने के लिए आवेदन करने के '*** 'लिए n=3, जैसे स्ट्रिंग के साथ शुरू होता है , फिर एक स्थान को जोड़ते हैं और स्ट्रिंग से अंतिम चरित्र को हटाते हैं और फिर से यह सब करते हैं।map/max*

— छड़ी
स्रोत

90 बाइट्स

— लीकी नॉन

आप को बदल नहीं सकता n*2*' 'के साथ n*' '?

— जकार्इ

map(maxसीधे एक बिना किया जा सकता zip। भी है, n*2+1है n-~n।

— xnor

1

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

f n=[[last$' ':['*'|y<-[1..n],(c-n-y)^2==r^2]|c<-[1..3*n]]|r<-[-n..n]]

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

तार की एक सूची आउटपुट करता है।

पंक्ति r, स्तंभ की प्रत्येक स्थिति के लिए , cयह निर्धारित करने के लिए एक सूत्र का उपयोग करता है कि यह दो विकर्ण बैंडों में से एक में गिरता है या नहीं *।

— XNOR
स्रोत

1

जावा 8, 119 118 बाइट्स

n->{String r="";for(int i=0,j;i<=n*2;i++,r+="\n")for(j=0;j<n*3;r+=j>=i&j<i+n|j<=n*3-i-1&j++>=n*2-i?"*":" ");return r;}

पोर्ट @CarlosAlejo के अद्भुत सी # जवाब से , के बाद मैंने उसे कुछ चीजें गोल्फ में मदद की। तो उसे भी उभारना सुनिश्चित करें!

इसे यहाँ आज़माएँ।

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

1

जावास्क्रिप्ट (ES2017), 155 157 बाइट्स

n=>[...e=[...Array(n+1)].map((a,i)=>[...d=((b=''.padEnd(n))[c='slice'](i)+'*'.repeat(n)+b[c](0,i))[c](n/2)].reverse().join``+d[c](n%1)),...e.reverse()[c](1)]

स्ट्रिंग्स की एक सरणी देता है। मैं सरणियों पर ऑपरेशन करता हूं, फिर इसे दर्पण करता हूं। यह संभवतः अन्य उत्तरों की तरह मैट्रिसेस के साथ अनुकूलित किया जा सकता है, लेकिन मैं अद्वितीय होना चाहता था।

संपादित करें: जैसा कि नील द्वारा बताया गया है, के मानों के लिए भी n, केंद्र रेखा nविस्तृत नहीं थी , इसलिए मैंने कॉलम को स्लाइस करते समय सम / विषम का पता लगाने के लिए एक मापांक जोड़ा।

n=5
['*****     *****',
 ' *****   ***** ',
 '  ***** *****  ',
 '   *********   ',
 '    *******    ',
 '     *****     ',
 '    *******    ',
 '   *********   ',
 '  ***** *****  ',
 ' *****   ***** ',
 '*****     *****']

Ungolfed

n => {
  e = [...Array(n+1)].map((a, i) => {   // Create and iterate over array with n+1 elements
    b = ''.padEnd(n)                    // String of n spaces
    d = (b.slice(i) + '*'.repeat(n) + b.slice(0, i)).slice(n/2) // Create row string
    return [...d].reverse().join`` + d.slice(1) // Mirror and combine row horizontally
  })
  return [...e,...e.reverse().slice(1)] // Mirror and combine vertically
}

वृत्त का चतुर्थ भाग

n=5
   *****
  ***** 
 *****  
*****   
****    
***

क्षैतिज रूप से प्रतिबिंबित

n=5
*****     *****
 *****   ***** 
  ***** *****  
   *********   
    *******    
     *****

मिरर किए हुए

n=5
*****     *****
 *****   ***** 
  ***** *****  
   *********   
    *******    
     *****     
    *******    
   *********   
  ***** *****  
 *****   ***** 
*****     *****

— andrewarchi
स्रोत

इसके लिए भी गलत आउटपुट उत्पन्न होता है n- सेंटर लाइन nचौड़ी नहीं होती है।

— नील

0

गणितज्ञ, 148 बाइट्स

T=Table;(a=Join[T[T["*",i],{i,(n=#)+2,2n,2}],T[Join[t=T["*",n],T[" ",y],t],{y,1,n,2}]];Column[Row/@Join[Reverse@a,{T["*",n]},a],Alignment->Center])&

— J42161217
स्रोत

0

आर, 102 बाइट्स

कोड:

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

परीक्षा:

> n=scan();x=matrix(" ",M<-3*n,N<-2*n+1);for(i in 1:N)x[c(i-1+1:n,M+2-i-1:n),i]="*";cat(x,sep="",fill=M)
1: 10
2: 
Read 1 item
**********          **********
 **********        ********** 
  **********      **********  
   **********    **********   
    **********  **********    
     ********************     
      ******************      
       ****************       
        **************        
         ************         
          **********          
         ************         
        **************        
       ****************       
      ******************      
     ********************     
    **********  **********    
   **********    **********   
  **********      **********  
 **********        ********** 
**********          **********

— djhurio
स्रोत

0

सीजेएम, 24 बाइट्स

{:T2*){S*T'**+}%_W%..e>}

यह एक ब्लॉक है जो स्टैक से एक संख्या लेता है और स्टैक के लिए लाइनों की एक सूची आउटपुट करता है।

स्पष्टीकरण:

{                        e# Stack:           | 2
 :T                      e# Store in T:      | 2, T=2
   2*                    e# Multiply by 2:   | 4
     )                   e# Increment:       | 5
      {                  e# Map over range:  | [0
       S                 e#   Push space:    | [0 " "
        *                e#   Repeat string: | [""
         T               e#   Push T:        | ["" 2
          '*             e#   Push char '*': | ["" 2 '*
            *            e#   Repeat char:   | ["" "**"
             +           e#   Concatenate:   | ["**"
              }%         e# End:             | ["**" " **" "  **" "   **" "    **"]
                _        e# Duplicate:       | ["**" " **" "  **" "   **" "    **"] ["**" " **" "  **" "   **" "    **"]
                 W%      e# Reverse:         | ["**" " **" "  **" "   **" "    **"] ["    **" "   **" "  **" " **" "**"]
                   ..e>  e# Overlay:         | ["**  **" " ****" "  **" " ****" "**  **"]
                       } e# End

— फल तोड़ना
स्रोत

0

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

x=a=0
n=c=input()
while x<2*n+1:
    print ' '*a+'*'*n+' '*c+'*'*(2*n-2*a-c)
    x+=1
    a=n-abs(n-x)
    c=max(0, n-2*a)

यह प्रोग्राम प्रत्येक लाइन को 4 भागों में विभाजित करता है, पहला स्पेस, पहला स्टार, दूसरा स्पेस और फिर दूसरा स्टार। एक्स की प्रत्येक क्षैतिज रेखा के लिए यह गणना करता है कि पंक्ति के 4 वर्गों में से प्रत्येक के लिए कितने सितारों या रिक्त स्थान की आवश्यकता है, फिर उस स्ट्रिंग का निर्माण और प्रिंट करता है।

— jacoblaw
स्रोत

0

रेटिना , 144 बाइट्स

.+
 $&$* $&$* $&
 
$`#$'¶
¶\d+$

( *)#( *)(\d+)
$1$3$**$2#$3$* #$2$3$**$1
( +)(\*+)( *)(# +#)\3\2\3 +
$3$2$1$4$1$2$3
+` (# +#)
$1 
+` #...
#
##

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

.+
 $&$* $&$* $&

इनपुट मूल्य (प्रत्येक आउटपुट लाइन के लिए एक) से पहले 2 एन + 1 रिक्त स्थान जोड़ें।

$`#$'¶

प्रत्येक स्थान को एक के साथ बदलें #और परिणाम एकत्र करें। यह #s का एक विकर्ण रेखा देता है , दोनों तरफ अंतरिक्ष गद्देदार होता है, जिसमें इनपुट मूल्य प्रत्यय होता है।

¶\d+$

मूल इनपुट मान हटाएं, क्योंकि अब हमारे पास प्रत्येक पंक्ति पर एक प्रति है।

( *)#( *)(\d+)
$1$3$**$2#$3$* #$2$3$**$1

N की दो विकर्ण रेखाओं का निर्माण करें *, एस के nएक जोड़े में लिपटे रिक्त स्थान के विभाजक स्तंभ के साथ #।

( +)(\*+)( *)(# +#)\3\2\3 +
$3$2$1$4$1$2$3

उन पंक्तियों पर जहां *एस बीच के करीब हैं, दो हिस्सों को चारों ओर स्वैप करें। यह एक जैसा दिखता है > | | <।

+` (# +#)
$1

को हटाओ | |एस को जहाँ तक वे जाते हैं, एक प्रकार की >> > <उपस्थिति देंगे ।

+` #...
#

के बीच प्रत्येक स्थान के लिए #एस के , निम्नलिखित तीन वर्ण हटाएं। यह > <एक में शामिल हो जाता है X।

##

अब अनावश्यक हटा दें # एस ।

— नील
स्रोत

एक बड़ा ASCII X ड्रा करें

मुसीबत

नियम

संपादित करता

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

MATL , 16 बाइट्स

व्याख्या

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

वी , 18 17 बाइट्स

05AB1E , 18 बाइट्स

वी , 23 बाइट्स

सी #, 139 130 115 बाइट्स

हास्केल , 88 87 86 बाइट्स

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

MATLAB, 153 126 बाइट्स (17.6% 126)

MATLAB, 153 बाइट्स

पायथन 2 , 93 90 89 83 बाइट्स

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

जावा 8, 119 118 बाइट्स

जावास्क्रिप्ट (ES2017), 155 157 बाइट्स

गणितज्ञ, 148 बाइट्स

आर, 102 बाइट्स

सीजेएम, 24 बाइट्स

स्पष्टीकरण:

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

रेटिना , 144 बाइट्स