Escriba un programa o función que tome un entero positivo N.

Cuando N es 1, salida

/\
\/

Cuando N es 2, salida

/\/\
\/ /
/ /
\/

Cuando N es 3, salida

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

Cuando N es 4, salida

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

Para N más grande, el patrón continúa, se agrega una nueva capa cada vez que se incrementa N.

• "Salida" significa imprimir el patrón de barra diagonal o devolverlo como una cadena.
• Se permite una nueva línea final en la salida.
• Los espacios finales en la salida están permitidos pero los espacios iniciales no.

El código más corto en bytes gana.

Pyth, 25 bytes

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

Pruébelo en línea: Demostración o conjunto de pruebas

Explicación:

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*

Pruébalo aquí.

Estaba tratando de ayudar a Reto a responder su respuesta de CJam, pero terminé con una solución que no tenía nada que ver con la suya, así que pensé que podría publicarla yo mismo.

Explicación

Esto hace uso de la simetría de la salida. En particular, el hecho de que la salida es la misma que su transposición.

Primero, generamos las primeras N+1líneas, pero sin el borde izquierdo:

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.

Ahora tenemos una serie de cadenas que representan la siguiente cuadrícula:

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

La transposición de eso se ve así:

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

Juntos, estos tienen todos los caracteres no espaciales que necesitamos. Ahora podemos usar la punta de rad de Dennis para combinar dos cuadrículas ASCII en una, tomando el máximo de cada par de caracteres correspondiente. En todas las posiciones en las que las dos cuadrículas difieren, una tendrá un espacio (o nada) y la otra tendrá el personaje que estamos buscando. Cuando una lista en una operación vectorizada es más larga que la otra, los elementos adicionales de la lista más larga simplemente se mantendrán, que es justo lo que estamos buscando. En los otros casos, el carácter sin espacio siempre será el máximo de los dos caracteres:

_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} ·

Pruébalo en línea!

Sin golfos y explicación

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

El núcleo del programa hace una lista de U * 2elementos, asigna cada uno a una fila del patrón, luego los une con nuevas líneas:

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.

En cuanto al patrón en sí, así es como lo he dividido:

/\/\/\/\

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

Como puede ver aquí, esto ahora se convierte en tres patrones simples. El primero es el más fácil, generado con este código:

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

Ahora para la mitad izquierda. Los índices impares deben correlacionarse \/, e incluso a /, por lo que utilizamos este código:

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

Esto hace que la mitad correcta sea más fácil; todo lo que necesitamos hacer es repetir  /varias veces:

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

Sugerencias bienvenidas!

GNU Sed, 59

La puntuación incluye +2 para las opciones '-nr' sed.

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

Ingrese en unario según esta meta respuesta .

Prueba de salida:

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

CJam, 36 35 34 bytes

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

Pruébalo en línea

Gracias a @NinjaBearMonkey por señalar el extra ;.

Si bien esto parece relativamente poco elegante, probé un par de otras opciones, y no terminaron más cortas.

Explicación:

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#}," "])&

Probablemente podría jugar más golf.

Java - 141 bytes

No es el más corto, por supuesto, pero es bueno tener una solución 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;}

Sin golf

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

Entrada

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

Salida

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

Pyth, 30 bytes

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

Probarlo aquí .

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 (también convertido a 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()));

Ruby, 50 bytes.

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

En programa de prueba:

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

El bucle imprime 2 filas para cada iteración de i = 0 a i = n-1.

La segunda fila siempre es '\'seguida por incidencias de '/ '.

La primera fila es la misma que la segunda fila de la iteración anterior, pero con la que '\'falta (por lo que almacenamos este valor scuando imprimimos la segunda fila de la iteración anterior).

La única excepción es la iteración cero, que se maneja inicializando sen '/\'*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+'\\/'}

¡Primera publicación aquí!

Solía ​​usar pero ahora usa , similar al de Ruby .Array(len).join(str) String.repeat(len)operator*(str,len)

Sin golf:

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

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

    return str + '\\/';
}

Gracias a:
107 => 104 bytes: @ inserciónusernamehere
97 => 90 bytes: @ user81655

Python 2, 66 bytes

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

Muy claro. El valor nes el número de /en la línea y bdice si la línea comienza con \. El valor de balterna entre 0 y 1, y ndisminuye cada segundo paso. La condición de terminación fea se detiene cuando n=1, b=0. La alternativa de un execbucle tendría el problema de necesitar muchos escapes "'\\\\'".

Me sorprendió encontrar este enfoque más corto que usar un solo número k=2*n+b. Esto es 68 bytes:

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

Una estrategia alternativa evitaría una separación printpara la línea superior, pero no vi una manera concisa.

Minkolang 0.14 , 46 bytes

Estoy seguro de que esto podría jugar golf, pero son las 4 am aquí y necesito ir a la cama.

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

Pruébalo aquí

Explicación

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

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

O si unary es aceptable, 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

Invocar con el número apropiado de 1s.

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

Dos soluciones de igual longitud.

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

y

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

Esto no es realmente competitivo con la solución Haskell existente porque ahorra 5 caracteres al devolver en lugar de imprimir una cadena. Lo publico solo para mostrar cómo el enfoque de patrón infinito se compara con el enfoque basado en coordenadas. Notas:

• p se puede alinear sin cambios de longitud.
• [t n l|(n,l)<-...]ahorra 2 más (map(uncurry t)$...).

Ceilán, 100

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

Esto presenta una "lista de argumentos con nombre" para join(sin ningún argumento con nombre, pero una comprensión iterable en su lugar), y varios usos String.repeat(uno de los cuales en realidad significa "incluir solo para impar i").

Formateado:

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

Asume que los avisos están desactivados y la entrada se toma de la línea de comando.

Sin golf:

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

Los comentarios son bienvenidos :)