एक गैर-नकारात्मक पूर्णांक को देखते हुए, Xउस बड़े का प्रिंट आउट लें । Xइनपुट के लिए आउटपुट है 0, और आप विस्तार करने के लिए प्रत्येक दिशा में इनपुट के बराबर स्लैश जोड़ देंगेX बड़े इनपुट के लिए ।

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

0

1

\ /
 X
/ \

2

\   /
 \ /
  X
 / \
/   \

...

10

\                   /
 \                 /
  \               /
   \             /
    \           /
     \         /
      \       /
       \     /
        \   /
         \ /
          X
         / \
        /   \
       /     \
      /       \
     /         \
    /           \
   /             \
  /               \
 /                 \
/                   \

नियम

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

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है!

code-golf ascii-art

— स्टीफन
स्रोत

सैंडबॉक्स ; संबंधित

— स्टीफन

6

... मैं बस चारकोल-बाइट समाधान के लिए इंतजार करने वाला हूं।

— लीकी नॉन

@LeakyNun मुझे आश्चर्य होगा कि अगर चारकोल आसानी Xसे बीच में निपट सकता है (क्यों मैंने इसे जोड़ा है) लेकिन कौन जानता है: D

— स्टीफन

इसके अलावा संबंधित

— वैल्यू इंक

संबंधित , संबंधित

— xnor

6

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

╵＼┼

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

चारकोल उत्तर के आकार का आधा: डी

