Écrivez un programme ou une fonction qui accepte un entier positif N.

Lorsque N est 1, la sortie

/\
\/

Lorsque N est 2, sortie

/\/\
\/ /
/ /
\/

Lorsque N est 3, sortie

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

Lorsque N est 4, sortie

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

Pour un N plus grand, le motif continue, un nouveau calque est ajouté chaque fois que N est incrémenté.

• "Sortie" signifie imprimer le motif de barre oblique ou le renvoyer sous forme de chaîne.
• Une seule nouvelle ligne de fin dans la sortie est autorisée.
• Les espaces de fin dans la sortie sont autorisés mais pas les espaces de début.

Le code le plus court en octets gagne.

Pyth, 25 octets

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

Essayez-le en ligne: démonstration ou suite de tests

Explication:

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 octets

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

Testez-le ici.

J'essayais d'aider Reto à jouer sa réponse CJam, mais je me suis retrouvé avec une solution qui n'avait rien à voir avec la sienne, alors j'ai pensé que je pourrais aussi bien la poster moi-même.

Explication

Cela utilise la symétrie de la sortie. En particulier, le fait que la sortie soit la même que sa transposition.

Tout d'abord, nous générons les premières N+1lignes, mais sans le bord gauche:

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.

Nous avons maintenant un tableau de chaînes représentant la grille suivante:

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

La transposition de cela ressemble à ceci:

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

Ensemble, ils ont tous les caractères non spatiaux dont nous avons besoin. Nous pouvons maintenant utiliser la pointe rad de Dennis pour combiner deux grilles ASCII en une, en prenant le maximum de chaque paire de caractères correspondante. Dans toutes les positions où les deux grilles diffèrent, l'une aura un espace (ou rien du tout) et l'autre aura le personnage que nous recherchons. Lorsqu'une liste dans une opération vectorisée est plus longue que l'autre, les éléments supplémentaires de la liste plus longue seront simplement conservés, ce qui est exactement ce que nous recherchons. Dans les autres cas, le caractère non-espace sera toujours le maximum des deux caractères:

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

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

Essayez-le en ligne!

Non golfé et explication

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

Le noyau du programme fait une liste d' U * 2éléments, mappe chacun sur une ligne du motif, puis les joint à des retours à la ligne:

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.

Quant au motif lui-même, voici comment je l'ai décomposé:

/\/\/\/\

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

Comme vous pouvez le voir ici, cela se divise désormais en trois modèles simples. Le premier est le plus simple, généré avec ce code:

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

Maintenant pour la moitié gauche. Les indices impairs doivent correspondre à \/, et même à /, nous utilisons donc ce code:

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

Cela rend la droite à mi-chemin plus facile; il suffit de répéter  /plusieurs fois:

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

Bienvenue suggestions!

GNU Sed, 59

Le score inclut +2 pour les options '-nr' sed.

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

Entrez en unaire selon cette méta-réponse .

Sortie de test:

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

CJam, 36 35 34 octets

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

Essayez-le en ligne

Merci à @NinjaBearMonkey d'avoir souligné le supplément ;.

Bien que cela semble relativement inélégant, j'ai essayé quelques autres options, et elles n'ont pas été plus courtes.

Explication:

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 octets

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

Mathematica, 123 122 121 octets

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

Pourrait probablement être joué au golf plus loin.

Java - 141 octets

Pas le plus court bien sûr, mais agréable d'avoir une solution 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;}

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

Contribution

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

Sortie

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

Pyth, 30 octets

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

Essayez-le ici .

JavaScript, 128 125 123 114 octets

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 (également converti en ES5) + démo:

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

Rubis, 50 octets

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

En programme de test:

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

La boucle imprime 2 lignes pour chaque itération de i = 0 à i = n-1.

La deuxième ligne est toujours '\'suivie de ni incidences de '/ '.

La première ligne est la même que la deuxième ligne de l'itération précédente, mais avec le '\'manquant (nous stockons donc cette valeur dans slorsque nous imprimons la deuxième ligne de l'itération précédente.)

La seule exception est l'itération zéro, qui est gérée en initialisant sà '/\'*n.

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

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

Premier post ici!

Utilisé pour utiliser mais utilise maintenant , similaire à Ruby .Array(len).join(str) String.repeat(len)operator*(str,len)

Non golfé:

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

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

    return str + '\\/';
}

Merci à:
107 => 104 octets: @insertusernamehere
97 => 90 octets: @ user81655

Python 2, 66 octets

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

Assez simple. La valeur nest le nombre de /sur la ligne et bindique si la ligne commence par \. La valeur de balterne entre 0 et 1 et ndiminue toutes les deux étapes. La vilaine condition de terminaison s'arrête quand n=1, b=0. L'alternative d'une execboucle aurait le problème d'avoir besoin de beaucoup d'évasions pour "'\\\\'".

J'ai été surpris de trouver cette approche plus courte que d'utiliser un seul numéro k=2*n+b. C'est 68 octets:

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

Une stratégie alternative éviterait une séparation printpour la ligne supérieure, mais je ne voyais pas de manière concise.

Minkolang 0.14 , 46 octets

Je suis sûr que cela pourrait être joué au golf, mais il est 4 heures du matin ici et je dois aller me coucher.

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

Essayez-le ici.

Explication

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

Lot, 121 octets

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

Ou si unaire est acceptable, 107 octets:

@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

Appelez avec le nombre approprié de 1.

Matlab, 122 octets

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 octets

Deux solutions de longueur égale.

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

et

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

Ce n'est pas réellement compétitif par rapport à la solution Haskell existante car elle enregistre 5 caractères en retournant au lieu d'imprimer une chaîne. Je ne le poste que pour montrer comment l'approche du modèle infini se compare à l'approche basée sur les coordonnées. Remarques:

• p peut être aligné sans changement de longueur.
• [t n l|(n,l)<-...]sauve 2 de plus (map(uncurry t)$...).

Ceylan, 100

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

Cela comprend une "liste d'arguments nommés" pour join(sans aucun argument nommé, mais une compréhension itérable à la place), et plusieurs utilisations String.repeat(dont l'une signifie en fait "inclure uniquement pour les impaires").i ").

Formaté:

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

PHP, 117 octets

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

Suppose que les notifications sont désactivées et que la saisie provient de la ligne de commande.

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

Les commentaires sont les bienvenus :)