El reto

En el menor número de caracteres posible, encuentre el valor de i ^ n, dado n, un número entero positivo mayor que 0. Esto debería salir como una Cadena.

Para aquellos que no saben, i se define de modo que i ^ 2 = -1. Asi que:

• i ^ 1 = i
• i ^ 2 = -1
• i ^ 3 = -i
• i ^ 4 = 1

Esto luego se repite ..

Reglas

• Si su idioma admite números complejos, no use ninguna función o aritmética que pueda resolver esto.
• Las inexactitudes de punto flotante están bien para respuestas que de todas formas devolverían decimales, pero las entradas enteras deberían dar resultados exactos

Puntos extra

-5 si puedes calcular el valor donde n también es negativo

-15 si puede calcular el valor de cualquier número real (este bono incluye el -5 del bono anterior)

¡Buena suerte!

Ruby, puntaje -2

(13 bytes, -15 bonus)

->n{[1,90*n]}

Las características incluyen: sin errores de redondeo! (si pasa la entrada como un racional)

publicado por el autor, Kezz101

Si admite cualquier número real, puede generarlo en cualquier forma compleja válida.

Los puntajes negativos hacen que mi adrenalina se dispare. Por lo tanto, las reglas de abuso se utilizan para lograr este noble objetivo.

Crea una función anónima y genera una matriz con 2 entradas que representan un número complejo en forma polar (unidad angular: grados).

CJam, 12 caracteres - 5 = 7

1'iW"-i"]li=

Pruébalo aquí.

Admite entradas negativas.

1              "Push 1.";
 'i            "Push the character i.";
   W           "Push -1.";
    "-i"       "Push the string -i.";
        ]      "Wrap all four in an array.";
         li    "Read STDIN and convert to integer.";
           =   "Access array. The index is automatically taken module the array length.";

El resultado se imprime automáticamente al final del programa.

Mathematica, 22 20 19 caracteres - 15 = 4

Sin[t=π#/2]i+Cos@t&

Esta es una función anónima, que puede usar como

Sin[t=π#/2]i+Cos@t&[15]

(O asignarlo para fdecir, y luego hacer f[15]).

Admite reales y da resultados exactos para la entrada de enteros.

Tenga en cuenta que noi es el complejo i de Mathematica (que sí lo es ). Es solo una variable indefinida.I

Además, a pesar del orden de la expresión, Mathematica reordenará la salida en R+Ciforma.

Python 2 - (24-5) = 19

lambda n:'1i--'[n%4::-2]

La mayor parte del crédito pertenece a @ user2357112, acabo de leer un poco más su respuesta de los comentarios sobre esta respuesta .

Explicación: comienza en el índice n%4de la cadena '1i--'. Luego, itera hacia atrás en pasos de dos sobre cada letra de la cadena. Entonces, por ejemplo, n=6comenzaría en el índice 2, el primero -, luego omitiría iy tomaría el 1, para regresar -1.

@xnor señaló una solución de la misma longitud:

lambda n:'--i1'[~n%4::2] 

Pyth - (14-5) = 9

Parece que solo puedo obtener 14, no importa cómo intente revertir / cortar / etc. : '(

%_2<"1i--"h%Q4

Que es esencialmente lo mismo que la respuesta anterior de python, pero en 2 pasos, porque pyth no admite todas las opciones de indexación de python. Pruébalo en línea.

Voy a hablar con Isaac sobre la indexación Pyth;)

TI-BASIC (NSpire) - 5 (20 caracteres-15)

cos(nπ/2)+sin(nπ/2)i

Si desea recibir un valor de retorno complejo, reemplace ial final con (complejo i).

Maravilloso , 43 bytes

No es realmente un ganador, pero Marbelous es divertido. :)

}0
^0
=0&2
&1
}0
^1\/
=0&02D3169
\/\/&0&1&2

Este es un programa que lee la entrada como un entero entero del primer argumento de línea de comandos. Tenga en cuenta que la entrada se toma el módulo 256, pero esto no afecta la validez del resultado para entradas mayores que 255, porque 256 es divisible por 4.

Explicación