╵    increment the input
 \   create a diagonal that long
  ┼  and quad-palindromize, mirroring what's required, with 1 overlap;
     This overlaps the `/` and `\`, resulting in `X`

— dzaima
स्रोत

डांग जो छोटा है।

— dylnan

: ||||||| गोल्फ के लिए +1

— केवल

मुझे यह भी आश्चर्य है कि क्या स्टैक-आधारित भाषाएं मूल रूप से हमेशा अन्य भाषाओं से बाहर होती हैं?

— केवल

@

— ASCII-

@ ऑक्स * स्टैक-आधारित / टैसिट

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

22

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

ＰX⁺¹ＮX

आपकी बकवास मुझे रोक नहीं रही है;)

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

— Okx
स्रोत

2

TIO दिखता है ... दिलचस्प है जब आप इसमें एक बहुत बड़ी संख्या डालते हैं

— स्टीफन

@StephenS केवल लपेटने के कारण।

— ओकेक्स

मुझे पता है, यह सिर्फ सहज है कि लिपटे हुए सभी को छोड़ दिया गया है (क्योंकि रिक्त स्थान लिपटे नहीं हैं)

— स्टीफन

5 चार्ट्स (पोस्टडेट्स की चुनौती) बस उस थोड़े से कैनवस के करीब जाने के लिए

— केवल

16

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

एक पुनरावर्ती फ़ंक्शन जी का उपयोग करता है जो ग्रिड के माध्यम से चलता है और चरित्र द्वारा आउटपुट चरित्र बनाता है।

n=>(g=x=>`/\\ X
`[~x?x-y?x+y-w&&2:x-n?1:3:4]+(~y?g(~x--?x:y--&&w):''))(y=w=n*2)

कैसे?

दोनों चर x और y पुनरावृति 2n से -1 , जहाँ n इनपुट है।

ग्रिड में प्रत्येक स्थिति (x, y) के लिए, हम इनमें से एक वर्ण चुनते हैं:

0: /
1: \
2: अंतरिक्ष
3: X
4: न्यूलाइन

निम्नलिखित परीक्षणों का उपयोग करना:

~x: गलत है अगर x == -1 : हम पंक्ति के अंत तक पहुँच चुके हैं।
x-y: मिथ्या अगर x == y : हम विरोधी विकर्ण पर स्थित हैं।
x+y-w: मिथ्या अगर x + y == w : हम विकर्ण पर स्थित हैं।
x-n: मिथ्या अगर x == n : क्योंकि यह परीक्षण केवल x == y के दौरान किया जाता है , इसका मतलब है कि हम ग्रिड के सटीक केंद्र में स्थित हैं।

और निम्नलिखित निर्णय पेड़:

डेमो

कोड स्निपेट दिखाएं

let f =

n=>(g=x=>`/\\ X
`[~x?x-y?x+y-w&&2:x-n?1:3:4]+(~y?g(~x--?x:y--&&w):''))(y=w=n*2)

console.log(f(0))
console.log(f(1))
console.log(f(4))

स्निपेट का विस्तार करें

— Arnauld
स्रोत

4

यह है ... जावास्क्रिप्ट? क्या हो गया है आपको, पुराने दोस्त।

— रोबर्टर्ट-एस

13

MATL , 16 बाइट्स

'\/X 'iEQXytEP+)

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

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

'\/X '  % Push this string
        %   STACK: '\/X '
iEQ     % Input a number, n. Multiply by 2, add 1: gives 2*n+1
        %   STACK: '\/X '
                   5
Xy      % Identity matrix of that size
        %   STACK: '\/X '
                   [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]
tEP     % Duplicate, multiply each entry by 2, flip vertically
        %   STACK: '\/X '
                   [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]
                   [0 0 0 0 2;
                    0 0 0 2 0;
                    0 0 2 0 0;
                    0 2 0 0 0;
                    2 0 0 0 0]
+       % Add the two matrices
        %   STACK: '\/X '
                   [1 0 0 0 2;
                    0 1 0 2 0;
                    0 0 3 0 0;
                    0 2 0 1 0;
                    2 0 0 0 1]
)       % Index into the string. Indexing is 1-based and modular, so 1 picks
        % the first character ('\'), ..., 0 picks the last (space)
        %   STACK: ['\   /';
                    ' \ / ';
                    '  X  ';
                    ' / \ ';
                    '/   \']
        % Implicit display

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

मैं ऑक्टेव में ऐसा ही कुछ करना चाहता था, लेकिन आपने मुझे हरा दिया और MATL में यह ऑक्टेव से भी छोटा है, इसलिए यह बहुत अच्छा काम है!

— मिकथन

@ मिखथन धन्यवाद! एक ऑक्टेव संस्करण निश्चित रूप से पोस्ट करने लायक भी होगा। मेरा atempt 38 बाइट्स पर है, आपका क्या है?

— लुइस मेंडो

मैं इसके बारे में सब सप्ताहांत में सोच रहा था और आपके द्वारा उपयोग किए जा रहे एक से अधिक कुशल तरीके नहीं खोज सका .. इसलिए सभी क्रेडिट आपको एक ऑक्टेव संस्करण के लिए जाना चाहिए।

— मिकथन

6

सी, 108 106 बाइट्स

a;g(n){for(int b=2*n,i=1,c=47;a+=i;b?puts(""):(i=-i,c=92),b-=2*i)printf("%*c%*c",a,b?c+45*i:88,b,b?c:10);}

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

(F2 गोल्फिंग एमडी एक्सएफ के लिए धन्यवाद)

यह दो अक्षर प्रिंट करता है (पहले, c = 47 , जो एक स्लैश है, औरc + 45 , जो एक बैकस्लैश है; फिर उन्हें स्वैप किया जाता है) एक गतिशील क्षेत्र की चौड़ाई के साथ।

क्षेत्र की चौड़ाई शुरू होती है 1 और 2nप्रत्येक पुनरावृत्ति पर, पहली चौड़ाई 1 से बढ़ाई जाती है, और दूसरी चौड़ाई 2 से घटाई जाती है।

जब दूसरी फ़ील्ड की चौड़ाई 0 हो जाती है, तो यह 'X'नियमित वर्णों के बजाय एक आउटपुट और एक नई पंक्ति बनाता है, और वेतन वृद्धि ( i) की दिशा को उलट देता है । अन्य सभी लाइनों के लिए अलग से एक नई लाइन छपी है ( puts(""))।

— anatolyg
स्रोत

106 बाइट्स: a,b,i=1,c;g(n){for(b=2*n,c=47;a+=i;b?puts(""):(i=-i,c=92),b-=2*i)printf("%*c%*c",a,b?c+45*i:88,b,b?c:10);} इसे ऑनलाइन आज़माएं!

— एमडी एक्सएफ

विचार के लिए धन्यवाद! मैंने केवल यह सुनिश्चित करने के लिए इसका एक हिस्सा इस्तेमाल किया कि कोड को दो बार कहा जा सकता है।

— अनातोलीग

5

शॉर्टसी , 111 बाइट्स

s(x){Wx--)R" ")}j;f(x){O;j<x;j++)s(j),P92),s((x-j)*2-1),R"/\n");s(x);R"X\n");Wj--)s(j),P47),s((x-j)*2-1),R"\\\n

मेरे C उत्तर के आधार पर । रूपांतरण:

R -> printf(
P -> putchar(
W -> while(
O -> for(
ऑटो-डाला बंद ");}

यह भी \और के लिए ASCII कोड का उपयोग करता है /।

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

— एमडी एक्सएफ
स्रोत

5

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

r=range(2*input()+1)
for i in r:print''.join(' \/X'[i==j::2][r[~i]==j]for j in r)

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

— XNOR
स्रोत

5

सी, 168 155 150 बाइट्स

^{-कम्पुट्रोनियम के लिए -5 धन्यवाद}

#define p printf(
s(x){while(x--)p" ");}j;f(x){for(;j<x;j++)s(j),p"\\"),s((x-j)*2-1),p"/\n");s(x);p"X\n");while(j--)s(j),p"/"),s((x-j)*2-1),p"\\\n");}

निश्चित रूप से गोल्फ हो सकता है; मैं ऐसा कर रहा हूं।इसे ऑनलाइन आज़माएं!

Ungolfed:

int space(int x)
{
    while (x--)
        putchar(' ');
}

int f(int x)
{
    for (int j = 0; j < x; j++) {
        space(j);
        printf("\\");
        space((x-j)*2-1);
        printf("/\n");
    }

    space(x);
    puts("X");

    while (j--) {
        space(j);
        putchar('/');
        space((x-j)*2-1);
        printf("\\\n");
    }
}

— एमडी एक्सएफ
स्रोत

2

आप पी को "प्रिंटफ" ("प्रिंटफ" के बजाय "" परिभाषित करके 5 अक्षर खो सकते हैं।

— कॉम्पोट्रोनियम

3

वी , 21 बाइट्स

éXÀñ>HÄÒ r\Á/YGpr/$r\

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

Hexdump:

00000000: e958 c0f1 3e48 c4d2 2072 5cc1 2f59 4770  .X..>H.. r\./YGp
00000010: 722f 2472 5c                             r/$r\

स्पष्टीकरण:

éX                      " Insert an 'X'
  Àñ                    " Arg1 times:
    >H                  "   Add a space to every line.
                        "   Conveniently, this also puts us on the first line
      Ä                 "   Duplicate this line
       Ò                "   And replace the whole line with spaces
         r\             "   Replace the first char with '\'
           Á/           "   Append a '/' char
             Y          "   Yank this line
              G         "   Move to the last line
               p        "   And paste the line we yanked
                r/      "   Replace the first character with a '/'
                  $     "   Move to the end of the line
                   r\   "   And replace the last character with a '\'

अनिवार्य रूप से, हमारे पास है एक्स सम्मिलित , n बार स्लैश का विस्तार करते हैं ।

लेकिन यह बिल्कुल सरल नहीं है क्योंकि हमें पहली बार स्लैश जोड़ना होगा। यदि स्लैश पहले से ही थे, हम लिख सकते हैं कि स्लैश का विस्तार इस प्रकार है:

>HÄX2pGÙX2p

जो हमें 6 बाइट बचा लेगा।

— DJMcMayhem
स्रोत

3

सी #, 157 122 120 बाइट्स

_=d=>"".PadLeft(d)
a=>{var s=_(a)+"X\n";for(int i=0;++i<=a;)s=$@"{_(a-i)}\{_(i*2-1)}/
{s+_(a-i)}/{_(i*2-1)}\
";return s;}

Ungolfed संस्करण:

 Func<int, string> _ = (d) =>"".PadLeft(d);
        Func<int, string> func = a => {

            var s = _(a) + "X\n";

            for (int i = 0; ++i <= a;) {

                s = $@"{_(a - i)}\{_(i * 2 - 1)}/
{s + _(a - i)}/{_(i * 2 - 1)}\
";

            }
            return s;
        };

— LiefdeWen
स्रोत

1

आप अन्य अनाम फ़ंक्शन को पहले से बाहर कर सकते हैं और फिर इसे शामिल कर सकते हैं _=d=>new string(' ',d);(ध्यान दें कि चारों ओर ब्रेस की कोई आवश्यकता नहीं है d)। आप लूप के लिए चारों ओर घुंघराले ब्रेसिज़ निकाल सकते हैं। वर्बेटिम स्ट्रिंग का उपयोग करें ताकि आपको बैकस्लैम के सभी से बचने की आवश्यकता न हो। यदि आप सेट करते हैं i=0तो आप कर सकते हैं ++i<a+1और निकाल सकते हैं i++।

— द लीथलकोडर

इसके अलावा शब्दशः तार के साथ आपको \nएक वास्तविक पंक्ति फ़ीड शामिल करने की आवश्यकता नहीं होगी , हालांकि मुझे यकीन नहीं है कि यदि आप तब लूप के लिए चारों ओर के ब्रेसिज़ को हटाने में सक्षम होंगे, तो आपको प्रयास करना होगा।

— ललथकोदर

1

TheLethalCoder द्वारा पहला सुझाव लागू करने के बाद , आप EDIT के ++i<a+1लिए भी बदल सकते हैं आप बदलकर 4 और बाइट्स बचा सकते हैं++i<=a Func से new string(' ',d)करने के लिए"".PadLeft(d)

— auhmaan

सुझावों के लिए धन्यवाद, @ TheLethalCoder क्या मुझे 2 कार्यों की घोषणा करने की अनुमति दी गई है, यदि हम ऐसा कर सकते हैं तो क्या बहुत सी सी # गोल्फिंग कम नहीं होगी?

— LiefdeWen

1

@StefanDelport कहीं न कहीं इसके बारे में एक मेटा चर्चा है, लेकिन जैसा कि यह खड़ा है मेरा मानना है कि जब तक आप फ़ंक्शन का नाम दिखाते हैं तब तक आप कर सकते हैं। इस मामले में _।

— TheLethalCoder

3

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

(जेनी_मैथी के 104-बाइट समाधान से आंशिक रूप से प्रेरित)

""<>#&/@(#"\\"+Reverse@#"/"&@IdentityMatrix[2#+1]/.{0->" ",a_+_->"X"})&

तार की सूची लौटाता है।

स्पष्टीकरण: IdentityMatrix[2#+1]विकर्ण के साथ 1s के साथ सही आकार का एक मैट्रिक्स बनाता है और कहीं और 0s। इसके बाद, हम इसे "\\"(एक एस्केप बैकस्लैश) से गुणा करते हैं , जो इसे विकर्ण और 0s के साथ कहीं और मैट्रिक्स बनाता है, क्योंकि 1 बार बैकस्लैश बैकस्लैश है और 0 बार सिस्लैश 0. है। हम इसे इसमें जोड़ते हैं।"/" इसे बनाने के लिए इसके विपरीत समय में हैं। एक्स आकार। हम लगभग पूरा कर चुके हैं, सिवाय इसके कि हर जगह अभी भी 0s हैं, और बीच है "\\" + "/"। हम इन दो चीजों को ठीक करने के " "लिए 0और इसके "X"लिए प्रतिस्थापित करते हैं a_+_, जो कि दो चीजों के किसी भी योग से मेल खाती है (जैसे _+_कि, गणितज्ञ को छोड़कर, अपने स्वयं के अच्छे के लिए बहुत चालाक है और व्याख्या करता है कि 2 बार के रूप में _)। अंत में, ""<>#&/@इसे स्ट्रिंग्स की सूची में बदल देता है।

— पेड़ नहीं
स्रोत

3

जावा (ओपनजेडके 8) , 135 बाइट्स

i->{int k=0,j,l=2*i+1;String[]s=new String[l];for(;k<l;k++)for(s[k]="",j=0;j<l;j++)s[k]+=j==k?j==i?"X":"\\":j==l-1-k?"/":" ";return s;}

लैम्ब्डा एक्सप्रेशन जो पूर्णांक लेता है और स्ट्रिंग्स की एक सरणी देता है

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

Ungolfed:

i->{
    int k=0,j,l=2*i+1;                // Some variables to be used
    String[]s=new String[l];            // Return array (size 2*i+1)
    for(;k<l;k++)                       // For each array entry
        for(s[k]="",j=0;j<l;j++)        // Set each character to 
            s[k]+=j==k?j==i?"X":"\\"    // \ or X if it's the jth character of the jth row
                 :j==l-1-k?"/"          // / if it's the opposite char
                 :" ";                  // else blank
    return s;
}

— PunPun1000
स्रोत

3

टी-एसक्यूएल, 201 बाइट्स

DECLARE @ INT SELECT @=a FROM t DECLARE @i INT=@
WHILE @>0BEGIN PRINT SPACE(@i-@)+'\'+SPACE(2*@-1)+'/'SET @-=1 END
PRINT SPACE(@i)+'X'WHILE @<@i BEGIN SET @+=1 PRINT SPACE(@i-@)+'/'+SPACE(2*@-1)+'\'END

प्रारूपित:

DECLARE @ INT 
SELECT @=a FROM t 
DECLARE @i INT=@
WHILE @>0
    BEGIN
        PRINT SPACE(@i-@)+'\'+SPACE(2*@-1)+'/'
        SET @-=1 
    END
PRINT SPACE(@i)+'X'
WHILE @<@i 
    BEGIN 
        SET @+=1 
        PRINT SPACE(@i-@)+'/'+SPACE(2*@-1)+'\'
    END

इनपुट कॉलम के माध्यम से है एक नामित तालिका में टी , हमारे दिशानिर्देशों के अनुसार ।

— BradC
स्रोत

3

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

पुनरावर्ती कार्य।

f=->x{?X[x]||"\\#{s=' '*(2*x-1)}/
#{f[x-1].gsub /^/,' '}
/#{s}\\"}

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

व्याख्या

f=->x{                  # Start of recursive function named `f`
      ?X[x]||           # Return 'X' if x==0, otherwise the following:
"\\#{s=' '*(2x-1)}/     #  Top edge of the cross. Save no. of spaces needed
#{f[x-1]                #  Get result of f[x-1]
        .gsub /^/,' '}  #  Regex sub to left-pad every line w/ a space
/#{s}\\"                #  Bottom edge of cross (insert saved no. of spaces)

— मूल्य स्याही
स्रोत

3

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

Ḥ‘=þ`µḤ+Uị“/\x ”Y

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

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

