Tous les crédits à Adnan pour avoir relevé ce défi.

Mon dernier défi, avant de partir en pause .

Tâche

Étant donné un entier positif n, s'il nest impair, répétez /cela plusieurs fois; si nc'est pair, répétez \cela plusieurs fois.

(Sérieusement, les cas de test seraient beaucoup plus clairs que cette description, alors regardez simplement les cas de test.)

Spécifications

• Tout format d'entrée / sortie raisonnable.
• Des échappatoires standard s'appliquent.

Cas de test

n output
1 /
2 \\
3 ///
4 \\\\
5 /////
6 \\\\\\

Javascript, 22 octets

n=>"\\/"[n%2].repeat(n)

Définit une fonction anonyme.

Si seulement *des chaînes répétées en Javascript. soupire

Python, 20 octets

lambda n:'\/'[n%2]*n

05AB1E / 2sable , 15 11 9 8 octets

DÈ„/\sè×

-2 octets grâce à Leaky Nun

-1 octet grâce à Emigna

Essayez-le en ligne! en 05AB1E
ou en 2sable

Perl, 20 octets

Comprend +1 pour -p

Exécuter avec entrée sur STDIN:

squigly.pl <<< 6

squigly.pl

#!/usr/bin/perl -p
$_=$_%2x$_;y;01;\\/

Rétine , 21

