Riesige Boolean-Array verkleinern?

Mathematiker · Verfasst: Mo 15.04.13 17:16

Hallo,

Tranx hat folgendes geschrieben :

... nur noch die Differenz zwischen der vorherigen und der aktuellen Primzahl. Das werden selbst bei sehr hohen Primzahlen immer noch wesentlich kleinere Werte als die Primzahlen selber sein.
Dann kommt man möglicherweise schon mit Longint (4 Byte Integer) aus.

Da ab der Primzahl 1425172824437699411 bis zur nächsten nur ein Abstand von 1476 auftritt, kannst Du auch smallint (2 Byte) für die Differenz verwenden.
Sicher gibt es zwei aufeinanderfolgende Primzahlen mit einem Abstand > 32767, aber die kleinste von denen ist nicht bekannt und wahrscheinlich sehr groß.

Eine schnelle bitorientierte Variante des Primzahlsiebs hat Fiete schon unter www.entwickler-ecke....tVersion_108729.html veröffentlicht.

Beste Grüße
Mathematiker

_________________
Töten im Krieg ist nach meiner Auffassung um nichts besser als gewöhnlicher Mord. Albert Einstein

IhopeonlyReader · Beiträge: 600 Erhaltene Danke: 23 Delphi 7 PE

ich rechne mit meinem Sieb schneller obwohl ich die geraden zahlen noch drin habe... allerdings arbeite ich immer noch mit 8 Bit- Booleans und ich denke nach der Umstellung werde ich zwar "weiter" rechnen können, das allerdings auf kosten der rechenzeit... ich werde es sehen.. denke morgen finde ich zeit dazu

_________________
Sucht "neueres" Delphi

Wer nicht brauch was er hat, brauch auch nicht was er nicht hat!

IhopeonlyReader · Beiträge: 600 Erhaltene Danke: 23 Delphi 7 PE

so ich habe das ganze nun umgesetzt.. ich brauche nun nur noch 1 Byte pro 8 Booleans + 40000MB an Arbeitsspeicher (vorher: 1Byte pro 1 Boolean + 4482 KB)

somit ist der Rechenaufwand ca 10x so groß und das zeigt sich in der Zeit... vorher: Primzahlen bis 1 Million in 0.016 sek.. jetzt nur noch 0.48 (ca 30x langsamer)

aber vielleicht findet ihr ja noch optimierungsvorschläge....

aus: //am Beispiel von 1 Million

markieren

Delphi-Quelltext

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

var BoolArray: Array of Boolean;

//Array setzten
setlength( BoolArray, 1000000 );
//Bool auslesen
if BoolArray[X] then //...
//Bool setzten
if BoolArray[X] then BoolArray[X] := False; // Die if Abfrage vorher, da es sein kann dass es schon False ist und schreiben wesentlich länger dauert als lesen

Jetzt:

markieren

Delphi-Quelltext

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:

var BitBoolArray : Array of Byte;
const Size = 8; //Größe des Speichers (SizeOf(Byte)*8)  .. so ist schneller wechsel auf z.B: Integer (32) möglich 
 
//Array setzen
setlength( BitBoolArray , 1000000 div Size +1); //Da ein Byte (8Bit) ja 8 Booleans fasst

//Bool auslesen
if GibBoolean(X) then //...
//Bool setzten
SetzteBool(X, False); //Keine if Abfrage, da schon in SetzteBoolean vorhanden

//einzelnen Funktionen:

Function GibBoolean(Zahl: Integer): Boolean;
var Z, CopyOfFeld: Byte;
begin
CopyOfFeld := BitBoolArray [Zahl div Size];
Result := False;
For Z:=(Size-1) downto (Zahl mod Size) do
  if CopyOfFeld>=power(2, Z) then
    begin
    CopyOfFeld := CopyOfFeld - Round(power(2, Z));
    Result := True;
    end
  else
    Result := False;
end; 


