Todos los créditos a Adnan por venir con este desafío.

Mi último desafío, antes de irme de vacaciones .

Tarea

Dado un entero positivo n, si nes impar, repita /eso muchas veces; si nes par, repite \eso muchas veces.

(En serio, los casos de prueba serían mucho más claros que esta descripción, así que solo mire los casos de prueba).

Especificaciones

• Cualquier formato de entrada / salida razonable.
• Se aplican lagunas estándar .

Casos de prueba

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

Javascript, 22 bytes

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

Define una función anónima.

Si solo *repite cadenas en Javascript. suspiros

Python, 20 bytes

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

05AB1E / 2sable , 15 11 9 8 bytes

DÈ„/\sè×

-2 bytes gracias a Leaky Nun

-1 byte gracias a Emigna

Pruébalo en línea! en 05AB1E
o en 2sable

Perl, 20 bytes

Incluye +1 para -p

Ejecutar con entrada en STDIN:

squigly.pl <<< 6

squigly.pl

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

Retina , 21

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

Pruébelo en línea (se agregó la primera línea para permitir la ejecución de múltiples casos de prueba).

C #, 42 bytes

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

Selecciona el carácter correcto, luego crea una nueva cadena que consta de ese carácter repetidas nveces.

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

Pruébalo en Ideone

Jalea , 5 bytes

ị⁾/\x

Pruébalo en línea! o Verificar todas las cajas de prueba.

ị⁾/\x

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

J, 10 bytes

#'\/'{~2|]

Este es un verbo de seis trenes, que consiste en:

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

Este es un gancho entre #y ('\/' {~ 2 | ]); un gancho se (f g) yexpande a y f (g y), por lo que esto se expande a y # (... y), que, para caracteres únicos, produce una lista de ycaracteres.

La segunda parte es un tren de 5, que consiste en:

'\/' {~ 2 | ]

Esto se evalúa en dos tenedores:

'\/' {~ (2 | ])

La horquilla interna 2 | ], es el módulo dos. La horquilla exterior, por lo tanto, es:

'\/' {~ mod2

Que toma ( {~) el índice mod2 ( mod2) de la cadena /.

Luego, usando el gancho de arriba:

y # (apt char)

Esto produce lo que queremos, y hemos terminado.

Haskell, 25 bytes

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

-1 byte gracias a Damien con cycle.

Mathematica, 34 32 28 bytes

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

Función anónima. Toma un entero como entrada y devuelve una lista de caracteres como salida.

Powershell, 30 27 bytes

Actualizar:

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

Cambiando a param, gracias a timmyd .

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

o un poco más legible

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

Prueba:

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

Mathematica, 29 bytes

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

Explota cruelmente el hecho de que [[1]]devuelve el primer argumento de una función mientras [[0]]devuelve la función (cabeza) en sí, aplicada a la función extrañamente válida llamada "\\"que se está "evaluando" en "/".

Rubí, 15 bytes

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

Véalo en eval.in: https://eval.in/632030

Fourier, 27 bytes

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

Pruébalo en línea!

Brachylog , 15 bytes

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

Pruébalo en línea!

Explicación

: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_"\/"=*

Pruébalo en línea!

Explicación

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.

> <> (Pescado), 30 Bytes

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

La primera vez que uso este lenguaje, pero creo que al menos ahorré un poco de espacio al usar condicionalmente / como parte de la salida o un espejo para redirigir el flujo. Sin embargo, probablemente todavía sea terriblemente ineficiente, siento que probablemente podría reducirse un poco más como mínimo.

La entrada es la pila inicial, la salida es stdout

Pruébalo en línea!

Dyalog APL , 11 bytes

Requiere ⎕IO←0cuál es el predeterminado en muchos sistemas.

⊢⍴'\/'⊃⍨2|⊢

⊢ el argumento

⍴ remodela (se repite)

'\/'⊃⍨ la cadena "/" seleccionada por

2|⊢ el resto de la división cuando el argumento se divide por dos

TryAPL en línea!

Java 7, 68 65 bytes

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

3 bytes guardados gracias a @ user902383 y @SeanBean .

Al igual que con esta respuesta , el código de golf más corto parece recorrer e imprimir. Ambos recursivos y
void c(int i){System.out.print(new String(new char[i]).replace("\0",i%2<1?"\\":"/"));}
parecen ser más largos.

Ungolfed y código de prueba:

Pruébalo aquí.

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

Salida:

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

R, 47 46 bytes

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

En R, debes escapar de las barras invertidas. el argumento septambién debe especificarse por completo ya que viene después .... Por lo tanto, molestamente pocas oportunidades para guardar caracteres :(

Gracias a bouncyball por jugar golf un byte.

T-SQL 50 bytes

Por supuesto que no STDINaquí, así que supongamos una INTvariable codificada como esta: DECLARE @ INTentonces la solución es:

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

Pip , 8 bytes

"\/"@aXa

Sencillo. Utiliza indexación modular para seleccionar el carácter y la repetición de cadena para multiplicarlo. Pruébalo en línea!

Esta pregunta presenta una comparación interesante entre Pip, Pyth y Jelly , cada uno de los cuales tiene una puntuación de 5 bytes. Los tres idiomas tienen una salida implícita, con operadores de un solo carácter para la indexación modular y la repetición de cadenas, y no es necesario escapar de las barras diagonales inversas en las cadenas. Sin embargo, hay dos diferencias clave:

1. Bajo ciertas circunstancias, Pyth y Jelly solo necesitan un delimitador para definir una cadena;
2. Pyth y Jelly tienen una sintaxis tal que la entrada no necesita ser representada explícitamente en el código (aunque por razones muy diferentes, como me explicó Maltysen ).

Es probable que ninguna de estas características aparezca en el Pip ¹ (no me gusta la estética de los delimitadores desequilibrados, y la sintaxis sin puntos o los operandos implícitos parecen ser demasiado ajenos a mi analizador de expresiones infijo), pero yo Estoy de acuerdo con tocar el tercer violín. Aunque la "legibilidad" es extremadamente relativa cuando se juega al golf, diría que esos tres bytes adicionales hacen que el programa Pip sea mucho más fácil de entender de un vistazo, y en mi libro, eso es una compensación que vale la pena.

_{¹ Aunque, las cadenas de un solo carácter en Pip usan un solo 'delimitador, inspirado en CJam y citando en Lisp.}

Pyth , 5 bytes

*@"\/

Banco de pruebas.

Indización modular en la cadena \/y luego repetir.

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

ODDdevuelve 1 si el número es impar, luego lo usa como índice para imprimir el carácter correcto n veces. Debe agregar 1 ya que las cadenas de SpecBAS comienzan en el carácter 1.

Java 8, 56 bytes

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

Me gustaría agradecer a @Kevin Cruijssen de antemano por jugar más al golf mi respuesta.

Programa de prueba sin 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 realidad, 10 bytes

Sugerencias de golf bienvenidas. Pruébalo en línea!

;'\'/2(%I*

Cómo 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.