Trouver i ^ n, étant donné n

27

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!

Kezz101
la source
1
Dans quel format retournons-nous exactement? Par sortie de fonction ou sortie standard?
fier haskeller
@proudhaskeller Le wiki wiki répertorie les valeurs par défaut pour cela. Sauf indication contraire, les fonctions et les programmes sont corrects, saisis via un argument de fonction, STDIN ou un argument de ligne de commande et sortis via STDOUT ou une valeur de retour de fonction. Il n'est pas nécessaire de nommer les fonctions.
Martin Ender
1
@ MartinBüttner mais si je choisis la sortie de fonction, comment la sortie doit-elle être formatée / stockée sans nombres complexes natifs dans ma langue?
fier haskeller
16
@BetaDecay Que sont les entiers à virgule flottante? oO
Martin Ender
2
@ MartinBüttner Haha mauvais mot: / Numéro à virgule flottante alors
Beta Decay

Réponses:

15

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

blutorange
la source
4
"Ruby, -2 octets" .....
FantaC
3
Alors, le téléchargement de ce million de millions de fois me donne-t-il 2 To d'espace libre sur le disque dur? Ca me parait être une bonne affaire.
Programmes Redwolf
^ Mon navigateur est tombé en panne avant que je ne réussisse. Peut-être essayer une "bombe zip" avec le fichier à l'intérieur? (Son extraction permet d'économiser de l'espace.)
A̲̲
15

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.

Martin Ender
la source
Vous n'en avez pas besoin 4%. Cela peut être fait automatiquement.
jimmy23013
@ user23013 nifty :)
Martin Ender
8
Les deux réponses ne devraient-elles pas être séparées?
Justin
@Quincunx Peut-être ... à l'origine, ils étaient tous les deux dans CJam, c'est pourquoi je les ai mis dans la même réponse. Mais le second n'était pas valide, donc je l'ai porté sur Mathematica, mais je l'ai laissé où il était. Si les gens insistent, je peux les diviser.
Martin Ender
Et vous pouvez enregistrer un personnage en l'utilisant avec f@15au lieu de f[15].
orome
14

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

FryAmTheEggman
la source
Le python lambdan'a- t-il pas besoin d'être affecté à une variable? À tout le moins, pour l'appeler, vous devez l'entourer de parenthèses, en ajoutant deux octets pour qu'il puisse être appelé (lambda...)(n).
mbomb007
@ mbomb007 Selon la méta, c'est acceptable. Le code ici crée une fonction qui exécute la tâche requise. Les lambdas anonymes sont utilisés relativement fréquemment en python pour des fonctions comme mapet sorted.
FryAmTheEggman
11

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

Shujal
la source
@ MartinBüttner TI-Basic semble utiliser une sorte de type «Expression», et les méthodes intégrées renvoient des résultats exacts pour celles-ci.
Shujal
Je vois, tout va bien alors. ;)
Martin Ender
Qu'en est-il de la règle "Si votre langue prend en charge les nombres complexes, n'utilisez aucune fonction ou arithmétique qui pourrait résoudre ce problème." + i est arithmétique
edc65
@ edc65 Le + est en fait une opération complexe. Cependant, si vous n'aimez pas cela, remplacez le par un normal i. Si la variable in'est pas définie, vous obtiendrez le nombre complexe, juste avec iau lieu de . Je calcule simplement les parties réelles et imaginaires séparément.
Shujal
1
@Shujal Dans ce cas, je pense que vous devriez utiliser iquand même. Le complexe i n'est même pas le caractère demandé par la question, et cela vous fera économiser deux octets, donc vous seriez au moins à égalité avec moi;).
Martin Ender
7

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 .

Martin Ender
la source
1
J'aime vraiment celle-ci! Marbelous sonne fabuleux, je vais devoir le vérifier très bientôt :)
Kezz101
3
@ Kezz101 Nous avons un projet de spécifications ici
Martin Ender
Oh sympa! Ça a l'air vraiment intéressant
Kezz101
N'oubliez pas que vous pouvez donner des entrées à la carte principale sur la ligne de commande, afin que cette carte puisse être utilisée telle quelle.
Sparr
1
@overactor Hm, je ne sais pas ... la sortie de caractères supplémentaires (même s'ils ne sont pas imprimables) semble toujours violer le format de sortie pour moi. Cela pourrait valoir une méta-question.
Martin Ender
6

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)}
Michael M.
la source
Oui, plus court ( f=n=>[1,'i',-1,'-i'][n%4]). Mais c'est moins sexy et il ne supportera pas les pouvoirs négatifs. Cela dépend du bonus je suppose.
Michael M.
Non, 29 octets. Les négatifs sont pris en charge avec ce code.
Michael M.
Est-ce que JS a un bit & opérateur au niveau du ? Si c'est le cas, vous pouvez le faire &3pour une véritable opération module-4. Edit: on dirait qu'il fait ce qui &2est utilisé dans votre réponse ...
feersum
5

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]
Traumatisme numérique
la source
1
Vous ne pouvez pas l'appeler exactement. Vous devez le stocker dans un endroit accessible. Vous pouvez donc faire foo=..., ou vous pouvez faire map(<your lambda>,range(10))pour obtenir une liste de valeurs de i^nfrom 0-9.
FryAmTheEggman
2
Fondamentalement, vous
créez
3
@DigitalTrauma: Oui, bien que vous puissiez peut-être faire mieux avec des astuces pour trancher les cordes. Par exemple lambda n:'--1i'[n%4-2::2],.
user2357112 prend en charge Monica
2
Pour traduire le message de user2357112: Supprimez tous les autres caractères à '--1i'partir de l'index n%4-2. Lorsque python obtient un index négatif, il commencera autant de positions restantes à partir de la fin du tableau, puis montera jusqu'à 0. De cette façon, 0et1 ne frappe jamais les -signes, tout 3et 4faire.
FryAmTheEggman
1
lambda n:n%4/2*'-'+'1i'[n%2] Supprime l'espace et est plus court :)
FryAmTheEggman
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)
Sean Allred
la source
4

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)