Procedure SetzteBoolean(Zahl: Integer; Wert: Boolean);
begin
if Wert then // Da Boolean <> Boolean ist (False<>False z.B. 255 und 13) frage ich sicherheitshalber einzeln ab und nicht if Wert<>GibBoolean(Zahl)
  begin
  if not GibBoolean(Zahl) then BitBoolArray [Zahl div Size] := BitBoolArray [Zahl div Size] + round(power(2, (Zahl mod Size)));
  end
else
  begin  
  if     GibBoolean(Zahl) then BitBoolArray [Zahl div Size] := BitBoolArray [Zahl div Size] - round(power(2, (Zahl mod Size)));
  end;
end;

Seht ihr verbesserungen?

Edit: Ein Vorteil, wo es mit Bytes schneller geht, ist die Initialiserung...
For C:=0 to High(BitBoolArray ) do BitBoolArray := 255; //X div 8 +1 Ausführungen power(2, Size)-1
vorher: For C := High(BoolArray) do BoolArray := True; //X ausführungen

_________________
Sucht "neueres" Delphi

Wer nicht brauch was er hat, brauch auch nicht was er nicht hat!

jfheins · Beiträge: 918 Erhaltene Danke: 158 Win 10 VS 2013, VS2015

Ja, jede Menge. Was hat zum Beispiel die Power-Funktion dort verloren, das geht doch auch mit bitweisen Operatoren?

So ungefähr:

markieren

Delphi-Quelltext

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

function GibBoolean(Zahl: Integer): Boolean;
var Mask, CopyOfFeld: Byte;
begin
  CopyOfFeld := BitBoolArray [Zahl div Size];
  Mask = 1 shl (Zahl mod Size);
  Result := Boolean(CopyOfFeld and Mask);
end;

procedure SetzeBoolean(Zahl: Integer; Wert: Boolean);
var Mask, Index: Byte;
begin
  Mask = 1 shl (Zahl mod Size);
  Index := Zahl div Size;
  if Wert then
    BitBoolArray[Index] := BitBoolArray [Index] or Mask;
  else
    BitBoolArray[Index] := BitBoolArray [Index] and not Mask;
end;

IhopeonlyReader · Beiträge: 600 Erhaltene Danke: 23 Delphi 7 PE

Deine Methode klappt nicht ganz !
Ab Zahlen>2048 gibt es fehler ! ich weißt warum, aber ist so^^ bis zur Primzahl 2039 rechnet er richtig, danach ist für ihn jede zahl eine Primzahl (2048 auch schon)

_________________
Sucht "neueres" Delphi

Wer nicht brauch was er hat, brauch auch nicht was er nicht hat!

jfheins · Beiträge: 918 Erhaltene Danke: 158 Win 10 VS 2013, VS2015

Oh, ja Index darf natürlich kein Byte sein. Cardinal ist angebrachter.

Und übrigens ist der Typ des Arrays nicht leicht austauschbar, die Variablen Mask und CopyOfFeld müssen nämlich den gleichen Typen haben wie das Feld - das könnte man noch ändern ;-)

Mr_Emre_D · Beiträge: 114 Erhaltene Danke: 14

2 Milliarden Bits (Boolean: Delphi = 1 Byte (8 Bits), aber
eigentlich nur 2 Zustände, also reicht 1 Bit) =
2.000.000.000
In Byte = 2 Milliarden. / 8 = 250 000 000 = 250 Millionen. Byte
In KBytes = /1024 = 244140.625 KBytes
In MBytes = /1024 = 238.41 ~ 239 MB

Wenn du also wirklich nur Bits verwendest, benötigst du nur 239 MBytes.
Im Vergleich - wenn du Pro Boolean 8 Bits verwendest, ist das letzendlich das 8 fache von 239 MB
was = 1907.34 ~ 1908 mb wären ~ 2 GB

