Trova i ^ n, dato n


27

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!


1
In quale formato restituiamo esattamente? Tramite uscita funzione o stdout?
orgoglioso haskeller il

@proudhaskeller Il tag wiki elenca le impostazioni predefinite per questo. Se non diversamente specificato, funzioni e programmi vanno bene, input tramite argomento di funzione, STDIN o argomento della riga di comando e output tramite STDOUT o valore di ritorno della funzione. Non è necessario assegnare un nome alle funzioni.
Martin Ender,

1
@ MartinBüttner, ma se scelgo l'output della funzione, come dovrebbe essere formattato / archiviato senza numeri complessi nativi nella mia lingua?
orgoglioso haskeller il

16
@BetaDecay Cosa sono gli interi in virgola mobile? oO
Martin Ender,

2
@ MartinBüttner Haha parola sbagliata: / Numero in virgola mobile quindi
Decadimento beta

Risposte:


15

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


4
"Ruby, -2 bytes" .....
FantaC

3
Quindi, scaricare questo 1.000.000.000.000 di volte mi dà 2 TB di spazio libero sul disco rigido? mi sembra un buon affare.
Programmi Redwolf il

^ Il mio browser si è rotto prima che riuscissi a farlo. Forse provare una "zip bomb" con il file all'interno? (L'estrazione fa risparmiare spazio.)
A̲̲

15

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.


Non hai bisogno del 4%. Può essere fatto automaticamente.
jimmy23013,

@ user23013 nifty :)
Martin Ender,

8
Le due risposte non dovrebbero essere separate?
Justin,

@Quincunx Forse ... originariamente erano entrambi in CJam, motivo per cui li ho messi nella stessa risposta. Ma il secondo non era valido, quindi l'ho portato su Mathematica, ma l'ho lasciato dov'era. Se la gente insiste, posso dividerli.
Martin Ender,

E puoi salvare un personaggio usandolo con f@15invece di f[15].
orome,

14

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


Il python non lambdadeve essere assegnato a una variabile? Per lo meno, per chiamarlo dovresti circondarlo tra parentesi, aggiungendo due byte in modo che possa essere chiamato (lambda...)(n).
mbomb007,

@ mbomb007 Secondo meta questo è accettabile. Il codice qui crea una funzione che esegue l'attività come richiesta. Le lambda anonime sono usate relativamente frequentemente in Python per funzioni come mape sorted.
FryAmTheEggman

11

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


@ MartinBüttner TI-Basic sembra utilizzare una sorta di tipo 'Expression', e i metodi integrati restituiscono risultati esatti per questi.
Shujal,

Vedo, allora tutto bene. ;)
Martin Ender,

Che dire della regola "Se la tua lingua supporta numeri complessi, non utilizzare alcuna funzione o aritmetica che potrebbe risolverlo." + i is arithmetic
edc65

@ edc65 Il + è in realtà un'operazione complessa. Tuttavia, se non ti piace, sostituisci con un normale i. Se la variabile inon è definita, otterrai il numero complesso, semplicemente con iinvece di . Sto solo calcolando le parti reali e immaginarie separatamente.
Shujal,

1
@Shujal In quel caso, penso che dovresti usare icomunque. Il complesso non sono nemmeno il personaggio che la domanda richiede, e ti farà risparmiare due byte, quindi ti legheresti almeno con me;).
Martin Ender,

7

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 .


1
Mi piace molto questo! Marbelous suona favoloso Dovrò verificarlo presto :)
Kezz101

3
@ Kezz101 Abbiamo una bozza specifica qui
Martin Ender,

Oh bello! Sembra davvero interessante
Kezz101

Non dimenticare che puoi fornire input alla scheda principale sulla riga di comando, quindi questa scheda può essere utilizzata così com'è.
Sparr,

1
@overactor Hm, non lo so ... la produzione di caratteri aggiuntivi (anche se non sono stampabili) sembra ancora violare il formato di output per me. Potrebbe valere una meta domanda però.
Martin Ender,

