Todos os créditos para Adnan por ter vindo com esse desafio.

Meu último desafio, antes que eu pare .

Tarefa

Dado inteiro positivo n, se nfor ímpar, repita /isso muitas vezes; se nfor par, repita \isso várias vezes.

(Sério, os casos de teste seriam muito mais claros do que esta descrição, basta olhar para os casos de teste.)

Especificações

• Qualquer formato de entrada / saída razoável.
• Aplicam-se brechas padrão .

Casos de teste

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

Javascript, 22 bytes

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

Define uma função anônima.

Se apenas *strings repetidas em Javascript. suspiros

Python, 20 bytes

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

05AB1E / 2sable , 15 11 9 8 bytes

DÈ„/\sè×

-2 bytes graças a Leaky Nun

-1 byte graças a Emigna

Experimente online! em 05AB1E
ou em 2sable

Perl, 20 bytes

Inclui +1 para -p

Execute com entrada no STDIN:

squigly.pl <<< 6

squigly.pl

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

Retina , 21

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

Experimente on-line (primeira linha adicionada para permitir a execução de vários casos de teste).

C #, 42 bytes

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

Seleciona o caractere correto e cria uma nova sequência que consiste nesse caractere repetidas nvezes.

PHP, 38 bytes

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

(variante 38 bytes)

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

(variante 38 bytes)

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

(variante 40 bytes)

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

C, 40 bytes

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

Experimente no Ideone

Gelatina , 5 bytes

ị⁾/\x

Experimente online! ou Verifique todas as caixas de teste.

ị⁾/\x

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

J, 10 bytes

#'\/'{~2|]

Este é um verbo de seis trens, composto por:

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

Este é um gancho entre #e ('\/' {~ 2 | ]); um gancho se (f g) yexpande para y f (g y), então isso se expande para y # (... y), o qual, para caracteres únicos, gera uma lista de ycaracteres.

A segunda parte é um trem de 5 trens, consistindo em:

'\/' {~ 2 | ]

Isso avalia dois garfos:

'\/' {~ (2 | ])

O garfo interno,, 2 | ]é o módulo dois. O garfo externo, portanto, é:

'\/' {~ mod2

Que pega ( {~) o índice mod2 ( mod2) da string /.

Em seguida, usando o gancho de cima:

y # (apt char)

Isso produz o que queremos e terminamos.

Haskell, 25 bytes

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

-1 byte graças a Damien com cycle.

Mathematica, 34 32 28 bytes

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

Função anônima. Pega um número inteiro como entrada e retorna uma lista de caracteres como saída.

Powershell, 30 27 bytes

Atualizar:

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

Mudando para param, graças a timmyd .

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

ou um pouco mais legível

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

Teste:

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

Mathematica, 29 bytes

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

Cruelmente explora o fato de que [[1]]retorna o primeiro argumento de uma função enquanto [[0]]retorna a própria função (cabeça), aplicada à função estranhamente válida chamada na "\\"qual está sendo "avaliada" em "/".

Ruby, 15 bytes

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

Veja-o em eval.in: https://eval.in/632030

Fourier, 27 bytes

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

Experimente online!

Braquilog , 15 bytes

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

Experimente online!

Explicação

: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 bytes

ri_"\/"=*

Experimente online!

Explicação

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.

> <> (Peixe), 30 bytes

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

Primeira vez usando esse idioma, mas acho que pelo menos economizei um pouco de espaço usando condicionalmente o / como parte da saída ou um espelho para redirecionar o fluxo. Provavelmente ainda terrivelmente ineficiente, eu sinto que provavelmente poderia ser reduzido um pouco mais, pelo menos.

Entrada é a pilha inicial, saída é stdout

Experimente online!

Dyalog APL , 11 bytes

Requer ⎕IO←0qual é o padrão em muitos sistemas.

⊢⍴'\/'⊃⍨2|⊢

⊢ o argumento

⍴ remodelar (repetições)

'\/'⊃⍨ a sequência "/" selecionada por

2|⊢ a divisão restante quando o argumento é dividido por dois

TryAPL online!

Java 7, 68 65 bytes

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

3 bytes salvos graças a @ user902383 e @SeanBean .

Assim como nesta resposta , o código de golfe mais curto parece circular e imprimir. Recursivo e
void c(int i){System.out.print(new String(new char[i]).replace("\0",i%2<1?"\\":"/"));}
parece ser mais longo.

Ungolfed & código de teste:

Experimente aqui.

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

Saída:

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

R, 47 46 bytes

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

Em R, você precisa escapar de barras invertidas. o argumento septambém precisa ser totalmente especificado, pois vem depois .... Assim, irritantemente poucas oportunidades para salvar caracteres :(

Graças ao bouncyball por jogar fora um byte.

T-SQL 50 bytes

Claro que não STDINaqui, então vamos assumir uma INTvariável codificada como esta: DECLARE @ INTentão a solução é:

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

Pip , 8 bytes

"\/"@aXa

Direto. Utiliza indexação modular para selecionar a repetição de caracteres e seqüências para multiplicá-lo. Experimente online!

Esta pergunta apresenta uma comparação interessante entre Pip, Pyth e Jelly , os dois últimos com 5 bytes. Todos os três idiomas têm saída implícita, com operadores de caractere único para indexação modular e repetição de cadeias, e nenhum requisito para escapar de barras invertidas nas cadeias. Existem duas diferenças principais, no entanto:

1. Sob certas circunstâncias, Pyth e Jelly precisam de apenas um delimitador para definir uma string;
2. Pyth e Jelly têm uma sintaxe tal que a entrada não precisa ser explicitamente representada no código (embora por razões muito diferentes, como Maltysen me explicou ).

É provável que nenhum desses recursos apareça no Pip ¹ (não gosto da estética de delimitadores desequilibrados, e sintaxe sem pontos ou operandos implícitos parecem que seriam muito estranhos ao meu analisador de expressões infix), mas eu ' estou bem em tocar terceiro violino. Mesmo que a "legibilidade" seja extremamente relativa no golfe, eu argumentaria que esses três bytes extras tornam o programa Pip muito mais fácil de entender de relance - e, no meu livro, essa é uma troca interessante.

_{¹ Embora, cadeias de caracteres únicos no Pip usem um único 'delimitador, inspirado no CJam e citando no Lisp.}

Pitão , 5 bytes

*@"\/

Suíte de teste.

Indexação modular na string \/e repita.

Perl 6 , 16 bytes

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

Uso:

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

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

Julia, 20 bytes

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

SpecBAS - 28 bytes

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

ODDretorna 1 se o número for ímpar e o usa como índice para imprimir o caractere correto n número de vezes. É necessário adicionar 1, pois as cadeias SpecBAS começam no caractere 1.

Java 8, 56 bytes

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

Gostaria de agradecer a @Kevin Cruijssen em avançado por jogar minha resposta ainda mais.

Programa de Teste Ungolfed

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

Na verdade, 10 bytes

Sugestões de golfe são bem-vindas. Experimente online!

;'\'/2(%I*

Como funciona

       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.