Array 3x3 prüfen ob Zahl doppelt

[Marcel2906]

Guten morgen,

ich habe ein Problem.
Ich habe ein Array 3x3 und möchte prüfen ob eine Zahl darin doppelt vorkommt.
Ich bin noch dabei ein Struktogramm zu entwerfen, habe noch nicht angefangen zu programmieren, deswegen leider noch kein Code. Vielleicht kann mir einer einen Denkanstoß geben

[Edit] Mein erster Versuch (Anhang)...aber so überprüfe ich nur ob die erste Zahl nochmals vorkommt.

[scrat1979]

Wie wäre es mit zwei Schleifen die Zeilen und Spalten des Arrays durchzugehen und einen Flag zu setzen, das ganze noch schön in einer Funktion verpackt...

[Marcel2906]

Zitat von scrat1979:

Wie wäre es mit zwei Schleifen die Zeilen und Spalten des Arrays durchzugehen und einen Flag zu setzen, das ganze noch schön in einer Funktion verpackt...

Ja schleife hört sich gut an, nur weiß ich nicht genau wie die schleife aussehen soll.
Und was ist "Flag" ?
Bin noch ein Anfänger im Programmieren

[himitsu]

Wie würdest du denn einmehrfaches Vorkommen in einem eindimensionalen Array prüfen?


für das Zweidimansionale könnte man
- zwei Schleifen für die Dimensionen und das nochmals doppelt, für die Suche
- oder eine Schleife für die Dimensionen (x und y verrechnet) und das ebenfalls verdoppelt


zweidimensionale Schleife:
für Indize von je 0 bis anzahl-1
schleife i := 0 bis anzahl_x*anzahl_y-1 .
und darin jeweils x := i div anzahl_x und y := i mod anzahl_x .

[Marcel2906]

Zitat von himitsu:

Wie würdest du denn einmehrfaches Vorkommen in einem eindimensionalen Array prüfen?

Ungefähr so:

Delphi-Quellcode:

while i < Array[high] begin

   if Array[x] = Array[x+i] then begin
      'Fehler'
      break;
   end;
      else begin
         i= i+1;
      end;
end;

Aber mit dem Zweidimensional hab ich noch nicht ganz verstanden wie das dann funktionieren soll

[himitsu]

Damit prüfst du aber nur, ob zwei aufeinanderfolgende (+1) Werte gleich sind.

Deine While-Schleife entspricht ja dieser For-Schleife:
(vergleiche jeden Wert mit seinem Nachfolger)

Delphi-Quellcode:

for i := 0 to High(arr) - 1 do
  if arr[i] = arr[i + 1] then Gleich;

> Bei einem sortieren Array wäre das aber dennoch vollkommen ausreichend.


So könnte man z.B. prüfen, ob Werte irgendwo mehrfach vorkommen.
(vergleiche jeden Wert mit allen anderen Werten)

Delphi-Quellcode:

for i := 0 to High(arr) do
  for i2 := 0 to High(arr) do
    if (i <> i2) and (arr[i] = arr[i2]) then Gleich;

oder schneller, da man bereits geprüfte Wertpaare leicht überspringen kann.

Delphi-Quellcode:

for i := 0 to High(arr) - 1 do
  for i2 := i + 1 to High(arr) do
    if arr[i] = arr[i2] then Gleich;

das ganze auf zweidimensional umgestellt

Delphi-Quellcode:

for x := 0 to High(arr) do
  for y := 0 to High(arr[x]) do
    for x2 := 0 to High(arr) do
      for y2 := 0 to High(arr[x2]) do
        if ((x <> x2) or (y <> y2)) and (arr[x, y] = arr[x2, y2]) then Gleich;

Wie man jetzt z.B. x und y eines zweidimensionalen Arrays zusammenrechnet und wieder zerlegt, hab ich ja vorhin schonmal genannt.
Somit kann man die "eindimensionalen" Schleifen verwenden und zerligt sich dann den Schleifenzähler wieder in zwei Schleifenwerte.

[DeddyH]

Sofern sich die Zahlen im Byte-Bereich (0 - 255) bewegen, ließe sich das noch einfacher über eine Menge lösen.

[edit] Oder auch über eine Liste oder ein dynamisches Array:
- Zuerst ist die Liste leer.
- Dann wird das zu untersuchende Array durchlaufen und untersucht, ob die aktuell enthaltene Zahl bereits in der Liste enthalten ist. Wenn nicht, dann hinzufügen, ansonsten sind wir ja schon fertig.[/edit]