Lassen Sie uns eine einfache, surjektive Zuordnung von positiven Ganzzahlen zu Gaußschen Ganzzahlen erstellen , bei denen es sich um komplexe Zahlen handelt, bei denen der Real- und Imaginärteil Ganzzahlen sind.

Wenn Sie zum Beispiel eine positive Ganzzahl haben 4538, drücken Sie sie in Binärform ohne führende 0Zeichen aus:

4538 base 10 = 1000110111010 base 2

Entfernen Sie alle folgenden 0Elemente:

100011011101

Ersetzen Sie alle Läufe von einem oder mehreren 0durch einen einzigen +:

1+11+111+1

Ersetzen Sie alle 1durch i's:

i+ii+iii+i

Bewerten Sie den resultierenden komplexen Ausdruck und geben Sie die vereinfachte Gaußsche Ganzzahl aus:

i+ii+iii+i = i+i*i+i*i*i+i = 2i+i^2+i^3 = 2i+(-1)+(-i) = -1+i

Die Ausgabe kann auf herkömmliche mathematische Weise ausgedrückt oder als zwei separate Ganzzahlen für den Realteil und den komplexen Teil angegeben werden. Für das 4538Beispiel wäre eines dieser Beispiele in Ordnung:

-1+i
i-1
-1+1i
(-1, 1)
-1 1
-1\n1

Für Eingänge , wie 29, mathy formatiert Ausgänge wie 0, 0ioder 0+0isind alle in Ordnung.

Verwenden j(oder etwas anderes) anstelle von iist in Ordnung, wenn dies für Ihre Sprache natürlicher ist.

Der kürzeste Code in Bytes gewinnt.

MATL , 7 Bytes

BJ*Y'^s

Probieren Sie es online!

Wie es funktioniert

Betrachten Sie 4538zum Beispiel die Eingabe .

B     % Implicit input. Convert to binary
      % STACK: [1 0 0 0 1 1 0 1 1 1 0 1 0]
J*    % Multiply by 1i
      % STACK: [1i 0 0 0 1i 1i 0 1i 1i 1i 0 1i 0]
Y'    % Run-length encoding
      % STACK: [1i 0 1i 0 1i 0 1i 0], [1 3 2 1 3 1 1 1]
^     % Power, element-wise
      % STACK: [1i 0 -1 0 -1i 0 1i 0]
s     % Sum of array. Implicit display
      % STACK: -1+1i

Gelee , 8 Bytes

BŒgaıP€S

Probieren Sie es online!

Wie es funktioniert

BŒgaıP€S  Main link. Argument: n (integer)

B         Convert to binary.
          If n = 4538, this yields [1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0].
 Œg       Group equal elements.
          This yields [[1], [0, 0, 0], [1, 1], [0], [1, 1, 1], [0], [1], [0]].
   aı     Logical AND with the imaginary unit.
          This yields [[ı], [0, 0, 0], [ı, ı], [0], [ı, ı, ı], [0], [ı], [0]].
     P€   Product each.
          This yields [ı, 0, -1, 0, -ı, 0, ı, 0].
       S  Sum.
          This yields -1+ı.

Python 2, 53 Bytes

f=lambda n,k=0:(n and f(n/2,n%2*(k or 1)*1j))+~n%2*k

Ich habe versucht, dies zu golfen, und es scheint golfen zu können, aber ich habe keine A ...

Mathematica, 44 38 Bytes