Adam
la source
3

Bash pur, 29 octets - 5 = 24

Prend en charge les entrées -ve.

a=(1 i -1 -i)
echo ${a[$1%4]}
Traumatisme numérique
la source
3

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

Kasran
la source
3

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

}
Le numéro un
la source
Vous pouvez en sauvegarder avec "import java.util. *"
Anubian Noob
@Anubian Fonction Noob classe est dans le paquet java.util.functionnon java.util(ou je me trompe?).
TheNumberOne
Mais si vous faites java.util.*le .*moyen tout à l'importation dans le cadre du paquet. Tout comme vous importez actuellement toutes les classes du fuctionpackage.
Anubian Noob
5
@ Anubian Noob importimporte uniquement les classes de ce package. Il n'importe aucune des classes des packages de ce package. Par exemple, la classe Functionest dans le package java.util.functionmais pas dans le package java.util.
TheNumberOne
Oh mon mauvais, désolé pour ça.
Noob anubien
3

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])
Stewie Griffin
la source
i^3est -i, plutôt que i, suppose qu'il ajoute juste 1 caractère. - Sidenote pour les autres lecteurs: sans la première règle du défi, la solution Matlab ne compterait que 3 caractères.
Dennis Jaheruddin
Oui, c'était une faute de frappe. Fixé! Merci d'avoir remarqué ... Au moins la deuxième approche (un peu plus intéressante) est correcte =)
Stewie Griffin
3

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]);}
Rames
la source
2
Vous pouvez supprimer les parenthèses autour n%2et les utiliser ~au lieu de !parce que la négation en npremier, puis %ing avec 2 donnera le même résultat, au moins pour n<(1<<32)-1. Et C ne nécessite pas de définir explicitement le type de retour pour la fonction, vous pouvez donc le supprimer int au début. Et utilisez également 0au lieu de '\0'. Ainsi -9 caractères.
Ruslan
3

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.

numéro d'utilisateur
la source
3

Pari / GP , 19 octets - 5 = 14

En anneau, C est isomorphe à R[X]/(X2+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!

alephalpha
la source
2

Rubis 32-5 = 27

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

Fonctionne pour les pouvoirs négatifs!

MegaTom
la source
Vous pouvez trivialement jouer au golf avec puts %w[1 i -1 i][gets.to_i % 4].
histocrate
2

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.

Hobbs
la source
2

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)

Rodolfo Dias
la source
vous pourriez réduire votre code, si vous le passez à l'argument main.
user902383
@ user902383 Je pourrais toujours faire une fonction, en effet. Publiera probablement les deux versions également.
Rodolfo Dias
en fait, je pensais à l'analyser, vous aurez doncint n = Integer.parseInt(a[0])
user902383
@ user902383 Daaaaamn, ne s'en souvenait même pas. coup de pouce
Rodolfo Dias
2

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.

kukac67
la source
2

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]
Rentsy
la source
2

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.

Sumner18
la source
29-5 = 24 octets
Giuseppe
@Giuseppe Totalement masqué à ce sujet. Ce qui m'inquiète, c'est que la sortie est techniquement mixte, moitié chaîne, moitié numérique.
Sumner18
Non, R contraint automatiquement les numerictypes characterlorsqu'ils sont mélangés! Le livre de Hadley explique assez bien cela - juste Ctrl + F à "Coercition" et vous le verrez, mais tout le livre vaut la peine d'être lu (principalement à des fins non golfiques, mais parfois vous prenez un tour ou deux, heheh )
Giuseppe
1

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)
colevk
la source
1

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.

Bob Jarvis - Reinstate Monica
la source
Instead of using a select structure, can't you use some sort of explicit array as in my answer?
Sean Allred
1

Groovy: 27-5 = 22

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

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);
}
bacchusbeale
la source
It doesn't even compile because you must parenthesize the assignments after : in ?: statements in plain C. Also, what's the point of using 0==0 when you can use single char 1? And no need in parentheses before ?. Also, the last ?: statement could be shortened to c[j]=i&1?'i':'1';.
Ruslan
@Ruslan In CodeBlocks Mingw there is only 1 warning around i&0. i&0==0 is a test for even, if i is even the result is 0 else it is 1.
bacchusbeale
Yeah, but what's the point of using 0==0 when it's identical to 1? Note that == has higher precedence than &, otherwise your (supposed) test of (i&0)==0 would always be true.
Ruslan
1

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.

Charles
la source
1

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.

Erik the Outgolfer
la source
"If your language supports complex numbers, don't use any functions or arithmetic that could work this out." I think it's pretty clear...
totallyhuman
@totallyhuman Well, I'm not sure if the 1j literal is banned either though?
Erik the Outgolfer
Yeah, but the arithmetic (*) is.
totallyhuman
1
@totallyhuman Hm, maybe I'll add another version below, although "don't use any functions or arithmetic that could work this out" seems to suggest that I can't use a built-in to do this exact task...BTW the way he phrases it gets me to think that you're encouraged to use 1j literals.
Erik the Outgolfer
1

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)
Kevin Cruijssen
la source