Convertire Array di decimali cifre a un array di cifre binarie

Question

Questa è probabilmente una domanda piuttosto esotica.

Il mio problema è il seguente:

Il TI 83+ calcolatrice grafica permette di programmare su di esso utilizzando un'assemblea e di un cavo di collegamento ad un computer o il suo linguaggio di programmazione integrato TI-BASIC.

Secondo quello che ho trovato, supporta solo numeri interi a 16 bit e alcuni carri emulati.

Voglio lavorare con un po 'più grandi numeri però (circa 64 bit), in modo che io uso per un allineamento con una sola cifra:

{1, 2, 3, 4, 5}

sarebbe il Decimale 12345.

In binario, che è 110000 00.111.001, o come matrice binaria cifre:

{1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1}

che sarebbe come la calcolatrice visualizza.

Come potrei fare per la conversione di questa serie di cifre decimali (che è troppo grande per la calcolatrice per visualizzare come un tipo nativo) in un array di cifre decimali?

L'efficienza non è un problema. Questo non è lavoro.

Questo mi avrebbe lasciato libero di implementare l'addizione di tali array e così via.

grazie!

Answer 1

Il pensiero su di esso e penso che lo farei con il seguente 'algoritmo'

• controllare l'ultima cifra (5 nel caso ad esempio)

• se è dispari, magazzini (dall'ordine inverso) un 1 nella matrice binaria

• ora dividere il numero per 2 tramite il seguente metodo:

• cominciare con la prima cifra e cancellare il 'trasportare' variabile.
• dividerlo per 2 e aggiungere la variabile 'portare'. Se il resto è 1 (controllare questo prima di fare il divario con una e & 1) poi mettere 5 nel bagaglio
• ripetere FINO A tutte le cifre sono state fatte

ripetere i due passaggi di nuovo fino a quando il numero intero si riduce a 0 di.

il numero nella propria matrice binaria è la rappresentazione binaria

il tuo esempio: 1,2,3,4,5

• il 5 è dispari così salviamo 1 nella matrice binaria: 1
• si divide l'array 2 utilizzando l'algoritmo:
• 0,2,3,4,5 => 0,1 + 5,3,4,5 => 0,6,1,4,5 => 0,6,1,2 + 5,5 = > 0,6,1,7,2

e ripetere:

0,6,1,7,2 ultima cifra è anche così abbiamo memorizzare un 0: 0,1 (avviso riempiamo la stringa binaria da destra a sinistra)

etc

si finisce con un binario

EDIT: Giusto per chiarire sopra: Tutto quello che sto facendo è la vecchiaia algoritmo:

 int value=12345;
 while(value>0)
 {
      binaryArray.push(value&1);
      value>>=1;     //divide by 2
 }

tranne che nel tuo esempio non abbiamo un int, ma una matrice che rappresenta una (10 di base) int; ^)

Answer 2

Il problema principale è che si sta andando tra le basi che non sono multipli di uno con l'altro, e quindi non c'è una mappatura isolato diretta tra le cifre di ingresso e cifre di uscita. Probabilmente stai andando ad avere per iniziare con la vostra cifra meno significativa, in uscita il maggior numero di cifre meno significative dell'uscita come si può prima è necessario consultare la cifra successiva, e così via. In questo modo hai solo bisogno di avere al massimo 2 dei vostri numeri di ingresso in fase di esame in un qualsiasi punto nel tempo.

Si potrebbe trovare vantaggioso in termini di ordine di elaborazione per memorizzare i numeri in forma invertita (in modo tale che le cifre meno significative vengono prima nella matrice).

Answer 3

Il modo sarebbe quello di convertire ogni cifra nella rappresentazione decimale è rappresentazione binaria e quindi aggiungere le rappresentazioni binarie di tutte le cifre:

5 = 101
40 = 101000
300 = 100101100
2000 = 11111010000
10000 = 10011100010000

             101
          101000
       100101100
     11111010000
+ 10011100010000
----------------
  11000000111001

Proof of concept in C #:

I metodi per la conversione in una serie di cifre binarie, l'aggiunta di array e moltiplicando un array di dieci:

private static byte[] GetBinary(int value) {
  int bit = 1, len = 1;
  while (bit * 2 < value) {
    bit <<= 1;
    len++;
  }
  byte[] result = new byte[len];
  for (int i = 0; value > 0;i++ ) {
    if (value >= bit) {
      value -= bit;
      result[i] = 1;
    }
    bit >>= 1;
  }
  return result;
}

private static byte[] Add(byte[] a, byte[] b) {
  byte[] result = new byte[Math.Max(a.Length, b.Length) + 1];
  int carry = 0;
  for (int i = 1; i <= result.Length; i++) {
    if (i <= a.Length) carry += a[a.Length - i];
    if (i <= b.Length) carry += b[b.Length - i];
    result[result.Length - i] = (byte)(carry & 1);
    carry >>= 1;
  }
  if (result[0] == 0) {
    byte[] shorter = new byte[result.Length - 1];
    Array.Copy(result, 1, shorter, 0, shorter.Length);
    result = shorter;
  }
  return result;
}

private static byte[] Mul2(byte[] a, int exp) {
  byte[] result = new byte[a.Length + exp];
  Array.Copy(a, result, a.Length);
  return result;
}

private static byte[] Mul10(byte[] a, int exp) {
  for (int i = 0; i < exp; i++) {
    a = Add(Mul2(a, 3), Mul2(a, 1));
  }
  return a;
}

La conversione di un array:

byte[] digits = { 1, 2, 3, 4, 5 };

byte[][] bin = new byte[digits.Length][];
int exp = 0;
for (int i = digits.Length - 1; i >= 0; i--) {
  bin[i] = Mul10(GetBinary(digits[i]), exp);
  exp++;
}
byte[] result = null;
foreach (byte[] digit in bin) {
  result = result == null ? digit: Add(result, digit);
}

// output array
Console.WriteLine(
  result.Aggregate(
    new StringBuilder(),
    (s, n) => s.Append(s.Length == 0 ? "" : ",").Append(n)
  ).ToString()
);

Output:

1,1,0,0,0,0,0,0,1,1,1,0,0,1

Modifica:
Metodi aggiuntivi per moltiplicare una matrice da decine. Intead di moltiplicare la cifra prima di convertirlo a una matrice binaria, deve essere fatto per l'array.