Tr[1##&@@@Split[I*#~IntegerDigits~2]]&

Erläuterung

#~IntegerDigits~2

Konvertiere die Eingabe in Basis 2. ( 4538wird {1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0})

I*

Multiplizieren mit I( {1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0}wird {I, 0, 0, 0, I, I, 0, I, I, I, 0, I, 0})

Split

Nach Läufen {I, 0, 0, 0, I, I, 0, I, I, I, 0, I, 0}aufteilen ( wird {{I}, {0, 0, 0}, {I, I}, {0}, {I, I, I}, {0}, {I}, {0}})

1##&@@@ ...

Finde das Produkt auf Stufe 2. ( {{I}, {0, 0, 0}, {I, I}, {0}, {I, I, I}, {0}, {I}, {0}}wird {I, 0, -1, 0, -I, 0, I, 0})

Tr

Summiere das Ergebnis. ( {I, 0, -1, 0, -I, 0, I, 0}Wird -1 + I)

Python 2 , 77 76 71 Bytes

p=r=0
for n in bin(input()*2):t=n=='1';r-=p*~-t;p=p*t*1jor t*1j
print r

Vielen Dank an @ZacharyT für das Golfen ab 1 Byte!

Probieren Sie es online!

JavaScript (ES6), 67 64 Bytes

f=(n,q=0,a=[0,0])=>q|n?f(n/2,n&1?q+1:q&&0*(a[q&1]+=1-(q&2)),a):a

<input oninput="O.innerHTML=f(this.value)" type="number" step=1 min=0 value="4538">
<pre id=O></pre>

Ausgabe als 2-Element-Array.

Erläuterung

Da JavaScript keine imaginären Zahlen hat, müssen wir die Real- und Imaginärteile in separaten Variablen verfolgen. Der einfachste Weg, dies zu tun, ist ein einzelnes Array, wobei der Realteil an erster Stelle steht. i wird als [0,1] , i ² (oder -1 ) als [-1,0] , i ³ (oder -i ) als [0, -1] und i ⁴ (oder 1 ) als [1] dargestellt , 0] .

Erstens teilen wir die Zahl wiederholt durch 2 und sammeln jeden Lauf von Einsen in seiner binären Darstellung. Jeder Lauf von n Einsen entspricht i ⁿ . Dies entspricht dem Hinzufügen von 1 - (n & 2) zu dem Element am Index n & 1 im Array mit zwei Elementen. Das machen wir also.

Ich sollte wahrscheinlich mehr Erklärungen hinzufügen, aber ich kann mir nicht vorstellen, was noch zu erklären ist. Wenn Sie Fragen haben, können Sie diese gerne kommentieren.

Python, 199 129 124 116 94 90 71 63 61 Bytes

print sum(1j**len(s)for s in bin(input())[2:].split('0')if s)

Die Eingabe ist nur die Zahl selbst.
Die Ausgabe erfolgt in dem Format (a+bj), in dem jsich die imaginäre Einheit befindet. 0jwird ausgegeben statt(0+0j)

Zuerst ins Binäre konvertieren. Abschneiden '0b'. Töte die nachgestellten Nullen. Teilen mit einem Block von Null (en) als Trennzeichen. Ordnen Sie jeden Block zu 1j ** len. Dann nimm die Summe des Ganzen.

-70 Bytes, indem nicht in Plus konvertiert wird.
-5 Bytes Regex ist kürzer.
-8 Bytes, indem die beiden unnötigen Variablen entfernt werden, die nur einmal aufgerufen wurden.
-22 Bytes durch die Verwendung komplexer Zahlen anstelle meiner seltsamen Sache. Vielen Dank an @Dennis 'Antwort, die mich über komplexe Zahlen informiert hat!
-4 Bytes durch die Erkenntnis, dass dies mapnur eine ausgefallene Art ist, Listenverständnisse zu erstellen, außer länger.
-19 Bytes durch Umschalten auf eine leicht arkane Methode zur Vermeidung von Fehlern j ** 0und zur Vermeidung von Regex. Inspiriert von @ Griffins Kommentar. Vielen Dank! :)
-8 Bytes durch Verschieben des ifTeils an das Ende.
-2 Bytes Vielen Dank an @Griffin für das Speichern von 2 Bytes durch Entfernen der eckigen Klammern, damit es stattdessen ein Generator-Ausdruck wird!

MATLAB, 58 Bytes

