Integer Arrays vergleichen & Primzahlen aus Array löschen?

[tommy_mey]

Hallo,
ich bin Schüler der 13. Klasse und soll bis Dienstag (26.10.04) ein Programm geschrieben haben,welches zwei Arrays vergleicht - das erste (zz) enthält Zufallszahlen, das zweite Array (hilfs) enthält Quadratzahlen die in einer Procedure berechnet werden.

Mein erstes Problem ist nun, ich will die beiden Arrays so vergleichen, dass ein drittes Array (hilfs2) automatisch mit den Werten aus dem Array (zz) aber ohne die Werte aus (hilfs) gefüllt wird...Die Ausgabe soll dann in einer Listbox erfolgen.

Dazu habe ich mir folgenden Algorithmus überlegt
um die Quadratzahlen zu berechnen und ins array (hilfs) zu schreiben

Delphi-Quellcode:

globale Variablen   const max=100;
                          zzA=100;
                          hilfsA=10;
                          hilfsmax=8;
                    var zz:Array[1..zzA] of integer;
                        hilfs:Array[1..hilfsA] of integer;
                        hilfs2:Array[1..zzA] of Integer;

procedure....
var a,z,t:integer;
begin
a:=1;
for z:=1 to hilfsmax do
 begin
  inc(a);
  hilfs[z]:=sqr(a+1);
  listbox3.items.add(inttostr(hilfs[z]));
 end;
end.

hat jemand einen Quelltext um die Arrays zu vergleichen (siehe Einleitung)?

Mein zweites Problem ist:
über eine andere Procedur sollen alle Primzahlen aus dem array (zz) gelöscht werden, davon hab ich keine Ahnung, hat jemand eine Procedure die Primzahlen errechnen kann, welche dann wieder in ein Array gepackt werden? Ich würde dann das Primzahlarray mit dem array (zz), wie bereits oben erwähnt vergleichen wollen, kann mir irgend jemand helfen?


Mein kompletter Quelltext:

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ExtCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    ListBox1: TListBox;
    ListBox2: TListBox;
    Button3: TButton;
    Button4: TButton;
    ListBox3: TListBox;
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure Button3Click(Sender: TObject);
    procedure Button4Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

  const max=100;
        zzA=100;
        hilfsA=10;
        hilfsmax=8;
  var zz:Array[1..zzA] of integer;
      hilfs:Array[1..hilfsA] of integer;
      hilfs2:Array[1..zzA] of Integer;
      anzahl:cardinal;
implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
randomize;
end;

procedure quicksort(li,re:integer); //Sortieren
var i,j,Mitte,hilf:integer;
begin
 i:=li;
 j:=re;
 Mitte:=zz[(re+li)DIV 2];
repeat
   while zz[i]<Mitte do i:=i+1;
   while Mitte<zz[j] do j:=j-1;
   if i<=j
    then
     begin
      hilf:=zz[i];
      zz[i]:=zz[j];
      zz[j]:=hilf;
      i:=i+1;
      j:=j-1;
     end;
until i>j;
if li < j then quicksort(li,j);
if i < re then quicksort(i,re);
end;

procedure TForm1.Button1Click(Sender: TObject); //Zufallszahlen erzeugen und in Array (zz) ablege
var i:Integer;
begin
  for i:=1 to max do
  begin
   zz[i]:=random(100)+1;
   listbox1.Items.add(inttostr(zz[i]));
   end;
end;




procedure TForm1.Button2Click(Sender: TObject); //Löschen der Listbox
begin
listbox1.Clear;
listbox2.Clear;
listbox3.clear;
end;

procedure TForm1.Button3Click(Sender: TObject); //Löschen von ungeraden Zahlen
var i:Integer;
begin
for i:=1 to max do
    begin
     if zz[i] mod 2 <> 1
      then
       begin
           quicksort(1, 100);
           listbox2.Items.add(inttoStr(zz[i]));
       end;
    end;
end;

procedure TForm1.Button4Click(Sender: TObject); //Das soll mal die Quadratzahlprocedure werden
var a,i,k,z,t:integer;
begin
a:=1;
for z:=1 to hilfsmax do //Hier werden die Quadratzahlen berechnet
 begin
  inc(a);
  t:=sqr(a+1);
  hilfs[z]:=t;
  listbox3.items.add(inttostr(hilfs[z]));
 end;
                        //Hier muss die Procedure mit dem Vergleich weitergeführt werden
end.

[edit=Christian Seehase]Weitere Delphi-Tags gesetzt. Code- durch Delphi-Tags ersetzt. Mfg, Christian Seehase[/edit]

[fiasko]

Hallo,

kannst du bitte Delphi-Tags verwenden? Dann kann man den Quellcode wesentlich besser lesen...

[edit]
Mist, zu langsam
[/edit]

...dann zum Quellcode: was ist den das für ein Stil? Ich werde jetzt darauf nicht weider rumreiten... denn bis Dienstag ist es ja nicht mehr lange