Falls es sich um ein sparse-Array handelt, lässt sich noch schön komprimieren (RLE+Huffman)

Aaaaber.. das alles ist nur ne Zahlenrumspieleri - im Grunde liegt hier
ein Design-fehler vor... Falls du eine Art BigInteger implementierst und somit große Zahlen brauchst,
tu das nicht auf Basis von Boolean und Boolean-Operatoren sondern nimm gleich 32 Bit (4 Byte - Integer/Cardinal) Blöcke..

Horst_H · Verfasst: Mi 17.04.13 13:01

Hallo,

man kann es auch mit set's lösen. Für 32 Bit Computer gehen 32 Bit am besten.

markieren

Delphi-Quelltext

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:

program unbenannt;
uses
  sysutils;

const
  BITPOS   =  5;//= 1 shl 5 = 32
  BITMASKE = 31;//= 1 shl BITPOS-1;
type
  tBoolSet = set of 0..BITMASKE; // 0.. 1 shl BITPOS-1 ;
  tBoolArr = Array of tBoolSet;
var
  bA : tBoolArr;

function GibBoolean(Zahl: Integer): Boolean;inline;
begin
  result:= (ZAHL AND BITMASKE) in bA[Zahl shr BITPOS];
end;

procedure SetzeBoolean(Zahl: Integer; Wert: Boolean);
begin
  //BitNr = Zahl AND BITMASKE;Index := Zahl SHR BITPOS;
  if Wert then
    include(bA[Zahl SHR BITPOS],Zahl AND BITMASKE)
  else
    exclude(bA[Zahl SHR BITPOS],Zahl AND BITMASKE);
end;


const
  ArrBitSize = 100*1000*1000;
  // Wieviel 32 Bit set werden gebraucht bei 1..32 -> 1; 33..64-> 2.
  ArrSize =(ArrBitSize+BITMASKE) SHR BITPOS;
var
  T1,T0: TDatetime;
  i : LongInt;

BEGIN
  setlength(bA,ArrSize);
  T0 := now;
  // Alle Bit setzen
  For i:= 1 to ArrBitSize do
    SetzeBoolean(i,true);
  // Test ob auch alles richtig war, keiner darf nicht gesetzt sein
  For i:= 1 to ArrBitSize do
    IF NOT(GibBoolean(i)) then
      writeln('Fehler bei: ',i);

  // Alle Bit loeschen
  For i:= 1 to ArrBitSize do
    SetzeBoolean(i,false);
  // Test ob auch alles richtig war, keiner darf gesetzt sein
  For i:= 1 to ArrBitSize do
    IF GibBoolean(i) then
      writeln('Fehler bei: ',i);
  T1 := now;
  Writeln( FormatDateTime('HH:NN:SSS.ZZZ',T1-T0));
  setlength(bA,0);
END.

Ich habe extra keine Variable BitNr und Index eingebaut, weil es hier so extrem kurze Ausdrücke sind, die auch nur einmal verwendet werden, die braucht man nicht vor zu berechnen.
Da kann der Kompiler besser hantieren.

Gruß Horst

Mr_Emre_D · Beiträge: 114 Erhaltene Danke: 14

--Doppel

IhopeonlyReader · Beiträge: 600 Erhaltene Danke: 23 Delphi 7 PE

jfheins hat folgendes geschrieben :

Oh, ja Index darf natürlich kein Byte sein. Cardinal ist angebrachter.

Und übrigens ist der Typ des Arrays nicht leicht austauschbar, die Variablen Mask und CopyOfFeld müssen nämlich den gleichen Typen haben wie das Feld - das könnte man noch ändern ;-)

markieren

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

type
  BaseofBitBool = Byte;

BitBoolArray: Array of BaseOfBitBool;

const
  Size= SizeOf(BaseOfBitBool)*8;

//Initialisieren mit
 For C:=0 to High(BitBoolArray) do
     BitBoolArray[C] := round(power(2, Size)-1); //geht wesentlich schneller als alle einzeln durchzugehen und auf true zu setzen

