1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

procedure TForm1.BerechnenClick(Sender: TObject);
var a,b,c:integer;
begin
  for a:=1 to 2500 do
  for b:=a to 2500 do
  for c:=b to 2500 do
  if a*a+b*b=c*c then
  if not((a mod 2=0) and (b mod 2=0) and (c mod 2=0)) then
  if not((a mod 3=0) and (b mod 3=0) and (c mod 3=0)) then
  if not((a mod 4=0) and (b mod 4=0) and (c mod 4=0)) then
  if not((a mod 5=0) and (b mod 5=0) and (c mod 5=0)) then
  if not((a mod 6=0) and (b mod 6=0) and (c mod 6=0)) then
  if not((a mod 7=0) and (b mod 7=0) and (c mod 7=0)) then
  if not((a mod 8=0) and (b mod 8=0) and (c mod 8=0)) then
  if not((a mod 9=0) and (b mod 9=0) and (c mod 9=0)) then
  if not((a mod 10=0) and (b mod 10=0) and (c mod 10=0)) then
  listbox1.items.add(inttostr(a)+' '+inttostr(b)+' '+inttostr(c));
end;                    

1:

 if (ggT(a,b) = 1) and (ggT(a,c) = 1) and (ggt(b,c) = 1) then                    

1:
2:
3:
4:
5:
6:
7:
8:

1. Erstelle Feld (Matrix), evtl. Shortint um Speicher zu sparen, der Dimension [1.. MaxZahl, 1..MaxZahl] und belege alle Werte mit "-1" (=Status des Zahlenpaars ist unbekannt)
2. für i=1 .. Maxzahl und j=i+1 .. Maxzahl:
 Wenn Feld[i,j]=-1  (also unbekannter Status des Paares (i,j) dann:
  Wenn sqrt (i*i+j*j) ganze Zahl dann:
   Feld [i,j] := 1 // Zahlenpaar (i,j) ist korrekte Lösung
   und weiterhin(wichtig!): Alle Feld  [i*x,j*x] mit i*x<=Maxzahl und j*x<Maxzahl auf 0 setzen. Bedeutet: Diese Zahlenpaare sind nur Vielfache der gefundenen Lösung, also für die weitere Berechnung überspringen

3. Ausgabe der Ergebnisse (gebe alle (i,j,i*i+j*j) aus, für die gilt: Feld[i,j]=1)                    

1:

 if (ggT(a,b) = 1) and (ggT(a,c) = 1) and (ggt(b,c) = 1) then                    

1:

 if (ggt(c,ggT(a,b)) = 1) then                    

1:

if (ggt(a,b)=1) and (ggt(a,c)=1) and (ggt(b,c)=1) then                    

1:

if ggt(ggt(a,b),c)=1 then                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:

procedure TForm1.BerechnenClick(Sender: TObject);
var a,b,c,cquadrat:integer;
function ggt(zahl1,zahl2:integer):integer;
var rest:integer;
begin
  repeat
  rest:=zahl1 mod zahl2;
  zahl1:=zahl2;
  zahl2:=rest;
  until rest=0;
  ggt:=zahl1;
end;
begin
  for a:=1 to 2500 do
  for b:=a to 2500 do
  begin
  cquadrat:=a*a + b*b;
  c:=trunc(sqrt(cquadrat));
  if (c<=2500) and (c * c = cquadrat) then
  begin
  if (ggt(a,b)=1) and (ggt(a,c)=1) and (ggt(b,c)=1) then
  listbox1.items.add(inttostr(a)+' '+inttostr(b)+' '+inttostr(c));
  end;
  end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:

procedure TForm1.BerechnenClick(Sender: TObject);
var 
  a,b,c,cquadrat:integer;
  
  function ggt(zahl1,zahl2:integer):integer;
  var 
    rest:integer;
  begin
    repeat
      rest:=zahl1 mod zahl2;
      zahl1:=zahl2;
      zahl2:=rest;
    until rest=0;
    Result:=zahl1;
  end;
  
begin
  ListBox1.Items.BeginUpdate;
  try
    ListBox1.Items.Clear;
    for a:=1 to 2500 do
      for b:=a to 2500 do
      begin
        cquadrat:=sqr(a) + sqr(b);
        c:=trunc(sqrt(cquadrat));
        if (c<=2500) and (sqr(c) = cquadrat) then
        begin
          if (ggt(a,b)=1) and (ggt(a,c)=1) and (ggt(b,c)=1) then
            listbox1.items.add(Format('%d %d %d', [a, b, c]));
        end;
      end;
  finally
    ListBox1.Items.EndUpdate;
  end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:

{$IFDEF FPC}
  {$MODE Delphi}
{$else}
  {$Apptype Console}
{$ENDIF}
uses
  sysutils;
const
  max = 100000;  
var
  T1,T0: TDateTime;
  Wur  : double;
  a,b,c,aMax,
  cnt1 : NativeInt; 
  
function ggt(zahl1,zahl2:NativeInt):NativeInt;
  var 
    rest:integer;
  begin
    repeat
      rest:=zahl1 mod zahl2;
      zahl1:=zahl2;
      zahl2:=rest;
    until rest=0;
    Result:=zahl1;
  end;
begin  
  T0 := now;
 cnt1 := 0;// Unter 3 gibt es keins
 for a:= 3 to max do
   begin
   aMax := trunc(sqrt(sqr(max)-sqr(a))); 
   for b:=a+1 to aMax do
     begin
     Wur := sqrt(sqr(a) + sqr(b));
     c := trunc(Wur);
     if c = Wur then
       begin
       IF (ggt(a,b)<>1) then
         continue;        
       inc(cnt1);
       IF (ggt(c,a)<>1) OR (ggt(c,b)<>1) then
         writeln(Format('%d %d %d', [a, b, c]));
       end;
     end;
   end;
  T1 := now;   
  writeln(' Anzahl: ',cnt1);
  writeln(FormatDateTime('HH:NN.SS.ZZZ',T1-T0));
end.
{Ausgabe
Anzahl: 15919
00:01.54.717
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:

         n       ̃P(n) ( Anzahl phytagoräischer Tripel mit a,b < n
        10         2
        50        16
       100        36
       500       180
      1000       358
      5000      1780
     10000      3576
     50000     17856
    100000     35722
    500000    178600
   1000000    357200
   5000000   1786016
  10000000   3572022
  50000000  17860382
 100000000  35720710
 200000000  71441356
 300000000 107162112
 400000000 142882968
 500000000 178603536
 600000000 214324350
 700000000 250045106
 800000000 285765804
 900000000 321486520
1000000000 357207278                    

1:
2:
3:

Folge A  a2 = 2·(c1-b1)+a1 ; b2 = 2·(c1+a1)-b1 ; c2 = 2·(a1-b1)+3·c1
Folge S  a2 = 2·(c1+a1)+b1 ; b2 = 2·(c1+b1)+a1 ; c2 = 2·(a1+b1)+3·c1
Folge D  a2 = 2·(c1-a1)+b1 ; b2 = 2·(c1+b1)-a1 ; c2 = 2·(b1-a1)+3·c1                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:

procedure TForm1.Button1Click(Sender: TObject);
var a,b,c,a2,b2,c2,anzahl,grenze:int64;

procedure folges(a,b,c:int64); forward;
procedure folged(a,b,c:int64); forward;

procedure folgea(a,b,c:int64);
begin
    a2:=2*(c-b)+a;
    b2:=2*(c+a)-b;
    c2:=2*(a-b)+3*c;
    a:=a2;
    b:=b2;
    c:=c2;
    if b<=grenze then
    begin
      inc(anzahl);
      folgea(a,b,c);
      folges(a,b,c);
      folged(a,b,c);
    end;
end;
procedure folges(a,b,c:int64);
begin
    a2:=2*(c+a)+b;
    b2:=2*(c+b)+a;
    c2:=2*(a+b)+3*c;
    a:=a2;
    b:=b2;
    c:=c2;
    if b<=grenze then
    begin
      inc(anzahl);
      folgea(a,b,c);
      folges(a,b,c);
      folged(a,b,c);
    end;
end;
procedure folged(a,b,c:int64);
begin
    a2:=2*(c-a)+b;
    b2:=2*(c+b)-a;
    c2:=2*(b-a)+3*c;
    a:=a2;
    b:=b2;
    c:=c2;
    if b<=grenze then
    begin
      inc(anzahl);
      folgea(a,b,c);
      folges(a,b,c);
      folged(a,b,c);
    end;
end;
begin
     grenze:=10;
   repeat
     anzahl:=1;
     a:=3; b:=4; c:=5;
     folgea(a,b,c);
     a:=3; b:=4; c:=5;
     folges(a,b,c);
     a:=3; b:=4; c:=5;
     folged(a,b,c);
     listbox1.items.add(format('%d'#9'%d',[grenze,anzahl]));
     if grenze>=1e8 then grenze:=grenze+100000000
                    else grenze:=grenze*10;
     application.processmessages;
   until (grenze>1e9);
end;                    

1:
2:
3:
4:
5:
6:

maximale
Rekursionstiefe      Bis           Anzahl phyth Tripel
      2234          10000000         3572022
      ... //                               Bis = 100-fach -> sqrt(100) = 10 fach Rekursionstiefe
     22359        1000000000       357207278
     44719        4000000000      1428828886                    

1:
2:

 44719  4000000000      1428828886
00:00.12.634                    

1:

MaxRekTiefe = sqrt(MAXGrenze div 2)                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:

procedure TForm1.Button1Click(Sender: TObject);
var a,b,c,anzahl,grenze:int64;

procedure folges(a,b,c:int64); forward;
procedure folged(a,b,c:int64); forward;

procedure folgea(a,b,c:int64);
var a2,b2,c2:int64;
begin
    b2:=2*(c+a)-b;
    if b2<=grenze then
    begin
      a2:=2*(c-b)+a;
      c2:=2*(a-b)+3*c;
      inc(anzahl);
      folgea(a2,b2,c2);
      folges(a2,b2,c2);
      folged(a2,b2,c2);
    end;
end;
procedure folges(a,b,c:int64);
var a2,b2,c2:int64;
begin
    b2:=2*(c+b)+a;
    if b2<=grenze then
    begin
      a2:=2*(c+a)+b;
      c2:=2*(a+b)+3*c;
      inc(anzahl);
      folgea(a2,b2,c2);
      folges(a2,b2,c2);
      folged(a2,b2,c2);
    end;
end;
procedure folged(a,b,c:int64);
var a2,b2,c2:int64;
begin
    b2:=2*(c+b)-a;
    if b2<=grenze then
    begin
      a2:=2*(c-a)+b;
      c2:=2*(b-a)+3*c;
      inc(anzahl);
      folgea(a2,b2,c2);
      folges(a2,b2,c2);
      folged(a2,b2,c2);
    end;
end;
var zeit:integer;
begin
     zeit:=gettickcount;
     grenze:=1000000000;
     anzahl:=1;
     a:=3; b:=4; c:=5;
     folgea(a,b,c);
     a:=3; b:=4; c:=5;
     folges(a,b,c);
     a:=3; b:=4; c:=5;
     folged(a,b,c);
     listbox1.items.add(format('%d'#9'%d',[grenze,2*anzahl]));
     label1.caption:=inttostr(gettickcount-zeit)+' ms';
end;                    

1:
2:

4000000000      1428828886
00:00.15.937                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:

{$IFDEF FPC}
  {$MODE Delphi}
  {$OPTIMIZATION ON}
  {$OPTIMIZATION Regvar}
  {$OPTIMIZATION Peephole}
  {$OPTIMIZATION cse}
  {$OPTIMIZATION asmcse}
{$else}
  {$Apptype Console}
{$ENDIF}
uses
  sysutils;
const
  max = 200000;
var
  T1,T0: TDateTime;
type
   tTripel =  record
                a,b,c : Int64;
              end;
   ptTripel = ^tTripel;           
const
  MaxGrenze = 4*1000*1000*1000;
  Maxtiefe =  round(sqrt(MAXGrenze div 2))+1;
var
  MeinStack : array[0..Maxtiefe+1] of tTripel;
  p0,p1 : ptTripel;
  anzahl,grenze:int64;

procedure folgea; forward;
procedure folges; forward;
procedure folged; forward;

procedure check;
begin
  inc(anzahl);
  // eins tiefer
  p0 := p1; inc(p1);    
  folgea;
  folges;
  folged;
  //wieder eins hoeher
  p1 := p0; dec(p0);
end;

procedure folgea;
begin
    with p0^ do
      begin
      p1^.a :=2*(c-b)+a;
      p1^.b :=2*(c+a)-b;
      p1^.c :=2*(a-b)+3*c;
      end;
    if p1^.b<= grenze then
     check;
end;
procedure folges;
begin
  with p0^ do
    begin
    p1^.a :=2*(c+a)+b;
    p1^.b :=2*(c+b)+a;
    p1^.c :=2*(a+b)+3*c;
    end;
    if p1^.b<= grenze then
     check;
end;

procedure folged;
begin
    with p0^ do
      begin
      p1^.a :=2*(c-a)+b;
      p1^.b :=2*(c+b)-a;
      p1^.c :=2*(b-a)+3*c;
      end;
    if p1^.b<= grenze then
     check;
end;

procedure CountPhyth;
begin
   grenze:= MaxGrenze;
   repeat
     anzahl:=1;
     p0 := @MeinStack[0];
     with p0^ do
       begin
       a:=3; b:=4; c:=5;
       end;
     p1 := p0;
     inc(p1);
      
     folgea;
     folges;
     folged;
     
     writeln(format('%d'#9'%d',[grenze,2*anzahl]));
     if grenze>=1e8 then grenze:=grenze+100000000
                    else grenze:=grenze*10;
   until (grenze>MaxGrenze);
end;
begin
  T0 := now;
  CountPhyth;
  T1 := now;
  writeln(FormatDateTime('HH:NN.SS.ZZZ',T1-T0));
end.
n       P(n)
        10         2
        50        16
       100        36
       500       180
      1000       358
      5000      1780
     10000      3576
     50000     17856
    100000     35722
    500000    178600
   1000000    357200
   5000000   1786016
  10000000   3572022
  50000000  17860382
 100000000  35720710
 500000000 178603536
1000000000 357207278                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:

P$PROGRAM_FOLGEA:
.Lc4:
# Temps allocated between rsp+0 and rsp+0
# [47] begin
  subq  $8,%rsp  // Wozu das? dass muss einen besonderen Grund haben, vielleicht eine Adreese, die bei Absturz aufgerufen wird
.Lc6:
# [48] with p0^ do
  movq  U_P$PROGRAM_P0,%rax  // Zeiger p0 ist in rax und bleibt auch da
# [50] p1^.a :=2*(c-b)+a;
  movq  U_P$PROGRAM_P1,%rsi  // Zeiger p1 ist jetzt in rsi
  movq  16(%rax),%rdx
  movq  8(%rax),%rcx
  subq  %rcx,%rdx
  shlq  $1,%rdx
  movq  (%rax),%rcx
  addq  %rcx,%rdx
  movq  %rdx,(%rsi)
# [51] p1^.b :=2*(c+a)-b;
  movq  U_P$PROGRAM_P1,%rsi // Der Zeiger war schon in RSI ?????????
  movq  16(%rax),%rdx
  movq  (%rax),%rcx
  addq  %rcx,%rdx
  shlq  $1,%rdx
  movq  8(%rax),%rcx
  subq  %rcx,%rdx
  movq  %rdx,8(%rsi)
# [52] p1^.c :=2*(a-b)+3*c;
  movq  U_P$PROGRAM_P1,%rsi // Der Zeiger war schon in RSI ?????????
  movq  (%rax),%rdx
  movq  8(%rax),%rcx
  subq  %rcx,%rdx
  shlq  $1,%rdx
  movq  16(%rax),%rax
  imulq  $3,%rax
  addq  %rax,%rdx
  movq  %rdx,16(%rsi)
# [54] if p1^.b> grenze then
  movq  U_P$PROGRAM_P1,%rax   //???? rsi hat immer noch die richtige Adresse 
  movq  8(%rax),%rax
  cmpq  U_P$PROGRAM_GRENZE,%rax
  jg  .Lj9
# [56] check;
  call  P$PROGRAM_CHECK
.Lj9:
# [57] end;
  addq  $8,%rsp  
  ret                    

1:
2:
3:
4:
5:

Maxtiefe :   223608
Stackgroesze 5366592
100000000000    35720725882
 10000000000     3572072820 // Zum Vergleich 1e9 eingefügt
00:05.45.730                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:

procedure check;
begin
  inc(anzahl);
  // eins tiefer
  inc(p0);
  folgea;
  folges;
  folged;
  //wieder eins hoeher
  dec(p0);
end;

procedure folgea;
var
  p,p1 :ptTripel;
begin
  p1 := p0;
  p:= p1;
  inc(p);
  with p1^ do
    begin
    p^.a :=2*(c-b)+a;
    p^.b :=2*(c+a)-b;
    p^.c :=2*(a-b)+3*c;
    end;
  if p^.b<= grenze then
   check;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:

     anzahl:=1;
     p00 := @MeinStack0[0];
     with p00^ do
       begin
       a:=3; b:=4; c:=5;
       end;
     p01 := @MeinStack1[0];
     with p01^ do
       begin
       a:=3; b:=4; c:=5;
       end;
     p02 := @MeinStack2[0];
     with p02^ do
       begin
       a:=3; b:=4; c:=5;
       end;
StarteTread0 mit folgea;
StarteTread1 mit folges;
StarteTread2 mit folged;