Scrivi un programma o una funzione che accetta un numero intero positivo N.

Quando N è 1, emettere

/\
\/

Quando N è 2, emettere

/\/\
\/ /
/ /
\/

Quando N è 3, emettere

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

Quando N è 4, emettere

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

Per N più grande il motivo continua, un nuovo livello viene aggiunto ogni volta che N viene incrementato.

• "Output" significa stampare il modello di barra o restituirlo come stringa.
• È consentita una nuova riga finale finale nell'output.
• Gli spazi finali nell'output sono consentiti, ma non gli spazi iniziali.

Vince il codice più breve in byte.

Pyth, 25 byte

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

Provalo online: Dimostrazione o Test Suite

Spiegazione:

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 byte

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

Provalo qui.

Stavo cercando di aiutare Reto a giocare a golf con la sua risposta di CJam, ma alla fine ho trovato una soluzione che non aveva nulla a che fare con la sua, quindi ho pensato di poterlo pubblicare anche io.

Spiegazione

Questo utilizza la simmetria dell'output. In particolare, il fatto che l'output sia uguale al suo recepimento.

Innanzitutto, generiamo le prime N+1linee, ma senza il bordo sinistro:

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.

Ora abbiamo una serie di stringhe che rappresentano la seguente griglia:

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

Il recepimento di questo assomiglia a questo:

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

Insieme, hanno tutti i caratteri non spaziali di cui abbiamo bisogno. Ora possiamo usare la punta di Dennis per combinare due griglie ASCII in una, prendendo il massimo di ciascuna coppia di caratteri corrispondente. In tutte le posizioni in cui le due griglie differiscono, una avrà uno spazio (o niente) e l'altra avrà il personaggio che stiamo cercando. Quando un elenco in un'operazione vettoriale è più lungo dell'altro, gli elementi aggiuntivi dell'elenco più lungo verranno semplicemente conservati, che è proprio quello che stiamo cercando. Negli altri casi, il carattere non spaziale sarà sempre il massimo dei due caratteri:

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

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

Provalo online!

Ungolfed e spiegazione

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

Il nucleo del programma crea un elenco di U * 2elementi, mappa ciascuno a una riga del modello, quindi li unisce con le nuove linee:

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.

Per quanto riguarda lo schema stesso, ecco come l'ho rotto:

/\/\/\/\

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

Come puoi vedere qui, questo ora si trasforma in tre semplici schemi. Il primo è il più semplice, generato con questo codice:

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

Ora per la metà sinistra. Gli indici dispari dovrebbero essere mappati \/e persino a /, quindi usiamo questo codice:

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

Questo rende la metà giusta più facile; tutto ciò che dobbiamo fare è ripetere  /alcune volte:

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

Suggerimenti benvenuti!

GNU Sed, 59

Il punteggio include +2 per le opzioni '-nr' a sed.

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

Inserimento in unario secondo questa meta risposta .

Uscita di prova:

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

CJam, 36 35 34 byte

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

Provalo online

Grazie a @NinjaBearMonkey per aver sottolineato il extra ;.

Sebbene ciò sembri relativamente poco elegante, ho provato un paio di altre opzioni e non sono finite in breve tempo.

Spiegazione:

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 byte

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

Mathematica, 123 122 121 byte

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

Probabilmente potrebbe essere ulteriormente giocato a golf.

Java - 141 byte

Non il più breve ovviamente, ma bello avere una soluzione Java:

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

Ingresso

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

Produzione

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

Pyth, 30 byte

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

Provalo qui .

JavaScript, 128 125 123 114 byte

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 (convertito anche in ES5) + 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()));

Rubino, 50 byte

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

Nel programma di test:

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

Il ciclo stampa 2 righe per ogni iterazione da i = 0 a i = n-1.

La seconda fila è sempre '\'seguita da nette incidenze di '/ '.

La prima riga è uguale alla seconda riga dell'iterazione precedente, ma con quella '\'mancante (quindi memorizziamo questo valore squando stampiamo la seconda riga dell'iterazione precedente.)

L'unica eccezione è l'iterazione zero, che viene gestita inizializzando ssu '/\'*n.

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

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

Primo post qui!

Usato per usare ma ora usa , simile a Ruby .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 + '\\/';
}

Grazie a:
107 => 104 byte: @inserireusernamehere
97 => 90 byte: @ user81655

Python 2, 66 byte

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

Abbastanza diretto. Il valore nè il numero di /sulla riga e bindica se la riga inizia con \. Il valore di si balterna tra 0 e 1 e ndiminuisce ogni secondo passaggio. La brutta condizione di terminazione si interrompe quando n=1, b=0. L'alternativa di un execciclo avrebbe il problema di aver bisogno di molte fughe per "'\\\\'".

Sono stato sorpreso di trovare questo approccio più breve rispetto all'utilizzo di un singolo numero k=2*n+b. Sono 68 byte:

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

Una strategia alternativa eviterebbe uno separato printper la linea superiore, ma non ho visto un modo conciso.

Minkolang 0,14 , 46 byte

Sono sicuro che questo potrebbe essere giocato a golf, ma sono le 4 del mattino e devo andare a letto.

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

Provalo qui.

Spiegazione

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

Lotto, 121 byte

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

O se unario è accettabile, 107 byte:

@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

Richiamare con il numero appropriato di 1s.

Matlab, 122 byte

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 byte

Due soluzioni di uguale lunghezza.

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

e

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

Questo non è effettivamente competitivo rispetto alla soluzione Haskell esistente perché salva 5 caratteri restituendo invece di stampare una stringa. Lo sto postando solo per mostrare come l'approccio all'infinito si confronta con l'approccio basato sulle coordinate. Gli appunti:

• p può essere allineato per nessun cambiamento di lunghezza.
• [t n l|(n,l)<-...]salva 2 su (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)};

Questo presenta un "elenco di argomenti con nome" per join(senza argomenti con nome, ma una comprensione iterabile) e diversi usiString.repeat (uno dei quali in realtà significa "include only for dispari i").

formattato:

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

PHP, 117 byte

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

Presuppone che gli avvisi siano disattivati ​​e che l'input sia preso dalla riga di comando.

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

I commenti sono benvenuti :)