एन स्लैब स्लट स्लैश केक

23

एक प्रोग्राम या फ़ंक्शन लिखें जो एक सकारात्मक पूर्णांक एन में लेता है।

जब एन 1, आउटपुट है

/\
\/

जब एन 2, आउटपुट है

/\/\
\/ /
/ /
\/

जब एन 3 है, आउटपुट

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

जब एन 4 है, आउटपुट

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

बड़े एन के लिए पैटर्न जारी रहता है, एन बढ़े जाने पर हर बार एक नई परत जोड़ी जाती है।

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

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

code-golf  string  ascii-art 
— केल्विन के शौक
स्रोत

जवाबों:

10

पायथ, 25 बाइट्स

j_+t.iJ*R"/ "SQ+L\\J*Q"/\

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

j_+t.iJ*R"/ "SQ+L\\J*Q"/\   implicit: Q = input number
             SQ             create the list [1, 2, ..., Q]
       *R"/ "               repeat "/ " accordingly to this numbers
      J                     assign this list of strings to J
               +L\\J        create a 2nd list, which contains the same strings
                            as in J, just with a "\" prepended
    .i                      interleave these two lists
   t                        remove the first element
                    *Q"/\   repeat the string "/\" Q times
  +                         append it to the list
 _                          reverse it
j                           print each string on a separate line
— Jakube
स्रोत
10

CJam, 32 30 29 28 बाइट्स

ri_"/\ /"2/f*)@,\f>+_z..e>N*

इसका परीक्षण यहां करें।

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

व्याख्या

यह आउटपुट की समरूपता का उपयोग करता है। विशेष रूप से, तथ्य यह है कि आउटपुट इसके ट्रांसपोज़ के समान है।

सबसे पहले, हम पहली N+1पंक्तियों को उत्पन्न करते हैं, लेकिन बाएं किनारे के बिना:

ri       e# Read input and convert to integer N.
_        e# Duplicate.
"/\ /"2/ e# Push an array with two strings: ["/\" " /"]
f*       e# Repeat each of the two strings N times. That gives the first two rows.
)        e# Detach the second row.
@,       e# Pull up the other copy of N and turn into range [0 1 ... N-1].
\f>      e# For each element i in that range, discard the first i characters of
         e# the second row.
+        e# Add all those lines back to the first row.

अब हमें निम्नलिखित ग्रिड का प्रतिनिधित्व करने वाले तार की एक सरणी मिली है:

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

इस तरह का परिवर्तन इस तरह दिखता है:

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

साथ में, ये सभी गैर-अंतरिक्ष वर्ण हैं जिनकी हमें आवश्यकता है। अब हम वर्णों की प्रत्येक संगत जोड़ी का अधिकतम लाभ उठाते हुए, दो ASCII ग्रिडों को एक में मिलाने के लिए डेनिस के रेड टिप का उपयोग कर सकते हैं । सभी स्थितियों में जहां दोनों ग्रिड अलग-अलग होते हैं, एक में एक स्थान होगा (या कुछ भी नहीं) और दूसरे में वह चरित्र होगा जिसकी हम तलाश कर रहे हैं। जब एक सदिश ऑपरेशन में एक सूची दूसरे की तुलना में लंबी होती है, तो लंबी सूची के अतिरिक्त तत्वों को बस रखा जाएगा, जो कि सिर्फ वही है जो आपको दिखता है। अन्य मामलों में, गैर-स्थान वर्ण हमेशा दो वर्णों का अधिकतम होगा:

_z   e# Duplicate the grid and transpose it.
..e> e# For each pair of characters in corresponding positions, pick the maximum.
N*   e# Join the lines by linefeed characters.
— मार्टिन एंडर
स्रोत
7

जाप , 46 44 41 40 बाइट्स

Uo-U £Y?"\\/"sYv)+" /"pU-Y/2 :"/\\"pU} ·

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

अपुष्ट और व्याख्या

Uo-U mXYZ{Y?"\\/"sYv)+" /"pU-Y/2 :"/\\"pU} qR

कार्यक्रम का मुख्य भाग U * 2आइटम की एक सूची बनाता है , पैटर्न की एक पंक्ति में प्रत्येक को मैप करता है, फिर उन्हें नए सिरे से जोड़ता है:

Uo-U    // Build an array of all integers in the range [-U, U).
mXYZ{   // Map each item X and index Y in this array with the following function.
 ...
} qR    // Join the resulting array with newlines.

पैटर्न के लिए ही, यहाँ बताया गया है कि मैंने इसे कैसे तोड़ा:

/\/\/\/\

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