Und: @Mr_Emre.. soweit sind wir schon dank Gerd Kayser

.. aber ich denke deshalb hast du auch

Mr_Emre_D hat folgendes geschrieben :

--Doppel

geschrieben^^
Und: @Horst_H ich arbeite zur Zeit mit Byte und dies klappt kaum langsamer als mit Booleans (0,7) mit deinem 32Bit--32Bool werde ich mich später auseinandersetzten) danke

_________________
Sucht "neueres" Delphi

Wer nicht brauch was er hat, brauch auch nicht was er nicht hat!

IhopeonlyReader · Beiträge: 600 Erhaltene Danke: 23 Delphi 7 PE

Guten Tag,
ich habe jetzt 2 verschiedene Bit-Boolean Arten! einmal ein auf einer 32 Bit Grundlage, und einmal auf Byte also 8 Bit Grundlage....

Die 32 Bit Grundlage ist von Horst_H umgesetzt worden

und die 8 Byte Grundlage mithilfe von jfheins

Die Units haben ich jeweils im Anhang... das einzige was ich dazu sagen kann:
- im "Alle setzen" ist die 8Bit-Variante schneller !
- im erstellen, loeschen, alle lesen nicht testbar (von mir), da die werte immer schwankten, mal das mal das war größer/brauchte mehr zeit
- im Bereich 1 Bit-Boolean zu schreiben, war die Zeit >1ms und somit zu klein für vergleiche/ Delphi zeigte eine benötige zeit von 0 an.

Deshalb würde ich euch einfach mal bitte diese Units auszutesten und evt. sogar verbesserungen vorzuschlagen

Danke für eure Hilfe, IHopeonlyReader (<- schon lange nicht mehr nur Leeser

)

Einloggen, um Attachments anzusehen!

_________________
Sucht "neueres" Delphi

Wer nicht brauch was er hat, brauch auch nicht was er nicht hat!

Delphi-Laie · Verfasst: Sa 20.04.13 19:44

Mathematiker hat folgendes geschrieben :

Sicher gibt es zwei aufeinanderfolgende Primzahlen mit einem Abstand > 32767, aber die kleinste von denen ist nicht bekannt und wahrscheinlich sehr groß.

Zumindest gibt es erste Kandidaten für eine solche Lücke: 32769! (hier ist Fakultät gemeint) und ff. .

Dieser Zahl, die keine Primzahl ist, folgen die Garantiert-Nicht-Primzahlen 32769!+2, 32769!+3, ... , 32769!+32769, das sind genau 32768 aufeinanderfolgende Zahlen, die keine Primzahlen sind. Die Differenz zwischen 32769!+1 zu 32769!+32769 müßte 32768>32767 sein, womit wenigstens diese Bedinung erfüllt ist.

Als nächstes wäre "nur" zu klären, ob 32769!+1 eine Primzahl ist.
32770 ist keine Primzahl, mithin auch 32769!+32770 keine (z.B. ist 2 gemeinsamer Teiler beider Summanden).
32771 ist eine Primzahl. Wäre als nächstes "nur" noch zu klären, ob 32769!+32771 eine Primzahl ist (falls ja, dann wäre die Differenz ohnehin schon größer als das oben angegebene Minimum).

Ich hoffe, daß ich mich jetzt nicht allzusehr vertan habe. Das genannte Prinzip, wo große Lücken zwischen den Primzahlen sich befinden müssen, dürfte aber für die Mathematiker in diesem Forum obertrivial sein.

Mathematiker · Verfasst: Sa 20.04.13 19:58

Hallo Delphi-Laie,

Delphi-Laie hat folgendes geschrieben :

Zumindest gibt es erste Kandidaten für eine solche Lücke: 32769! (hier ist Fakultät gemeint) und ff.

Vollkommen richtig.