6

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

Sì, più corto ( f=n=>[1,'i',-1,'-i'][n%4]). Ma è meno sexy e non supporterà poteri negativi. Dipende dal bonus immagino.
Michael M.,

No, 29 byte. I negativi sono supportati con questo codice.
Michael M.,

JS ha un &operatore bit a bit ? Se è così puoi farlo &3per una vera operazione modulo-4. Modifica: sembra che faccia come &2viene usato nella tua risposta ...
feersum

5

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]

1
Non puoi chiamarlo esattamente. Devi memorizzarlo in un luogo a cui puoi accedere. Quindi potresti fare foo=...o potresti map(<your lambda>,range(10))ottenere un elenco di valori di i^nda 0-9.
FryAmTheEggman,

2
Fondamentalmente stai facendo un puntatore a funzione, se questo è più chiaro: P
FryAmTheEggman

3
@DigitalTrauma: Sì, anche se potresti essere in grado di fare meglio con i trucchi per affettare le stringhe. Ad esempio lambda n:'--1i'[n%4-2::2],.
user2357112 supporta Monica il

2
Per tradurre il post di user2357112: prendi ogni altro carattere a '--1i'partire dall'indice n%4-2. Quando python ottiene un indice negativo, inizierà molte posizioni rimaste dalla fine dell'array e poi salirà a 0. In questo modo, 0e 1non colpire mai i -segni, mentre 3e 4farlo.
FryAmTheEggman,

1
lambda n:n%4/2*'-'+'1i'[n%2]Rimuove lo spazio ed è più corto :)
FryAmTheEggman

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)

4

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)



3

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


3

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

}

You can save some with "import java.util.*"
Anubian Noob

@Anubian Noob Class Function is in package java.util.function not java.util (or am I wrong?).
TheNumberOne

But if you do java.util.* the .* means import everything under the package. Just like you're currently importing all classes in the fuction package.
Anubian Noob

5
@ Anubian Noob import only imports the classes in that package. It does not import any of the classes from packages in that package. For example, class Function is in package java.util.function but not in package java.util.
TheNumberOne

Oh my bad, sorry about that.
Anubian Noob

3

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

i^3 is -i, rather than i, guess it just adds 1 char. -- Sidenote for other readers: without the first rule of the challenge, the Matlab solution would only be 3 characters long.
Dennis Jaheruddin

Yes, that was a typo. Fixed! Thanks for noticing... At least the second (a bit more interesting) approach is correct =)
Stewie Griffin

3

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

2
You can remove parentheses around n%2 and use ~ instead of ! because negating n first, then %ing with 2 will give the same result, at least for n<(1<<32)-1. And C doesn't require to explicitly define return type for function, so you can remove int at the beginning. And also use 0 instead of '\0'. Thus -9 chars.
Ruslan

3

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.


3

Pari/GP, 19 bytes - 5 = 14

As a ring, C is isomorphic to R[x]/(x2+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!


2

Ruby 32-5=27

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

Works for negative powers!


You can trivially golf this more with puts %w[1 i -1 i][gets.to_i % 4].
histocrat

2

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.


2

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)


you could reduced your code, if you pass it to main as argument.
user902383

@user902383 I could always make a function, indeed. Probably will post both versions, too.
Rodolfo Dias

actually i was thinking about parsing it, so you will have int n = Integer.parseInt(a[0])
user902383

@user902383 Daaaaamn, didn't even remember that. thumbs up
Rodolfo Dias

2

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.


2

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]

2

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.



@Giuseppe Totally blanked on that. My concern with that is that the output is technically mixed, half string, half numeric.
Sumner18

nope, R automatically coerces numeric types to character when they're mixed! Hadley's book explains this pretty well -- just Ctrl + F to "Coercion" and you'll see it, but the whole book is worth a read (for non-golfing purposes mostly, but sometimes you pick up a trick or two, heheh)
Giuseppe


1

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)

1

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.


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

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

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.


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.


"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)
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.