Le défi

En aussi peu de caractères que possible, recherchez la valeur de i ^ n, étant donné n, un entier positif supérieur à 0. Elle doit être sortie sous forme de chaîne.

Pour ceux qui ne le savent pas, i est défini tel que i ^ 2 = -1. Alors:

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

Cela se répète ensuite ..

Règles

• Si votre langue prend en charge les nombres complexes, n'utilisez aucune fonction ou arithmétique qui pourrait résoudre ce problème.
• Les inexactitudes en virgule flottante conviennent parfaitement aux réponses qui renverraient de toute façon des décimales, mais les entrées entières devraient donner des résultats exacts.

Points bonus

-5 si vous pouvez calculer la valeur où n est également négatif

-15 si vous pouvez calculer la valeur de n'importe quel nombre réel (ce bonus inclut le -5 du bonus ci-dessus)

Bonne chance!

Ruby, score -2

(13 octets, -15 en bonus)

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

Les fonctionnalités incluent: aucune erreur d'arrondi! (si vous passez l'entrée en tant que Rational)

posté par l'auteur, Kezz101

Si vous prenez en charge un nombre réel, vous pouvez sortir sous n'importe quelle forme complexe valide.

Les scores négatifs font monter mon adrénaline. Ainsi, les règles abusées sont utilisées pour atteindre ce noble objectif.

Crée une fonction anonyme et génère un tableau avec 2 entrées représentant un nombre complexe sous forme polaire (unité angulaire: degrés).

CJam, 12 caractères - 5 = 7

1'iW"-i"]li=

Testez-le ici.

Prend en charge les entrées négatives.

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

Le résultat est imprimé automatiquement à la fin du programme.

Mathematica, 22 20 19 caractères - 15 = 4

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

Ceci est une fonction anonyme, que vous pouvez utiliser comme

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

(Ou attribuez-le à fdire, puis faites f[15].)

Prend en charge les réels et donne des résultats exacts pour l'entrée entière.

Notez que le in'est pas le complexe i de Mathematica (qui l'est I). C'est juste une variable non définie.

De plus, malgré l'ordre de l'expression, Mathematica réorganisera la sortie sous R+Ciforme.

Python 2 - (24-5) = 19

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

La plupart des crédits appartiennent à @ user2357112, je viens de jouer sa réponse à partir des commentaires sur un peu plus cette réponse .

Explication: commence à l'index n%4de la chaîne '1i--'. Puis itère en arrière par étapes de deux sur chaque lettre de la chaîne. Ainsi, par exemple, n=6commencerait à l'index 2, le premier -, puis ignorerait iet prendrait le 1, pour revenir -1.

@xnor a souligné une solution de même longueur:

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

Pyth - (14-5) = 9

Je peux seulement sembler en avoir 14, peu importe comment j'essaye d'inverser / slice / etc. : «(

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

Ce qui est essentiellement le même que la réponse python ci-dessus, mais en 2 étapes, car pyth ne prend pas en charge les options d'indexation complètes de python. Essayez-le en ligne.

Je vais parler avec isaacg de l'indexation Pyth;)

TI-BASIC (NSpire) - 5 (20 caractères-15)

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

Si vous souhaitez recevoir une valeur de retour complexe, remplacez le ià la fin par (complexe i).

Marbelous , 43 octets

Pas vraiment gagnant, mais Marbelous est amusant. :)

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

Il s'agit d'un programme qui lit l'entrée comme un entier unique à partir du premier argument de ligne de commande. Notez que l'entrée est prise modulo 256, mais cela n'affecte pas la validité du résultat pour les entrées supérieures à 255, car 256 est divisible par 4.

Explication

Marbelous est un langage de programmation 2D, qui simule des "billes" (valeurs d'octets) tombant à travers un tas d'appareils. Le plateau est composé de cellules larges de 2 caractères (les appareils), qui peuvent traiter les billes. Tout ce qui tombe du bas d'une planche est imprimé sur STDOUT.

Passons en revue les appareils utilisés:

• }0est l'endroit où va le premier argument de ligne de commande. J'ai utilisé deux instances de cet appareil, donc j'obtiens deux copies de la valeur d'entrée (en même temps).
• ^nvérifie le nbit e de la bille d'entrée (où n=0est le bit le moins significatif), et produit 1ou en 0fonction du bit.
• =0vérifie l'égalité avec 0. Si la bille d'entrée est égale, elle tombe juste à travers, sinon elle est poussée vers la droite.
• \/ est une poubelle, donc elle avale simplement le marbre d'entrée et ne produit jamais rien.
• 2Dest le code ASCII de -, 31est le code ASCII de 1et 69est le code ASCII de i.
• Ce &nsont des synchroniseurs. Les synchroniseurs bloquent une bille jusqu'à ce que tous les synchroniseurs avec le même ntiennent une bille, à quel point ils laisseront tous leur bille stockée passer.

Donc, en fait, ce que je fais, c'est de conserver les trois caractères pertinents dans trois synchroniseurs, et de les libérer en fonction de la façon dont les bits les moins significatifs sont définis dans l'entrée.

Pour plus d'informations, voir le projet de spécification .

JavaScript (ES6) 29-5 = 24

Prend en charge la puissance négative.

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

ES5:

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

Python 28 octets - 5 = 23

Prend en charge les entrées -ve.

En supposant que les fonctions lambda sont acceptables (merci FryAmTheEggman!):

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

sinon 31 octets - 5 = 26

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