zum 1. Problem (Aussortieren der Werte):

Du nimmst 2 verschachtelte for-Schleifen, die erste iteriert über dein zz Array. Für jedes Element aus zz guckst du dann mit der 2. inneren Schleife nach ob es in hilfs existiert - falls ja kommt der nächste drann. Andernfalls kommt es in das Ergebnis Array. Dafür brauchst du dann noch eine Variable die die letzte Position im Ergebnis-Array speichert um immer an die nächst "freie" stelle zu schreiben.


zum 2. Problem:

Das vorgehen ist hier im Prinzip gleich, nur in der 2. Schleife kommt der Primzahlentest. Da du ja schon den Modulo Operator verwendest hast du eigentlich alles was du brauchst. Du schaust einfach ob die Zahl X durch 2 bis X-1 teilbar ist. Vielleicht gibt es da auch tolle Algorithmen dafür... hab ich jetzt aber keine Lust danach zu googlen .

Das sind erstmal ein paar Ansätze....

[Nikolas]

Musst du das zweite Array mit den Quadratzahlen benutzen? Wenn nicht mach es doch einfach so:

Nimm die erste Zufallszahl, zieh die Wurzel draus und schau, ob das Ergebniss eine ganze Zahl ist.

[tommy_mey]

Sorry, wegen dem Stil - könnt ihr mir den Code dazu machen, ich hab versucht es mit
der Methode von toxman zu machen, aber ich kann nciht prüfen lassen ob eine ganze Zahl rauskommt (integer), weil Qurzelziehen einen real Datentyp veraussetzt - damit kann man aber wie gesagt nicht schreiben "mod 2<>1" um auf eine ganze Zahl prüfen zu lassen...
kannst du mir das mal schreiben...bitte...

zu fiasko...das mit den Primzahlen versth ich nicht, kannst du mir dazu den Code schreiben zu meinen Problem geben - sorry, aber ich versteh nur Bahnhof
bei mir würde das mit den ²Zahlen so aussehen:

Code:

for i:=1 to max do
 begin
  for x:=1 to max do
   begin
    if hilfs[x] = zz[x] 
    then 
     begin
      boolean = true ;
      ....weiter weiß ich noch nicht

Dank ech....Thomas

[fiasko]

Hallo,

Bitte verwende die Delphi-Code Tags wenn du Delphi-Code schreibst - das erhöht die Leserlichkeit wesentlich!

Zitat von tommy_mey:

Sorry, wegen dem Stil - könnt ihr mir den Code dazu machen, ich hab versucht es mit

Ne, wir können dir Tips geben wo du weiterkommst, deine Hausaufgaben lösen wir dir aber nicht. Ist schon ziemlich knapp kalkuliert sich am 24. anzumelden um bis zum 26. eine Lösung serviert zu bekommen


Der Vorschlag von Toxman funktioniert schon, man könnte etwas der Art

sqrt(zz[i]) - trunc(sqrt(zz[i])) <= 0.001 testen. Zu deinem Code-Schnipsel:

Delphi-Quellcode:

function ist_quadratzahl(x: integer): boolean;
begin
  result := sqrt(x) - trunc(sqrt(x)) <= 0.001;
end;

// ...

pos := 0;

for i:=1 to max do
begin
  if not ist_quadratzahl(zz[i]) then
  begin
    inc(pos);
    hilfs2[pos] := zz[i];
  end;
end;

Damit sollten dann in hilfs2 alle nicht Quadratzahl enthalten seien (insgesammt pos Stück). Für die Primzahlen schreibst du einfach eine Funktion ist_primzahl die TRUE zurückgibt wenn es eine ist, ansonsten FALSE und verwendest die mit der gleichen Schleife wie oben.

Wie die ist_primzahl FUnktion aussehen mußt du dir noch ausdenken... könnte man ja mal anwenden was man so aus Mathe weiß, daß eine Primzahl nur durch 1 und durch sich selbst ohne Rest teilbar ist...

[Nikolas]

Warum so ungenau bei ist_quadratzahl?

Delphi-Quellcode:

function ist_quadratzahl(x: integer): boolean;
begin
  if (sqrt(x) = trunc(sqrt(x)) then result:=true else result:= false;
end;

[fiasko]

Zitat von Toxman:

Warum so ungenau bei ist_quadratzahl?

Weil es Fließkommazahlen sind und ein Gleichheitszeichen bei Fließkommazahlen eigentlich ziemlich witzlos ist - ich hab das jetzt allerdings auch nicht nachgeprüft ob meine Grenze fein genug ist... so richtig schmecken tut mir die Lösung aber auch nicht.

[Nikolas]

Ich hab's getestet und da funktioniert es gut. Bei deiner Version (>0,001) gibt es immer eine Grenze, ab der die Funktion nicht mehr genau ist. Wär interessant, die mal zu errechnen, aber dafür bin ich jetzt zu müde