@(x)eval([strrep(strrep(dec2bin(x),48,43),49,'i*1'),'.0'])

dec2bin(x) % converts the decimal value to a binary string of 1s and 0s.
strrep(dec2bin(x),48,43) % Substitutes ASCII character 48 with 43 (0s become +)
strrep(___,49,'i*1')     % Substitutes ASCII character 49 with 'i*1'
                         % 1s become 'i*1' (this is the gem)
eval([___,'.0']          % Appends .0 in the end and evaluates the expression.   

Lassen Sie uns 285den Prozess veranschaulichen:

temp1 = dec2bin(285)
      = 100011101

temp2 = strrep(temp1,48,43)
      = 1+++111+1

Zum Glück 1+++1verhält es sich genauso wie 1+1in MATLAB 1+111+1.

temp3 = strrep(temp2,49,'i*1')
      = i*1+++i*1i*1i*1+i*1

Jetzt ist dieser strrepAnruf der wahre Schatz! Durch Einsetzen i*1für 1uns etwas wirklich schön bekommen. Wenn es nur einen gibt 1, bekommen wir einfach i*1den i. Wenn es mehr ist , als man dann i*1in eine Sequenz wiederholt und verkettet wird: i*1i*1i*1i*1. Da i==1iin MATLAB und das 1i*1==iist einfach: i*i*i*i.

temp4 = [temp3,'.0']
      = i*1+++i*1i*1i*1+i*1.0

Das Anhängen .0erscheint hier unnötig, wird aber benötigt, wenn das letzte Zeichen von a temp3ist +. Wir können nicht einfach eine Null anhängen, da dies i*10im obigen Fall zu einem falschen Ergebnis führen würde.

Und schlussendlich:

eval(temp4)
0.0000 + 1.0000i

Dies funktioniert in Octave aus mehreren Gründen nicht. strrepASCII-Werte können nicht als Eingabe verwendet werden, es werden die tatsächlichen Zeichen ( '0'anstelle von 48) benötigt. Auch +++wird nicht nur +in Oktave ausgewertet , da dies die Inkrement / Dekrement-Verknüpfungen x++und stören würde x--.

Pyth - 15 Bytes

Frustrierend lang.

s^L.j)hMe#r8jQ2

Test Suite .

Mathematica, 84 Bytes

