La sfida

Nel minor numero di caratteri possibile, trova il valore di i ^ n, dato n, un numero intero positivo maggiore di 0. Questo dovrebbe essere emesso come una stringa.

Per quelli che non lo sanno, i è definito in modo tale che i ^ 2 = -1. Così:

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

Questo quindi ripete ..

Regole

• Se la tua lingua supporta numeri complessi, non utilizzare alcuna funzione o aritmetica che possa risolverlo.
• Le imprecisioni in virgola mobile vanno bene per le risposte che restituirebbero comunque decimali, ma gli input interi dovrebbero fornire risultati esatti

Punti bonus

-5 se riesci a capire il valore dove n è anche negativo

-15 se riesci a calcolare il valore per qualsiasi numero reale (questo bonus include il -5 dal bonus sopra)

In bocca al lupo!

Rubino, punteggio -2

(13 byte, -15 bonus)

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

Le caratteristiche includono: nessun errore di arrotondamento! (se si passa l'input come Rational)

pubblicato dall'autore, Kezz101

Se si supporta un numero reale, è possibile produrre in qualsiasi forma complessa valida.

I punteggi negativi fanno esplodere la mia adrenalina. Quindi le regole vengono abusate vengono utilizzate per raggiungere questo nobile obiettivo.

Crea una funzione anonima e genera un array con 2 voci che rappresentano un numero complesso in forma polare (unità angolare: gradi).

CJam, 12 caratteri - 5 = 7

1'iW"-i"]li=

Provalo qui.

Supporta input negativi.

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.";

Il risultato viene stampato automaticamente alla fine del programma.

Mathematica, 22 20 19 caratteri - 15 = 4

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

Questa è una funzione anonima, che puoi usare come

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

(O assegnalo per fdire, e poi fallo f[15].)

Supporta reali e fornisce risultati esatti per l'input di numeri interi.

Nota che noni è il complesso i di Mathematica (che èI ). È solo una variabile indefinita.

Inoltre, nonostante l'ordine dell'espressione, Mathematica riordinerà l'output nella R+Ciforma.

Python 2 - (24-5) = 19

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

La maggior parte del merito appartiene a @ user2357112, ho appena giocato un po 'di più alla sua risposta dai commenti su questa risposta .

Spiegazione: Inizia dall'indice n%4nella stringa '1i--'. Quindi scorre all'indietro a passi di due su ogni lettera nella stringa. Quindi, per esempio, n=6inizierebbe dall'indice 2, il primo -, quindi salterà ie prenderà 1, per tornare -1.

@xnor ha sottolineato una soluzione della stessa lunghezza:

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

Pyth - (14-5) = 9

Posso solo sembrare di ottenere 14, indipendentemente da come provo a invertire / tagliare / ecc. : '(

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

Che è essenzialmente lo stesso della risposta python sopra, ma in 2 passaggi, perché pyth non supporta le opzioni di indicizzazione complete di python. Provalo online.

Vado a parlare con isaacg dell'indicizzazione Pyth;)

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

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

Se si desidera ricevere un valore di ritorno complesso, sostituire ialla fine con (complesso i).

Marbelous , 43 byte

Non proprio un vincitore, ma Marbelous è divertente. :)

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

Questo è un programma che legge l'input come singolo intero dal primo argomento della riga di comando. Si noti che l'input è preso modulo 256, ma ciò non influisce sulla validità del risultato per input superiori a 255, perché 256 è divisibile per 4.

Spiegazione

Marbelous è un linguaggio di programmazione 2D, che simula "marmi" (valori di byte) che cadono attraverso un gruppo di dispositivi. La scheda è composta da celle larghe a 2 caratteri (i dispositivi), che possono elaborare i marmi. Tutto ciò che cade dal fondo di una tavola viene stampato su STDOUT.

Esaminiamo i dispositivi in ​​uso:

• }0è dove va il primo argomento della riga di comando. Ho usato due istanze di questo dispositivo, quindi ottengo due copie del valore di input (contemporaneamente).
• ^ncontrolla il nth bit del marmo di input (dove n=0è il bit meno significativo) e produce 1o 0dipende dal bit.
• =0verifica l'uguaglianza con 0. Se il marmo di input è uguale, passa semplicemente attraverso, se non lo è viene spinto a destra.
• \/ è un cestino, quindi ingoia solo il marmo di input e non produce mai nulla.
• 2Dè il codice ASCII di -, 31è il codice ASCII di 1ed 69è il codice ASCII di i.
• L' &nsono sincronizzatori. I sincronizzatori bloccano un marmo fino a quando tutti i sincronizzatori con lo stesso ntengono un marmo, a quel punto lasceranno cadere tutti i loro marmi immagazzinati.

Quindi, in effetti, ciò che faccio è mantenere i tre caratteri rilevanti in tre sincronizzatori e rilasciarli a seconda di come sono impostati i bit meno significativi nell'input.

Per ulteriori informazioni, consultare la bozza delle specifiche .

JavaScript (ES6) 29-5 = 24

Supporta potenza negativa.

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

ES5:

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

Python 28 byte - 5 = 23

Supporta input -ve.

