Gibt es ein mathematisches Verfahren, mit dem man 2 Integerwerte a, b mit Hilfe einer Konstante k so in EINEM Integerwert c speichern kann, dass man mit Hilfe dieser Konstante k aus c wieder a, b gewinnen kann?

Irgendwie habe ich das Gefühl, dass das gehen müsste ...

markieren

Delphi-Quellcode:

c := Speichern(a, b, k);

a := Extrahieren1(c, k);
b := Extrahieren2(c, k);

Das geht nicht!

Das würde ja bedeuten das man jede Datei ( 4 GB DVD-Video) in einem Integer speichern können müßte wenn man den Dateiinhalt jeweils als Blöcke von 2 Integerwerten (4 Byte) ansehen würde und den Algorithmus rekursiv anwendet.

Du könntest höchstens 2 16-Bit Integerwerte in einem 32-Bit Integer speichern. Da sparst du aber nichts

Da gibt es zwei Möglichkeiten:

1. Weniger (wie mkinzler vorgeschlagen) - du speicherst also keine zwei Integers in einem, sondern zwei Words in einem int oder zwei ints in einem Int64. Einen oben, einen unten -> kein Informationsverlust

2. xor - geht nicht ganz so, wie du es willst: c := a xor b; ==> du kannst mit einem wert den anderen herausfinden.

Aber wenn man zwei beliebige Integers in einem verlustfrei und reversiebel speichern könnte, wäre das ja ein endgeiles Komprimierungsverfahren

Zitat von mkinzler:

Du könntest höchstens 2 16-Bit Integerwerte in einem 32-Bit Integer speichern. Da sparst du aber nichts

Es geht mir nicht um's Sparen, sondern um's Verfahren (reimt sich sogar ...)
Wie würde das in Delphi-Code aussehen?

Ganz einfach? So:

markieren

Delphi-Quellcode:

a: Cardinal;
begin
  a := MakeLong(2457, 546);
end;

Rausholen dann so:

markieren

Delphi-Quellcode:

b := HiWord(a);
c := LoWord(a);

Um die Antwort von mkinzler (die einzig brauchbare soweit mal etwas zu verallgemeinern.

Eine normale Integer-Variable hat einen gewissen Wertebereich (je nach Typ siehe Online-Hilfe). Wenn Du jetzt zwei Werte speichern möchtest, die aber nur einen kleineren Wertebereich annehmen können, dann kannst du das natürlich umwandeln.

Beispiel: Du möchtest Alter und Gewicht speichern, beim Alter gehst Du von möglichen Werten von 0-200 aus (Sicherheitsreserve!), beim Gewicht von 0-1000kg. Dann multiplizierst Du den einen Wert des einen Parameters (Alter) mit dem Maximalwert des anderen Parameters (Gewicht) und bekommst so eine einzelne Integerzahl. Die kannst Du nun in einer Variable speichern, wenn diese Variable mindestens Zahlen von (Maximalwert Alter)*(Maximalwert Gewicht) aufnehmen kann, in unserem Fall also 200000. Das sollte jede 32bit-Integervariable können.

Um an die Einzelwerte zu kommen, teilst Du Deine Integervariable durch den Maximalwert des einen Parameters, dann erhälst Du als ganzzahliges Ergebnis das Alter und als Rest der Division das Gewicht.

markieren

Delphi-Quellcode:

const MaxGewicht = 1000
var variable: Integer;
      Alter, Gewicht: Integer;
begin
  // kodieren..
  variable := Alter * MaxGewicht + Gewicht;
  // und wieder zurück
  Alter := variable div MaxGewicht);
  Gewicht := variable mod MaxGewicht);
end;

Wenn negative Werte ins Spiel kommen, wird es allerdings etwas komplizierter, aber das Grundprinzip bleibt gleich.

Gruß,
Michael

ein normaler Integer ist 32bit(4 Byte) groß. Wenn du 2 darin 2 Integer speichern willst dürfen diese jeweils nur 2 Byte groß sein sonst gibts ein Problem.
Funktionieren würde es mit move (speicher direkt kopieren) oder mit Bytes shiften oder durch definieren eines neuen Types oder....

zusammenfalten · markieren

Delphi-Quellcode:

type
  TInteger = packed record
    case Bool of
      True : (NormalInt: Integer);
      False : (Part1: SmallInt;
               Part2: SmallInt;);
  end;


var
  Variable: TInteger;
begin
  Varialbe.Part1 := Zahl1;
  Variable.Part2 := Zahl2;
  Variable.NormalInt := Variable.NormalInt xor Zahl3;
end;

Die Variante von fJeins ist natürlich um einiges kürzer

Zitat:

Gibt es ein mathematisches Verfahren, mit dem man 2 Integerwerte a, b mit Hilfe einer Konstante k so in EINEM Integerwert c speichern kann, dass man mit Hilfe dieser Konstante k aus c wieder a, b gewinnen kann?

Ja das geht, hängt aber von bestimmten Randbedinungen ab.

Falls zb. |A| und |B| kleiner 128 wären dann multiplizierst du A mit 128 und addierst B drauf. Das |Resulat| kann dann niemals 127*129 überschreiten und das passt in den Datentyp Integer rein.

Zurückwandeln kannst du mit A := Resultat mod 128, B := Resultat div 128;

Gruß Hagen

Zitat von negaH:

Falls zb. |A| und |B| kleiner 128 wären dann multiplizierst du A mit 128 und addierst B drauf. Das |Resulat| kann dann niemals 127*129 überschreiten und das passt in den Datentyp Integer rein.

Hallo Hagen,
wie schnell die doch Zeit vergeht. Gestern noch 8bit und heute sind wir schon beim 32bit Prozessor. Damit ist die Grenze nicht mehr bei 128, sondern bei 32768.

Sirius

PS: Ich weis: Krümelkacker
PPS: Soll ich dir nochwas verraten? Ca. 10km von hier wird ein 64bit-Prozessor gebaut