Hilfe bei Turbo Pascal

[Ineluki]

Aloa

Die aufgaben sind alle recht einfach und zudem noch sehr interessnt ..

ich reisse mal hier die loesungen kurz an

Aufgabe 7_1

Das kgv von a und b ist die kleinste zahl, die sowohl a als auch b als teiler hat .. daher koennte man folgendermassen vorgehen

Code:

function kgv(a,b:integer):integer;
var result:integer;
begin
result:=1;
while ((result mod a)<>0)OR((result mod b)<>0) do inc(result);
kgv:=result;
end;

Erklaehrung ... solange result bei der division durch a einen rest ungleich 0 gibt oder analog bei b, so ist die zahl nicht durch a und b teilbar ... somt erhoehen wir um 1 ... und da wir bei 1 beginnen, tasten wir uns von unten an das kgv heran

man koennte die ganze sache beschleunigen, wenn man vorher ueberprueft, ob a oder b kleiner ist und dann statt mit 1 mit dem kleineren der beiden werte angngen lassen zu zaehlen, da ein kgv nie kleiner als a und b sein kann

Code:

 if a < b then result:=a else result:=b;

Aufgabe 7_2

Hierbei liegt das Problem darin, das die zahlen so lang sind, das sie nicht mehr in ein integer passen ...

es gibt mehere loesungen ...
man koennte veruchen, die zahlen als real zu speichern .. aber das wird wahrscheinlich nicht ausreichen ...

auf neueren compilern gibt es auch 64 bit integer typen .. aber die unterstuetzt TP noch nicht ...

die sicherste moegliechkeit ist, die zahlen als strings zu speichern und die bereechnungen selber zu uebernehmen ...

dazu verwendet man am besten die regeln fuer die schriftliche addition / subtraktion / multiplikation, die dir ja gelaeufig sein sollten ...

dann musst du den kuerzeren string mit nullen am anfang auffuellen, das beide die selbe laenge haben

und dann liest du die strings von rechts nach links aus und betrachtest die einzelnen zeichen als ziffern (val und str helfen hier sicherlich oder du rechnest per ord und chr um)

das ganze packst du in eine forschleife ...

Code:

function c2b(c:char):byte;
begin
c2b:=ord(c)-ord('0');
end; 

function b2c(b:byte):char;
begin
b2c:=chr(b+ord('0'));
end;

function add(zahl1,zahl2:string):string;
var addstring:string;
    temp,i,rest:byte;
begin
{zahl1 = lange zahl  zahl 2 = kurze zahl, aufgefuellt mit beginnenden Nullen }

addstring:='';
rest:=0;
for i:=length(zahl1) downto 1 do
begin
temp:=c2b(zahl1[i])+c2b(zahl2[i])+rest;
if temp>10 then begin 
                 rest:=1;
                 temp:=temp-10;
                end
else rest:=0;
addstring:=b2c(temp)+addstring;
end;
if rest<>0 then addstring:=b2c(rest)+addstring;
add:=addstring;
end;

das ganze machst du analog fuer die subtraktion und die multiplikation .. wobei die multiplikation etwas kniffliger wrden koennte und du vielleicht zum zwischenspeichern der strings eine textdatei verwenden solltest

Aufgabe 7_3

diese aufgabe besteht aus zwei teilabschnitten .. a) dem ermitteln der teiler (wieder mit mod) und dere aufsummieren und vergleichen mit der zahl selber ...

das ganze sieht dann so aus

Code:

var perfekt,zahl,i,summe:integer;
begin
perfekt:=0;
zahl:=6; {wir fangen mit 7 an, da es sonst zu trivial wird 1 waere perfekt und 6 waere perfekt .. aber die sind nicht gesucht}
repeat
inc(zahl); {daher 7}
summe:=0;
for i:=1 to zahl-1 do 
if (zahl mod i)=0 then summe:=summe+i;
{alle teiler aufsummiert, jetzt testen ob summe = zahl}
if summe = zahl then
begin
inc(perfekt);
writeln(perfekt,'. perfekte Zahl: ',zahl);
end;
until perfekt>=4;
end.

Aufgabe 7_4

Der trick der verkuerzung ist folgender:
1) Da jede gerade zahl durch 2 teilbar ist, kann sie keine primzahl sein.
2) Da eine Primzahl nur durch 1 und sich selbst teilbar ist kommen nur die zahlen, die kleiner als die wurzel der zahl sind als teiler in frage, da wenn der teiler groesser als die wurzel waere, er als zweiten faktor eine zahl brauchte, die kleiner als die wurzel ist

daher ergibt sich folgende aenderung:

die zeile pz:=TRUE; aendern wir in pz:=Odd(zahl) or (zahl=2);
damit wird erst gar nicht nach teilern gesucht, wenn die zahl gerade ist

zudem koennen wir eine weitere beschleunogung vornehmen, indem wir die zeile inc(probenteiler) in inc(probenteiler,2) umaendern .. da eine ungerade zahl nie eine gerade zahl als teiler haben kann, muessen wir nur auf ungerade zahlen als teiler testen .. und die erhaellt man, indem man zu einer ungeraden zahl (probenteiler:=1) immer 2 addiert

um bedingung 2) zu erfuellen reicht es aus, die bedingung der repeatschleife zu aendern in

UNTIL (Probeteiler>=sqrt(zahl)) OR not(PZ);

damit waeren wir fertig mit der bechleunigung

zudem hat das vorgegebene programm einen schoenheitsfehler und einen bug:

die zeile Probeteiler:=-1; gleich an anfang hat keinerlei funktion und kann entfallen ... und 1 ist laut definition KEINE primzahl und dennoch gibt das programm bei 1 TRUE zurueck ... dies laesst sich durch eine eifache aenderung beheben :

pz:=(odd(zahl) AND (zahl<>1)) or (zahl=2);

die ausgabe aller primzahlen bis 10000 laesst sich in einer einfachen forschleife realisieren bzw schneller ueber eine repeat until schleife

Code:

i:=1;
repeat
i:=i+2;
if prim(i) then write(i,'   ');
until i>=10000;

fuer den abstand zwischen den primzahlen zaehlt man einfach bei der ueberpruefung mit, wieoft keine primzahl seit der letzten primzahl auftauchte

Code:

i:=1; luecke:=0; letzte_PZ:=0;
jenseits50:=false;
repeat
i:=i+2; luecke:=luecke+2;
if prim(i) then 
 begin 
 luecke:=0;
 if jenseits50 then naechste_PZ:=i else letzte_PZ:=i;
end;
jenseits50:= luecke>=50 or jenseits50;
until (jenseits50) and (luecke=0);
writeln('Zwischen ',letzte_PZ,' und ',naechste_PZ,' stehen erstmals 50 andere Zahlen');

So das wars .. hoffe, ich konnte dir etwas weiterhelfen ...

Fuer Bugs, tippfehler und Richtigkeit wird wie immer keinerlei haftung uebernommen. Alle texte sind NICHT getestet und frei aus dem gefaechtnis geschrieben

Gruss Ineluki