Sortie des nombres de base quater-imaginary en binaire

Écrivez une fonction ou un programme qui produit une base imaginaire Quater affichée sous forme de chiffres binaires. La base numérique est 2 i , où i est la racine carrée de -1. Voir Numéro complexe pour plus de détails sur i . Chaque position de chiffre peut aller de 0 à 3 (quaternaire), car chaque partie réelle et imaginaire est -4 fois plus grande que la partie réelle et imaginaire précédente. Les chiffres quaternaires en binaire sont les suivants: 0: 00, 1: 01, 2: 10et 3: 11.

Répartition des positions numériques:

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)

Le nombre 100110000est 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)

Le nombre 1100.1est 3x2 i + 2x-0,5 i = 6 i + - i = 5 i .

Votre code prendra une paire de nombres, qui pourrait être un entier ou une virgule flottante, et affichera le nombre complexe sous la forme d'une chaîne de chiffres binaires. Le premier nombre sera réel, le deuxième nombre entré sera la valeur imaginaire. Un point binaire ne doit être imprimé que si le nombre de positions non nulles est inférieur à 1 (c'est-à-dire si l'une des positions pour -0,5 i , -0,25, 0,125 i , etc. a un chiffre différent de zéro). Les zéros de tête et de fin ne sont pas autorisés, sauf pour un seul chiffre zéro immédiatement avant le point binaire s'il n'y a pas d'autres chiffres. La sortie ne doit pas commencer par un point binaire (* 00.1- faux, 0.1- droit, * .1- faux, * 0.10- faux). Vous pouvez supposer que tous les nombres entrés auront des représentations binaires finies.

Numéros de test:

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

Remarque: La sortie de toutes les valeurs entières se terminera .1si la partie imaginaire est impaire.

Code-golf standard.

JavaScript (ES6), 340 octets

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

fconvertit un nombre en base -4(avec fin .si le nombre est un entier). gprend deux -4numéros de base , les rembourre aux deux extrémités à la même longueur et la même .position, mélange les chiffres ensemble, convertit tout de base 4en base 2, puis dépouille finalement les zéros de tête et de queue.

Explication: Pour représenter le nombre complexe donné en base modifiée, 2inous devons représenter la partie réelle et la moitié de la partie complexe (c'est-à-dire en divisant la partie imaginaire par 2i) en base 2i²(c'est-à-dire-4 ), mélanger les chiffres ensemble, puis les convertir à partir de la base 4à la base 2. Pour représenter un nombre réel en base, -4nous commençons par la 4conversion de base . Les chiffres alternatifs ont le signe correct (dans le cas d'un nombre positif, ce sont les chiffres dans les positions paires; dans le cas d'un nombre négatif, ce sont les chiffres dans les positions impaires) mais les chiffres restants ont le mauvais signe et une correction doit être appliquée. Exemples:

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

Comme vous pouvez le voir, la correction est 8moins le chiffre d'origine, mod 8. Cependant, un calcul légèrement plus pratique est le chiffre d'origine, plus 3, xor 3 (en effet, en arithmétique d'entier 32 bits, nous pourrions simplement écrire +0xCCCCCCCC^0xCCCCCCCCpour convertir le nombre entier en une seule fois). Enfin, comme la correction s'applique à des chiffres alternatifs, il est plus simple d'effectuer une conversion initiale en base 16qui récupère automatiquement des paires de 4chiffres de base , puis de corriger en utilisant un facteur de l'un 3ou de l'autre 0xCselon le cas. Reste à ignorer le- signe.

Perl - 313 octets

Comme personne n'a encore posté de réponse, j'ai pensé que je pourrais la lancer moi-même.

$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

Je suis sûr qu'il y a beaucoup d'occasions de jouer au golf plus loin.