.+
$*/
T`/`\\`^(..)+$

Essayez-le en ligne (première ligne ajoutée pour permettre l'exécution de plusieurs tests).

C #, 42 octets

string f(int n)=>new string("\\/"[n%2],n);

Sélectionne le caractère correct, puis crée une nouvelle chaîne composée de ce caractère répété plusieurs nfois.

PHP, 38 octets

for(;$i++<$a=$argv[1];)echo'\/'[$a%2];

(variante 38 octets)

while($i++<$a=$argv[1])echo'\/'[$a%2];

(variante 38 octets)

<?=str_pad('',$a=$argv[1],'\/'[$a%2]);

(variante 40 octets)

<?=str_repeat('\/'[($a=$argv[1])%2],$a);

C, 40 octets

i;f(n){for(i=n;i--;)putchar(n%2?47:92);}

Essayez-le sur Ideone

Gelée , 5 octets

ị⁾/\x

Essayez-le en ligne! ou Vérifiez tous les cas de test.

ị⁾/\x

ị⁾/\    modular-indexing into the string "/\"
    x   repeat

J, 10 octets

#'\/'{~2|]

Il s'agit d'un verbe à six trains, composé de:

# ('\/' {~ 2 | ])

Ceci est un crochet entre #et ('\/' {~ 2 | ]); un crochet se (f g) ydéveloppe en y f (g y), donc cela se développe en y # (... y), ce qui, pour les caractères uniques, produit une liste de ycaractères.

La deuxième partie est un 5 trains, composé de:

'\/' {~ 2 | ]

Cela équivaut à deux fourches:

'\/' {~ (2 | ])

La fourche intérieure,, 2 | ]est le module deux. La fourche extérieure est donc:

'\/' {~ mod2

Qui prend ( {~) l'index mod2 ( mod2) de la chaîne /.

Ensuite, en utilisant le crochet d'en haut:

y # (apt char)

Cela donne ce que nous voulons, et nous avons terminé.

Haskell, 25 octets

f n=cycle"\\/"!!n<$[1..n]

-1 octet merci à Damien avec cycle.

Mathematica, 34 32 28 octets

If[OddQ@#,"/","\\"]~Table~#&

Fonction anonyme. Prend un entier en entrée et renvoie une liste de caractères en sortie.

Powershell, 30 27 octets

Mise à jour:

param($n)('\','/')[$n%2]*$n

Passer à param, grâce à timmyd .

"$("\/"[$args[0]%2])"*$args[0]

ou légèrement plus lisible

("\","/")[$args[0]%2]*$args[0]

Tester:

> 1..10 | % { ./run.ps1 $_ }
/
\\
///
\\\\
/////
\\\\\\
///////
\\\\\\\\
/////////
\\\\\\\\\\

Mathematica, 29 octets

"\\"["/"][[#~Mod~2]]~Table~#&

Cruelly exploite le fait que [[1]]renvoie le premier argument d'une fonction tandis que [[0]]renvoie la fonction (head) elle-même, appliquée à la fonction étrangement valide nommée "\\"qui est "évaluée" à "/".

Rubis, 15 octets

->n{'\/'[n%2]*n}

Voir sur eval.in: https://eval.in/632030

Fourier, 27 octets

92~SI~N%2{1}{47~S}N(Sai^~i)

Essayez-le en ligne!

Brachylog , 15 octets

:2%:"\/"rm:?jbw

Essayez-le en ligne!

Explication

:2%                Input mod 2…
   :"\/"rm         …is the index of the element in string "\/",…
          :?j      …element that we juxtapose Input times to itself…
             bw    …and print to STDOUT after removing one slash/backslash

CJam , 9 octets

ri_"\/"=*

Essayez-le en ligne!

Explication

ri     e# Read input and convert to integer N.
_      e# Duplicate N.
"\/"=  e# Use N as cyclic index into "\/", giving '\ for even and '/ for odd inputs.
*      e# Repeat N times.

> <> (Poisson), 30 octets

:2%?'/'o1-:?!;30.
30.  >'\'50p

Première utilisation de ce langage, mais je pense qu'au moins j'ai économisé un peu de place en utilisant conditionnellement le / comme partie de la sortie ou un miroir pour rediriger le flux. Probablement encore horriblement inefficace, j'ai l'impression que cela pourrait probablement être réduit un peu plus au moins.

L'entrée est la pile initiale, la sortie est stdout

Essayez-le en ligne!

Dyalog APL , 11 octets

Requiert ⎕IO←0ce qui est par défaut sur de nombreux systèmes.

⊢⍴'\/'⊃⍨2|⊢

⊢ l'argument

⍴ remodèle (répète)

'\/'⊃⍨ la chaîne "/" sélectionnée par

2|⊢ le reste de la division lorsque l'argument est divisé par deux

TryAPL en ligne!

Java 7, 68 65 octets

void c(int i){for(int x=0;x++<i;)System.out.print(i%2<1?92:'/');}

3 octets enregistrés grâce à @ user902383 et @SeanBean .

Tout comme avec cette réponse , le code-golf le plus court semble boucler et s'imprimer. Les deux récursifs et
void c(int i){System.out.print(new String(new char[i]).replace("\0",i%2<1?"\\":"/"));}
semblent être plus longs.

Code non testé et testé:

Essayez-le ici.

class M{
  static void c(int i){
    for(int x = 0; x++ < i;){
      System.out.print(i % 2 < 1
                        ? 92
                        : '/');
    }
  }

  public static void main(String[] a){
    for(int i = 0; i < 10; i++){
      c(i);
      System.out.println();
    }
  }
}

Sortie:

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

R, 47 46 octets

n=scan();cat(rep(c("\\","/")[n%%2+1],n),sep="")

Dans R, vous devez échapper aux barres obliques inverses. l'argument sepdoit également être entièrement spécifié car il vient après .... Ainsi, peu d'occasions de sauver les caractères :(

Merci à bouncyball d'avoir joué un octet au golf.

T-SQL 50 octets

Bien sûr que non STDINici, supposons donc une INTvariable codée en dur comme ceci: DECLARE @ INTalors la solution est:

PRINT IIF(@%2=0,REPLICATE('\',@),REPLICATE('/',@))

Pip , 8 octets

"\/"@aXa

Simple. Utilise l'indexation modulaire pour sélectionner le caractère et la répétition de chaîne pour le multiplier. Essayez-le en ligne!

Cette question présente une comparaison intéressante entre Pip, Pyth et Jelly , les deux derniers ayant chacun marqué 5 octets. Les trois langues ont une sortie implicite, avec des opérateurs à caractère unique pour l'indexation modulaire et la répétition de chaînes, et aucune obligation d'échapper les barres obliques inverses dans les chaînes. Il existe cependant deux différences clés:

1. Dans certaines circonstances, Pyth et Jelly n'ont besoin que d'un délimiteur pour définir une chaîne;
2. Pyth et Jelly ont une syntaxe telle que l'entrée n'a pas besoin d'être explicitement représentée dans le code (bien que pour des raisons très différentes, comme Maltysen me l'a expliqué ).

Aucune de ces fonctionnalités ne devrait apparaître dans Pip ¹ (je n'aime pas l'esthétique des délimiteurs non équilibrés, et la syntaxe sans point ou les opérandes implicites semblent être trop étrangers à mon analyseur d'expression d'infixe), mais je '' m d'accord avec jouer le troisième violon. Même si la "lisibilité" est extrêmement relative lors du golf, je dirais que ces trois octets supplémentaires rendent le programme Pip beaucoup plus facile à comprendre en un coup d'œil - et dans mon livre, c'est un compromis valable.

_{¹ Bien que les chaînes à caractère unique dans Pip utilisent un seul 'délimiteur, inspiré de CJam et des citations en Lisp.}

Pyth , 5 octets

*@"\/

Suite de tests.

Indexation modulaire dans la chaîne \/, puis répétez.

Perl 6 , 16 octets

{<\ />[$_%2]x$_}

Usage:

for 1..6 {
  say $_, {<\ />[$_%2]x$_}( $_ )
}

1/
2\\
3///
4\\\\
5/////
6\\\\\\

Julia, 20 octets

!x="$("/\\"[x%2])"^x

SpecBAS - 28 octets

1 INPUT n: ?"\/"(ODD(n)+1)*n

ODDretourne 1 si le nombre est impair, puis l'utilise comme index pour imprimer le bon caractère n nombre de fois. Vous devez ajouter 1 car les chaînes SpecBAS commencent au caractère 1.

Java 8, 56 octets

(i,j)->{for(j=i;j-->0;)System.out.print(i%2<1?92:'/');};

Je voudrais remercier @Kevin Cruijssen à l'avance pour avoir approfondi ma réponse.

Programme de test non golfé

public static void main(String[] args) {
    BiConsumer<Integer, Integer> consumer = (i, j) -> {
        for (j = i; j-- > 0;) {
            System.out.print(i % 2 < 1 ? 92 : '/');
        }
    };

    consumer.accept(5, 0);
    consumer.accept(1, 0);
    consumer.accept(8, 0);
}

En fait, 10 octets

Suggestions de golf bienvenues. Essayez-le en ligne!

;'\'/2(%I*

Comment ça marche

       Implicit input of n
;      Duplicate n
'\'/   The strings "/" and "\"
2(%    n mod 2
I      If n mod 2, then "/", else "\"
*      Multiply by n. Implicit print at the end.