Stampa numeri di base quater-immaginari in binario

Scrivi una funzione o un programma che genera una base quater-immaginaria visualizzata come cifre binarie. La base numerica è 2 i , dove i è la radice quadrata di -1. Vedi il numero complesso per maggiori dettagli su i . Ogni posizione delle cifre può andare da 0 a 3 (quaternaria), poiché ogni parte reale e immaginaria è -4 volte più grande della precedente parte reale e immaginaria. Le cifre quaternari di binario sono i seguenti: 0: 00, 1: 01, 2: 10e 3: 11.

Ripartizione delle posizioni delle cifre:

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)

Il numero 100110000è 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)

Il numero 1100.1è 3x2 i + 2x-0,5 i = 6 i + - i = 5 i .

Il codice prenderà una coppia di numeri, che potrebbero essere numeri interi o in virgola mobile, e produrrà il numero complesso come una stringa di cifre binarie. Il primo numero sarà reale, il secondo numero di input sarà il valore immaginario. Un punto binario deve essere stampato solo se ci sono posizioni di numero diverso da zero inferiori a 1 (ovvero se una delle posizioni per -0,5 i , -0,25, 0,125 i , ecc. Ha una cifra diversa da zero). Gli zeri iniziali e finali non sono consentiti, ad eccezione di una singola cifra zero immediatamente prima del punto binario se non ci sono altre cifre. L'output non deve iniziare con un punto binario (* 00.1- errato, 0.1- giusto, * .1- sbagliato, * 0.10- sbagliato). Si può presumere che tutti i numeri di input abbiano rappresentazioni binarie finite.

Numeri di prova:

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

Nota: l'output di tutti i valori interi termina .1se la parte immaginaria è dispari.

Code-golf standard.

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

fconverte un numero in base -4(con trascinamento .se il numero è un numero intero). gprende due -4numeri di base , li .unisce ad entrambe le estremità della stessa lunghezza e posizione, mescola le cifre insieme, converte tutto da base 4a base 2, quindi infine taglia gli zeri iniziali e finali.

Spiegazione: Per rappresentare il numero complesso dato in base modificata 2idobbiamo rappresentare la parte reale e metà della parte complessa (cioè dividendo la parte immaginaria per 2i) in base 2i²(cioè-4 ), mescolando le cifre insieme, quindi convertendole dalla base 4alla base 2. Per rappresentare un numero reale in base -4, iniziamo con la 4conversione di base . Le cifre alternative hanno il segno corretto (nel caso di un numero positivo, queste sono le cifre nelle posizioni pari; nel caso di un numero negativo, queste sono le cifre nelle posizioni dispari) ma le cifre rimanenti hanno il segno sbagliato e è necessario applicare una correzione. Esempi:

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

Come puoi vedere, la correzione è 8meno la cifra originale, mod 8. Tuttavia un calcolo leggermente più conveniente è la cifra originale, più 3, xo 3 (in effetti nell'aritmetica dei numeri interi a 32 bit potremmo semplicemente scrivere +0xCCCCCCCC^0xCCCCCCCCper convertire l'intero numero in una volta sola). Infine, poiché la correzione si applica alle cifre alternate, è più semplice eseguire una conversione iniziale in base 16che raccoglie automaticamente coppie di 4cifre di base , quindi corregge utilizzando un fattore di 3o 0xCappropriato. Resta solo da ignorare il- segno.

Perl - 313 byte

Dato che nessuno ha ancora pubblicato una risposta, ho pensato di dare il via a me stesso.

$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

Sono sicuro che ci sono molte opportunità di giocare a golf ulteriormente.