(Emacs) Lisp - 34

Juste pour le plaisir, en (Emacs) Lisp:

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

Si vous souhaitez l'utiliser, utilisez un defunou utilisez 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 caractères - 15 bonus = score -7

La fonction intégrée (et donc interdite) est 0J1*⊢ , mais elle utilise la méthode de @ blutorange .

¯12○.5×○

L'auteur du défi, Kezz101, a écrit :

Si vous prenez en charge un nombre réel, vous pouvez sortir sous n'importe quelle forme complexe valide.

Cela renvoie un nombre complexe sous la forme aJb qui est la manière normale pour APL d'afficher des nombres complexes.

Essayez-le en ligne!

Explication

¯12○ trouver le vecteur unitaire qui a l'angle en radians de

.5× une demi-fois

○ l'argument multiplié par 𝜋 (la constante du cercle)

Bash pur, 29 octets - 5 = 24

Prend en charge les entrées -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*' +,,@

Prend en charge les entiers négatifs. Ne va pas gagner de prix avec cette solution, mais peu importe.

Il accepte simplement un nombre en entrée, effectue une ruse sur le module (qui, frustrant, ne fonctionne pas comme le module habituel pour les nombres négatifs dans l'interpréteur que j'ai utilisé pour le tester) pour faire fonctionner les négatifs, puis fait des conditions idiotes pour décidez de ce que devrait être chaque personnage.

Je suis sûr que cela peut être approfondi. Pour l'instant, voici une autre solution qui n'accepte pas les négatifs, mais compense la perte du bonus en étant plus courte:

Befunge-98, 32 26 23

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

Modifier - Profite maintenant du fait que "-" est à 13 (0xd) caractères de "".

Edit 2 - Maintenant, encore une fois, profite du fait que "i" est à 56 (0x38 ou '8) caractères de "1".

Score Java 8: 72

À Java, le pire langage de golf de tous les temps! Golfé:

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

Étendu:

class Complex{

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

}

Remarque: je ne suis pas habitué à Java 8. Je n'ai pas encore d'exécution pour cela. Veuillez me dire s'il y a des erreurs de syntaxe. C'est aussi mon premier golf.

Modifier: supprimé import.

Edit: Déclaration de classe supprimée.

Une autre réponse avec score = 87 - 15 = 72

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

Étendu:

class Complex{

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

}

MATLAB, 33 octets - 5 = 28

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

Même si c'est quelques octets de plus (37-5 = 32), j'aime mieux cette approche:

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

Amélioré grâce à Ruslan

C 74-5 = 69

Oh et bien sûr l'approche la plus évidente

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

Ce n'est pas une solution primée, mais c'est la première fois que je joue au code, donc je ne suis pas exactement sûr de ce que je fais. J'ai essayé d'utiliser la correspondance de motifs, mais cela m'a fait dépasser 58.

Pari / GP , 19 octets - 5 = 14

En anneau, $\mathbb{C}$ est isomorphe à $\mathbb{R}[x]/(x^2+1)$.

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

L' iici n'est qu'un symbole, pas l'unité imaginaire (qui est Ien Pari / GP).

Essayez-le en ligne!

Rubis 32-5 = 27

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

Fonctionne pour les pouvoirs négatifs!

Perl, 26 - 5 = 21

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

fonctionne comme un programme autonome (argument sur la ligne de commande) ou le corps d'une fonction.

Java: 151 131-5 = 126

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

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

En fonction: 72-5 = 67

Golfé:

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

Non golfé:

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

Oui, encore une autre réponse Java - et a joué au golf encore pire que jamais. Mais vous travaillez avec ce que vous pouvez ...

EDIT : version de fonction ajoutée.

EDIT 2 : donc, après un peu d'essais et d'erreurs, voici une version qui essaie de le faire par le livre, sans explorer la faille du cycle. Alors…

Java avec calcul de valeur: 146-15 = 131

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

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

(au moins, je pense que je peux réclamer le meilleur bonus, corrigez-moi sinon)

Python - 31

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

Je n'ai commencé que récemment à apprendre le python. Même si je sais que ce n'est pas bon, c'est le mieux que je puisse faire.

Haskell GHCi, 29 octets - 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 octets

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

Essayez-le en ligne!

Identique à la plupart des méthodes ci-dessus, prend un modulo de 4 et l'augmente de 1, car les tableaux de R sont indexés sur 1. Fonctionne également pour les entiers négatifs.

J'étais préoccupé par les sorties mixtes ici, mais Giuseppe a souligné que R contraint les types numériques aux types de chaînes lorsqu'ils sont mixés.

PowerShell , 28 octets -5 = 23

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

Essayez-le en ligne!

Port de toute l'indexation cyclique

Haskell, 29 octets - 5 = 24

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

Fonctionne pour les pouvoirs négatifs.

J'avais une version sans point élaborée, mais il s'avère qu'elle est en fait plus longue.

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

Clojure ( 64 54 31 caractères)

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

modifier

Selon la suggestion de @ SeanAllred, voici une version qui utilise un vecteur littéral au lieu d'une casefonction:

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

Modifier 2

En comptant sur le REPL pour imprimer la collection résultante et en codant la fonction à l'aide du #()raccourci, nous pouvons la réduire à

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

(Ce qui est en fait beaucoup plus Clojure / Lisp-ish car la fonction retourne désormais le résultat généré, permettant à la fonction d'être utilisée avec map, comme dans

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

qui imprime

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

Partagez et profitez.

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)