Convertir matriz de dígitos decimales a una serie de dígitos binarios

Question

Esta es probablemente una pregunta bastante exótico.

Mi problema es el siguiente:

La calculadora gráfica TI 83+ le permite programar en él utilizando montaje y un cable de conexión a un ordenador o su lenguaje de programación integrado en TI-BASIC.

De acuerdo con lo que he encontrado, es compatible sólo enteros de 16 bits y algunos flotadores emulados.

Quiero trabajar con un bit números más grandes sin embargo (alrededor de 64 bits), así que para que utilizo una matriz con un solo dígito:

{1, 2, 3, 4, 5}

sería el decimal 12345.

en binario, que es 110.000 00.111.001, o como una matriz de dígito binario:

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

lo que sería la forma en que la calculadora muestra.

¿Cómo hago para convertir este conjunto de dígitos decimales (que es demasiado grande para la calculadora para que aparezca como un tipo nativo) en una matriz de dígitos decimales?

La eficiencia no es un problema. Esto no es tarea.

Esto me dejaría libre de implementar adición de tales matrices y tal.

Gracias!

Answer 1

pensado en ello y creo que lo haría con la siguiente 'algoritmo'

• comprobar el último dígito (5 en el caso del ejemplo)

• si es impar, almacén (de orden inverso) un 1 en la matriz binaria

• ahora dividir el número por 2 a través del siguiente método:

• comenzar con el primer dígito y claro el 'carry' variable.
• se divide por 2 y añadir la variable continuar '. Si el resto es 1 (comprobar esto antes de hacer la división y con un & 1) a continuación, poner 5 en el transporte
• repetición untill todos los dígitos se han hecho

repetir los dos pasos de nuevo hasta el conjunto el número se reduce a 0 de.

el número en su matriz binaria es la representación binaria

tu ejemplo: 1,2,3,4,5

• el 5 es impar, así que almacenamos 1 en la matriz binaria: 1
• dividimos la matriz por 2 utilizando el 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

y repetir:

0,6,1,7,2 último dígito es aun así almacenamos un 0: 0,1 (aviso llenamos la cadena binaria de derecha a izquierda)

etc.

se termina con un binario

EDIT: Solo para aclarar arriba: Todo lo que estoy haciendo es el algoritmo de vejez:

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

excepto en su ejemplo que no tenemos un int pero una matriz que representa una (10 base) int; ^)

Answer 2

El principal problema aquí es que usted va entre bases que no son múltiplos de uno al otro, y por lo tanto no hay una correspondencia directa entre los dígitos aislados de entrada y salida dígitos. Usted está probablemente va a tener que comenzar con el dígito menos significativo, salida tantos dígitos menos significativos de la salida como sea posible antes de tener que consultar el siguiente dígito, y así sucesivamente. De esa manera usted sólo necesita tener como máximo 2 de los dígitos de entrada es examinado en cualquier punto dado en el tiempo.

Puede que le resulte ventajosa teniendo en cuenta el orden de procesamiento para almacenar los números en forma invertida (de tal manera que los dígitos menos significativos son lo primero en la matriz).

Answer 3

En forma sería convertir cada dígito en la representación decimal a su representación binaria y luego añadir las representaciones binarias de todos los dígitos:

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

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

Prueba de concepto en C #:

Los métodos para convertir a una serie de dígitos binarios, añadiendo arrays y multiplicando una matriz por diez:

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;
}

en la conversión de una matriz:

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

Salida:

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

Editar:
métodos Añadido para multiplicar una matriz por decenas. Intead de multiplicar el dígito antes de convertirlo en una matriz binaria, que tiene que ser hecho a la matriz.