Tutti i crediti per Adnan per aver affrontato questa sfida.

La mia ultima sfida, prima di andare in pausa .

Compito

Dato un numero intero positivo n, se nè dispari, ripeterlo /più volte; se nè pari, ripeterlo \più volte.

(Seriamente, i testcase sarebbero molto più chiari di questa descrizione, quindi basta guardare i testcase.)

Specifiche

• Qualsiasi ragionevole formato di input / output.
• Si applicano scappatoie standard .

Casi test

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

Javascript, 22 byte

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

Definisce una funzione anonima.

Se solo *ripetesse stringhe in Javascript. sospiri

Python, 20 byte

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

05AB1E / 2sable , 15 11 9 8 byte

DÈ„/\sè×

-2 byte grazie a Leaky Nun

-1 byte grazie a Emigna

Provalo online! in 05AB1E
o in 2sable

Perl, 20 byte

Include +1 per -p

Esegui con input su STDIN:

squigly.pl <<< 6

squigly.pl

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

Retina , 21

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

Provalo online (Prima riga aggiunta per consentire l'esecuzione di più testcase).

C #, 42 byte

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

Seleziona il carattere corretto, quindi crea una nuova stringa composta da quel carattere ripetuto più nvolte.

PHP, 38 byte

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

(variante 38 byte)

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

(variante 38 byte)

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

(variante 40 byte)

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

C, 40 byte

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

Provalo su Ideone

Gelatina , 5 byte

ị⁾/\x

Provalo online! oppure Verifica tutti i test.

ị⁾/\x

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

J, 10 byte

#'\/'{~2|]

Questo è un verbo a sei treni, composto da:

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

Questo è un gancio tra #e ('\/' {~ 2 | ]); un hook si (f g) yespande a y f (g y), quindi questo si espande a y # (... y), che, per i singoli caratteri, produce un elenco di ycaratteri.

La seconda parte è un treno 5, composto da:

'\/' {~ 2 | ]

Questo valuta due forcelle:

'\/' {~ (2 | ])

La forcella interna 2 | ], è il modulo due. La forcella esterna, quindi, è:

'\/' {~ mod2

Che prende ( {~) l'indice mod2 ( mod2) dalla stringa /.

Quindi, utilizzando il gancio dall'alto:

y # (apt char)

Questo produce ciò che vogliamo e abbiamo finito.

Haskell, 25 byte

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

-1 byte grazie a Damien con cycle.

Mathematica, 34 32 28 byte

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

Funzione anonima. Accetta un numero intero come input e restituisce un elenco di caratteri come output.

Powershell, 30 27 byte

Aggiornare:

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

Passare a param, grazie a timmyd .

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

o leggermente più leggibile

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

Test:

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

Mathematica, 29 byte

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

Crudelmente sfrutta il fatto che [[1]]restituisce il primo argomento di una funzione mentre [[0]]restituisce la funzione (head) stessa, applicata alla funzione stranamente valida denominata "\\"che viene "valutata" in "/".

Rubino, 15 byte

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

Guardalo su eval.in: https://eval.in/632030

Fourier, 27 byte

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

Provalo online!

Brachylog , 15 byte

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

Provalo online!

Spiegazione

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

ri_"\/"=*

Provalo online!

Spiegazione

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.

> <> (Pesce), 30 byte

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

La prima volta che utilizzo questo linguaggio, ma penso di aver almeno salvato un po 'di spazio usando condizionalmente / come parte dell'output o come mirror per reindirizzare il flusso. Probabilmente, comunque, terribilmente inefficiente, mi sembra che probabilmente potrebbe essere ridotto un po 'di più.

L'input è lo stack iniziale, l'output è stdout

Provalo online!

Dyalog APL , 11 byte

Richiede il ⎕IO←0valore predefinito su molti sistemi.

⊢⍴'\/'⊃⍨2|⊢

⊢ l'argomento

⍴ rimodella (ripetizioni)

'\/'⊃⍨ la stringa "/" selezionata da

2|⊢ il resto della divisione quando l'argomento è diviso per due

ProvaAPL online!

Java 7, 68 65 byte

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

3 byte salvati grazie a @ user902383 e @SeanBean .

Proprio come con questa risposta , il codice-golf più breve sembra essere ripetuto e stampato. Entrambi ricorsivi e
void c(int i){System.out.print(new String(new char[i]).replace("\0",i%2<1?"\\":"/"));}
sembrano essere più lunghi.

Codice non testato e test:

Provalo qui.

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

Produzione:

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

R, 47 46 byte

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

In R, devi sfuggire alle barre rovesciate. l'argomento sepdeve anche essere completamente specificato poiché viene dopo .... Quindi fastidiosamente poche opportunità per salvare i caratteri :(

Grazie a bouncyball per giocare a golf con un byte.

T-SQL 50 byte

Ovviamente no STDINqui, quindi supponiamo una INTvariabile hardcoded come questa: DECLARE @ INTquindi la soluzione è:

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

Pip , 8 byte

"\/"@aXa

Semplice. Utilizza l'indicizzazione modulare per selezionare la ripetizione di caratteri e stringhe per moltiplicarla. Provalo online!

Questa domanda presenta un interessante confronto tra Pip, Pyth e Jelly , i cui ultimi due hanno segnato 5 byte ciascuno. Tutti e tre i linguaggi hanno un output implicito, con operatori a carattere singolo per l'indicizzazione modulare e la ripetizione delle stringhe, e non è necessario evitare le barre rovesciate nelle stringhe. Esistono due differenze chiave, tuttavia:

1. In determinate circostanze, Pyth e Jelly necessitano di un solo delimitatore per definire una stringa;
2. Pyth e Jelly hanno una sintassi tale che l'input non ha bisogno di essere esplicitamente rappresentato nel codice (anche se per ragioni molto diverse, come mi ha spiegato Maltysen ).

Nessuna di queste funzionalità è probabile che appaia in Pip ¹ (non mi piace l'estetica dei delimitatori sbilanciati, e la sintassi senza punti o operandi impliciti sembrano essere troppo estranei al mio parser di espressioni infix), ma io ' va bene suonare il terzo violino. Anche se la "leggibilità" è estremamente relativa quando si gioca a golf, direi che quei tre byte extra rendono il programma Pip molto più facile da capire a colpo d'occhio - e nel mio libro, questo è un compromesso utile.

_{¹ Sebbene le stringhe a carattere singolo in Pip utilizzino un unico 'delimitatore, ispirato a CJam e citando in Lisp.}

Pyth , 5 byte

*@"\/

Suite di test.

Indicizzazione modulare nella stringa \/e quindi ripetere.

Perl 6 , 16 byte

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

Uso:

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

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

Julia, 20 byte

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

SpecBAS - 28 byte

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

ODDrestituisce 1 se il numero è dispari, quindi lo utilizza come indice per stampare il carattere corretto n numero di volte. È necessario aggiungere 1 poiché le stringhe SpecBAS iniziano dal carattere 1.

Java 8, 56 byte

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

Vorrei ringraziare @Kevin Cruijssen in anticipo per aver golf ulteriormente la mia risposta.

Programma di prova non golfato

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

In realtà, 10 byte

Suggerimenti di golf benvenuti. Provalo online!

;'\'/2(%I*

Come funziona

       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.