Supponendo che le funzioni lambda siano accettabili (grazie FryAmTheEggman!):

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

altrimenti 31 byte - 5 = 26

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

(Emacs) Lisp - 34

Solo per divertimento, in (Emacs) Lisp:

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

Se vuoi usarlo, usa a defuno usa 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 caratteri - 15 bonus = punteggio -7

La funzione integrata (e quindi proibita) è 0J1*⊢, ma utilizza il metodo di @ blutorange .

¯12○.5×○

L'autore della sfida, Kezz101, ha scritto :

Se si supporta un numero reale, è possibile produrre in qualsiasi forma complessa valida.

Ciò restituisce un numero complesso nella forma aJbche è il modo normale per APL di visualizzare numeri complessi.

Provalo online!

Spiegazione

¯12○ trova il vettore unitario che ha l'angolo in radianti di

.5× mezzo volte

○ l'argomento moltiplicato per 𝜋 (la costante del cerchio)

Bash puro, 29 byte - 5 = 24

Supporta input -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*' +,,@

Supporta numeri interi negativi. Non vinceremo alcun premio con questa soluzione, ma qualunque cosa.

Accetta solo un numero come input, fa qualche trucco sul modulo (che, frustrantemente, non funziona come il solito modulo per i numeri negativi nell'interprete che ho usato per testarlo) per far funzionare i negativi, e poi fa alcuni sciocchi condizionali per decidere cosa dovrebbe essere ogni personaggio.

Sono sicuro che questo può essere ulteriormente risolto. Per ora, ecco un'altra soluzione che non accetta i negativi, ma compensa la perdita del bonus essendo più breve:

Befunge-98, 32 26 23

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

Modifica - Ora sfrutta il fatto che "-" è 13 (0xd) caratteri da "".

Modifica 2 - Ora, ancora una volta, sfrutta il fatto che "i" è a 56 (0x38 o '8) caratteri da "1".

Punteggio Java 8: 72

In Java, il peggior linguaggio del golf di sempre! golfed:

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

Allargato:

class Complex{

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

}

Note: I'm not used to Java 8. I also do not have the runtime for it yet. Please tell me if there are any syntax errors. This is also my first golf.

Edit: Removed import.

Edit: Removed class declaration.

Another answer with score = 87 - 15 = 72

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

Expanded:

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

Even though it's a few bytes more (37-5=32), I actually like this approach better:

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

Improved thanks to Ruslan

C 74-5=69

Oh and of course the most obvious approach

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

Not an award winning solution, but this is my first time code-golfing, so I'm not exactly sure of what I'm doing. I tried to use pattern matching, but that got me over 58.

Pari/GP, 19 bytes - 5 = 14

As a ring, $\mathbb{C}$ is isomorphic to $\mathbb{R}[x]/(x^2+1)$.

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

The i here is just a symbol, not the imaginary unit (which is I in Pari/GP).

Try it online!

Ruby 32-5=27

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

Works for negative powers!

Perl, 26 - 5 = 21

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

works as a standalone program (argument on the commandline) or the body of a function.

Java: 151 131-5=126

Golfed:

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

Ungolfed:

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

As a function: 72-5=67

Golfed:

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

Ungolfed:

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

Yes, yet another Java reply - and golfed even worse than ever. But you work with what you can...

EDIT: added function version.

EDIT 2: so, after a bit of trial and error, here's a version that tries to do it by the book, without exploring the cycle loophole. So…

Java with value calculation: 146-15=131

Golfed:

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

Ungolfed:

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

(at least, I think I can claim the top bonus, correct me otherwise)

Python - 31

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

I have only recently started learning python. Even though I know it's not good, it's the best I can do.

Haskell GHCi, 29 Bytes - 15 = 14

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

Usage:

*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]

Try it online!

Same as most methods above, takes a modulo of 4, and increases that by 1, because R's arrays are 1-indexed. Works for negative integers as well.

I was worried about mixed outputs here, but Giuseppe pointed out that R coerces numeric types to string types when they are mixed.

PowerShell, 28 bytes -5 = 23

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

Try it online!

Port of all the cyclic indexing

Haskell, 29 bytes - 5 = 24

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

Works for negative powers.

I had a pointfree version worked out, but it turns out it's actually longer.

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

Clojure (64 54 31 chars)

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

Edit

Per @SeanAllred's suggestion, here's a version which uses a literal vector instead of a case function:

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

Edit 2

By counting on the REPL to print out the resultant collection and coding the function using the #() shortcut we can reduce it to

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

(Which is actually much more Clojure/Lisp-ish as the function now actually returns the generated result, allowing the function to be used with map, as in

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

which prints

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

Share and enjoy.

Groovy: 27-5 = 22

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

C 105, was 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) is one character shorter, but doesn't handle exact answers. Of course n->I^n is disallowed, and presumably also PARI's powIs.

Jelly, 2 - 20 = -18 bytes

ı*

Try it online!

It doesn't use an i ^ x builtin but it uses builtins for 1j and ** so not sure if allowed.

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

'i®„-i1)Iè

Try it online or verify some more test cases.

Explanation:

'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)