जैसा कि आप यहां देख सकते हैं, यह अब तीन सरल पैटर्न में विकसित होता है। पहले वाला सबसे आसान है, इस कोड के साथ उत्पन्न:

Y? ... :  // If Y, the current index, is 0,
"/\\"pU   // return the pattern "/\" repeated U*2 times.

अब बाएं आधे के लिए। अजीब सूचकांकों को मैप करना चाहिए \/, और यहां तक ​​कि /, इसलिए हम इस कोड का उपयोग करते हैं:

"\\/"s  // Otherwise, slice the pattern "\/" at 
Yv)     //  if Y is even, 1; otherwise, 0.

यह सही आधे रास्ते को आसान बनाता है; बस हमें  /कुछ समय दोहराने की जरूरत है :

" /"p  // Repeat the pattern " /"
U-Y/2  //  floor(U - (Y/2)) times.

सुझावों का स्वागत है!

— ETHproductions
स्रोत
5

जीएनयू सैड, 59

स्कोर में '-nr' विकल्पों के लिए +2 शामिल हैं sed।

s|1|/\\|gp
y|/\\| /|
s| |\\|p
:
s|\\(..)|\1|p
s|/ |\\|p
t

इस मेटा उत्तर के अनुसार इनपुट इन यूनरी है ।

परीक्षण उत्पादन:

$ sed -nrf slantcake.sed <<< 111
/\/\/\
\/ / /
/ / /
\/ /
/ /
\/
$
— डिजिटल आघात
स्रोत
4

CJam, 36 35 34 बाइट्स