Delphi-Laie hat folgendes geschrieben :

Als nächstes wäre "nur" zu klären, ob 32769!+1 eine Primzahl ist.

Ist es nicht. Die einzigen Faktorprimzahlen n!+1 bis n = 60000 existieren für
n = 1, 2, 3, 11, 27, 37, 41, 73, 77, 116, 154, 320, 340, 399, 427, 872, 1477, 6380, 26951, ..., 110059, 150209.
Von den letzten beiden weiß man nur, dass sie "wahrscheinlich" Primzahlen sind.

Beste Grüße
Mathematiker

_________________
Töten im Krieg ist nach meiner Auffassung um nichts besser als gewöhnlicher Mord. Albert Einstein

Delphi-Laie · Verfasst: Sa 20.04.13 20:02

Ich meinte natürlich "einen ersten Kandidaten für eine solche Lücke". Wie schön & danke, daß Du es gleich aufklären konntest.

IhopeonlyReader · Beiträge: 600 Erhaltene Danke: 23 Delphi 7 PE

Mathematiker hat folgendes geschrieben :

n = 1, 2, 3, 11, 27, 37, 41, 73, 77, 116, 154, 320, 340, 399, 427, 872, 1477, 6380, 26951, ..., 110059, 150209.
Von den letzten beiden weiß man nur, dass sie "wahrscheinlich" Primzahlen sind.

110059 ist die 10458. Primzahl !
150209 ist die 13867. Primzahl

wann die lücke so groß ist werde ich euch bald sagen

(dann werde ich alle Primzahlen bis 16.000.000.000.000.000.000 (4Milliarden)² durchgehen und euch sagen können und bis zu dieser riesig großen zahl eine große lücke entsteht, bzw. wie groß die lücke ist).. ich denke das das relativ bald sein wird

(evt morgen)

_________________
Sucht "neueres" Delphi

Wer nicht brauch was er hat, brauch auch nicht was er nicht hat!

Mathematiker · Verfasst: Sa 20.04.13 21:52

Hallo,

IhopeonlyReader hat folgendes geschrieben :

110059 ist die 10458. Primzahl !
150209 ist die 13867. Primzahl

Du hast etwas falsch verstanden. Nicht 110059 und 150209 sondern 110059!+1 und 150209!+1 sind gemeint, die erste mit mehr 500000 Ziffern, die zweite mit mehr als 710000.
Ich hatte geschrieben:

Zitat:

Die einzigen Faktorprimzahlen n!+1 bis n = 60000 existieren für
n = 1, 2, 3, 11, 27, 37, 41, 73, 77, 116, 154, 320, 340, 399, 427, 872, 1477, 6380, 26951, ..., 110059, 150209.

Wenn Du aber die nachfolgende Tabelle mit Deiner neuen Unit erweitern könntest, wäre das schon sehr gut. Die Tabelle enthält die gegenwärtig bekannten aufeinanderfolgenden, monoton wachsenden maximalen Abstände von benachbarten Primzahlen.

Beste Grüße
Mathematiker

Anhang: Tabelle der größten wachsenden Abstände benachbarter Primzahlen

markieren

Quelltext

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:

