Überprüfen, ob Zahl in unregelmäßigen Bereichen

[xZise]

Ich habe bestimmte Bereiche in einem Array gespeichert (Deren Länge).

Dann habe ich eine Zahl die in einem der Bereiche ist.
Wie kann ich am besten überprüfen in welchen Bereichen die Zahl ist?

Ich hatte zuerst an ein Case gedacht, aber das Problem ist, das es en dyn. Array ist...

PS: Ich will keinen Code snorren (:D) sondern ich würde gerne einen kleinen Denkanstoß haben :D

[3_of_8]

Ich verstehe nicht genau, was du machen willst. Was verstehst du unter einem "Bereich"?

[JasonDX]

Wie speicherst du diese Bereiche?
Das einfachste wird sein, wenn du Schritt fuer Schritt jeden durchgehst und ueberpruefst, ob die Zahl in dem Bereich liegt.
In Pseudocode:

Code:

foreach Bereich in Bereiche do
  if ((Zahl >= Bereich.UntereGrenze) and (Zahl <= Bereich.ObereGrenze)) then
    //Zahl ist in diesem Bereich

greetz
Mike

[Sidorion]

Delphi-Quellcode:

iLoop:=0;
iTest:=0;
Result:=-1;
While iLoop<Length(Bereiche)
Do Begin
  iTest:=iTest+Bereiche[iLoop];
  If _iZahl<=iTest
  Then Begin
    Result:=iLoop;
    Break;
  End;
End;

[xZise]

Also ich speichere eigentlich nur die Länge der "Bereiche"...
Und ein Bereich ist eine Spanne von zusammenhängenden Zahlen:
1, 2, 3, 4, 5, 6, 7, 8, 9

Das wären zum Beispiel 4 Bereiche.

Und nun habe ich eine Zahl zwischen 1 und 9 und möchte gucken, in welchen Bereich diese liegt.

Ich habe mal darüber nachgedacht und folgendes gedacht:

Delphi-Quellcode:

BereicheSum := 0;
for i := 0 to High(Bereiche) do begin
  if (Zahl >= BereicheSum) and (Zahl <= BereicheSum + Bereiche[i]) then
    Showmessage('Bereich gefunden: ' + IntToStr(i));
  BereicheSum := BereicheSum + Bereiche[i];
end;

Nur bekomme ich eine AV bei folgenden (?):
1 2
Zahl = 1

Ich kann mir schon irgendein dummen Fehler denken :D

[bigg]

moin,

Willst du nun wissen wie viele Stellen eine Zahl hat?
Dann denk mal an unser heutiges Zahlensystem. Wie lautet da die Basis? :shock:
Wer zwei gesunde Hände hat, dürfte wohl drauf kommen. :stupid:

x Basis
xx Basis^2
xxx Basis^3
xxxx

Ansonsten könntest du versuchen aus allen Zahlen einen Durschnittswert zu bilden +- einem Toleranzwert von sagen wir 1-5. %

[xZise]

Nein nix mit Stellen: Ich habe eben bestimmte Bereiche... Ich weiß eigentlich nicht wie ich's anders erklären soll!
Hier ist ein Versuch:

Du hast eine zufällige Zahl: x
Und wir haben ein array of bereiche. Diese Bereiche kennzeichenen eine Länge. Sagen wir: b(1), b(2), b(3), b(4), b(5)
Nun ergeben diese Bereiche zusammen eine Länge: l = b(1) + b(2) + b(3) + b(4) + b(5)

Jetzt wollen wir wissen, wo dieses "x" ist. Das heißt ob diese Zahl in einen bereiche-Item ist.
Also könnte man sagen:
Ist im Bereich Y, wenn x - b(1 bis y) <= 0!

[negaH]

Zitat:

1, 2, 3, 4, 5, 6, 7, 8, 9

Das wären zum Beispiel 4 Bereiche.

Und nun habe ich eine Zahl zwischen 1 und 9 und möchte gucken, in welchen Bereich diese liegt.

Ich gehe mal von diesen Angaben aus.

Delphi-Quellcode:

const
  Bereich: array[1..9] of Byte = (0,0,1,2,2,2,2,3,3);
begin
  assert(Zahl in [1...9], 'Zahl muß zwischen 1 bis 9 liegen');

  BereichIndex := Bereich[Zahl];
end;

in der Variablen BereichIndex findest du den Index des Bereiches

