Variationen

Wissenschaft Physik
1

Hi.

Gegeben seien:

k-Elemente mit den Ausprägungen: 0 oder 1.

Ich möchte ALLE Variationen erzeugen lassen.

Kein Problem?
Einfach k-FOR Schleifen verwenden?
Das ist das Problem!
Ich suche eine kleine & saubere (möglichst NICHT-rekursive)
Lösung (auch für k>30).
Zudem sollte die aktuell erzeugte Variation einfach & bequem
für die weitere Bearbeitung übergeben werden können.

Für Hinweise / Empfehlungen / (Komplett)Lösungen
vielen Dank!

mfg
SAB

2

Hallo,
also, ich hoffe, ich hab Dich richtig verstanden: Du willst alle Möglichkeiten k Nullen und Einsen hintereinander anzuordnen? Oder so ähnlich? Das wäre doch…

M={m | m=bin(i), i elem 20…2k}

Oder? Wobei bin(x) die binäre Darstellung von x ist. Im Zweifelsfalle die Menge {0} hinzufügen. Entscheiden für die bin() ist, wie Du in den nachfolgenden Bearbeitunsschritten die mi gerne hättest (Liste, String…).

Und wenn wir uns jetzt völlig mißverstanden haben und ich kompletten Blödsinn geqatscht hab, dann möchte ich mich schon im Vorraus entschuldigen.

Das Zentrum.

[Bei dieser Antwort wurde das Vollzitat nachträglich automatisiert entfernt]

3

Hi.

moin
hmm wieviel bit hat noch mal nen longint, 32 oder so, na egal also ich schreibs mal in pascal notation (iss für mich einfacher)

const bitlaenge = 29; {dein k-1}
var i:longint;
procedure writebin(v:longint);
var s:string;
begin
s := ‚‘;
for c := 0 to bitlänge
if odd(v) then s:=‚1‘+s else s:= ‚0‘+s;
v := v div 2;
end;

for i:= 0 to 1073741824 {2^(bitlänge+1)}
do writebin(i);

mfg
SAB

bei k> 32 wirds natürlich schwieriger … *fg*

ciao norbert

4

Hi Norbert.

Vielen Dank für Dein Programmlisting.

bei k> 32 wirds natürlich schwieriger … *fg*

Genau das ist mein Problem, da ich auch unter TP arbeite.

Gruss,
SAB

5

Genau das ist mein Problem, da ich auch unter TP arbeite.

Gruss,
SAB

Tach nochmal.
Hm, mit der Aussage über TP wird das Problem doch schon konkretisiert. Wie wäre es mit einer Liste von Charactern? Oder gleich einem String, wo doch TP sowas schon als Grundtyp dahat? Dann würde die Grenze zumindest erstmal auf 255, wenn ich mich recht entsinne ansteigen. Hab leider kein TP da. Also ich würde eine Funktion schreiben, die mir jeweils den Nachfolger der Liste bildet und die dann jedesmal ausgeben. Warte, wie war das gleich (lang, lang ist’s her):

function nachfolg (jetzt: array[1..k] of int) : array[1..k] of int;
var uebertr, i: int;
begin
 {eins dazuaddieren}
 jetzt[1] := jetzt[1] + 1;
 {gucken, ob es einen Übertrag gibt}
 if jetzt[1] = 2 then
 begin
 jetzt[1] := 0;
 uebertr := 1;
 end {then}
 else
 uebertr := 0;
 {
 und den evtl bis zum Ende durchschleifen (vielleicht könnte man hier vorher noch ein if einbauen)
 }
 for i = 2 to k do
 begin
 jetzt[i] := jetzt[i] + uebertr;
 if jetzt[i] = 2 then
 begin
 jetzt[i] := 0;
 uebertr := 1;
 end {then}
 else
 uebertr := 0;
 end; {for}
 nachfolg := jetzt;
end; {function}

Nagelt mich jetzt bitte nicht auf die genaue Syntax fest (hab keinen Compiler da), aber so oder so änlich könnte es doch funktionieren. Und das array sollte eigentlich nur durch den Speicher begrenzt werden. Evtl könnte man int auch duch byte ersetzten, sowas gab’s, glaube ich. Der Effekt ist aber bescheiden, da ein Byte auch zwei Byte groß ist. Klingt doof. Allerdings wird der Speicher geradzahlig ausgerichtet (oder so ähnlich). Hülft das?