31

दो सकारात्मक पूर्णांकों को देखते हुए, डब्ल्यू और एच, एक एएससीआईआई-आर्ट बॉक्स का उत्पादन करते हैं जिसकी सीमा शीर्ष और निचले किनारों पर डब्ल्यू "स्पाइक्स" के साथ स्लैश ( /और \) से बनी है, और बाएं और दाएं किनारों पर एच "स्पाइक्स" है। बॉक्स का इंटीरियर रिक्त स्थान से भरा है।

एक "स्पाइक" एक तीर का आकार बनाने के लिए एक साथ आने वाले दो स्लैश हैं:

/\    \/

/      \
\      /

तो आउटपुट के लिए W = 4, H = 3होगा

/\/\/\/\
\      /
/      \
\      /
/      \
\/\/\/\/

जैसा कि ऊपर की ओर इशारा करते हुए 4 स्पाइक्स हैं, नीचे की तरफ 4, नीचे की ओर इशारा करते हुए 3, बाईं ओर के 3 और दाईं ओर के दाईं ओर के 3 बिंदु हैं।

यहाँ कुछ अन्य इनपुट / आउटपुट जोड़े हैं:

W H
[spiky slash box]

1 1
/\
\/

1 2
/\
\/
/\
\/

2 1
/\/\
\/\/

2 2
/\/\
\  /
/  \
\/\/

1 3
/\
\/
/\
\/
/\
\/

3 1
/\/\/\
\/\/\/

2 3
/\/\
\  /
/  \
\  /
/  \
\/\/

3 2
/\/\/\
\    /
/    \
\/\/\/

10 1
/\/\/\/\/\/\/\/\/\/\
\/\/\/\/\/\/\/\/\/\/

10 2
/\/\/\/\/\/\/\/\/\/\
\                  /
/                  \
\/\/\/\/\/\/\/\/\/\/

4 5
/\/\/\/\
\      /
/      \
\      /
/      \
\      /
/      \
\      /
/      \
\/\/\/\/

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

बाइट्स में सबसे छोटा कोड जीतता है।

— केल्विन के शौक
स्रोत

Can कोई है जो javascripts इस के लिए एक ढेर टुकड़ा है?

— फंतासी

15

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

Ｂ×²Ｎ×²Ｎ/\

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

व्याख्या

Ｂ           Box
  ×²Ｎ       Next input as number * 2
      ×²Ｎ   Next input as number * 2
          /\ With border "/\"

— ASCII-केवल
स्रोत

3

बेशक चारकोल में 'ड्रा बॉक्स' के लिए बिल्ट-इन है

— बेंजीन

1

@बेनज़ीन कुछ भाग्यशाली थीं कि उन्होंने हाल ही में बॉक्स के चारों ओर एक मनमाना तार खींचने की क्षमता जोड़ी, लेकिन इससे पहले भी कोडगॉल्फ.स्टैकएक्सचेंज.com

— नील

1

@ हाल ही में प्रतीक्षा करें? कब? (क्या मुझे पता है कि चारकोल कम अच्छी तरह से धन्यवाद करते हैं? हाहा)

— ASCII-only

@ ASCII- केवल मेरा बुरा! कर्सर की स्थिति को पुनः प्राप्त करने वाले परिवर्तन के कारण मैं भ्रमित हो गया। (मनमाना बॉर्डर स्ट्रिंग पेश करने वाला परिवर्तन ca904b0 था जो लगभग एक साल पहले था।)

— नील

@benzene बॉक्स के बिना यह अभी भी केवल 13 बाइट्स है: Ｆ²«↷Ｐ…\/Ｎ»‖Ｍ¬(ऊंचाई, चौड़ाई क्रम में इनपुट लेता है)।

— नील

11

MATL , 18 बाइट्स