0 = 1,2
1 = 3
2 = 4,5,6,7
3 = 8,9

Gruß Hagen

[oldmax]

Hi
Und auch, wenn mir wieder so ein superschlauer sagt, Strings sind "Strohdumm", langsam und uneffizient...
Wie wär es mit einem Array von Strings..
etwa so

Delphi-Quellcode:

Zahlengruppe[1] :=';1;2;3;';
Zahlengruppe[2] :=';4;5;6;';
Zahlengruppe[3] :=';77;106;122;';
Zahlengruppe[4] :=';10;20;30;';

etc.

Delphi-Quellcode:

gefunden:=False;
GuppenNr:=1;
While (GruppenNummer<=MaxNr) and not Gefunden do
begin
  if Pos(';'+IntToStr(ReferenzZahl)+';',Zahlengruppe[GruppenNr])>0 then Gefunden:=True
  else GruppenNr:=GruppenNr+1;
end;

Damit hast du den Vorteil, auch Zahlen in beliebiger Reihenfolge zu gruppieren. Wichtig ist halt, das du das Semikolon am Anfanf und auch am Schluß setzt, damit er mehrstellige Zahlen findet.
Ist doch gar nicht so schwer......
Ach ja, ich sollte noch ergänzen
if Gefunden then ergebnis:=Zahlengeruppe[GuppenNr] else Ergebnis:= 'nicht geführt';

Was immer du zurückbekommst ist erst einmal ein String, den du bei positiven Ergebnis ja Zerlegen kannst, oder einfach nur sagst, "Ok, war nix".
Gruß oldmax

[xZise]

Okay dummerweise hätte ich noch das Const-Array belegen müssen (Es wäre dann ein Var-Array).... Aber so funktionierts:

Delphi-Quellcode:

  Weightings := 0;
  for i := 0 to High(Weighting) do begin
    if (Durchschnitt > Weightings) and (Durchschnitt <= Weightings + Weighting[i]) then begin
      lEntscheidung.Caption := getSelectedItem(i + 1, lwEntscheidungen).Caption;
      break;
    end;
    Weightings := Weightings + Weighting[i];
  end;

Und es tut seinen Dienst. :bounce2:

[bigg]

huch, :shock:

ich glaube ich habe dein Problem nun verstanden. Wobei sich dann eine Liste mit Zeigern verknüpft mit einer Liste mit Integern besser machen würde, imho. Die Liste wird anschließend sortiert und auf Konsistenz geprüft.

[xZise]

Zitat:

Zitat von bigg

Wobei sich dann eine Liste mit Zeigern verknüpft mit einer Liste mit Integern besser machen würde, imho. Die Liste wird anschließend sortiert und auf Konsistenz geprüft.

:D Ähn ja... Ich versteh fast nix :D

[negaH]

Ist auch nicht so wichtig da es besseres gibt.

1. Frage: welche Zahlen kommen vor und wie viele Bereiche gibt es ? Ich frage weil wenn das Set der Zahlen klein ist, zb. eben 1 bis 9 dann ist mein Vorschlag der effizienteste. Es ist eine einfach und direkte Lookup Tabelle und hat Komplexität O(1) !!

2. falls der Zahlenbereich zu groß ist so wird auch die Lockup Tabelle enorm groß und unpraktikabel. In diesem Moment benutzt du einen sortierten binären Baum deiner Bereiche. Bei der Suche in welchem Bereich deine Zahl nun liegt gehst du defakto per binärer Suche vor. Alle bisherigen Vorschläge gehen iterativ und sequientiell durch deine Bereichsliste durch. Dies ist bei vielen Bereichen wesentlich ineffizienter als eine binäre Suche, sei es als Binärer Baum (Trie) oder eine sortierte Liste die per binärer Suche durchsucht wird.

Gruß Hagen

[xZise]

Also die Zahl kann so groß wie ein Int sein und die Berieche zwischen 1 und 10.

[negaH]

bei max. 10 Bereichen lohnt keine aufwendige binäre Suche/Baum.

Delphi-Quellcode:

var
  Bereich: array[0..10] of Integer = (10,100,1000,234567,87654321, MaxInt, 0, 0, 0); // MaxInt als End-Marker
begin
  BereichIndex := Low(Bereich);
  while Zahl > Bereich[BereichIndex] do
    Inc(BereichIndex);
end;

Gruß Hagen