Ḥ‘=þ`µḤ+Uị“/\x ”Y   main link, input a
Ḥ‘                  input doubled and incremented
   þ                Make a table: Apply  
  =                 "equals"/ to      
    `               each element in range(2a+1) cartesian multiplied with itself.
                      eg. For input 1: [1=1,1=2,1=3],[2=1,2=2,2=3],[3=1,3=2,3=3]      
     µ              on this array:
       +            add: 
      Ḥ             double of it to
        U           its reverse (changes south-east to north-west)
         ị“/\x ”    index into the string "/\x " to get the right characters
                Y   join by newlines for the final output.

-6 बाइट्स अतिरिक्त सुधार के साथ @LeakyNun और -1 बाइट के लिए धन्यवाद

— fireflame241
स्रोत

18 बाइट्स

— लीक नून

2

बैच, 201 बाइट्स

@echo off
set s= /
for /l %%i in (2,1,%1)do call set s=  %%s%%
set s=\%s%
for /l %%i in (-%1,1,%1)do call:c
exit/b
:c
echo %s%
set s=%s:\ = \%
set s=%s:X =/\%
set s=%s:\/=X %
set s=%s: /=/ %

शीर्ष रेखा का निर्माण करके शुरू होता है, फिर प्रत्येक पंक्ति को मुद्रित करने के बाद, \सही एक स्थान और /एक बार बाईं ओर स्थानांतरित होता है, जिससे यह सुनिश्चित होता है कि वे Xबीच में बनाते हैं ।