ToExpression[#~IntegerString~2~StringTrim~"0"~StringReplace~{"0"..->"+","1"->"I "}]&

Anonyme Funktion. Nimmt eine Zahl als Eingabe und gibt eine komplexe Zahl als Ausgabe zurück.

Mathematica, 75 Bytes

ToExpression[#~IntegerString~2~StringReplace~{"1"->"I ","0"..->"+"}<>"-0"]&

Independent hat sich fast dieselbe Lösung ausgedacht, die LegionMammal978 vor 23 Minuten gepostet hat! Ersetzen 1durch I (das interne Symbol von Mathematica für die Quadratwurzel von -1) funktioniert, weil Leerzeichen als Multiplikation benachbarter Ausdrücke behandelt werden. Der Platz, den ich bei der anderen Lösung gespart habe, nämlich indem ich das Erfordernis vermieden habe StringTrim, besteht darin, immer anzuhängen -0: Wenn die Binärzahl auf endet 1, endet dieser Ausdruck, ...I-0der seinen Wert nicht beeinflusst; Wenn die Binärzahl mit '0' endet, endet dieser Ausdruck, ...+-0der als "negative 0 hinzufügen" analysiert wird und somit das nachfolgende Pluszeichen beseitigt.

Matlab, 99 Bytes

function c=z(b)
c=0;b=strsplit(dec2bin(b),'0');for j=1:numel(b)-isempty(b{end});c=c+i^nnz(b{j});end

Testfälle:

z(656) = 3i
z(172) = -1 + 2i
z(707) = -2 + i
z(32)  = i
z(277) = 4i

Haskell, 102 91 89 87 Bytes

0%a=a
n%c@[a,b]|odd n=div n 2%[-b,a]|d<-div n 2=zipWith(+)c$d%[mod d 2,0]
(%[0,0]).(*2)

Dividiert wiederholt durch zwei und überprüft das Bit. Behält einen Akkumulator bei, i^(number of odds)in dem angegeben a+b*iist, wie [a,b]und wie er *iist [a,b]↦[-b,a](Drehung um 90 Grad). Die Initiale (*2)besteht darin, eine Suche nach dem ersten Bit zu vermeiden.

Verwendung (Danke an @OwenMorgan für die Beispiele):

(%[0,0]).(*2)<$>[656,172,707,32,277]
[[0,3],[-1,2],[-2,1],[0,1],[0,4]]

Java, 172 Bytes

l->{int i=0,j=i;for(String x:l.toString(2).split("0")){int a=x.length();j+=a&1>0?(a&3>2?(a-3)/-4+1:(a-3)/4+1):0;i+=a&1<1?(a&3>1?(a-3)/4+1:(a-3)/-4+1):0;}return i+"|"j+"i";}

Clojure, 183 Bytes

#(loop[x(clojure.string/split(Integer/toString % 2)#"0+")y[0 0]a 0](if(= a(count x))y(recur x(let[z([[1 0][0 1][-1 0][0 -1]](mod(count(x a))4))][(+(y 0)(z 0))(+(y 1)(z 1))])(inc a))))

Darf ich das tun?

Verwenden Sie die Funktion wie folgt:

(#(...) {num}) -> (Wrap the # function in brackets first!)

Eigentlich 35 Bytes

├'0' aÆô' @s"j+"j'jo`"1j*1"'1τ(Æ`Y≡

Probieren Sie es online!

Erläuterung:

├'0' aÆô' @s"j+"j'jo`"1j*1"'1τ(Æ`Y≡
├                                    binary representation of input
 '0' aÆ                              replace 0s with spaces
       ô                             trim leading and trailing spaces
        ' @s                         split on spaces
            "j+"j                    join with "j+"
                 'jo                 append "j"
                    `"1j*1"'1τ(Æ`Y   do until the string stops changing (fixed-point combinator):
                     "1j*1"'1τ(Æ       replace "11" with "1j*1"
                                  ≡  evaluate the resulting string to simplify it

Etwa gleichwertiger Python 3-Code:

a='j+'.join(bin(eval(input()))[2:].replace('0',' ').strip().split())+'j'
b=0
while a!=b:b,a=a,a.replace("11","1j*1")
print(eval(a))

Probieren Sie es online!

Gelee , 10 Bytes

Dies ist nicht besser als Dennis 'Gelee-Antwort, aber ich wollte mich trotzdem an einer Gelee-Antwort versuchen. Golfvorschläge willkommen! Probieren Sie es online!

BŒrm2Ṫ€ı*S

Ungolfing

BŒrm2Ṫ€ı*S   Main link. Argument: n (integer)

B            Convert n to binary.
 Œr          Run-length encode the binary list.
   m2        Every 2nd element of the run_length encoding, getting only the runs of 1s.
     Ṫ€      Tail each, getting only the lengths of the runs.
       ı*    The imaginary unit raised to the power of each run (as * is vectorized).
         S   Sum it all into one complex number.

Eigentlich 15 Bytes

Golfvorschläge willkommen! Probieren Sie es online!

├'0@s``░`lïⁿ`MΣ

Ungolfing:

         Implicit input n.
├        Convert n to binary.
'0@s     Split by '0's.
``░      Filter out non-truthy values.
`...`M   Map over the filtered result, a list of runs of '1's.
  l        Yield the length of the run of '1's.
  ïⁿ       Yield the imaginary unit to the power of that length.
Σ        Sum all of this into one complex number.

Axiom, 140, 131, 118, 108 Bytes

b(x)==(s:=0;repeat(x=0=>break;r:=x rem 2;repeat(x rem 2=1=>(r:=r*%i;x:=x quo 2);break);s:=s+r;x:=x quo 2);s)

% i ist der imaginäre Costant.Ungolfed

sb(x:NNI):Complex INT==
  r:Complex INT;s:Complex INT:=0
  repeat
    x=0=>break
    r:=x rem 2
    repeat
       x rem 2=1=>(r:=r*%i;x:=x quo 2)
       break
    s:=s+r
    x:=x quo 2
  s

Ergebnisse

(3) -> b 4538
   The type of the local variable r has changed in the computation.
   We will attempt to interpret the code.
   (3)  - 1 + %i
                                                    Type: Complex Integer
(4) -> b 29
   (4)  0
                                                    Type: Complex Integer
(5) -> sb 299898979798233333333333333339188888888888888888222
   Compiling function sb with type NonNegativeInteger -> Complex Integer
   (5)  - 7 + 12%i
                                                    Type: Complex Integer
(6) -> b 299898979798233333333333333339188888888888888888222
   (6)  - 7 + 12%i
                                                    Type: Complex Integer

Perl 6 ,  40  46 Bytes

Das habe ich mir ziemlich schnell ausgedacht

*.base(2).comb(/1+/).map(i***.chars).sum

Leider ist es derzeit in der Rakudo- Implementierung auf MoarVM ungenau .
say i ** 3; # -1.83697019872103e-16-1i

Also musste ich das nächstbeste machen:

*.base(2).comb(/1+/).map({[*] i xx.chars}).sum

Erweitert:

*\             # Whatever lambda
.base(2)       # convert to a Str representation in base 2
.comb(/ 1+ /)  # get a list of substrings of one or more ｢1｣s
.map({         # for each of those

  [*]            # reduce using ｢&infix:<**>｣
    i xx .chars    # ｢i｣ list repeated by the count of the characters matched

}).sum          # sum it all up

Prüfung:

.say for (4538, 29).map:

    *.base(2).comb(/1+/).map({[*] i xx.chars}).sum

# -1+1i
# 0+0i

PHP, 87 Bytes

for($n=$argv[1];$n|$i;$n>>=1)$n&1?$i++:($i?$i=0*${$i&1}+=1-($i&2):0);echo"(${0},${1})";

Fast wie die Lösung von ETHproductions; nur iterativ statt rekursiv.
Übernimmt Eingaben von der Kommandozeile, setzt Variablen ${0}und ${1}.

TI-Basic (TI-84 Plus CE), 70 Byte

Prompt X
0→S
0→N
While X
If remainder(X,2
Then
N+1→N
int(X/2→X
Else
S+i^Nnot(not(N→S
X/2→X
0→N
End
End
S+i^Nnot(not(N

Es gibt keinen eingebauten Code zum Konvertieren in eine Binärzeichenfolge (und auch keinen zum Parsen einer Zeichenfolge). Daher teilt dieses Programm manuell durch 2, inkrementiert N jedes Mal, wenn es eine 1 sieht, und fügt i ^ N zu S (N> 0) hinzu und setzt zurück N, wenn eine Null angezeigt wird.

Java , 100 Bytes

int[]f(int n){int c=2,r[]=new int[2];for(;n>0;r[c&1]+=n%4==1?(c&2)-1:0,n/=2)c=n%2<1?2:c+1;return r;}

Probieren Sie es online!

R , 54 Bytes

function(n,x=rle(n%/%2^(0:log2(n))%%2))sum(1i^x$l*x$v)

Probieren Sie es online!

n%/%2^(0:log2(n))%%2berechnet einen Vektor der Binärziffern. Unter Verwendung der Lauflängencodierung verwenden wir den complexTyp von R , um die entsprechende Summe zu berechnen, und multiplizieren sie mit x$values, um Nullen zu entfernen.

Gibt einen complexVektor eines Elements zurück.