'\/',iE:]!+)O6Lt&(

MATL ऑनलाइन पर यह कोशिश करो !

व्याख्या

आदानों पर विचार करें W = 4, H = 3। कोड पंक्ति वैक्टर बनाता है [1 2 3 4 5 6 7 8](से सीमा 1के लिए 2*W) और [1 2 3 4 5 6](से सीमा 1के लिए 2*H)। प्रसारण के साथ बाद वाले को जोड़ना और पूर्व में जोड़ना मैट्रिक्स देता है

2  3  4  5  6  7  8  9
3  4  5  6  7  8  9 10
4  5  6  7  8  9 10 11
5  6  7  8  9 10 11 12
6  7  8  9 10 11 12 13
7  8  9 10 11 12 13 14

स्ट्रिंग में मॉड्यूलर अनुक्रमण \/मैट्रिक्स सीमा में वांछित परिणाम उत्पन्न करता है:

/\/\/\/\
\/\/\/\/
/\/\/\/\
\/\/\/\/
/\/\/\/\
\/\/\/\/

गैर-सीमा मूल्यों को हटाने के लिए, हम उन्हें 0(जब इसे अंतरिक्ष के रूप में प्रदर्शित किया जाता है) के रूप में व्याख्या करते हैं:

/\/\/\/\
\      /
/      \
\      /
/      \
\/\/\/\/

टिप्पणी कोड:

'\/'    % Push this string. Will be indexed into
,       % Do twice
  i     %   Input a number
  E     %   Multiply by 2
  :     %   Range 
]       % End
!       % Transpose
+       % Add
)       % Index
O       % Push 0
6L      % Push [2 -1+1j]. As an index, this means 2:end
t       % Duplicate
&(      % Write 0 into the center rectangle. Implicit display

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

8

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

_{-1 केविन क्रूज़सेन को धन्यवाद}

lambda w,h:'/\\'*w+'\n'+'\\%s/\n/%s\\\n'%(('  '*~-w,)*2)*~-h+'\\/'*w

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

— Sisyphus
स्रोत

\\%sबन सकता है \%sऔर बन \\/सकता है \/।

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

7

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

1 6 बाइट्स ने लिन का धन्यवाद बचाया

a#b=[1..a]>>b
x!y|i<-(x-1)#"  "=x#"/\\":(y-1)#['\\':i++"/",'/':i++"\\"]++[x#"\\/"]

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

अभी भी वास्तव में लंबा लगता है, मैं देखूंगा कि मैं क्या कर सकता हूं।

— गेहूं का जादूगर
स्रोत

a#b=[a..b]सभी घटनाओं को परिभाषित करने और प्रतिस्थापित करने से एक बाइट बचती है:a#b=[a..b];x!y|i<-2#x>>" "=(1#x>>"/\\"):(2#y>>['\\':i++"/",'/':i++"\\"])++[1#x>>"\\/"]

— लिन

ओह, a#b=[1..a]>>b;x!y|i<-(x-1)#" "=x#"/\\":(y-1)#['\\':i++"/",'/':i++"\\"]++[x#"\\/"]वास्तव

— लिन

@Lynn धन्यवाद! तुम सच में मेरे सुस्त हाल ही में पकड़ लिया गया है।

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

@ लीन मुझे यह काम करने के लिए मिला, लेकिन दूसरे बाइट की कीमत पर।

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

5

05AB1E , 14 बाइट्स

„/\|∍`S¦`).B∞∊

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

व्याख्या

„/\|∍`S¦`).B∞∊   Arguments: x, y
„/\              Push the string "/\"
   |             Push inputs as array: [x,y]
    ∍            Push the string extended/shortened to those lengths
     `           Flatten
      S          Push seperate chars of second string
       ¦`        Remove first char and flatten again
         )       Wrap stack to an array
          .B     Squarify
            ∞∊   Mirror on both axes

यह केवल ऊपरी बाएं कोने, x वर्ण चौड़े और y वर्ण लंबे बनाता है। इसके बाद दोनों अक्षों पर यह प्रतिबिम्बित होता है:

x=3, y=2

/\/|
\  |
---+

— kalsowerus
स्रोत

4

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

करी सिंटैक्स में इनपुट लेता है (w)(h)।

w=>h=>'/\\'[R='repeat'](w)+`
${`\\${p='  '[R](w-1)}/
/${p}\\
`[R](h-1)}`+'\\/'[R](w)

डेमो

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

let f =

w=>h=>'/\\'[R='repeat'](w)+`
${`\\${p='  '[R](w-1)}/
/${p}\\
`[R](h-1)}`+'\\/'[R](w)

function upd() { O.innerHTML = W.value+'x'+H.value+'\n\n'+f(W.value)(H.value) }
upd()

<input id=W type=range value=5 min=1 max=10 oninput="upd()">
<input id=H type=range value=5 min=1 max=10 oninput="upd()">
<pre id=O>

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

— Arnauld
स्रोत

3

स्विफ्ट 3 , 166 बाइट्स

func f(a:Int,b:Int){let k=String.init(repeating:count:),n="\n";var r="\\"+k("  ",a-1)+"/";print(k("/\\",a)+n+k(r+n+String(r.characters.reversed())+n,b-1)+k("\\/",a))}

पूर्ण परीक्षण सूट।

बंद संस्करण थोड़ा लंबा है, दुर्भाग्य से (175 बाइट्स):

var g:(Int,Int)->String={let k=String.init(repeating:count:),n="\n";var r="\\"+k("  ",$0-1)+"/";return k("/\\",$0)+n+k(r+n+String(r.characters.reversed())+n,$1-1)+k("\\/",$0)}

क्लोजर संस्करण के साथ टेस्ट सूट।

— मिस्टर एक्सकोडर
स्रोत

3

रेटिना , 77 73 बाइट्स

\d+
$*
 1+|1(?=1* (1+))
$1¶
1
/\
.((..)*.)
/$1¶$1/
¶$

(?<=¶.+).(?=.+¶)

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। प्रारूप में इनपुट लेता है <height> <width>। स्पष्टीकरण:

\d+
$*

इनपुट्स को यूनीरी में बदलें।

 1+|1(?=1* (1+))
$1¶

इनपुट्स को गुणा करें, लेकिन एक नई पंक्ति जोड़ें ताकि परिणाम एक आयत हो।

1
/\

स्पाइकी टॉप बनाएं।

.((..)*.)
/$1¶$1/

प्रत्येक स्पाइकी पंक्ति को डुप्लिकेट करें, लेकिन स्पाइक्स के साथ दूसरी पंक्ति पर ऑफसेट करें।

¶$

अनुगामी newlines हटाएँ।

(?<=¶.+).(?=.+¶)

बॉक्स के अंदर हटाएं। (अंतिम पंक्ति पर ध्यान दें।)

— नील
स्रोत

3

एक्सेल, 95 बाइट्स