— नील
स्रोत

2

PHP , 115 बाइट्स

for(;$i<$c=1+2*$argn;$b?:$t[$i-1]="\\".!$t[$c-$i]="/",$o.="$t\n")$t=str_pad(" X"[$b=$argn==+$i++],$c," ",2);echo$o;

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

— जार्ग हुल्सरमन
स्रोत

2

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

.+
$* X
+`^ ( *).( *)
$1\  $2/¶$&
+`¶ ( *).( *).?$
$&¶$1/  $2\
m` (\W)$
$1

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

.+
$* X

इसे रखो X ।

+`^ ( *).( *)
$1\  $2/¶$&

पर प्रारंभ हो X, ऊपर की ओर काम कर रहा है, एक जगह \तिरछे हर बार छोड़ दिया। इसके अलावा a//पिछली बार की तुलना में दो और स्थान ।

+`¶ ( *).( *).?$
$&¶$1/  $2\

पर प्रारंभ हो X, काम कर नीचे की ओर, एक जगह /तिरछे हर बार छोड़ दिया। इसके अलावा a\/पिछली बार की तुलना में दो और स्थान ।

m` (\W)$
$1

दो विकर्णों के बीच रिक्त स्थान की संख्या विषम होनी चाहिए, इसलिए प्रत्येक पंक्ति (मूल Xरेखा को छोड़कर ) पर अंतिम स्थान हटा दिया जाता है।

