Schreiben Sie ein Programm oder eine Funktion, die eine positive ganze Zahl N enthält.

Wenn N 1 ist, wird ausgegeben

/\
\/

Wenn N 2 ist, wird ausgegeben

/\/\
\/ /
/ /
\/

Wenn N 3 ist, wird ausgegeben

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

Wenn N 4 ist, wird ausgegeben

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

Bei größerem N wird das Muster fortgesetzt, und jedes Mal, wenn N inkrementiert wird, wird eine neue Ebene hinzugefügt.

• "Ausgabe" bedeutet, dass das Schrägstrichmuster gedruckt oder als Zeichenfolge zurückgegeben wird.
• Eine einzelne nachgestellte Zeile in der Ausgabe ist zulässig.
• Nachgestellte Leerzeichen in der Ausgabe sind zulässig, führende Leerzeichen jedoch nicht.

Der kürzeste Code in Bytes gewinnt.

Pyth, 25 Bytes

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

Probieren Sie es online aus: Demo oder Test Suite

Erläuterung:

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

CJam, 32 30 29 28 Bytes

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

Teste es hier.

Ich habe versucht, Reto bei der Beantwortung seiner CJam-Frage zu helfen, aber am Ende hatte ich eine Lösung, die nichts mit seiner zu tun hatte.

Erläuterung

Dies nutzt die Symmetrie des Ausgangs. Insbesondere die Tatsache, dass die Ausgabe mit der Transponierung identisch ist.

Zuerst erzeugen wir die ersten N+1Zeilen, aber ohne den linken Rand:

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.

Jetzt haben wir eine Reihe von Zeichenfolgen, die das folgende Raster darstellen:

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

Die Umsetzung sieht so aus:

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

Zusammen haben diese alle nicht-Leerzeichen, die wir brauchen. Wir können jetzt Dennis 'rad-Tipp verwenden , um zwei ASCII-Gitter zu einem zu kombinieren, indem wir das Maximum von jedem entsprechenden Zeichenpaar nehmen. In allen Positionen, in denen sich die beiden Gitter unterscheiden, hat eines ein Leerzeichen (oder gar nichts) und das andere den Charakter, den wir suchen. Wenn eine Liste in einer vektorisierten Operation länger als die andere ist, werden die zusätzlichen Elemente der längeren Liste einfach beibehalten, und genau das ist, wonach wir suchen. In den anderen Fällen ist das Nicht-Leerzeichen immer das Maximum der beiden Zeichen:

_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.

Japt , 46 44 41 40 Bytes

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

Probieren Sie es online!

Ungolfed und Erklärung

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

Der Kern des Programms erstellt eine Liste von U * 2Elementen, ordnet sie jeweils einer Zeile des Musters zu und verbindet sie dann mit Zeilenumbrüchen:

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.

Das Muster selbst habe ich folgendermaßen aufgeteilt:

/\/\/\/\

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

Wie Sie hier sehen können, gliedert sich dies nun in drei einfache Muster. Der erste ist der einfachste und wird mit folgendem Code generiert:

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

Nun zur linken Hälfte. Ungerade Indizes sollten auf \/und gerade auf abgebildet werden /, daher verwenden wir diesen Code:

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

Das macht die rechte Hälfte leichter; Alles was wir tun müssen, ist  /ein paar Mal zu wiederholen :

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

Vorschläge willkommen!

GNU Sed, 59

Die Punktzahl enthält +2 für '-nr' Optionen auf sed.

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

Eingabe in unary gemäß dieser Meta-Antwort .

Testausgang:

$ sed -nrf slantcake.sed <<< 111
/\/\/\
\/ / /
/ / /
\/ /
/ /
\/
$ 

CJam, 36 35 34 Bytes

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

Probieren Sie es online aus

Vielen Dank an @NinjaBearMonkey für den Hinweis auf das Extra ;.

Während dies relativ unelegant aussieht, habe ich ein paar andere Optionen ausprobiert und sie wurden nicht kürzer.

Erläuterung:

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.

Python 2, 80 Bytes

n=input()
print"/\\"*n
for i in range(n*2,1,-1):print"\\"*(1-i%2)+"/ "*(i/2+i%2)

Mathematica, 123 122 121 Bytes