=REPT("/\",A1)&"
"&REPT("\"&REPT(" ",2*A1-2)&"/
/"&REPT(" ",2*A1-2)&"\
",B1-1)&REPT("\/",A1)

— Wernisch
स्रोत

3

एपीएल (डायलॉग) , 41 39 बाइट्स

की सूची के लिए संकेत देता है [H,W]

'\'@2@1⊢¯1⌽@1{⌽⍉⍵,'/\'⍴⍨≢⍵}⍣4⊢''⍴⍨2×⎕-1

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

⎕-1 इनपुट के लिए संकेत (mnemonic: स्टाइल कंसोल) और घटाना 1

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

''⍴⍨ एक रिक्त स्ट्रिंग (रिक्त स्थान वाले पैड) को फिर से खोलने के लिए इसका उपयोग करें

⊢ उपज है कि (से अलग करने के लिए कार्य करता है 4)

{… }⍣4 निम्नलिखित फ़ंक्शन को चार बार लागू करें:

≢⍵ टैली (लंबाई) का तर्क

'/\'⍴⍨ चक्रीय r eshape "/\"कि लंबाई में

⍵, उस तर्क के दाईं ओर संलग्न करें

⌽⍉ संक्रमण और दर्पण (यानी 90 ° बारी)

¯1⌽1 चक्रीय 1 ^सेंट पंक्ति को दाईं ओर एक कदम घुमाएं

⊢ उपज है कि (से अलग करने के लिए कार्य करता है 1)

'\'@2@11 ^सेंट प्रमुख वस्तु के 2 ^{एन डी} स्थिति में एक बैकस्लैश डालें ।

— एडम
स्रोत

3

सी (जीसीसी) ,170 166 158 155 108 105

-3 बाइट्स क्लैब्लांक के लिए धन्यवाद

x,y;f(w,h){for(y=h*=2;y--;puts(""))for(x=w*2;x--;)putchar(!x|x==w*2-1|!y|y==h-1?x&y&1|~x&~y&1?47:92:32);}

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

मुझे लगता है कि इसे कम सीधे दृष्टिकोण के साथ आगे बढ़ाया जा सकता है, मैं देखता हूं कि जब मुझे समय मिलता है तो मैं क्या कर सकता हूं।

ठीक है मैं उस कोड के लिए बाइट्स की संख्या को कम करने का कोई अन्य तरीका नहीं खोज सकता।

स्पष्टीकरण: एक साधारण डबल-लूप प्रिंटिंग बॉक्स बॉक्स चार द्वारा चार।

बॉर्डर प्रिंट करते समय: यदि x और y दोनों निर्देशांक सम या विषम हैं, तो यह a प्रदर्शित करता है /, अन्यथा, एक \प्रदर्शित होता है

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

— scottinet
स्रोत

1

आप puts("")इस तरह लूप के लिए पहली में ले जाकर एक और 3 बाइट्स दाढ़ी कर सकते हैंx,y;f(w,h){for(y=h*=2;y--;puts(""))for(x=w*2;x--;)putchar(!x|x==w*2-1|!y|y==h-1?x&y&1|~x&~y&1?47:92:32);}

— क्लैब्लांक

@ अंकलबैंक धन्यवाद!

— स्कूटनीट

3

/// , 172 117 बाइट्स

इसलिए, क्योंकि आउटपुट में ///s और whitespaces होते हैं , उन 2 भाषाओं में सबमिशन होना चाहिए।

कोड W,Hको एकात्मक संख्या के रूप में डालने के बाद इनपुट डालें (/// के लिए यूरीरी की अनुमति है , सुझाव के लिए चैलेंजर 5 के लिए धन्यवाद) ( *अंक का प्रतिनिधित्व करने के लिए उपयोग करें, ,प्रारूप के साथ अलग )।

/W/VV//V/\\\///`/\\\\\\\\\\\\\V/,/W>+  V`/`\>+W  !V!``WV>+WV-  V`\
`\W+  V`/
`/W-!V`\
W``\\V`\V>!//!*/+%-%!//*/  //%/

इसे ऑनलाइन आज़माएं! (इनपुट के साथ W=4, H=3)

— user202729
स्रोत

आप Unary में इनपुट लेकर पार्सिंग को छोड़ सकते हैं ।

— फलों का

इसके अलावा, मुझे यह उल्लेख करना चाहिए कि यह बहुत प्रभावशाली है! बहुत बढ़िया!

— फल

2

पायथन 3 , 87 82 बाइट्स

संपादित करें: सहेजी गयी 5 के लिए धन्यवाद बाइट्स @officialaimm , @ Mr.Xcoder और @tsh

def f(a,b,n="\n"):r="\\"+"  "*~-a+"/";print("/\\"*a+n+(r+n+r[::-1]+n)*~-b+"\\/"*a)

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

— हलवार्ड वुल्म
स्रोत

कुछ सुधार के बाद अजगर 2 में 81 बाइट्स

— आधिकारिक

यदि आप इसे पायथन 3 में रखना चाहते *(b-1)हैं *~-b, -2 बाइट्स के लिए हो सकता है ।

— श्री Xcoder

2

@officialaimm क्यों " "*2*~-a? बस "__"*~-a।

— tsh

@tsh हां, आप सही कह रहे हैं ... हाहा को इस बात का अहसास नहीं था ...

— officialaimm

@officialaimm इसे पायथन 3 बनाये रखेगा, हालाँकि आपकी वजह से कुछ बाइट्स बच गए हैं, मिस्टरकोड और टीश

— हलवार्डम

2

जे, 48 बाइट्स

' '&((<,~<<0 _1)})@(+:@[$(1&|.,:])@('\/'$~+:)@])

ungolfed

' '&((< ,~ <<0 _1)}) @ (+:@[ $ (1&|. ,: ])@('\/' $~ +:)@])

व्याख्या

                       (+:@[ $ (1&|. ,: ])@('\/' $~ +:)@])    creates box, but interior filled with slashes
                                           ('\/' $~ +:)@]       take right arg, W, doubles it, then fills that
                                          @                       many characters with '\/' repeating
                               (1&|. ,: ])                      stacks (,:) the above on top of itself rotated 
                                                                  by one char, producing top and bottom spikes
                              $                                 reshape to..
                       (+:@[                                    double the length of the left arg, height
                                                                  this creates the sides, as well as a filled interior
                     @                                    
' '&((< ,~ <<0 _1)})                                          removes slashes from interior by using the complement               
                                                                form of amend }.  ie, replace everything but the first
                                                                and last row and first and last col with a space

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

— जोनाह
स्रोत

1

33 बाइट्स ' '(<,~<<0 _1)}'\/'{~=/&(2|i.)&+:। यहां अमेंड शानदार है।

— मील

ooooh, बहुत अच्छा सुधार

— योना

1

'/\ '{~2(<,~<<0 _1)}2|+/&i.&+:कुछ रिफैक्टिंग के साथ 30 बाइट्स

— मील

2

05AB1E , 19 बाइट्स

4FNÈi¹}·„\/NÉiR}N·Λ

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

तर्कों को उलट दिया।

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

हम्म, मैं गंध ... कैनवस मोड ?

— श्री Xcoder

2

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

w%h=[[last$"/\\"!!mod(x+y)2:[' '|x>1,y>1,x<2*w,y<2*h]|x<-[1..2*w]]|y<-[1..2*h]]

इसे ऑनलाइन आज़माएं! उदाहरण का उपयोग: 3%6लाइनों की एक सूची देता है। mapM putStrLn $ 3%6बॉक्स को सुंदर प्रिंट करने के लिए उपयोग करें ।

— Laikoni
स्रोत

मुझे लिन की मदद से आपका जवाब नीचे मिला , लेकिन मैं आपको फिर से हराकर देखना पसंद करूंगा।

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

1

@WheatWizard वहाँ आप जाते हैं;)

— लाकोनी

2

जावा 8, 141 बाइट्स

चौड़ाई से ऊंचाई तक एक करीबी लैम्बडा से आउटपुट तक।

w->h->{String f="/",b="\\",t=f,o=b,p="";char i=1;for(;i++<w;t+=b+f,o+=f+b)p+="  ";t+=b;o+=f;for(i=10;--h>0;)t+=i+b+p+f+i+f+p+b;return t+i+o;}

यह ऑनलाइन की कोशिश करो (नहीं, return t+i+o;जानबूझकर नहीं किया गया था)

अघोषित लंबोदर

w ->
    h -> {
        String
            f = "/",
            b = "\\",
            t = f,
            o = b,
            p = ""
        ;
        char i = 1;
        for (; i++ < w; t += b + f, o += f + b)
            p += "  ";
        t += b;
        o += f;
        for (i = 10; --h > 0; )
            t += i + b + p + f + i + f + p + b;
        return t + i + o;
    }

यह समाधान इनपुट आकार के बारे में असामान्य रूप से अचार है क्योंकि charचौड़ाई इनपुट तक गणना करने के लिए उपयोग किया जाता है। सौभाग्य से, एल्गोरिथ्म काफी खराब है कि उन आकारों के कार्यक्रम को पूरा करना शायद पहले से ही एक मुद्दा है। मैंने charलूप इंडेक्स के लिए उपयोग करना चुना ताकि मैं इसे बाद में फिर से सस्ते उर्फ के रूप में उपयोग कर सकूं '\n'।

— जेकब
स्रोत

2

SOGL V0.12 , 22 21 13 बाइट्स

/\”m;HΙ»mč+╬¡

यह कोशिश करो! (स्टैक पर दोनों इनपुट की उम्मीद है.. (और "क्योंकि एक स्ट्रिंग स्पष्ट रूप से शुरू नहीं हुई है) - आसानी से उपयोग किए जाने के लिए दो बार नंबर इनपुट जोड़ा जाता है)

स्पष्टीकरण:

/\”            push "/\"
   m           mold to the 1st inputs length
    ;          get the other input ontop of stack
     H         decrease it
      Ι        push the last string - "/\"
       »       rotate it right - convert to "\/"
        m      mold "\/" to the length of 2nd input - 1
         č     chop into characters
          +    prepend the 1st molded string to the character array of the 2nd
           ╬¡  quad-palindromize

— dzaima
स्रोत

>: D यह यहां चारकोल को नहीं मार रहा है

— ASCII-only

@ ASCII- केवल इसलिए कि चारकोल में इसके लिए अंतर्निहित है: p (और SOGLs वास्तव में जटिल और लंबी चुनौतियों के लिए किसी भी तरह से बना है)

— dzaima

1

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

Table[Which[1<i<2#2&&1<j<2#," ",OddQ[i+j],"\\",1>0,"/"],{i,2#2},{j,2#}]~Riffle~"
"<>""&

मैथिक्स में इसे आज़माएं (यह किसी कारण से अधिकांश लाइनों की शुरुआत में अतिरिक्त रिक्त स्थान प्रिंट करता है), या पर वोल्फ्राम सैंडबॉक्स में ! इनपुट के रूप में दो पूर्णांक लेता है।

यह एक काफी भोला समाधान है, लेकिन मैंने जिन चालाक चीजों की कोशिश की उनमें सभी बाइट्स अधिक थे। कुछ है कि लगभग काम करता है

ArrayPad[Array[" "&,2#-2],1,{{"/",s="\\"},{s,"/"}}]~Riffle~"\n"<>""&

सिवाय यह विफल रहता है कि या तो आयाम 1 है (इनपुट आयामों वाली एक सूची है)।

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

1

पायथ , 40 39 38 बाइट्स

+++*Q"/\\"b*tE+++K++\\*d*2tQ\/b_Kb*"\/

यह दो पूर्णांकों को एक नई रेखा से अलग करता है।

पूर्ण परीक्षण सूट।

— मिस्टर एक्सकोडर
स्रोत

1

रूबी , 62 61 60 बाइट्स

->r,c{["/\\"*c]+["\\#{w="  "*~-c}/",?/+w+?\\]*~-r+["\\/"*c]}

-1 बाइट अरनौल को धन्यवाद

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

— जीबी
स्रोत

1

दरअसल , 38 बाइट्स

"/\"*;.R;l¬' *"\/"@j;R(D(╗WD(;.(;.(Wé╜

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

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

1

जे , 39 बाइट्स

(' \/'{~=/&(2&|)(*>:)~0=*/&(*|.))&i.&+:

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

heightLHS और widthRHS पर दो तर्क देता है ।

— मील की दूरी पर
स्रोत

अच्छा काम, हमेशा की तरह। दिलचस्प दृष्टिकोण, भी।

— जोनाह

@ जोना नहीं, संशोधन का उपयोग करके आपका विचार बहुत बेहतर है। अगर मेरा आधा हिस्सा संयुक्त हो ...

— मील

1

VBA (एक्सेल), 161 बाइट्स

Sub a()
c=[A2]*2
r=[B2]*2
For i=1To r
For j=1To c
b=IIf(i=1 Or j=1 Or i=r Or j=c,IIf((i+j) Mod 2,"\","/")," ")
d=d & b
Next
d=d & vbCr
Next
Debug.Print d
End Sub

— remoel
स्रोत

गोल्फ उप (139 बाइट्स):Sub b c=[2*A1] r=[2*B1] For i=1To r For j=1To c Debug.?IIf(i=1Or j=1Or i=r Or j=c,IIf((i + j)Mod 2,"\","/")," "); Next Debug.? Next End Sub

— टेलर स्कॉट

ऊपर (113 बाइट्स) का अनाम तत्काल विंडो फ़ंक्शन संस्करण:c=[2*A1]:r=[2*B1]:For i=1To r:For j=1To c:?IIf(i=1Or j=1Or i=r Or j=c,IIf((i + j)Mod 2,"\","/")," ");:Next:?:Next

— टेलर स्कॉट

1

आर, 160 बाइट्स 152 बाइट्स

p=function(x,n){paste(rep(x,n),collapse='')}
function(w,h){f=p(' ',w*2-2)
cat(paste0(p('/\\',w),'\n',p(paste0('\\',f,'/\n/',f,'\\\n'),h-1),p('\\/',w)))}

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

8 बाइट शेविंग करने के लिए धन्यवाद BLT।

— निशान
स्रोत

क्या आप कभी sफ़ंक्शन का उपयोग करते हैं?

— बीटीटी

एस फ़ंक्शन वह है जिसे आप स्पाइक बॉक्स बनाने के लिए कहते हैं

— मार्क

1

समझ गया। यदि आप व्हाट्सएप और s=बिट को हटाते हैं तो आप 152 बाइट तक नीचे जा सकते हैं । बेनामी कार्यों की अनुमति है।

— BLT

एनोन कार्यों को जानने के लिए अच्छा है

— मार्क

0

डीसी , 123 बाइट्स

?1-sesf[/\]su[lfsh[lunlh1-dsh0<q]dsqx]dsrx[[
\]P[lf2*2-st[32Plt1-dst0<z]dszx]dsmx[/
/]Plmx92Ple1-dse0<l]slle0<l10P[\/]sulrx

यह सबसे छोटी से दूर है, लेकिन, अगर कोई अंतिम दो पंक्तियों को लेता है और उन्हें pi/2एक "ईमानदार" स्थिति में दक्षिणावर्त घुमाता है , तो यह एक तरह दिखता है कुलदेवता की है ।

दो अंतरिक्ष-पृथक पूर्णांकों के रूप में इनपुट लेता है।

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

— आर। कप
स्रोत

1

वर्तमान में यहां सबसे लंबा उत्तर है। मुझे लगा कि जावा की नौकरी है ...

— आर। कप।

चिंता न करें, अब एक जावा समाधान है , और यह लंबा है।

— जैकब

0

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

(c=Column;o=Table;v=""<>o[" ",2*#-2];w=""<>o["/\\",#];c[{w,c@o[c[{"\\"<>v<>"/","/"<>v<>"\\"}],#2-1],Rotate[w,Pi]}])&

— J42161217
स्रोत

Rotate[w,Pi]के बराबर है w~Rotate~Pi, के रूप में है o["/\\",#]के लिए"/\\"~o~#

— जोनाथन frech

मुझे पता है कि इन्फिक्स संकेतन और मैं हमेशा इसका उपयोग करता हूं जब मुझे वास्तव में 1 बाइट की आवश्यकता होती है। इस मामले में मैंने इसे बस जाने दिया ... ;-)

— J42161217

2

मुझे आपकी जानकारी के बारे में संदेह नहीं है; मैं सिर्फ बाइट काउंट कम करना चाहता था। तुम्हें पता है, गोल्फ और इस तरह की भावना में।

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

0

वी , 18 बाइट्स

Ài/\Ùæ$Àäkllòjjkè

उत्तर की आवश्यकता नहीं होगी llअगर <M-h>ollowबाएं 2 चार कॉलम अकेले :(

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

— nmjcman101
स्रोत

0

C # (.NET Core) , 188 बाइट्स

a=>b=>string.Join("\n",new int[2*b].Select((x,i)=>string.Concat(string.Concat(new int[a].Select(y=>i%2==0?"/\\":"\\/")).Select((y,j)=>i>0&i<2*b-1&j>0&j<2*a-1?" ":""+y))))

बाइट काउंट में ये भी शामिल हैं:

using System.Linq;

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

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

यहाँ स्पष्टीकरण मध्य-बाहर जा रहा है (सबसे भीतरी कमांड पहले):
सबसे पहले, पूर्ण बॉक्स के लिए पंक्तियाँ बनाएँ, और एक स्ट्रिंग के लिए संक्षिप्त करें

string.Concat(new int[a].Select(y => i % 2 == 0 ? "/\\" : "\\/"))

फिर एक पंक्ति में प्रत्येक वर्ण प्राप्त करें, और यदि यह बॉक्स की रूपरेखा नहीं है, तो स्थान के साथ बदलें, उन्हें प्रत्येक पंक्ति के लिए एक स्ट्रिंग में वापस मिलाएं

string.Concat(PREVIOUS_STEP.Select((y, j) => i > 0 & i < 2 * b - 1 & j > 0 & j < 2 * a - 1 ? " " : "" + y))

अंत में, प्रत्येक पंक्ति प्राप्त करें और उन्हें नए सिरे से एक साथ मिलाएं (इसमें पंक्तियों के लिए एक संग्रह बनाना भी शामिल है)

string.Join("\n", new int[2 * b].Select((x, i) => PREVIOUS_STEP));

— ग्रेज़गोरज़ पुलावस्की
स्रोत

0

पर्ल ५ , 83 + 1 (एन) = 84 बाइट्स

say"/\\"x($q=$F[0]);print(("\\".($s=$"x(2*$q-2))."/$//$s\\$/")x--$F[1]);say"\\/"x$q

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

— Xcali
स्रोत

एक स्पाइकी बॉक्स बनाओ

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

व्याख्या

MATL , 18 बाइट्स

व्याख्या

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

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

05AB1E , 14 बाइट्स

व्याख्या

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

डेमो

स्विफ्ट 3 , 166 बाइट्स

रेटिना , 77 73 बाइट्स

एक्सेल, 95 बाइट्स

एपीएल (डायलॉग) , 41 39 बाइट्स

सी (जीसीसी) ,170 166 158 155 108 105

/// , 172 117 बाइट्स

पायथन 3 , 87 82 बाइट्स

जे, 48 बाइट्स

ungolfed

व्याख्या

05AB1E , 19 बाइट्स

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

जावा 8, 141 बाइट्स

अघोषित लंबोदर

SOGL V0.12 , 22 21 13 बाइट्स

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

पायथ , 40 39 38 बाइट्स

रूबी , 62 61 60 बाइट्स

दरअसल , 38 बाइट्स

जे , 39 बाइट्स

आर, 160 बाइट्स 152 बाइट्स

डीसी , 123 बाइट्स

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

वी , 18 बाइट्स

C # (.NET Core) , 188 बाइट्स

पर्ल ५ , 83 + 1 (एन) = 84 बाइट्स