ri_"/\\"*N@,W%{'\'/@" /"*+_N\N}/;;

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

अतिरिक्त इंगित करने के लिए @NinjaBearMonkey का धन्यवाद ;।

हालांकि यह अपेक्षाकृत अशुभ लगता है, मैंने कुछ अन्य विकल्पों की कोशिश की, और वे किसी भी छोटे को समाप्त नहीं करते थे।

स्पष्टीकरण:

ri_     Get input, convert to integer, and copy.
"/\\"   Pattern for first line.
*N      Repeat N times, and add a newline.
@,      Rotate N to top, and create [0 .. N-1] sequence.
W%      Invert sequence to [N-1 .. 0].
{       Loop over counts, creating two lines for each.
  '\      Leading character for first in pair of lines. Rest will be the same
          for both lines.
  '/      First character for repeated part.
  @       Rotate count to top.
  " /"    Repetitive pattern.
  *       Replicate it by count.
  +       Concatenate with '/.
  _       Copy whole thing for use as second in pair of lines.
  N\      Put a newline between the pair of lines.
  N       Add a newline after second line.
}/      End of loop over counts.
;;      Created an extra line, get rid of it.
— रेटो कोराडी
स्रोत
1
अब आप अंतिम ;s को हटा सकते हैं ।
— निंजाबियरनॉकी
या प्रतिस्थापित ;;; + के साथ;
— GamrCorps
3

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

n=input()
print"/\\"*n
for i in range(n*2,1,-1):print"\\"*(1-i%2)+"/ "*(i/2+i%2)
— नीला
स्रोत
2

जावा - 141 बाइट्स

निश्चित रूप से सबसे छोटा नहीं है, लेकिन जावा समाधान के लिए अच्छा है:

String a(int a){String s="";int b=-1,c,e;for(a*=2;++b<a;){for(c=-1;++c<a;)s+=(e=b+c)>a?" ":e%2==0?"/":b==0||c==0?"\\":" ";s+="\n";}return s;}

Ungolfed

String a(int a){
    String s ="";
    int b=-1,c,e;
    for (a*=2;++b < a;){
        for (c = -1 ; ++c < a ;)
            s+= (e=b+c)>a?" ": e%2==0? "/" : b==0||c==0? "\\" : " ";
        s+="\n";
    }
    return s;
}

इनपुट

System.out.println(a(5));

उत्पादन

/\/\/\/\/\
\/ / / / /
/ / / / / 
\/ / / /  
/ / / /   
\/ / /    
/ / /     
\/ /      
/ /       
\/
— यासिन हज
स्रोत
1

जावास्क्रिप्ट, 128 125 123 114 बाइट्स

n=>{r='';for(i=0;i<n;i++)r+='/\\';for(j=0;j<2*n-1;j++){r+='\n'+(j%2?'':'\\');for(i=n-j/2;i>0;i--)r+='/ '}return r}

डी-गोल्फ (ES5 में भी परिवर्तित) + डेमो:

function c(n) {
    r = '';
    for (i = 0; i < n; i++) r += '/\\';
    for (j = 0; j < 2 * n - 1; j++) {
        r += '\n' + (j % 2 ? '' : '\\');
        for (i = n - j / 2; i > 0; i--) r += '/ '
    }
    return r
}

alert(c(prompt()));
स्निपेट का विस्तार करें

— nicael
स्रोत
1

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

->n{s='/\\'*n
n.times{|i|puts s,?\\+s='/ '*(n-i)}}

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

f=->n{s='/\\'*n
n.times{|i|puts s,?\\+s='/ '*(n-i)}}
f[gets.to_i]

लूप प्रत्येक पुनरावृत्ति के लिए 2 पंक्तियों को i = 0 से i = n-1 तक प्रिंट करता है।

दूसरी पंक्ति हमेशा '\'नी के घटनाओं के बाद होती है '/ '।

पहली पंक्ति पिछली पुनरावृत्ति की दूसरी पंक्ति के समान है, लेकिन '\'लापता (इसलिए हम इस मान को संग्रहीत करते हैंs जब हम पिछली पुनरावृत्ति की दूसरी पंक्ति को प्रिंट करते हैं ।)

एकमात्र अपवाद पुनरावृत्ति शून्य है, जिसे प्रारंभ sकरने से नियंत्रित किया जाता है '/\'*n।

— स्तर नदी सेंट
स्रोत
1

जावास्क्रिप्ट (ईएस 6), 107 104 100 98 97 91 90 बाइट्स

p=>{s=`/\\`.repeat(p++)+`
`;for(i=p;i>2;s+='\\'+o+o)o=`/ `.repeat(--i)+`
`;return s+'\\/'}

पहली पोस्ट यहाँ!

उपयोग करने के लिए प्रयुक्त लेकिन अब का उपयोग करता है , रूबी के समानArray(len).join(str) String.repeat(len)operator*(str,len) ।

Ungolfed:

len => {
    var str = `/\\`.repeat(len++) + '\n';

    for (var i = len, mid; i > 2; str += '\\' + mid + mid) {
        mid = `/ `.repeat(--i) + '\n';
    }

    return str + '\\/';
}


धन्यवाद:
107 => 104 बाइट्स: @insertusernamehere
97 => 90 बाइट्स: @ user81655

— usandfriends
स्रोत
1
आप को बचा सकता है 3 बाइट्स : p=>{s=Array(++p).join('/\\')+'\n';for(i=p;i>2;i--,s+='\\'+o+o)o=Array(i).join('/ ')+'\n';return s+'\\/'}।
— सम्मिलित
मैंने अपना उत्तर हटा दिया क्योंकि यह बहुत समान था लेकिन आपके बाद पोस्ट किया गया था।
— 2:81 बजे user81655
@ user81655 आह, इसके बारे में क्षमा करें। मुझे repeatविधि दिखाने के लिए धन्यवाद ।
— usandfriends
1

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

n=input();b=1
print'/\\'*n
while~-n+b:print'\\'*b+'/ '*n;b^=1;n-=b

बहुत सीधा। मान लाइन पर nसंख्या है /, और bकहता है कि क्या लाइन के साथ शुरू होता है \। b0 और 1 के बीच वैकल्पिक का मूल्य , और nहर दूसरे चरण में घट जाती है। बदसूरत समाप्ति की स्थिति कब बंद हो जाती हैn=1, b=0 । एक execलूप के विकल्प के लिए बहुत सारे पलायन की आवश्यकता का मुद्दा होगा"'\\\\'" ।

मैं एक एकल संख्या का उपयोग करने से कम इस दृष्टिकोण को देखकर हैरान था k=2*n+b। यह 68 बाइट्स है:

k=2*input()+1
print k/2*"/\\"
while k>2:print k%2*'\\'+k/2*'/ ';k-=1

एक वैकल्पिक रणनीति printशीर्ष रेखा के लिए एक अलग से बचती है , लेकिन मैंने संक्षिप्त तरीका नहीं देखा।

— XNOR
स्रोत
1

मिन्कोलांग 0.14 , 46 बाइट्स

मुझे यकीन है कि यह गोल्फ हो सकता है, लेकिन यह 4 बजे यहां है और मुझे बिस्तर पर जाने की जरूरत है।

n$z"/\"z$D$OlOz[" /"zi-$Dlr$d"\"zi1+-3&5$X$O].

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

व्याख्या

n$z               Take number from input (n) and store it in the register (z)
   "/\"           Push these characters (in reverse)
       z$D        Push register value and duplicate the whole stack that many times
          $O      Output whole stack as characters
            lO    Output newline

z                                   Push n from register
 [                                  Open for loop that repeats n times
  " /"                              Push these characters (in reverse)
      zi-                           n - loop counter
         $D                         Pop k and duplicate whole stack k times
           l                        Push 10 (for newline)
            r                       Reverse stack
             $d                     Duplicate whole stack
               "\"                  Push this character
                  zi1+-             0 if n = loop counter + 1, truthy otherwise
                       3&           Do the next three characters if top of stack is 0
                         5$X        Dump the bottom-most five items of the stack
                            $O      Output whole stack as characters
                              ].    Close for loop and stop
— एलेंडिया स्ट्राटन
स्रोत
1

बैच, 121 बाइट्स

@echo off
set/an=%1-1
if %1==1 (echo /\%2) else call %0 %n% /\%2
set a=/\%2
echo \%a:\= %
if not \%2==\ echo %a:\= %

या यदि स्वीकार्य स्वीकार्य है, 107 बाइट्स:

@echo off
set a=%1
echo %a:1=/\%
:a
echo \%a:1=/ %
set a=%a:~1%
if not %a%1==1 echo / %a:1=/ %&goto a

1s की उचित संख्या के साथ आह्वान करें।

— नील
स्रोत
0

मतलाब, 122 बाइट्स

M=2*input('');
z=zeros(M);[y,x]=ndgrid(1:M);
z(~mod(x+y,2)&x+y<M+3)=1;v=2-mod(1:M,2);
z(1,:)=v;z(:,1)=v;disp([15*z.^2+32,''])
— flawr
स्रोत
0

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

बराबर लंबाई के दो समाधान।

पुकारते हैं f।

f n=mapM_ putStrLn$[[x?y|x<-[0..2*n-y-0^y]]|y<-[0..2*n-1]]
x?y|mod(x+y)2==0='/'|x*y==0='\\'|0<1=' '

तथा

f n=mapM_ putStrLn$[[x?y|x<-[y..2*n-0^y]]|y<-[0..2*n-1]]
x?y|mod x 2==0='/'|mod y x==0='\\'|0<1=' '
— लीफ़ विलर्ट्स
स्रोत
0

हास्केल, 96

f=g.(*2)
g m=unlines$t m(c"/\\"):[t n l|(n,l)<-zip[m,m-1..2]$c['\\':p,p]]
p=c"/ "
c=cycle
t=take

यह वास्तव में मौजूदा हास्केल समाधान के खिलाफ प्रतिस्पर्धी नहीं है क्योंकि यह एक स्ट्रिंग को प्रिंट करने के बजाय वापस लौटकर 5 वर्णों को बचाता है। मैं इसे केवल यह दिखाने के लिए पोस्ट कर रहा हूं कि अनंत पैटर्न दृष्टिकोण समन्वय आधारित दृष्टिकोण की तुलना कैसे करता है। टिप्पणियाँ:

  • p लंबाई में कोई परिवर्तन नहीं करने के लिए इनलाइन किया जा सकता है।
  • [t n l|(n,l)<-...]2 ओवर बचाता है (map(uncurry t)$...)।
— केविन रीड
स्रोत
0

सीलोन, 100

String s(Integer n)=>"\n".join{"/\\".repeat(n),for(i in 2*n+1..3)"\\".repeat(i%2)+"/ ".repeat(i/2)};

इसके लिए "नामित तर्क सूची" join(किसी भी नामित तर्क के बिना, लेकिन इसके बजाय एक चलने योग्य समझ) की सुविधा है, और कई उपयोग String.repeat(जिनमें से एक का वास्तव में अर्थ है) में केवल विषम शामिल हैंi ")।

प्रारूपित:

String s(Integer n) =>
        "\n".join{
            "/\\".repeat(n),
            for (i in 2*n + 1 .. 3)
                "\\".repeat(i % 2)
                        + "/ ".repeat(i / 2)
        };
— पाओलो एबरमन
स्रोत
0

PHP, 117 बाइट्स

<?$n=$argv[1];$r=str_repeat;echo$r("/\\",$n);for(;$i++<$n*2-1;)echo"\n".($i%2?"\\":'').$r("/ ",$n-floor(($i-1)/2));?>

मान लिया जाता है कि नोटिस बंद कर दिए गए हैं और इनपुट कमांड लाइन से लिया गया है।

Ungolfed:

<?php
error_reporting(E_ALL & ~E_NOTICE);

$n = $argv[1];
$r='str_repeat';
echo $r("/\\",$n);
for(;$i++<$n*2-1;){
    echo"\n".(($i%2)?"\\":'') . $r("/ ",$n-floor(($i-1)/2));
}
?>

टिप्पणियाँ स्वागत है :)

— कोडोस जॉनसन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.