O desafio

No menor número de caracteres possível, encontre o valor de i ^ n, dado n, um número inteiro positivo maior que 0. Isso deve ser gerado como uma String.

Para aqueles que não sabem, i é definido de forma que i ^ 2 = -1. Tão:

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

Isso então se repete ..

Regras

• Se o seu idioma suportar números complexos, não use nenhuma função ou aritmética que possa resolver isso.
• Imprecisões de ponto flutuante são boas para respostas que retornariam decimais de qualquer maneira, mas entradas inteiras devem fornecer resultados exatos

Pontos bônus

-5 se você puder calcular o valor em que n também é negativo

-15 se você puder calcular o valor para qualquer número real (esse bônus inclui -5 do bônus acima)

Boa sorte!

Pontuação Ruby -2

(13 bytes, -15 de bônus)

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

Os recursos incluem: sem erros de arredondamento! (se você passar a entrada como um Rational)

publicado pelo autor, Kezz101

Se você oferecer suporte a qualquer número real, poderá gerar qualquer forma complexa válida.

Pontuações negativas fazem minha adrenalina avançar. Assim, as regras são abusadas são utilizadas para atingir esse objetivo nobre.

Cria uma função anônima e gera uma matriz com 2 entradas que representam um número complexo na forma polar (unidade angular: graus).

CJam, 12 caracteres - 5 = 7

1'iW"-i"]li=

Teste aqui.

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

O resultado é impresso automaticamente no final do programa.

Mathematica, 22 20 19 caracteres - 15 = 4

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

Esta é uma função anônima, que você pode usar como

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

(Ou atribua-o a fdizer e faça f[15].)

Suporta reais e fornece resultados exatos para entrada inteira.

Observe que nãoi é o complexo i do Mathematica (que é ). É apenas uma variável indefinida.I

Além disso, apesar da ordem da expressão, o Mathematica reordenará a saída em R+Ciforma.

Python 2 - (24-5) = 19

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

A maior parte do crédito pertence a @ user2357112, apenas respondi um pouco mais a resposta dele nos comentários sobre essa resposta .

Explicação: Inicia no índice n%4na sequência '1i--'. Em seguida, itera para trás em etapas de dois sobre cada letra da string. Assim, por exemplo, n=6começaria no índice 2, o primeiro -, depois ignoraria ie pegaria o 1, para retornar -1.

@xnor apontou uma solução do mesmo comprimento:

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

Pitão - (14-5) = 9

Eu só consigo obter 14, não importa como eu tente inverter / cortar / etc. : '(

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

Que é essencialmente o mesmo que a resposta python acima, mas em 2 etapas, porque o pyth não suporta as opções de indexação completas do python. Experimente online.

Vou conversar com isaacg sobre a indexação Pyth;)

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

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

Se você deseja receber um valor de retorno complexo, substitua ino final por (complexo i).

Marbelous , 43 bytes

Não é realmente um vencedor, mas Marbelous é divertido. :)

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

Este é um programa que lê a entrada como um único inteiro a partir do primeiro argumento da linha de comando. Observe que a entrada é obtida no módulo 256, mas isso não afeta a validade do resultado para entradas maiores que 255, porque 256 é divisível por 4.

Explicação

Marbelous é uma linguagem de programação 2D, que simula "bolinhas de gude" (valores de bytes) caindo em vários dispositivos. O quadro é composto de células largas de 2 caracteres (os dispositivos), que podem processar os mármores. Tudo o que cai do fundo de um quadro é impresso em STDOUT.

Vamos examinar os dispositivos em uso:

• }0é onde o primeiro argumento da linha de comando vai. Eu usei duas instâncias deste dispositivo, então recebo duas cópias do valor de entrada (ao mesmo tempo).
• ^nverifica o nth bit do mármore de entrada (onde n=0é o bit menos significativo) e produz 1ou 0depende do bit.
• =0verifica a igualdade com 0. Se o mármore de entrada for igual, ele simplesmente cai direto, se não for, é empurrado para a direita.
• \/ é uma lata de lixo, apenas engole o mármore de entrada e nunca produz nada.
• 2Dé o código ASCII de -, 31é o código ASCII de 1e 69é o código ASCII de i.
• Os &nsão sincronizadores. Os sincronizadores paralisam uma bola de gude até que todos os sincronizadores com a mesma nbola segurem uma bola de gude, altura em que todos deixarão cair a bola de gude armazenada.

Portanto, na verdade, o que faço é manter os três caracteres relevantes em três sincronizadores e liberá-los, dependendo de como os bits menos significativos são definidos na entrada.

Para mais informações, consulte o rascunho das especificações .

JavaScript (ES6) 29-5 = 24

Suporta energia negativa.

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

ES5:

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

Python 28 bytes - 5 = 23

Suporta entradas -ve.

Supondo que as funções lambda sejam aceitáveis ​​(Obrigado FryAmTheEggman!):

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

caso contrário, 31 bytes - 5 = 26

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

(Emacs) Lisp - 34

Apenas por diversão, no (Emacs) Lisp:

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