Marbelous es un lenguaje de programación 2D, que simula "canicas" (valores de bytes) que caen a través de un montón de dispositivos. El tablero está compuesto por celdas de 2 caracteres de ancho (los dispositivos), que pueden procesar las canicas. Todo lo que se cae del fondo de un tablero se imprime en STDOUT.

Veamos los dispositivos en uso:

• }0es donde va el primer argumento de la línea de comandos. He usado dos instancias de este dispositivo, por lo que obtengo dos copias del valor de entrada (al mismo tiempo).
• ^ncomprueba el nbit th de la canica de entrada (donde n=0es el bit menos significativo) y produce 1o 0depende del bit.
• =0comprueba la igualdad con 0. Si la canica de entrada es igual, simplemente cae directamente, si no es así, se empuja hacia la derecha.
• \/ es un bote de basura, por lo que se traga la canica de entrada y nunca produce nada.
• 2Des el código ASCII de -, 31es el código ASCII de 1y 69es el código ASCII de i.
• El &nson sincronizadores. Los sincronizadores detienen una canica hasta que todos los sincronizadores con la misma nsostienen una canica, en cuyo punto todos dejarán caer su canica almacenada.

En efecto, lo que hago es mantener los tres caracteres relevantes en tres sincronizadores y liberarlos dependiendo de cómo se establezcan los bits menos significativos en la entrada.

Para obtener más información, consulte el borrador de la especificación .

JavaScript (ES6) 29-5 = 24

Apoya el poder negativo.

f=n=>(n&2?'-':'')+(n&1?'i':1)

ES5:

function f(n){return (n&2?'-':'')+(n&1?'i':1)}

Python 28 bytes - 5 = 23

Admite entradas -ve.

Asumiendo que las funciones lambda son aceptables (¡Gracias FryAmTheEggman!):

lambda n:n%4/2*'-'+'1i'[n%2]

de lo contrario 31 bytes - 5 = 26

print[1,"i",-1,"-i"][input()%4]

(Emacs) Lisp - 34

Solo por diversión, en (Emacs) Lisp:

(lambda(n)(elt[1 i -1 -i](% n 4)))

Si desea usarlo, use a defuno use funcall:

(funcall
 (lambda (n) (elt [1 i -1 -i] (% n 4)))
 4) => 1

(mapcar
 (lambda(n)(elt[1 i -1 -i](% n 4)))
 [0 1 2 3 4 5 6 7 8])
 => (1 i -1 -i 1 i -1 -i 1)

APL (Dyalog) , 8 caracteres - 15 bonus = puntaje -7

La función incorporada (y por lo tanto prohibida) es 0J1*⊢, pero utiliza el método de @ blutorange .

¯12○.5×○

El autor del desafío, Kezz101, escribió :

Si admite cualquier número real, puede generarlo en cualquier forma compleja válida.

Esto devuelve un número complejo en la forma aJbque es la forma normal en que APL muestra números complejos.

Pruébalo en línea!

Explicación

¯12○ encontrar el vector unitario que tiene el ángulo en radianes de

.5× la mitad de las veces

○ el argumento multiplicado por 𝜋 (la constante del círculo)

Golpe puro, 29 bytes - 5 = 24

Admite entradas -ve.

a=(1 i -1 -i)
echo ${a[$1%4]}

Befunge-98, 41-5 = 36 35-5 = 30 32-5 = 27

