Geben Sie quaterimaginäre Basiszahlen in Binärform aus

Schreiben Sie eine Funktion oder ein Programm, das eine als Binärziffern angezeigte Quater-Imaginary-Basis ausgibt . Die Zahlenbasis ist 2 i , wobei i die Quadratwurzel von -1 ist. Weitere Informationen zu i finden Sie unter Komplexe Nummer . Jede Ziffernposition kann von 0 bis 3 (quaternär) gehen, da jeder Real- und Imaginärteil -4-mal so groß ist wie der vorherige Real- und Imaginärteil. Die quaternären Ziffern in binär sind wie folgt: , , & .0: 001: 012: 103: 11

Aufschlüsselung der Ziffernpositionen:

re   im       16 -8i  -4  2i   1 -0.5i, etc.
 4    0        1   0   3   0   0        (quaternary representation)
              01  00  11  00  00        (binary representation)

Die Zahl 100110000ist 1x16 + 3x-4 = 16 + -12 = 4.

re   im       16 -8i  -4  2i   1 -0.5i, etc.
 0    5        0   0   0   3   0   2    (quaternary representation)
              00  00  00  11  00 .10    (binary representation)

Die Zahl 1100.1ist 3x2 i + 2x-0,5 i = 6 i + - i = 5 i .

Ihr Code verwendet ein Zahlenpaar, das eine Ganzzahl oder ein Gleitkomma sein kann, und gibt die komplexe Zahl als Binärziffernfolge aus. Die erste Zahl ist real, die zweite eingegebene Zahl ist der imaginäre Wert. Ein Binärpunkt darf nur gedruckt werden, wenn eine von Null verschiedene Ziffernposition unter 1 liegt (dh wenn eine der Positionen für -0,5 i , -0,25, 0,125 i usw. eine von Null verschiedene Ziffer hat). Führende und nachfolgende Nullen sind nicht zulässig, mit Ausnahme einer einzelnen Nullstelle unmittelbar vor dem Binärpunkt, sofern keine anderen Stellen vorhanden sind. Die Ausgabe darf nicht mit einem Binärpunkt beginnen (* 00.1- falsch, 0.1- richtig, * .1- falsch, * 0.10- falsch). Sie können davon ausgehen, dass alle Eingabenummern endliche Binärdarstellungen haben.

Testnummern:

re   im            output
 0    0                 0
 1    0                 1
 2    0                10
 3    0                11
 4    0         100110000
-1    0             10011
-2    0             10010
-3    0             10001
 0    1               100.1
 0    2               100
 0    3              1000.1
 0    4              1000
 0   -1                 0.1
 0   -2           1001100
 0   -3           1001100.1
 3    4              1011
 4    3         100111000.1
 6   -9         101110010.1
-6    9       10011100110.1
-9   -6           1110111
 0.5 14.125   10011001101.001001

Hinweis: Die Ausgabe aller ganzzahligen Werte endet, .1wenn der Imaginärteil ungerade ist.

Standard Code-Golf.

JavaScript (ES6), 340 Byte

f=x=>[0,...x.toString(16)].reverse().map(d=>s=d<'.'?s:d<`0`?d+s.slice(0,-1):`${(c=+`0x${d}`+(c>>4)+m^m)>>2&3}${c&3}`+s,c=s='.',m=x<0?3:12)&&s
g=(s,t,n=s.indexOf`.`,m=t.indexOf`.`)=>n<m?g(0+s,t):n>m?g(s,0+t):t[s.length]?g(s+0,t):s.replace(/\d/g,(c,i)=>`${t[i]>>1}${t[i]&1}${c>>1}${c&1}`).replace(/^0+(\d)|\.?0*$/g,'$1')
(r,i)=>g(f(r),f(i/2))

fwandelt eine Zahl in eine Basis um -4(mit nachgestelltem Wert, .wenn die Zahl eine Ganzzahl ist). gNimmt zwei Basisnummern -4, füllt sie an beiden Enden auf die gleiche Länge und .Position auf, mischt die Ziffern, konvertiert alles von Basis 4zu Basis 2und entfernt schließlich führende und nachfolgende Nullen.

Erklärung: Um die gegebene komplexe Zahl in der modifizierten Basis 2idarzustellen, müssen wir den Realteil und die Hälfte des komplexen Teils (dh das Teilen des Imaginärteils durch 2i) in der Basis darstellen 2i²(dh -4), die Ziffern zusammenmischen und sie dann von der Basis konvertieren 4zu stützen 2. Um eine reelle Zahl in der Basis darzustellen, -4beginnen wir mit der 4Basisumrechnung. Alternative Ziffern haben das richtige Vorzeichen (im Falle einer positiven Zahl sind dies die Ziffern an den geraden Stellen; im Falle einer negativen Zahl sind dies die Ziffern an den ungeraden Stellen), die übrigen Ziffern haben jedoch das falsche Vorzeichen und Es muss eine Korrektur vorgenommen werden. Beispiele:

 0 -> 000 -> 000 (no correction needed)
 4 -> 010 -> 130 }
 8 -> 020 -> 120 } (correction includes carry)
12 -> 030 -> 110 }

Wie Sie sehen können, ist die Korrektur 8minus der ursprünglichen Ziffer, mod 8. Eine etwas bequemere Berechnung ist jedoch die ursprüngliche Ziffer plus 3, xor 3 (in der Tat könnten wir in einer 32-Bit-Ganzzahlarithmetik einfach schreiben +0xCCCCCCCC^0xCCCCCCCC, um die gesamte Zahl auf einmal zu konvertieren). Da die Korrektur für alternative Ziffern gilt, ist es schließlich einfacher, eine anfängliche Konvertierung in eine Basis 16durchzuführen, bei der automatisch Paare von Basisziffern 4erfasst und dann mit einem Faktor von entweder 3oder 0xCentsprechend korrigiert werden . Es bleibt nur das -Zeichen zu ignorieren .

Perl - 313 Bytes

Da noch niemand eine Antwort gepostet hat, dachte ich, ich würde es selbst loswerden.

$r=$ARGV[0];$i=$ARGV[1]/2;$m=1;while($r!=int($r)||$i!=int($i)){$c++;$m*=-1;$i*=4;$r*=4}while($r||$i){$r-=($d[$n++]=$r/$m%4)*$m;$i-=($d[$n++]=$i/$m%4)*$m;$m*=-4}$_=join("",map({sprintf"%02b",$_}reverse splice(@d,$c*2)))||"0";@d and$_.=".".join("",map({sprintf"%02b",$_}reverse@d));s/^0+1/1/;s/(\.\d*1)0+$/$1/;print

Ich bin mir sicher, dass es so viele Möglichkeiten gibt, weiter Golf zu spielen.