Se você deseja usá-lo, use a defunou 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 de bônus = pontuação -7

A função interna (e, portanto, proibida) é 0J1*⊢, mas ela usa o método de @ blutorange .

¯12○.5×○

O autor do desafio, Kezz101, escreveu :

Se você oferecer suporte a qualquer número real, poderá gerar qualquer forma complexa válida.

Isso retorna um número complexo no formulário, aJbque é a maneira normal de o APL exibir números complexos.

Experimente online!

Explicação

¯12○ encontre o vetor unitário que tem o ângulo em radianos de

.5× vezes e meia

○ o argumento multiplicado por 𝜋 (a constante do círculo)

Festa pura, 29 bytes - 5 = 24

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

Suporta números inteiros negativos. Não vou ganhar nenhum prêmio com esta solução, mas tanto faz.

Ele apenas aceita um número como entrada, faz alguns truques no módulo (que, frustrantemente, não funciona como o módulo habitual para números negativos no intérprete que eu o testei) para fazer os negativos funcionarem e, em seguida, faz algumas condições tolas para decida o que cada personagem deve ser.

Tenho certeza que isso pode ser jogado muito mais longe. Por enquanto, aqui está outra solução que não aceita negativos, mas compensa a perda do bônus sendo mais curta:

Befunge-98, 32 26 23

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

Editar - Agora aproveita o fato de que "-" está a 13 (0xd) caracteres de "".

Editar 2 - Agora, novamente, aproveita o fato de que "i" está a 56 (0x38 ou '8) caracteres de "1".

Java 8 Pontuação: 72

Em Java, a pior linguagem de golfe de todos os tempos! Golfe:

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: Não estou acostumado ao Java 8. Também não tenho o tempo de execução para isso. Por favor, diga-me se houver algum erro de sintaxe. Este também é o meu primeiro golfe.

Editar: Removido import.

Editar: declaração de classe removida.

Outra resposta com pontuação = 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))

Mesmo com alguns bytes a mais (37-5 = 32), eu realmente gosto mais dessa abordagem:

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

Melhorado graças a Ruslan

C 74-5 = 69

Ah, e claro, a abordagem mais óbvia

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

Não é uma solução premiada, mas esta é minha primeira vez em código de golfe, por isso não tenho exatamente certeza do que estou fazendo. Tentei usar a correspondência de padrões, mas isso me deu mais de 58 anos.

Pari / GP , 19 bytes - 5 = 14

$\mathbb{C}$$\mathbb{R}[x]/(x^2+1)$

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

O iaqui é apenas um símbolo, não a unidade imaginária (que está Iem Pari / GP).

Experimente online!

Ruby 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 um programa independente (argumento na linha de comando) ou no corpo de uma função.

Java: 151 131-5 = 126

Golfe:

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

Como função: 72-5 = 67

Golfe:

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

Sim, mais uma resposta do Java - e jogou ainda pior do que nunca. Mas você trabalha com o que pode ...

EDIT : versão da função adicionada.

EDIT 2 : então, depois de algumas tentativas e erros, aqui está uma versão que tenta fazer isso pelo livro, sem explorar a brecha do ciclo. Tão…

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

Golfe:

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

(pelo menos, acho que posso reivindicar o bônus máximo, me corrija o contrário)

Python - 31

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

Apenas recentemente comecei a aprender python. Mesmo sabendo que não é bom, é o melhor que posso fazer.

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]

Experimente online!

O mesmo que a maioria dos métodos acima, pega um módulo de 4 e aumenta em 1, porque as matrizes de R são indexadas em 1. Também funciona para números inteiros negativos.

Eu estava preocupado com saídas mistas aqui, mas Giuseppe apontou que R restringe tipos numéricos a tipos de string quando eles são misturados.

PowerShell , 28 bytes -5 = 23

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

Experimente online!

Porta de toda a indexação cíclica

Haskell, 29 bytes - 5 = 24

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

Funciona para poderes negativos.

Eu tinha uma versão sem pontos elaborada, mas na verdade é mais longa.

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

Por sugestão do @ SeanAllred, aqui está uma versão que usa um vetor literal em vez de uma casefunção:

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

Editar 2

Contando com o REPL para imprimir a coleção resultante e codificando a função usando o #()atalho, podemos reduzi-la para

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

(Na verdade, é muito mais Clojure / Lisp-ish, pois a função agora realmente retorna o resultado gerado, permitindo que a função seja usada com map, como em

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

Compartilhe e curta.

Groovy: 27-5 = 22

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

C 105, era 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)é um caractere mais curto, mas não lida com respostas exatas. É claro que n->I^nnão é permitido e, presumivelmente, também é do PARI powIs.

Gelatina , 2 - 20 = -18 bytes

ı*

Experimente online!

Ele não usa um i ^ xbuiltin, mas usa builtins para 1je, **portanto, não tem certeza se é permitido.

05AB1E , pontuação 5 (10 bytes - bônus 5)

'i®„-i1)Iè

Experimente online ou verifique mais alguns casos de teste .

Explicação:

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