C, Dezimal -> Ternärzahl

Schau mal hier:
http://de.wikipedia.org/wiki/Stellenwertsystem#Konvertierungen

Sehr nett, danke, ist ein guter Anfang :)

In itoa/utoa kann man doch die Bases (radix) angeben. Damit ist die 
Umwandling ins 3er-System eine C-Zeile.

Kannst du mal kurz ein Pseudocode-Beispiel mit itoa geben? Weil ich habs 
damit trotz Recherche nicht hinbekommen

Jeromyo Hochgesang schrieb:
> Kannst du mal kurz ein Pseudocode-Beispiel mit itoa geben? Weil ich habs
> damit trotz Recherche nicht hinbekommen

http://www.cplusplus.com/reference/cstdlib/itoa/

Ich bastel an einem Verschlüsselungsalgorithmus auf dem AVR, durch den 
Zahlenbasiswechseln und reduzieren von Bitanzahlen wird der ursrüngliche 
Text bei falschem Schlüssel nicht mehr rekonstruierbar, so weit der 
Gedanke, klappt auch ganz gut :)

Danke an be stucki!

Nein, Mr. X, es läuft alles schon so wie geplant :) Tzdm danke, ich habe 
es mit dem sukzessiven Teilen hinbekommen.

Mr. X schrieb:
> Und wie lange dauert das im Vergleich zur Subtraktion?

Hab ich vor einem halben Jahr mal versucht. Um eine Zahl nur durch 
Subtraktion in einen String umzuwandeln, benötigte mein Controller ca. 
1.5 mal länger als mit Modulo und Division. Der benötigte 
Programmspeicher war etwa gleich. Getestet mit einem PIC18 und dem XC8 
Compiler von Microchip. Sourcecode hab ich nicht mehr.

Falls Geschwindigkeit zählt, kann man / und % verwenden und den Code auf 
Geschwindigkeit optimieren. Der Compiler verwendet dann eine 
Multiplikation.

Beispiel:

1

unsigned d, m;

2

3

void f (unsigned x)

4

{

5

    d = x / 3;

6

    m = x % 3;

7

}

Ergebnis mit avr-gcc 4.7:

1

f:

2

  movw r30,r24   ;  2  *movhi/1  [length = 1]

3

  movw r18,r24   ;  6  *movhi/1  [length = 1]

4

  ldi r26,lo8(-85)   ;  7  *movhi/5  [length = 2]

5

  ldi r27,lo8(-86)

6

  rcall __umulhisi3   ;  8  *umulhi3_highpart_call  [length = 1]

7

  lsr r25   ;  31  *lshrhi3_const/2  [length = 2]

8

  ror r24

9

  sts d+1,r25   ;  11  *movhi/4  [length = 4]

10

  sts d,r24

11

  movw r20,r24   ;  27  *movhi/1  [length = 1]

12

  lsl r20   ;  32  *ashlhi3_const/2  [length = 2]

13

  rol r21

14

  add r20,r24   ;  20  *addhi3/1  [length = 2]

15

  adc r21,r25

16

  sub r30,r20   ;  21  subhi3/1  [length = 2]

17

  sbc r31,r21

18

  sts m+1,r31   ;  22  *movhi/4  [length = 4]

19

  sts m,r30

20

  ret   ;  30  return  [length = 1]

Und hier noch die 8-Bit Version, nochma kürzer:

1

f:

2

  ldi r25,lo8(-85)   ;  6  movqi_insn/2  [length = 1]

3

  mul r24,r25   ;  7  umulqi3_highpart  [length = 3]

4

  mov r25,r1

5

  clr __zero_reg__

6

  lsr r25   ;  8  *lshrqi3/3  [length = 1]

7

  sts d,r25   ;  9  movqi_insn/3  [length = 2]

8

  mov r18,r25   ;  23  movqi_insn/1  [length = 1]

9

  lsl r18   ;  14  *ashlqi3/3  [length = 1]

10

  add r18,r25   ;  16  addqi3/1  [length = 1]

11

  sub r24,r18   ;  17  subqi3/1  [length = 1]

12

  sts m,r24   ;  18  movqi_insn/3  [length = 2]

13

  ret   ;  26  return  [length = 1]

Was ich nicht verstehe ist, was das mit Verschlüsselung zu tun haben 
soll.

Scheint eher ne Obfuscation zu werden als ne handfeste, seriöse 
Verschlüsselung...

Mir fällt gerade auf, das innere, die tatsächliche Division+Modulo, 
könnte man in eine Schleife packen, aber so ists übersichtlicher :)

Jeromyo Hochgesang schrieb:
> aber so ists übersichtlicher :)
ernsthaft?