&4%:01-`!4*+:2%'8*'1+\2/d*' +,,@

Soporta enteros negativos. No voy a ganar ningún premio con esta solución, pero lo que sea.

Simplemente acepta un número como entrada, hace algunos trucos en el módulo (que, frustrantemente, no funciona como el módulo habitual para números negativos en el intérprete que solía probar) para hacer que los negativos funcionen, y luego hace algunos condicionales tontos para decide cuál debe ser cada personaje.

Estoy seguro de que esto se puede jugar mucho más. Por ahora, aquí hay otra solución que no acepta negativos, pero compensa la pérdida del bono al ser más corto:

Befunge-98, 32 26 23

&4%:2%'8*'1+\2/d*' +,,@

Editar : ahora aprovecha el hecho de que "-" está a 13 (0xd) caracteres de "".

Edición 2 : ahora, nuevamente, aprovecha el hecho de que "i" está a 56 (0x38 o '8) caracteres de distancia de "1".

Puntuación Java 8: 72

¡En Java, el peor lenguaje de golf de todos los tiempos! Golfizado:

java.util.function.Function s=n->{new String[]{"i","-1","-i","1"}[n%4]};

Expandido:

class Complex{

    java.util.function.Function s = n -> {new String[]{"i","-1","-i","1"}[n%4]};

}

Nota: No estoy acostumbrado a Java 8. Tampoco tengo el tiempo de ejecución. Por favor, dime si hay algún error de sintaxis. Este es también mi primer golf.

Editar: eliminado import.

Editar: Se eliminó la declaración de clase.

Otra respuesta con puntaje = 87 - 15 = 72

java.util.function.Function s=n->{Math.cos(n*Math.PI/2)+"+"+Math.sin(n*Math.PI/2)+"i"};

Expandido:

class Complex{

    java.util.function.Function s = n -> {Math.cos(n * Math.PI/2) + " + " + Math.sin(n * Math.PI/2) + "i"};

}

MATLAB, 33 bytes - 5 = 28

x={'i','-1','-i','1'};x(mod(n,4))

Aunque son unos pocos bytes más (37-5 = 32), en realidad me gusta más este enfoque:

x='1i -';x((mod([n/2,n],2)>=1)+[3,1])

C 77

main(){int n;scanf("%d",&n);char c[]={n%4>1?'-':' ',~n%2?'1':'i',0};puts(c);}

Mejorado gracias a Ruslan

C 74-5 = 69

Ah, y por supuesto, el enfoque más obvio

main(){unsigned n,*c[]={"1","i","-1","-i"};scanf("%d",&n);puts(c[n%4]);}

OCAML 47

let m n=List.nth["1";"i";"-1";"-i"](n mod 4);;

No es una solución galardonada, pero esta es mi primera vez jugando al golf en código, así que no estoy exactamente seguro de lo que estoy haciendo. Traté de usar la coincidencia de patrones, pero eso me dio más de 58.

Pari / GP , 19 bytes - 5 = 14

Como un anillo $\mathbb{C}$ es isomorfo a $\mathbb{R}[x]/(x^2+1)$.

n->Str(i^n%(i^2+1))

El iaquí es solo un símbolo, no la unidad imaginaria (que está Ien Pari / GP).

Pruébalo en línea!

Rubí 32-5 = 27

puts(%w[1 i -1 -i][gets.to_i%4])

¡Funciona para poderes negativos!

Perl, 26 - 5 = 21

say qw(1 i -1 -i)[pop()%4]

funciona como un programa independiente (argumento en la línea de comandos) o el cuerpo de una función.

Java: 151 131-5 = 126

Golfizado:

class A{public static void main(String[]a){int n=Integer.parseInt(a[0]);System.out.print(n%4==0?"1":n%4==1?"i":n%4==2?"-1":"-i");}}

Sin golf:

class A {
    public static void main(String[] a) {
        int n = Integer.parseInt(a[0]);
        System.out.print(n % 4 == 0 ? "1" : n % 4 == 1 ? "i" : n % 4 == 2 ? "-1" : "-i");
    }
}

Como una función: 72-5 = 67

Golfizado:

void f(int n){System.out.print(n%4==0?"1":n%4==1?"i":n%4==2?"-1":"-i");}

Sin golf:

public void f(int n) {
    System.out.print(n % 4 == 0 ? "1" : n % 4 == 1 ? "i" : n % 4 == 2 ? "-1" : "-i");
}

Sí, otra respuesta más de Java, y jugó incluso peor que nunca. Pero trabajas con lo que puedes ...

EDITAR : versión de función agregada.

EDIT 2 : entonces, después de un poco de prueba y error, aquí hay una versión que intenta hacerlo por el libro, sin explorar la escapatoria del ciclo. Asi que…

Java con cálculo de valor: 146-15 = 131

Golfizado:

class B{public static void main(String[]a){float n=Float.parseFloat(a[0]);System.out.print(Math.cos((n*Math.PI)/2)+Math.sin((n*Math.PI)/2)+"i");}}

Sin golf:

class B {
    public static void main(String[] a) {
        float n = Float.parseFloat(a[0]);
        System.out.print(Math.cos((n * Math.PI) / 2) + Math.sin((n * Math.PI) / 2) + "i");
    }
}

(al menos, creo que puedo reclamar el bono superior, corrígeme de lo contrario)

Python - 31

print[1,'i',-1,'-i'][input()%4]

Hace poco comencé a aprender Python. Aunque sé que no es bueno, es lo mejor que puedo hacer.

Haskell GHCi, 29 Bytes - 15 = 14

i p=[cos(p*pi/2),sin(p*pi/2)]

Uso:

*Main> i 0
[1.0,0.0]
*Main> i pi
[0.22058404074969779,-0.9753679720836315]
*Main> i (-6.4)
[-0.8090169943749477,0.5877852522924728]

R , 29 - 5 = 24 bytes

c(1,"i",-1,"-i")[scan()%%4+1]

Pruébalo en línea!

Igual que la mayoría de los métodos anteriores, toma un módulo de 4 y lo aumenta en 1, porque las matrices de R están indexadas en 1. Funciona para enteros negativos también.

Estaba preocupado por las salidas mixtas aquí, pero Giuseppe señaló que R obliga a los tipos numéricos a los tipos de cadenas cuando se mezclan.

Potencia Shell , 28 bytes -5 = 23

('i',-1,'-i',1)["$args"%4-1]

Pruébalo en línea!

Puerto de toda la indexación cíclica.

Haskell, 29 bytes - 5 = 24

f n=words"1 i -1 -i"!!mod n 4

Funciona para poderes negativos.

Tuve una versión sin problemas, pero resultó que en realidad es más larga.

f=(words"1 i -1 -i"!!).(`mod`4)

Clojure ( 64 54 31 caracteres)

(defn i2n[n](println(case(mod n 4) 1 "i" 2 "-1" 3 "-i" 0 "1")))

Editar

Según la sugerencia de @ SeanAllred, aquí hay una versión que usa un vector literal en lugar de una casefunción:

(defn i2n[n](println (["1" "i" "-1" "-i"] (mod n 4))))

Editar 2

Al contar con REPL para imprimir la colección resultante y codificar la función utilizando el #()acceso directo, podemos reducirlo a

#(["1" "i" "-1" "-i"](mod % 4))

(Que en realidad es mucho más Clojure / Lisp-ish ya que la función ahora devuelve el resultado generado, permitiendo que la función se use con map , como en

(map #(["1" "i" "-1" "-i"](mod % 4)) [0 1 2 3 4 5 6 7 8])

que imprime

("1" "i" "-1" "-i" "1" "i" "-1" "-i" "1")

Comparte y Disfruta.

Groovy: 27-5 = 22

f={n->[1,'i',-1,'-i'][n%4]}

C 105, tenía 117

char c[2];
int main()
{
int n,i,j=0;scanf("%d",&n);i=n%4;
i>1?c[j++]='-':c[j+1]='\0';
c[j]=i&1?'i':'1';
puts(c);
}

PARI / GP , 26 - 5 = 21

n->Str([1,I,-1,-I][n%4+1])

n->cos(t=Pi*n/2)+I*sin(t)es un carácter más corto, pero no maneja respuestas exactas. Por supuesto n->I^n, no está permitido, y presumiblemente también PARI's powIs.

Gelatina , 2-20 = -18 bytes

ı*

Pruébalo en línea!

No utiliza una i ^ xorden interna pero utiliza órdenes internas para 1jy **así que no sé si está permitido.

05AB1E , puntaje 5 (10 bytes - 5 bonus)

'i®„-i1)Iè

Pruébelo en línea o verifique algunos casos de prueba más .

Explicación:

'i         '# Push character "i"
  ®         # Push -1
   „-i      # Push string "-i"
      1     # Push 1
       )    # Wrap everything on the stack into a list: ["i", -1, "-i", 1]
        Iè  # Use the input to index into it (0-based and with automatic wrap-around)
            # (and output the result implicitly)