Abstand  ab  bis
1  2  3
2  3  5
4  7  11
6  23  29
8  89  97
14  113  127
18  523  541
20  887  907
22  1129  1151
34  1327  1361
36  9551  9587
44  15683  15727
52  19609  19661
72  31397  31469
86  155921  156007
96  360653  360749
112  370261  370373
114  492113  492227
118  1349533  1349651
132  1357201  1357333
148  2010733  2010881
154  4652353  4652507
180  17051707  17051887
210  20831323  20831533
220  47326693  47326913
222  122164747  122164969
234  189695659  189695893
248  191912783  191913031
250  387096133  387096383
282  436273009  436273291
288  1294268491  1294268779
292  1453168141  1453168433
320  2300942549  2300942869
336  3842610773  3842611109
354  4302407359  4302407713
382  10726904659  10726905041
384  20678048297  20678048681
394  22367084959  22367085353
456  25056082087  25056082543
464  42652618343  42652618807
468  127976334671  127976335139
474  182226896239  182226896713
485  241160024143  241160024628
490  297501075799  297501076289
500  303371455241  303371455741
514  304599508537  304599509051
516  416608695821  416608696337
532  461690510011  461690510543
534  614487453423  614487453957
540  738832927927  738832928467
582  1346294310749  1346294311331
588  1408695493609  1408695494197
602  1968188556461  1968188557063
652  2614941710599  2614941711251
674  7177162611713  7177162612387
716  13828048559701  13828048560417
766  19581334192423  19581334193189
778  42842283925351  42842283926129
804  90874329411493  90874329412297
806  171231342420521  171231342421327
906  219209405436543  219209405437449
916  1189459969825483  1189459969826399
924  1686994940955803  
1132  1693182318746371
1184  43841547845541059
1198  55350776431903243
1220  80873624627234849
1370  418032645936712127
1442  804212830686677669
1476  1425172824437699411

_________________
Töten im Krieg ist nach meiner Auffassung um nichts besser als gewöhnlicher Mord. Albert Einstein

IhopeonlyReader · Beiträge: 600 Erhaltene Danke: 23 Delphi 7 PE

Da fehlt aber was, wenn ich das richtig verstehe !

deine 7 ist der Abstand von 14.. was mit dem Abstand von 10?
das erste aufeinanderfolgende primzahlen-paar mit dem abstand 10 sind
139 und 149.. ein anderes Beispiel: 337 und 347

Habe ich das jetzt falsch verstanden oder ist die Tabelle wirklich nicht vollständig?
weil zum Abstand von 12, 16, 24, 26, 28, 30, 32 etc. fehlen die paare ja immer..

_________________
Sucht "neueres" Delphi

Wer nicht brauch was er hat, brauch auch nicht was er nicht hat!

Mathematiker · Verfasst: Sa 20.04.13 23:19

Hallo,
es geht um das Wachstum der maximalen Primzahlabstände.
Nach dem Abstand 8 zwischen 89 und 97 ist der nächste größere Abstand schon die 14 zwischen 113 und 127.
Abstand 10 folgt erstmals bei 139-149, Abstand 12 bei 199-211. Der größere Abstand 14 war aber eben schon früher aufgetreten.

Eine Tabelle, die für alle möglichen Abstände das kleinste Paar angibt, könnte man auch erstellen. Vielleicht mache ich das einmal.

Beste Grüße
Mathematiker

Nachtrag: Mit dem kleinen Programm

markieren

Delphi-Quelltext

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.Button1Click(Sender: TObject);
var abstand:array[1..1000] of cardinal;
    a,i,j,grenze:cardinal;
    z:integer;