— नील
स्रोत

2

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

(F[x_,y_]:=Table[x<>StringJoin@Table[" ",i]<>y,{i,1,#*2,2}];Column[Join[Reverse@F["\\","/"],{"X"},F["/","\\"]],Alignment->Center])&

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

यहाँ ग्रिड का उपयोग कर एक और दृष्टिकोण है

(S=DiagonalMatrix[Table["\\",r=2#+1]];Table[S[[r+1-i,0+i]]="/",{i,r}];S[[#+1,#+1]]="X";Grid@S/. 0->" ")&

— J42161217
स्रोत

2

APL (Dyalog) , 25 बाइट्स

⎕IO←0कई सिस्टम पर डिफ़ॉल्ट की आवश्यकता होती है।

' \/X'[(⊢+2×⌽)∘.=⍨⍳1+2×⎕]

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

' \/'[... ] स्ट्रिंग को साथ में अनुक्रमित करें

⎕ इनपुट प्राप्त करें

2× दो से गुणा करें

1+ एक जोड़ें

⍳ कई पूर्णांकों की तुलना में

∘.=⍨ समानता तालिका (अर्थात पहचान मैट्रिक्स; NW-SE विकर्ण)

(… ) उस पर निम्नलिखित टैसिट फ़ंक्शन लागू करें

⊢ बहस

+ प्लस

2× दो बार

⌽ क्षैतिज रूप से प्रतिबिंबित तर्क (यानी NE-SW विकर्ण)

— एडम
स्रोत

2

बैश , 138 बाइट्स

for i in `seq $1;seq $[$1-1] -1 1`
{ $[a++]
printf "%*c%*s\n" `echo ' '$i $[a>$1?1:2] $[($1-i)*2]' '$[a<$1?1:2]`
}|sed 's/22/X/'|tr 12 /\\

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

वास्तव में लंबे, गर्मी हीट 'और /'

कम गोल्फ वाला

 for i in {1..10} {9..1};{
   $[a++];                      #argument as padding, prints 1 for \ and 2 for /
   printf "%*c%*s\n" `echo ' '$i $[a>$1?1:2] $[($1-i)*2]' '$[a<$1?1:2]`;
  }|sed 's/22/X/g' | tr 12 /\\

— marcosm
स्रोत

2

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

-10 बाइट्स @FelipeNardiBatista को धन्यवाद

f=lambda s,i='\n':i+(s and'\\'+'  '*~-s+' /'+f(s-1,i+' ')+i+'/'+'  '*~-s+' \\'or'X')

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

— OVS
स्रोत

1

85 बाइट्स: टीआईओ

— फेलिप नार्डी बतिस्ता

@FelipeNardiBatista बहुत बहुत धन्यवाद

— अंडा

2

05AB1E , 21 बाइट्स

F'\Nú}'X¹ú).B€.∞ø€.∞»

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

— जादू ऑक्टोपस Urn
स्रोत

1

पर्ल 5, 110 + 1 = 111 बाइट्स

-nध्वज का उपयोग करता है ।

$x=$_;$,="\n";push@x,$"x($x-$_)."\\".$"x(2*--$_+1)."/"while$_>0;say@x,$"x$x."x";for(reverse@x){y!\\/!/\\!;say}

— क्रिस
स्रोत

1

QBIC , 90 बाइट्स

~b=0|?@X`\[0,:-1|X=space$(a)┘Z=Z+X+@\`+space$((b-a)*2-1)+@/`+X+@┘`]Z=Z+space$(b)+A+_fZ

कैसे यह राक्षसी काम करती है, पाठक के लिए एक बहाना बनकर रह जाती है ...

नमूना उत्पादन:

Command line: 3
\     /
 \   / 
  \ /  
   X
  / \  
 /   \ 
/     \

— steenbergh
स्रोत

1

विजुअल बेसिक.नेट , 454 450 बाइट्स

Option Strict Off
module m
sub main(a As String())
dim v=Convert.toInt32(a(0))
for i as Integer=v to 1 step -1
for j as Object=1 to v-i
w(" ")
next
w("\")
for j as Object=1 to i*2-1
w(" ")
next
console.writeline("/")
next
console.writeline(new String(" ",v)&"X")
for i as Object=1 to v
for j as Object=1 to v-i
w(" ")
next
w("/")
for j as Object=1 to i*2-1
w(" ")
next
console.writeline("\")
next
end sub
sub w(s)
console.write(s)
end Sub
end module

यकीन नहीं के लिए एक समारोह बनाने के लिए कि क्या writelineपर इशारा करते हुए के लिए कुछ बाइट्स स्टीफन एस करने के लिए धन्यवाद की बचत होगी as ...हटाने भी बदल integerमें object पिछले संपादन पहले एक वापस बदल दिया

— polyglotrealIknow
स्रोत

आप एक बहादुर हैं :) मेरा मानना है कि आप सभी को हटा सकते हैं as Types, क्योंकि अगर आपके पास है Option Strict Off, तो VB.NET एक ढीली टाइप की गई भाषा की तरह काम करता है।

— स्टीफन

वर्तमान में लिनक्स मोनो पर anoying है

— polyglotrealIknow

मोनो विकल्प सख्त के बारे में परवाह नहीं करता है, या कम से कम मुझे क्या लगता है

— पॉलीग्लॉटेरियल आईकॉन

ओह ऐसा लग रहा था functionरों =! for loops गोल्फ के लिए धन्यवाद

— polyglotrealIknow

Option Strictडिफ़ॉल्ट रूप से बंद नहीं है? यह कम से कम दृश्य स्टूडियो में है

— स्टीफन

1

05AB1E , 22 बाइट्स

F'\IN-úR.∞})Âí'Xs)˜.c»

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

व्याख्या

F                        # for N in [0...input-1] do
 '\                      # push a backslash
   IN-ú                  # prepend input-N spaces
       R                 # reverse
        .∞               # mirror
          }              # end loop
           )             # wrap stack in a list
            Â            # bifurcate
             í           # reverse each item
              'Xs        # push an "X" between the 2 lists on the stack
                 )˜      # wrap in flattened list
                   .c    # pad lines to equal length
                     »   # join on newlines

वैकल्पिक 22 बाइट समाधान

F'\N·>ú'/ì})Âí'X¸«ì.c»

— Emigna
स्रोत

1

पाइके, 14 बाइट्स

\XQV.X \   /\/

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

\X             - "X"
  QV           - repeat input times:
    .X \   /\/ -  surround(^, all=" ", 
                              tl="\", 
                              left=" ",  
                              right=" ",  
                              lower=" ",  
                              tr="/",  
                              br="\",  
                              bl="/")

— नीला
स्रोत

1

tcl, 134

proc P {x s b} {time {puts [format %[incr ::i $x]s%[expr ($::n-$::i)*2+2]s $s $b]} $::n}
P 1 \\ /
puts [format %[incr i]s X]
P -1 / \\

डेमो

सेट nपहली पंक्ति पर ।

हो सकता है कि मैं एक पुनरावर्ती दृष्टिकोण का उपयोग करके इसे और अधिक गोल्फ कर सकता हूं

— sergiol
स्रोत

1

आर , 75 72 बाइट्स

y=diag(b<-2*scan()+1);write(c(" ",'\\','/','X')[y+2*y[,b:1]+1],'',b,,'')

से प्रेरित होकर इस जवाब , एक अंतर्निहित मैट्रिक्स उत्पन्न करता है और यह stdout के लिए लिखते हैं; स्टड से आकार पढ़ता है। इसे अंतरिक्ष वर्णों का एक मैट्रिक्स बनाना है और sep=''b / c का उपयोग करना है अन्यथा इसमें रिक्त स्थान हैं।

diag(b)                     # generates a main diagonal of 1, rest 0
2*diag(b)[,b:1]             # the other diagonal is 2
                            # [,b:1] reverses columns
                            # [b:1,] reverses the rows; they're equivalent
diag(b)+2*diag(b)[,b:1]     # sums, so we get 1 for main diagonal
                            # 2 for other diagonal, 3 for center
diag(b)+2*diag(b)[,b:1]+1   # add 1 since R is 1-indexed
                            # the result is indices for the vector
c(' ','\\','/','X')

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

— ग्यूसेप
स्रोत

एक बड़ा स्लैश एक्स ड्रा करें

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

नियम

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

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

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

कैसे?

डेमो

MATL , 16 बाइट्स

सी, 108 106 बाइट्स

शॉर्टसी , 111 बाइट्स

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

सी, 168 155 150 बाइट्स

वी , 21 बाइट्स

सी #, 157 122 120 बाइट्स

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

जावा (ओपनजेडके 8) , 135 बाइट्स

टी-एसक्यूएल, 201 बाइट्स

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

व्याख्या

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

बैच, 201 बाइट्स

PHP , 115 बाइट्स

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

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

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

APL (Dyalog) , 25 बाइट्स

बैश , 138 बाइट्स

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

05AB1E , 21 बाइट्स

पर्ल 5, 110 + 1 = 111 बाइट्स

QBIC , 90 बाइट्स

विजुअल बेसिक.नेट , 454 450 बाइट्स

05AB1E , 22 बाइट्स

पाइके, 14 बाइट्स

tcl, 134

डेमो

आर , 75 72 बाइट्स