Convert Array tizedesjegyek tömbjére bináris számjegy

Question

Convert Array tizedesjegyek tömbjére bináris számjegy

szavazat

2

Ez valószínűleg egy meglehetősen egzotikus kérdés.

A problémám az alábbiak szerint:

A TI 83+ grafikus számológép segítségével beállítható rajta segítségével akár Szerelés és egy link kábellel a számítógéphez vagy a beépített TI-BASIC programozási nyelv.

Az alapján, amit én találtam, hogy támogatja csak 16 bites egész és néhány emulált úszik.

Szeretnék dolgozni egy kicsit nagyobb számban azonban (mintegy 64 bit), így, hogy tudom használni egy tömböt az egyetlen számjegy:

{1, 2, 3, 4, 5}

lenne a decimális 12345.

A bináris, ez 110000 00111001, vagy egy bináris számjegy tömböt:

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

ami, hogy a számológép kijelzi.

Honnan megy konvertáló ezt tömb decimális számjegy (amely túl nagy a számológép megjelenítéséhez, mint egy natív típus) egy sor tizedesjegy?

Hatékonyság nem probléma. Ez NEM a házi feladatot.

Ez hagyj szabadon megvalósíthatja Kiegészítés az ilyen tömbök és ilyen.

Kösz!

pseudocode

A kérdést 01/11/2009 13:10
a forrás felhasználó wsd

Más nyelveken...

3 válasz

szavazat

0

A fő kérdés az, hogy fogsz bázisok között, amelyek nem többszörösei egymásnak, és így nincs közvetlen izolált közötti leképezést számjegyeket és kimeneti szám. Valószínűleg kell majd kezdeni a legkisebb helyiértékű, kiadási annyi legalább számjeggyel a kimeneti mint akkor, mielőtt meg kell forduljon a következő számjegyre, és így tovább. Így csak akkor kell, hogy legfeljebb 2 a számjegyeket vizsgálják bármely adott időpontban.

Meg lehet találni szempontjából előnyös feldolgozás céljából tárolja a számokat fordított formában (például, hogy a legkevésbé számjeggyel jönnek először a tömbben).

Válaszolt 01/11/2009 13:19
a forrás felhasználó Amber

szavazat

0

Az út az lenne átalakítani minden számjegy a decimális hogy ez bináris, majd hozzáadjuk a bináris ábrázolása az összes számjegy:

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

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

Koncepciók C #:

Módszerek átalakítására, hogy egy sor bináris számjegy, hozzátéve, tömbök és megszorozzuk egy tömböt ten:

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

Konvertálása egy tömböt:

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

Edit:
Hozzáadott módszerek megszorozzuk egy tömböt tízes. Intead szorzataként jegyű konvertálása előtt egy bináris tömb, meg kell tenni, hogy a tömbben.

Válaszolt 01/11/2009 14:23
a forrás felhasználó Guffa

Toad · Accepted Answer · 2009-11-01 14:02

Gondolt, és azt hiszem, nem ez a következő „algoritmus”

ellenőrizze az utolsó számjegy (5 a példában az esetben)
ha páratlan, tárolja (a fordított sorrendben) egy 1 a bináris tömb
most ossza száma 2 keresztül a következő módszerrel:
kezdődik az első számjegyet, és törölje a „carry” változó.
oszd el 2 és adjuk hozzá a „carry” változó. Ha a maradék 1 (nézd meg ezt, mielőtt ezt a megosztottságot egy és & 1), majd tegye az 5. a carry
ismételje meg, amíg az összes számjegyet volna tenni

ismételje meg mindkét lépést újra, amíg az egész szám 0-ra csökken a.

A szám a bináris tömb a bináris

A példa: 1,2,3,4,5

5 páratlan így tároljuk 1 bináris tömb: 1
elosztjuk a tömböt 2 az algoritmus:
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

és ismételje meg:

0,6,1,7,2 utolsó számjegy még így tárolni 0: 0,1 (értesítő töltse ki a bináris sztring jobbról balra)

stb.

akkor a végén egy bináris

EDIT: Csak tisztázni felett: Minden csinálok a kor régi algoritmus:

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

kivéve a példában nincs egy int, de egy tömböt, ami jelentése (10 bázis) int; ^)