""<>(#<>"
"&/@Normal@SparseArray[{{i_,j_}/;2∣(i+j)&&i+j<2#+3->"/",{i_,j_}/;i~Min~j<2&&2∣i~Max~j->"\\"},{2#,2#}," "])&

Könnte wahrscheinlich weiter golfen werden.

Java - 141 Bytes

Natürlich nicht die kürzeste, aber schön, eine Java-Lösung zu haben:

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;
}

Eingang

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

Ausgabe

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

Pyth, 30 Bytes

*"/\\"QVr*2Q1+*\\!%N2*s.DN2"/ 

Probieren Sie es hier aus .

JavaScript, 128 125 123 114 Bytes

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}

De-Golf (auch auf ES5 umgestellt) + Demo:

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()));

Ruby, 50 Bytes

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

Im Testprogramm:

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

Die Schleife druckt 2 Zeilen für jede Iteration von i = 0 bis i = n-1.

Auf die zweite Reihe '\'folgen immer ni Vorkommen von '/ '.

Die erste Zeile ist die gleiche wie die zweite Zeile der vorherigen Iteration, jedoch mit dem '\'fehlenden (daher speichern wir diesen Wert in, swenn wir die zweite Zeile der vorherigen Iteration drucken.)

Die einzige Ausnahme ist die Iteration Null, die bei der Initialisierung sauf behandelt wird '/\'*n.

Javascript (ES6), 107 104 100 98 97 91 90 Bytes

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

Erster Beitrag hier!

Verwendet zu verwenden Array(len).join(str) aber jetzt verwendet String.repeat(len) , ähnlich wie Ruby's 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 + '\\/';
}

Dank an:
107 => 104 Bytes: @insertusernamehere
97 => 90 Bytes: @ user81655

Python 2, 66 Bytes

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

Ziemlich einfach. Der Wert nist die Nummer /in der Zeile und bgibt an, ob die Zeile mit beginnt \. Der Wert von bwechselt zwischen 0 und 1 und nnimmt mit jedem zweiten Schritt ab. Die hässliche Beendigungsbedingung hört auf, wenn n=1, b=0. Die Alternative einer execSchleife hätte das Problem, dass viele Fluchtwege erforderlich sind "'\\\\'".

Ich war überrascht, dass dieser Ansatz kürzer war als die Verwendung einer einzelnen Zahl k=2*n+b. Das sind 68 Bytes:

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

Eine alternative Strategie würde eine Trennung printfür die oberste Zeile vermeiden , aber ich sah keinen prägnanten Weg.

Minkolang 0,14 , 46 Bytes

Ich bin mir sicher, dass das Golf spielen könnte, aber es ist 4 Uhr morgens und ich muss ins Bett.

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

Probieren Sie es hier aus.

Erläuterung

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

Batch, 121 Bytes

@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:\= %

Oder wenn unary akzeptabel ist, 107 Bytes:

@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

Rufen Sie mit der entsprechenden Anzahl von 1s auf.

Matlab, 122 Bytes

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,''])

Haskell, 99 Bytes

Zwei Lösungen gleicher Länge.

Rufen Sie an 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=' '

und

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=' '

Haskell, 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

Dies ist im Vergleich zur vorhandenen Haskell-Lösung nicht konkurrenzfähig, da 5 Zeichen gespart werden, indem ein String zurückgegeben wird, anstatt gedruckt zu werden. Ich poste es nur, um zu zeigen, wie der Unendlichkeitsmusteransatz mit dem koordinatenbasierten Ansatz verglichen wird. Anmerkungen:

• p kann für keine Längenänderung inliniert werden.
• [t n l|(n,l)<-...]spart 2 über (map(uncurry t)$...).

Ceylon, 100

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

Dies beinhaltet eine "benannte Argumentliste" für join(ohne benannte Argumente, aber stattdessen ein iterierbares Verständnis) und mehrere Verwendungen String.repeat(von denen eine tatsächlich "nur für ungerade enthalten" bedeuteti " bedeutet).

Formatiert:

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

PHP, 117 Bytes

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

Es wird davon ausgegangen, dass Benachrichtigungen deaktiviert sind und die Eingabe über die Befehlszeile erfolgt.

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));
}
?>

Kommentare sind willkommen :)