begin
    fillchar(abstand,sizeof(abstand),0);
    listbox1.clear;
    i:=3;
    j:=5;
    a:=1;
    grenze:=strtoint(edit1.text);
    repeat
      while not istprime(j) do j:=j+2;
      z:=j-i;
      if (z<1001) and (abstand[z]=0) then
      begin
        abstand[z]:=i;
        listbox1.items.add(format('%4d'#9'%d'#9'%d',[z,i,j]));
      end;
      i:=j;
      j:=j+2;
      inc(a);
      if a mod 100000 = 0 then
      begin
        label2.caption:=inttostr(j);
        application.processmessages;
      end;
    until j>grenze;
    z:=2;
    repeat
      if abstand[z]=0 then listbox1.items.add(format('%4d'#9'-',[z]));
      z:=z+2;
    until z>1000;
    listbox1.items.savetofile('liste2.000');
end;

habe ich schnell mal die Liste mit den kleinsten Paaren erstellt, die einen geradzahligen Abstand haben.
istprime ist die Routine, die ich beim Moser-Problem nutze. www.entwickler-ecke....rProblem_111412.html
Gesucht habe ich bis 1 Milliarde. Der kleinste nicht gefundene Abstand ist 254, der größte gefundene 282.

Einloggen, um Attachments anzusehen!

_________________
Töten im Krieg ist nach meiner Auffassung um nichts besser als gewöhnlicher Mord. Albert Einstein

IhopeonlyReader · Beiträge: 600 Erhaltene Danke: 23 Delphi 7 PE

ok, also sozusagen ein weiteres dyn. Array anlegen und die Primzahlen "normal errechnen" und danach die liste der Primzahlen durchgehen und den Abstand zwischen Primzahl[X-1] und Primzahl[X] errechnen und wenn Abstand > AltAbstand dann zum dyn. Array hinzufügen, das heißt man könnte bis zur "Maximal-Errechenbar-Primzahl" auch den größten Abstand errechnen..

P.S: ich habe gerade germerkt, dass mein Programm THEÒRETISCH bis (4Mrd)² die Primzahlen errechnen könnte!, allerdings wären das 1.862.645.149 GB (1,9 Milliarde GB)
da ich natürlich nicht soviel Ram habe, ist das natürlich nicht möglich :/
Mein Maximum liegt bei ca 12.884.901.890 Millarden.. somit kann ich maximal alle Primzahlen bis 12,8 Milliarden errechnen.. mit der Optimierung dass ich nur "ungerade" zahlen verwende (+1 wegn der 2) dann käm ich bis ca 25 Milliarden..

Und: Mathematiker: "die einen geradzahligen Abstand haben".. ein ungerade Abstand ist (außer bei dem Abstand 1 (von 2 zu 3)) NIE möglich ! denn x,y <- Primzahlen (also ungerade, sonst vielfaches von 2) und x-y-> ungeradezahl-ungeradezahl -> geradezahl (also ist der abstand immer GERADE)

Edit1: Der Abstand von 254 ist gefunden

bei dem Primzahlenpaar: 1202442343 und 1202442089

_________________
Sucht "neueres" Delphi

Wer nicht brauch was er hat, brauch auch nicht was er nicht hat!

Mathematiker · Verfasst: Sa 20.04.13 23:57

Hallo,

IhopeonlyReader hat folgendes geschrieben :

Mein Maximum liegt bei ca 12.884.901.890 Millarden.. somit kann ich maximal alle Primzahlen bis 12,8 Milliarden errechnen.. mit der Optimierung dass ich nur "ungerade" zahlen verwende (+1 wegn der 2) dann käm ich bis ca 25 Milliarden..

Ich bin schon gespannt.

IhopeonlyReader hat folgendes geschrieben :

Mathematiker: "die einen geradzahligen Abstand haben".. ein ungerade Abstand ist (außer bei dem Abstand 1 (von 2 zu 3)) NIE möglich ! denn x,y <- Primzahlen (also ungerade, sonst vielfaches von 2) und x-y-> ungeradezahl-ungeradezahl -> geradezahl (also ist der abstand immer GERADE)

Natürlich ist das so. Die Liste enthält aber nicht den Abstand 1. Und um was wollen wir wetten, dass garantiert einer im Forum mich freundlich daraufhinweisen würde, dass dieser Abstand fehlt. :wink:

Und deshalb der Kommentar "geradzahliger Abstand".
Aber es ist nett von Dir, dass Du es für mich beweist. :roll:

Ich habe nochmals bis 2 Milliarden gesucht (Rev 1 der Liste2). Der kleinste nicht gefundene Abstand ist nun 264, der größte gefundene 292.

Beste Grüße
Mathematiker

_________________
Töten im Krieg ist nach meiner Auffassung um nichts besser als gewöhnlicher Mord. Albert Einstein

	Mitgliederliste
	Gruppen
	Das Team
	Richtlinien
	Synonyme