20.06.2003 Anfangsdatum Stand 16.10.2005 Hans-Peter Kuberna Germany E-MAIL hans-peter@kuberna.de Ob der Text in dieser Textdatei richtig geschrieben wurde ist mir egal !!!!! Ebenso die Groß- und Kleinschreibung !!!!! ----------------------------------------------------------------------- ----------------------------------------------------------------------- Aus dem Inhalt: Kuberna's Primzahlenfolge. Die Primzahlen 2, 3 und 5 passen nicht in diese Zahlenfolge hinein. Die erlaubten Positionen. Die Zahlen hoch 2 . ( Zahl ** 2 ) Die Mersenne Primzahlen . Die Maximale Anzahl der Primzahlen bei n Zahlen. Die Spiegelung in der Fläche. Die Ausschliessung. Lösungsweg 3 ( Erscheint mir als gute Lösung ! ) Testprogramm für PZahl(n) ( in C ) Lösungsweg 2 Lösungsweg 1 Lösungsweg wie PRIMFOR1.BAS Für die Berechnung der unerlaubten Spalten und Zahlen gibt es zum Beispiel diese Lösung. Ausgabe der Vielfachen von der Zahl 7 . Kuberna's Primzahlenfolge und die gebrochene Symmetrie. Berechnung der Endziffer: Berechnung der Quersumme: Die gebrochene Symmetrie und das Atom. Die gebrochene Symmetrie und das 3 Realitäten-Problem. Kuberna's Primzahlenfolge und die Seitenlänge beim Würfel ( Cube ) Die Anzahl der Elektronen, und die Primzahlen 7 und 11. Die Anzahl der Elektronen und die Primzahl 29. Das ( 2**i ) - 1 Problem Die Anzahl der Stellen ( Basis 10 ) ändert sich bei (2**103)-1 Die Anzahl der Stellen ( Basis 30 ) ändert sich bei (2**54)-1. Die Dielektrizitätskonstante und die Zahl 7. Berechnung der Zahlennummer; Positionsnummer innerhalb der Zeile. Bestimmung der Werte für n , die eine Quadratzahl ergeben. Von Kuberna's Primzahlenfolge, die Quadratzahlen und der Satz des Pythagoras. Von Kuberna's Primzahlenfolge und die Ecken eines Würfels. { Kuberna's prime numbers follow and the corners of a cube. } Bestimmung der Werte für n , die keine Primzahl ergeben. Ausgabe der Werte für n , die keine Primzahl ergeben. Ich habe mir weitere Fragen gestellt! Ob sich die Zahl PI durch 9 teilen läßt. Oder: Welche Ausmaße hat die Cheops Pyramide. Suche nach einer Vereinfachung der Sinusberechnung. ------------------------------------------------------ ----------------------------------------------------------------------- Nachtrag vom 16.10.2005 Auf die Fragen die Ich mir stellte: Was kann Ich Suchen, wenn Ich zu den Naturkonstanten mal keine Lust habe ? Antwort: Die Lösung der Fragen: Wer hatte die Mathematischen Kenntnisse , vor circa 3500 Jahren, um hinter den Buchstaben der Hebrew Thora den Bibel Code zu machen ? Wieso sieht der Buchstabe lamed ( ergibt das k ) aus wie eine 7 ? Wieso sieht der Buchstabe kuf ( ergibt das e ) aus wie eine 7 mit Strich ? Wieso ergibt die Summe der Zahlen für das Bitmuster der Buchstaben "K", "U" und "B" die Summe 343 ? 343 = 7 * 7 * 7 Wieso ergibt die Summe der Zahlen für das Bitmuster des Buchstaben "E" 343, also die Summe von "K", "U" und "B" ? Wer legte über die ersten 3 Buchstaben eine Checksumme, die den Wert des 4ten Buchstaben hat ? Dieses ergibt über die Buchstaben "K", "U", "B" und "E" die Summe 686. Diese erinnert mich an den Mikroprozessor 6x86. Mit den Fragen beschäftige ich mich jetzt auf der Seite Bible_Code, auf meiner HomePage ! Meine Überlegungen zu den Naturgesetzen findet man unter der Seite KubeQuarks, auf meiner HomePage ! Zu den Arbeiten von Prof. Eliyahu Rips Einstein Institute of Mathematics The Hebrew University of Jerusalem und zum Taschenbuch ( HEYNE< Velag ) von MICHAEL DROSNIN Der Bibel Code II: Der Countdown Das Pentagon und der Bibel Code Ende Nachtrag 16.10.2005 ------------------------------------------------------ ----------------------------------------------------------------------- Das Jahr 2005 , Kuberna's Primzahlenfolge und die Suche nach Der Theorie von Allem ! The Theorie of every Thing ! . Die Ziffernfolge der Lichtgeschwindigkeit und die Zahl 56 ( 7*8 ) Die Ziffernfolge der Planckschen Laenge und die Zahl 56 ( 7*8 ) Die Ziffernfolge der Planckschen Zeit und die Zahlen 49 ( 7*7 ) und 56 ( 7*8 ) Das Jahr 2005 und die Zahlen 49 ( 7*7 ) und 56 ( 7*8 ) 1900 + 56 + 49 = 2005 1900 + ( 7 + 8 ) * 7 = 2005 Ergebnisse von NaturkonstantenV7.pov 01.04.2005 Ziffernfolge Lichtgeschwindigkeit = 2.9979245750628936 Kc=3 - (1/(480+1+sin(pi/180*56))) = 2.9979245750628936 Kc=3 - (1/(480+1+sin(7/45*2*pi))) = 2.9979245750628936 Ziffernfolge Lichtgeschwindigkeit -30km/s = 2.9976245765907645 Kc30=3-(1/(420+(1/(5+sqrt(3)))+sin(pi/180*56))) = 2.9976245765907645 Ziffernfolge Umlaufgeschwindigkeit der ERDE um die Sonne = 0.0002999984721290 vERDE=Kc-Kc30 = 0.0002999984721290 Ziffernfolge Plancksche Konstante = 6.6260686404208293 Kh=(324+1-(sin(18/sin(pi/180*73)*pi/180)))/49 = 6.6260686404208293 Ziffernfolge Gravitationskonstante = 6.6725899884206754 KG=(324+1+1+(sin(73/sin(pi/180*(45+40+sqrt(3)))*pi/180)))/49 = 6.6725899884206754 Ziffernfolge Plancksche Laenge = 1.6162398615757567 Kpl=sqrt(3-(1/(1+1+(sin(34/sin(pi/180*74)*pi/180))))) = 1.6162398615757567 Ziffernfolge Fallbeschleunigung auf der Erde = 9.8066500533061483 Kgn=(480+((480/7.5)/((11*11)+0.5*sqrt(2))))/49 = 9.8066500533061483 Ziffernfolge Plancksche Zeit = 5.3911958793632442 Ktp=(264+1-(sin((((sqrt(3)/10+2.5)/11)+56)*pi/180)))/49 = 5.3911958793632442 Fuer Differenz Ktp sichern: Ktp49=Ktp Ziffernfolge Plancksche Zeit = 0.5391195879375483 Ktp=Kpl/Kc = 0.5391195879375483 Differenz Plancksche Zeit = 0.0000000000122391 KtpDif=(Ktp*10)-Ktp49 = 0.0000000000122391 Ziffernfolge Plancksche Masse = 2.1764500059136402 Kpm=sqrt((232+1-sin(pi/180*(62+sin(pi/180*64))))/49) = 2.1764500059136402 Das Dreieck aus Ziffernfolge Lichtgeschwindigkeit Ziffernfolge Plancksche Laenge Ziffernfolge Plancksche Zeit muss geschlossen sein ! Ziffernfolge Lichtgeschwindigkeit = 2.9979245750628936 Kc=3 - (1/(480+1+sin(pi/180*56))) = 2.9979245750628936 Ziffernfolge Plancksche Laenge = 1.6162398615757567 Kpl=sqrt(3-(1/(1+1+(sin((90-56)/sin(pi/180*74)*pi/180))))) = 1.6162398615757567 Ziffernfolge Plancksche Zeit = 5.3911958793632442 Ktp=(264+1-(sin((((sqrt(3)/10+2.5)/11)+56)*pi/180)))/49 = 5.3911958793632442 So wie es aussieht ist es geschlossen ! Was für ein Zufall ! Die Zahl 56 steht für den Winkel pi/180*56 ( 56/360 ) oder 7/45*2*pi ( 7*8/45*8 ) . Dieser Winkel ist in jeder der 3 Berechnungen vorhanden ! Siehe dazu das Bild unter /Mathe/LightSpeedSin56V1Gross.png Weiteres zu der Lichtgeschwindigkeit und Co. kommt in die Text-Datei KubeQuarks.txt ! Quelle: Homepage-Seite Kube_Quarks Noch etwas zur Zahl 37: Im Bild /Mathe/Primzahl/OffsetRaster5pr30gross.png Position 9. 666 / 9 = 74 = 2 * 37 7 -> Position 1 ( 0*8 + 1 ) 30+7 = 37 -> Position 9 ( 1*8 + 1 ) Die Zahl 37 und Lucifers ABC 37 A 74 B 111 C 148 D 185 E 222 F 259 G 296 H 333 I 370 J 407 K 444 L 481 M 518 N 555 O 592 P 629 Q 666 R 703 S 740 T 777 U 814 V 851 W 888 X 925 Y 962 Z Die römischen Zahlen und Lucifers ABC I = 1 -> 333 = 09*37 V = 5 -> 814 = 22*37 X = 10 -> 888 = 24*37 L = 50 -> 444 = 12*37 C = 100 -> 111 = 03*37 D = 500 -> 148 = 04*37 M = 1000 -> 481 = 13*37 Der Buchstabe M ( 480+1 ) und die Berechnung der Ziffernfolge der Lichtgeschwindigkeit. Wollte mich jemand dazu anregen über die Summen der zugeordneten Zahlen bei: Meinem Nachnamen kuberna 2664 = 666 * 4 407 + 777 + 74 + 185 + 666 + 518 + 37 = 2664 Titel der Homepage-Seite Paula paula die hundedame 5328 = 666 * 8 592+37+777+444+37+148+333+185+296+777+518+148+185+148+37+481+185 = 5328 Titel der Homepage-Seite Kube Quarks Kube Quarks 4662 = 666 * 7 407 + 777 + 74 + 185 + 629 + 777 + 37 + 666 + 407 + 703 = 4662 nachzudenken ? Man beachte auch: 2 + 6 + 6 + 4 = 18 = 8 + 10 = 3 * 6 5 + 3 + 2 + 8 = 18 = 8 + 10 = 3 * 6 4 + 6 + 6 + 2 = 18 = 10 + 8 = 3 * 6 ------------------------------------------------------ ----------------------------------------------------------------------- Im Jahre 2002, deren Jahreszahl ganzahlig durch 7 teilbar ist, begann die lange Reise in die Welt der Zahlen. 2002 : 7 = 2 * 11 * 13 Im Jahre 2003, deren Jahreszahl eine Primzahl ist, war es an der Zeit die Definition der Primzahl neu zu überdenken. 2003 : 30 = Zahl 66 und dem Rest Primzahl 23. 66 * 8 + 6 = 534 ; 6 * 89 = Zahl Nr. 534 Das Ergebnis ist: Es gibt 2 Primzahlenfolgen, die sich nur unterhalb der Primzahl 7 unterscheiden. Es ist die gängige Primzahlenfolge und Kuberna's Primzahlenfolge. Es entstand im Jahre 2003 die Text-Datei Primzahl3D1.txt . ----------------------------------------------------------------------- ------------------------------------------------------ Kuberna's Primzahlenfolge ------------------------- ------------------------- Die Kube - Prims -------------------- Die Darstellung der Primzahlen in der 2-dimensonalen Fläche und in dem 3-dimensonalen Raum. ------------------------------------------------------------ Die Primzahlen unter der Betrachtung der Zahlen-Basis 30. Ergebnisse: ----------- Diese Primzahlenfolge unterscheidet sich nur, gegenüber der gängigen Primzahlenfolge, im Bereich unterhalb der Primzahl 7. Die Primzahlen 2, 3 und 5 passen nicht in diese Primzahlenfolge hinein. Die Primzahlenfolge ist sehr geordnet und nicht chaotisch. Regelmässige Vielecke mit mehr als 6 Seiten sind unter ausschliesslicher Verwendung von Primzahlen, für die Eckpunkte, nicht möglich!!! Die Zahl 1 bleibt in dieser Zahlenreihe eine Primzahl, weil Sie für die Bildung von regelmässigen Vielecken wichtig ist. Die Zahl 1 entscheidet mit, wie groß das kleinste Vieleck ist ! Innerhalb von Kuberna's Primzahlenfolge hat die Summe von zwei Quadratzahlen die Endziffern 0 , 2 oder 8. Es gibt für den Satz des Pythagoras , a*a + b*b = c*c , unter der Verwendung von Zahlen aus Kuberna's Primzahlenfolge , keine Lösung. Alle meine mathematischen Erkenntnisse / Vermutungen gehen ins frei verwertbare Eigentum aller Lebewesen über ! Für die Richtigkeit gibt es keine Garantie. Für die Anwendung und deren Folgen haftet der, der diese Erkenntnisse / Vermutungen verwendet. ----------------------------------------------------------------------- Die Betrachtung der Zahlen. --------------------------- Die erlaubten Positionen. ------------------------- In einem X-Y-Koordinatensystem im Wertebereich der Spalten X von 0 bis 29 , und der Zeilen Y von 0*30 bis 29*30 bestehen folgende Gesetzmässigkeiten. Mögliche Primzahlen stehen nur in den Spalten 1, 7, 11, 13, 17, 19, 23 und 29, der einzelnen Zeilen. Es sind nur 8 Spalten pro Zeile möglich. Die Zahlen 1, 7, 11, 13, 17, 19, 23, 29 31, 37, 41, 43, 47, , 53, 59 61, 67, 71, 73, 79, 83, 89 , 97, und so weiter, sind Primzahlen. Die Zahlen berechnen sich so. Zahl=Zeile*30+Spalte. Die Zahlen 2,3 und 5 sind keine echten Primzahlen, weil sie nicht in einer der erlaubten Spalten stehen. für 2, 3, 5 ; stehen nicht in einer erlaubten Spalte Werden 2 Primzahlen addiert ergibt ihre Summe immer eine Zahl die ganzzahlig durch 2 teilbar ist. für 2 2+7=9 9:2=4.5 ; nicht ganzzahlig durch 2 teilbar In der Fläche mit den Spalten X (0..29) und den Zeilen Y (0..29) gibt es 900 Zahlen (0..899). Von den 900 Zahlen können maximal 240 Primzahlen sein. ----------------------------------------------------------------------- Die Zahlen hoch 2 . ( Zahl ** 2 ) ------------------------- Für die Zahlen der Spalten 1 bis 29 besteht folgender Zusammenhang. Das Ergebnis der Zahl**2 mit den Endziffern 1 oder 9 befindet sich in der Spalte 1 , also Endziffer 1; mit den Endziffern 3 oder 7 befindet sich in der Spalte 19 , also Endziffer 9; Zum Beispiel Endziffern 1 oder 9 Spalte 1 Zahl 391 391*391=152881 ( 5096*30)+1=152881 Spalte 11 Zahl 671 671*671=450241 (15008*30)+1=450241 Spalte 19 Zahl 139 139*139= 19321 (644*30)+1= 19321 Spalte 29 Zahl 599 599*599=358801 (11960*30)+1=358801 Zum Beispiel Endziffern 3 oder 7 Spalte 7 Zahl 727 727*727=528529 (17617*30)+19=528529 Spalte 13 Zahl 313 313*313= 97969 (3265*30)+19= 97969 Spalte 17 Zahl 167 167*167= 27889 (929*30)+19= 27889 Spalte 23 Zahl 473 473*473=223729 (7457*30)+19=223729 ----------------------------------------------------------------------- Die Mersenne Primzahlen . ------------------------- Mersenne Primzahlen -> ( 2 ** Primzahl ) -1 = Primzahl liegen nur in den Spalten 1 oder 7. Sie haben die Endziffern 1 oder 7 , sind also durch 30 mit dem Rest 1 oder 7 teilbar. Siehe auch weiter unten. --> Das ( 2**i ) - 1 Problem ----------------------------------------------------------------------- Die Maximale Anzahl der Primzahlen bei n Zahlen. ------------------------------------------------ Vorgabe: n=30 (Anzahl Zeilen) Bei n*30 Zahlen sind es maximal n*30 * (( 8 * n)/(30 * n)) Primzahlen. Hieraus ergibt sich n*30/3.75 = 900/3.75 = 240 für das theoretische Maximal. Man nehme auch zur Kenntnis. 3.75/(1/8) = 3.75/0.125 = 30 900/8 = 112.5 Es kommen aber nur 19*8=152 Primzahlen vor. ( ohne 2,3 und 5 ) 900/(19*8) = (112.5*8)/(19*8) = 112.5/19 = 5,921052631579 Hieraus ergibt sich n*30/5,921052631579 für praktische Maximal. Vermutung !!!! Bei Vorgabe n*30=Unendlich wird das unendliche Maximal bei 30*30/11.25 liegen. Wahrscheinlich ist 11.25 (11.25=90/8) als Wert noch zu niedrig,dürfte sich aber durch 1/8 teilen lassen. Diese Anzahl wird in dem Feld von 30*30 Zahlen nicht mehr überschritten!! ----------------------------------------------------------------------- Die Spiegelung in der Fläche. ------------------------------ Wenn man die Fläche in der Mitte teilt, und die Hälften übereinander legt, also über die Y-Achse spiegelt, ergibt die Summe, der übereinander liegenden Zahlen 30*Zeile. ( Zeile = y ) Spiegelt man die untere Hälfte zuerst über die obere Hälfte, also über die X-Achse, und anschliessend, wie oben beschrieben , über die Y-Achse, ergibt die Summe der übereinander liegenden Zahlen das Ergebnis aus 900*Lage. ( Lage = z ) ----------------------------------------------------------------------- Die Ausschliessung. ------------------- Bei der Multiplikation der Zahlen 7, 11, 13, 17, 19, 23, 29,... mit 7, 11, 13, 17, 19, 23, 29,... ist das Ergebnis keine Primzahl. Zum Beispiel 7* 7 = 49 ; 11* 7 = 77 ; 13* 7 = 91 ; 17* 7 =119 .... 7*11 = 77 ; 11*11 =121 ; 13*11 =143 ; 17*11 =187 .... 7*13 = 91 ; ........ Das Ergebniss aus zum Beispiel 5*17 braucht nicht berücksichtigt werden, weil 5 nicht in einer der erlaubten Spalten liegt. Siehe auch. TEILN301.pov ( POV-Ray Datei ) TEILN301gross.png ( Bild Datei ) KubePrimeTestKreis1.pov ( POV-Ray Datei ) KubePrimeTestKreis1Gross.png ( Bild Datei ) Informationen zum Bild TEILN301gross.png -------------------------------------------- Bei n=1 welche die Zahl 7 ergibt, wiederholen sich die Abstände der Werte fuer n so. n= 0 ergibt Zahl 1 n= 1 ergibt Zahl 7 man beachte 7*8 = 56 n=13 ergibt Zahl 49 n=20 ergibt Zahl 77 n=24 ergibt Zahl 91 n=31 ergibt Zahl 119 n=35 ergibt Zahl 113 n=42 ergibt Zahl 161 n=54 ergibt Zahl 203 Die Abstände der Werte für n ---------------------------- 13 - 1 = 12 20 - 13 = 7 24 - 20 = 4 31 - 24 = 7 35 - 31 = 4 42 - 35 = 7 54 - 42 = 12 57 - 54 = 3 69 - 57 = 12 76 - 69 = 7 ....... Die Zahlenfolgen bei n= 1 1, 2, 3, 4, 5, 6, 7, 8 bei n=13 12, 7, 4, 7, 4, 7, 12, 3 bei n=20 18, 12, 6, 11, 6, 12, 18, 15 Die Umkreisten diagonalen Werte ------------------------------- n = 0 ergibt 1 * 1 n = 13 ergibt 7 * 7 n = 32 ergibt 11 * 11 n = 45 ergibt 13 * 13 n = 77 ergibt 17 * 17 n = 96 ergibt 19 * 19 n = 141 ergibt 23 * 23 n = 224 ergibt 29 * 29 n = 256 ergibt 31 * 31 n = 365 ergibt 37 * 37 Die Wiederholung der Werte ab n ---------------------------- n= 8 ergibt sich aus 1*8+ 0 n= 57 ergibt sich aus 7*8+ 1 n= 90 ergibt sich aus 11*8+ 2 n= 107 ergibt sich aus 13*8+ 3 n= 140 ergibt sich aus 17*8+ 4 n= 157 ergibt sich aus 19*8+ 5 n= 190 ergibt sich aus 23*8+ 6 n= 239 ergibt sich aus 29*8+ 7 n= 256 ergibt sich aus 31*8+ 8 n= 365 ergibt sich aus 45*8+ 5 ----------------------------------------------------------------------- Die Berechnung. --------------- --------------- Für die Berechnung der erlaubten Spalten und Zahlen gibt es verschiedene Lösungswege. Lösungsweg 3 scheint der beste Lösungsweg zu sein. Basic-Progamme erstellt mit PowerBASIC Compiler Version 2.10f von 1990 Teilweise laufen die Basic-Progamme auch mit Microsoft QBASIC.EXE. Es sind aber teilweise Änderungen nötig. -------------------------- Win95 - CDROM ( mit USB- Unterstützung ) : Verzeichnis \other\oldmsdos\ Dateien Qbasic.exe und Qbasic.hlp . -------------------------- Win98SE - CDROM : Verzeichnis \tools\oldmsdos\ Dateien qbasic.exe und qbasic.hlp . -------------------------- ----------------------------------------------------------------------- Lösungsweg 3 ( Erscheint mir als gute Lösung ! ) -------------------------------------------------- REM PRIOFFN1.BAS REM 19.09.2003 N$="Hans-Peter Kuberna" EMail$="hans-peter@kuberna.de" cls print Date$,Time$ print N$,EMail$ print " ","Die möglichen Primzahlpositionen ( ->Wert ) " print " Mul6","VorZei ";"MiPl4 ";" ";"Zeile","Spalte","Wert" for n= 0 to 17 nmod8=n mod 8 intnd8=int(n/8) Zeile=intnd8 Mul6=int(nmod8/2)*6 REM Vorzeichen berechnen VorZei=1-((nmod8+1) mod 2)*2 REM -/+ 4 addieren bei n=0 / n=7 MiPl4=(((int(nmod8/7))-int((nmod8+6)/7)+1)*4)*VorZei REM Wert für Ergebnisanpassung w3=6 Spalte=Mul6+VorZei+MiPl4+w3 Wert=(Zeile*30)+Spalte print Mul6,VorZei;" ";MiPl4,Zeile,Spalte,Wert next n Bildschirmausgabe 09-19-2003 13:05:52 Hans-Peter Kuberna hans-peter@kuberna.de Die möglichen Primzahlpositionen ( ->Wert ) Mul6 VorZei MiPl4 Zeile Spalte Wert 0 -1 -4 0 1 1 0 1 0 0 7 7 6 -1 0 0 11 11 6 1 0 0 13 13 12 -1 0 0 17 17 12 1 0 0 19 19 18 -1 0 0 23 23 18 1 4 0 29 29 0 -1 -4 1 1 31 0 1 0 1 7 37 6 -1 0 1 11 41 6 1 0 1 13 43 12 -1 0 1 17 47 12 1 0 1 19 49 18 -1 0 1 23 53 18 1 4 1 29 59 0 -1 -4 2 1 61 0 1 0 2 7 67 ----------------------------------------------------------------------- Testprogramm für PZahl(n) ( in C ) ---------------------------------- Getestet mit Microsoft Visual C++, Version 6.0 /* FnPrimOffN2test.c 05.12.2003 Hans-Peter Kuberna hans-peter@kuberna.de Germany */ #include #include #include #ifndef ZahlP_t typedef struct { long int ZahlFN; long int ZeileFN; long int SpalteFN; }ZahlP_t; #endif ZahlP_t __cdecl PZahl(long int n) { long int ZahlFN,ZeileFN,SpalteFN; long int nmod8; long int nmod8p1,nmod8p6,nmod8p1mod2; long int nmod8div7,nmod8p6div7,ndiv8; long int Mul6,VorZei,MiPl4,w6; ZahlP_t Zresult; ldiv_t div_result; div_result = ldiv( n,8 ); nmod8=div_result.rem; nmod8p1 = nmod8+1; nmod8p6 = nmod8+6; div_result = ldiv( nmod8p1,2 ); nmod8p1mod2=div_result.rem; div_result = ldiv( nmod8,7 ); nmod8div7=div_result.quot; div_result = ldiv( nmod8p6,7 ); nmod8p6div7 = div_result.quot; div_result = ldiv(n,8); ndiv8 = div_result.quot; ZeileFN = ndiv8; div_result = ldiv(nmod8,2); Mul6 = div_result.quot *6 ; /* Vorzeichen berechnen */ VorZei = 1-(nmod8p1mod2*2); /* -/+ 4 addieren bei n=0 / n=7 */ MiPl4 = (nmod8div7 - nmod8p6div7 + 1)*4*VorZei; /* Wert fuer Ergebnisanpassung */ w6 = 6; SpalteFN = Mul6+VorZei+MiPl4+w6; ZahlFN = ZeileFN*30+SpalteFN; Zresult.ZahlFN = ZahlFN; Zresult.ZeileFN = ZeileFN; Zresult.SpalteFN = SpalteFN; return Zresult; } void main( void ) { long int Zahl,Zeile,Spalte; long int n,Offs,Nmax; ZahlP_t Z; Zahl = 0; Zeile = 0; Spalte = 0; Nmax=20; /* Maximal Offs=572662306-Nmax;*/ /*Offs=0;*/ /* Offs=572662306-Nmax; */ Offs=0; for (n = 0; n < Nmax; n++) { Z = PZahl(n+Offs); Zahl = Z.ZahlFN; Zeile = Z.ZeileFN; Spalte = Z.SpalteFN; printf( "\tn+Offs: %.12d Zahl: %.12d",n+Offs,Zahl); printf( "\tZeile: %.12d Spalte: %.2d\n",Zeile,Spalte); } } Bildschirmausgabe: ------------------ n+Offs: 000000000000 Zahl: 000000000001 Zeile: 000000000000 Spalte: 01 n+Offs: 000000000001 Zahl: 000000000007 Zeile: 000000000000 Spalte: 07 n+Offs: 000000000002 Zahl: 000000000011 Zeile: 000000000000 Spalte: 11 n+Offs: 000000000003 Zahl: 000000000013 Zeile: 000000000000 Spalte: 13 n+Offs: 000000000004 Zahl: 000000000017 Zeile: 000000000000 Spalte: 17 n+Offs: 000000000005 Zahl: 000000000019 Zeile: 000000000000 Spalte: 19 n+Offs: 000000000006 Zahl: 000000000023 Zeile: 000000000000 Spalte: 23 n+Offs: 000000000007 Zahl: 000000000029 Zeile: 000000000000 Spalte: 29 n+Offs: 000000000008 Zahl: 000000000031 Zeile: 000000000001 Spalte: 01 n+Offs: 000000000009 Zahl: 000000000037 Zeile: 000000000001 Spalte: 07 n+Offs: 000000000010 Zahl: 000000000041 Zeile: 000000000001 Spalte: 11 n+Offs: 000000000011 Zahl: 000000000043 Zeile: 000000000001 Spalte: 13 n+Offs: 000000000012 Zahl: 000000000047 Zeile: 000000000001 Spalte: 17 n+Offs: 000000000013 Zahl: 000000000049 Zeile: 000000000001 Spalte: 19 n+Offs: 000000000014 Zahl: 000000000053 Zeile: 000000000001 Spalte: 23 n+Offs: 000000000015 Zahl: 000000000059 Zeile: 000000000001 Spalte: 29 n+Offs: 000000000016 Zahl: 000000000061 Zeile: 000000000002 Spalte: 01 n+Offs: 000000000017 Zahl: 000000000067 Zeile: 000000000002 Spalte: 07 n+Offs: 000000000018 Zahl: 000000000071 Zeile: 000000000002 Spalte: 11 n+Offs: 000000000019 Zahl: 000000000073 Zeile: 000000000002 Spalte: 13 ----------------------------------------------------------------------- Lösungsweg 2 ------------ REM PRIOF301.BAS REM 27.06.2003 REM Hans-Peter Kuberna cls locate 2,10:print "PRIOF301.BAS" locate 2,50:print "27.06.2003"; for n=0 to 16 nmod8=n MOD 8 nmod8d4=nmod8/4 intnmod8d4=int(nmod8d4) intnd8=INT(n/8) Bit4=(INT(nmod8/4) MOD 2)*16 Bit3=(INT((nmod8+(1+intnmod8d4))/3) MOD 2)*8 Bit2=(INT(nmod8/(1+(intnmod8d4 MOD 2 ))) MOD 2)*4 Bit1=(INT((nmod8+1)/2) MOD 2)*2 Bit0=1 Offsg=Bit4+Bit3+Bit2+Bit1+Bit0 Zeile=intnd8 Zahl=Zeile*30+Offsg locate n+5,3: print n locate n+5,10: print Bit4 locate n+5,16: print Bit3 locate n+5,22: print Bit2 locate n+5,28: print Bit1 locate n+5,34: print Bit0 locate n+5,43: print Offsg locate n+5,49: print Zeile locate n+5,56: print Zahl next n Bildschirmausgabe. PRIOF301.BAS 27.06.2003 0 0 0 0 0 1 1 0 1 1 0 0 4 2 1 7 0 7 2 0 8 0 2 1 11 0 11 3 0 8 4 0 1 13 0 13 4 16 0 0 0 1 17 0 17 5 16 0 0 2 1 19 0 19 6 16 0 4 2 1 23 0 23 7 16 8 4 0 1 29 0 29 8 0 0 0 0 1 1 1 31 9 0 0 4 2 1 7 1 37 10 0 8 0 2 1 11 1 41 11 0 8 4 0 1 13 1 43 12 16 0 0 0 1 17 1 47 13 16 0 0 2 1 19 1 49 14 16 0 4 2 1 23 1 53 15 16 8 4 0 1 29 1 59 16 0 0 0 0 1 1 2 61 ----------------------------------------------------------------------- Lösungsweg 1 ------------ REM PRIMFOR1.BAS REM 10.06.2003 REM Hans-Peter Kuberna cls locate 1,3 : print "nz" locate 1,8 : print "nwMod8" locate 1,18 : print "F1" locate 1,24 : print "F2" locate 1,34 : print "Zahl1" locate 1,42 : print "Zahl2" locate 1,50 : print "Zahl3" locate 1,58 : print "ZahlmodX" for nz= 0 to 15 Zeile=2+nz nw=nz+8*0 IntNwd8=Int(nw/8) Nwmod8=nw mod 8 n= Nwmod8 IntNd4=int(n/4) F1=(IntNd4+0) mod 2 F2=(IntNd4+1) mod 2 IntN1d5=int(n1/5) n1=((F1*7+(0-F1)*n)+(n*F2)) Zahl1=(((int((n1+3)/4) mod 2)+(2*n1)-(Int(n1/3)))*2)+1 Zahl2=(F1*30)+((0-F1)+F2)*Zahl1 Zahl3=Zahl2+IntNwd8*30 locate Zeile,2 : print nz; locate Zeile,10 : print Nwmod8; locate Zeile,18 : print F1; locate Zeile,24 : print F2; locate Zeile,34 : print Zahl1; locate Zeile,42 : print Zahl2; locate Zeile,50 : print Zahl3; locate Zeile,60 : print Zahl3 mod 7; locate 20,12+Zahl2 : print "Z"; next nz end Bildschirmausgabe. nz nwMod8 F1 F2 Zahl1 Zahl2 Zahl3 ZahlmodX 0 0 0 1 1 1 1 1 1 1 0 1 7 7 7 0 2 2 0 1 11 11 11 4 3 3 0 1 13 13 13 6 4 4 1 0 13 17 17 3 5 5 1 0 11 19 19 5 6 6 1 0 7 23 23 2 7 7 1 0 1 29 29 1 8 0 0 1 1 1 31 3 9 1 0 1 7 7 37 2 10 2 0 1 11 11 41 6 11 3 0 1 13 13 43 1 12 4 1 0 13 17 47 5 13 5 1 0 11 19 49 0 14 6 1 0 7 23 53 4 15 7 1 0 1 29 59 3 Z Z Z Z Z Z Z Z ----------------------------------------------------------------------- Lösungsweg wie PRIMFOR1.BAS --------------------------- REM PRIMFOR2.BAS REM 10.06.2003 REM Hans-Peter Kuberna cls locate 1,3 : print "n" locate 1,12 : print "Zahl" for n= 0 to 15 nmod8=n mod 8 intnmod8d4=int(nmod8/4) intnd8=int(n/8) Zeile=intnd8 F1=(intnmod8d4+0) mod 2 F2=(intnmod8d4+1) mod 2 n1=((F1*7+(0-F1)*nmod8)+(nmod8*F2)) Zahl=(F1*30)+((0-F1)+F2)*((((int((n1+3)/4) mod 2)+(2*n1)-(Int(n1/3)))*2)+1) locate 3,20+Zahl : print "Z"; Zahl=Zeile*30+Zahl locate 2+n,2 : print n; locate 2+n,12 : print Zahl; next n end Bildschirmausgabe. n Zahl 0 1 1 7 Z Z Z Z Z Z Z Z 2 11 3 13 4 17 5 19 6 23 7 29 8 31 9 37 10 41 11 43 12 47 13 49 14 53 15 59 ----------------------------------------------------------------------- Für die Berechnung der unerlaubten Spalten und Zahlen gibt es zum Beispiel diese Lösung. ------------------------------------------------------------- REM ZAHLBIT1.BAS REM 05.06.2003 REM Hans-Peter Kuberna cls locate 1,4 : print "n" locate 1,17 : print "Bit 0" locate 1,9 : print "Bit 1" locate 1,30 : print "ZahlBit10a" locate 1,26 : print "nb0" locate 1,41 : print "ZahlFolge1" locate 1,53 : print "nb1" locate 1,58 : print "ZahlBit10b" locate 1,69 : print "ZahlGesamt" for n=0 to 21 Zeile=2+n locate Zeile,3 : print n; nb0=int((((n+3)/3) mod 3)+0) mod 2 Bit0=int(((n+2) mod 3)+0) mod 2 locate Zeile,18 : print Bit0; Bit1=int(((n+4) mod 3)+1) mod 2 locate Zeile,10 : print Bit1; ZahlBit10a=(Bit1*2+Bit0)*nb0 locate Zeile,34 : print ZahlBit10a; locate Zeile,26 : print nb0; Reihenfolge1=int(n/12)*1 ZahlFolge1=int(((n+0) mod 3)+Reihenfolge1) mod 3 nb1=int((((n+2)/3) mod 3)+1) mod 2 ZahlBit10b=Zahlfolge1*nb1 rem (int(((n+2) mod 3)+0) mod 3)*nb1 locate Zeile,43 : print ZahlFolge1 locate Zeile,53 : print nb1 locate Zeile,62 : print Zahlbit10b ZahlGesamt=Zahlbit10a+Zahlbit10b locate Zeile,72 : print ZahlGesamt next n n Bit 1 Bit 0 nb0 ZahlBit10a ZahlFolge1 nb1 ZahlBit10b ZahlGesamt 0 0 0 1 0 0 1 0 0 1 1 0 1 2 1 0 0 2 2 1 1 1 3 2 0 0 3 3 0 0 0 0 0 0 0 0 4 1 0 0 0 1 1 1 1 5 1 1 0 0 2 1 2 2 6 0 0 0 0 0 1 0 0 7 1 0 0 0 1 1 1 1 8 1 1 0 0 2 1 2 2 9 0 0 1 0 0 1 0 0 10 1 0 1 2 1 0 0 2 11 1 1 1 3 2 0 0 3 12 0 0 0 0 1 0 0 0 13 1 0 0 0 2 1 2 2 14 1 1 0 0 0 1 0 0 15 0 0 0 0 1 1 1 1 16 1 0 0 0 2 1 2 2 17 1 1 0 0 0 1 0 0 18 0 0 1 0 1 1 1 1 19 1 0 1 2 2 0 0 2 20 1 1 1 3 0 0 0 3 21 0 0 0 0 1 0 0 0 ----------------------------------------------------------------------- Für die Berechnung der unerlaubten Spalten und Zahlen gibt es zum Beispiel diese Lösung. ------------------------------------------------------------- REM ZAHLBIT2.BAS Zahlenbasis 16 REM 05.06.2003 REM Hans-Peter Kuberna cls locate 1,4 : print "n" locate 1,7 : print "ZahlGesamt" locate 1,18 : print "nb2" locate 1,22 : print "ZahlBit32a" locate 1,33 : print "ZahlGesamt1" locate 1,45 : print "nb3" locate 1,49 : print "nb4" locate 1,53 : print "nb6" locate 1,57 : print "ZahlBit32b" locate 1,68 : print "ZahlGesamt2" for nz=0 to 21 Zeile=2+nz : Color 15,0 n=nz+0 nalt=n n=n mod 30 locate Zeile,3 : print n; nb0=int((((n+3)/3) mod 3)+0) mod 2 Bit0=int(((n+2) mod 3)+0) mod 2 Bit1=int(((n+4) mod 3)+1) mod 2 ZahlBit10a=(Bit1*2+Bit0)*nb0 Reihenfolge1=int(n/12) ZahlFolge1=int(((n+0) mod 3)+Reihenfolge1) mod 3 nb1=int((((n+2)/3) mod 3)+1) mod 2 ZahlBit10b=Zahlfolge1*nb1 ZahlGesamt=Zahlbit10a+Zahlbit10b locate Zeile,10 : print ZahlGesamt nb2=(int(n/21)+1) mod 2 Zahlbit32a=int(n/3)*nb2 locate Zeile,18 : print nb2 locate Zeile,25 : print Zahlbit32a ZahlGesamt1=ZahlGesamt+Zahlbit32a*4 locate Zeile,37 : print ZahlGesamt1 nb3=(int(n/12)+0) mod 2 locate Zeile,45 : print nb3 nb4=(int(n/20)+1) mod 2 locate Zeile,49 : print nb4 nb5=(int(n/20)+0) mod 2 nb6=nb2*nb5 Zahlbit32b=int((n+nb3)/3)-nb6 locate Zeile,53 : print nb6 locate Zeile,61 : print ZahlBit32b ZahlGesamt2=ZahlGesamt+(Zahlbit32b*4) locate Zeile,72 : print ZahlGesamt2 + int(nalt/30)*30 next nz n ZahlGesamt nb2 ZahlBit32a ZahlGesamt1 nb3 nb4 nb6 ZahlBit32b ZahlGesamt2 0 0 1 0 0 0 1 0 0 0 1 2 1 0 2 0 1 0 0 2 2 3 1 0 3 0 1 0 0 3 3 0 1 1 4 0 1 0 1 4 4 1 1 1 5 0 1 0 1 5 5 2 1 1 6 0 1 0 1 6 6 0 1 2 8 0 1 0 2 8 7 1 1 2 9 0 1 0 2 9 8 2 1 2 10 0 1 0 2 10 9 0 1 3 12 0 1 0 3 12 10 2 1 3 14 0 1 0 3 14 11 3 1 3 15 0 1 0 3 15 12 0 1 4 16 1 1 0 4 16 13 2 1 4 18 1 1 0 4 18 14 0 1 4 16 1 1 0 5 20 15 1 1 5 21 1 1 0 5 21 16 2 1 5 22 1 1 0 5 22 17 0 1 5 20 1 1 0 6 24 18 1 1 6 25 1 1 0 6 25 19 2 1 6 26 1 1 0 6 26 20 3 1 6 27 1 0 1 6 27 21 0 0 0 0 1 0 0 7 28 ----------------------------------------------------------------------- Für die Berechnung der unerlaubten Spalten und Zahlen gibt es zum Beispiel diese Lösung. ------------------------------------------------------------- REM ZAHLFOR5.BAS REM 09.06.2003 REM Hans-Peter Kuberna cls color 15,0 locate 1,3 : print "n" locate 1,10 : print "ZahlG" for nz= 0 to 21 color 15,0 Zeile=2+nz IntNd22=int((nz+0)/22) Nmod22=nz+0 mod 22 n=Nmod22 IntNd11=int(n/11) F1=(IntNd11+0) mod 2 F2=(IntNd11+1) mod 2 n1=((F1*22+(0-F1)*n)+(n*F2)) IntN1d5=int(n1/5) IntN1d6=int(n1/6) ZahlG=(F1*30)+((0-F1)+F2)*((int((n1+3)/4 mod 2)+IntN1d5+IntN1d6+n1)) ZahlG1=ZahlG+30*IntNd22 locate Zeile,2 : print n; locate Zeile,10 : print ZahlG1; rem color 3,3 locate 6,18+ZahlG : print "Z"; next nz end n ZahlG 0 0 1 2 2 3 3 4 4 5 Z ZZZZZ ZZZ Z ZZZ Z ZZZ ZZZZZ 5 6 6 8 7 9 8 10 9 12 10 14 11 15 12 16 13 18 14 20 15 21 16 22 17 24 18 25 19 26 20 27 21 28 ----------------------------------------------------------------------- Ausgabe der Vielfachen von der Zahl 7 . --------------------------------------- REM ZAHLX73.bas REM 15.04.2003 REM Hans-Peter Kuberna REM Germany cls for n=0 to 22 nt7=n rem *4 nt7p1=nt7+1 ZahlOffset=(int((nt7p1*3+2)/4) mod 2)*1 ZahlOffset=ZahlOffset+(nt7p1 mod 2)*2 ZahlOffset=ZahlOffset+int(((nt7+2) mod 4)/2)*4 ZahlOffset=ZahlOffset+int((nt7 mod 8)/4)*8 rem ZahlZeile=(nt7+(nt7 mod 2)+1)*7 ZahlZeile=(int(nt7/4)+(int(nt7/4) mod 2)+1)*7 Zahl=ZahlZeile-ZahlOffset Zahl7=Zahl*15+ZahlOffset rem Zahld7=Zahl7/7 Print n, print ZahlZeile,ZahlOffset, print ZahlZeile-ZahlOffset, ZahlViel7=(((ZahlZeile-ZahlOffset)*15)+ZahlOffset) print using"#####";ZahlViel7; print using"########";ZahlViel7/7 0 7 7 0 7 1 1 7 4 3 49 7 2 7 2 5 77 11 3 7 1 6 91 13 4 21 14 7 119 17 5 21 13 8 133 19 6 21 11 10 161 23 7 21 8 13 203 29 8 21 7 14 217 31 9 21 4 17 259 37 10 21 2 19 287 41 11 21 1 20 301 43 12 35 14 21 329 47 13 35 13 22 343 49 14 35 11 24 371 53 15 35 8 27 413 59 16 35 7 28 427 61 17 35 4 31 469 67 18 35 2 33 497 71 19 35 1 34 511 73 20 49 14 35 539 77 21 49 13 36 553 79 22 49 11 38 581 83 ----------------------------------------------------------------------- 19.07.2003 Kuberna's Primzahlenfolge und die gebrochene Symmetrie. ----------------------------------------------------------------- Man zeichne einen Kreis, teile ihn in 30 gleichlange Stücke ein und nummeriere die Anfangspunkte der Stücke mit den Zahlen von 0 bis 29. Nun verbindet man die Anfangspunkte 1-7 , 7-13 , 13-19 und man erhält nur !!! 3 Seiten eines 5-Eckes. Die Anfangspunkte 19-25 , 25-1 lassen sich nicht verbinden, weil Anfangspunkt 25 nicht vorhanden ist. Betrachtet man das Bild testhelix21pr30gross.png , sieht man oben rechts neben der roten Null, 3 rote Kugeln ( die Zahlen 2, 3, 5 ) und daneben 6 blaue Kugeln ( die Zahlen 7, 11, 13, 17, 19, 23 ). Unter der blauen Kugel 23 befinden sich senkrecht ( Spalte ) noch 5 weitere Kugeln. Die 6 Kugeln entsprechen den Primzahlen 23 + 0*240 = 23 , 23 + 1*240 = 263 , 23 + 2*240 = 503 , 23 + 3*240 = 743 , 23 + 4*240 = 983 und 23 + 5*240 = 1223 . Vorgehensweise wie oben angegeben , jedoch Einteilung in 6*240 = 1440 gleichlange Stücke. Nun verbindet man die Anfangspunkte 23-263 , 263-503 , 503-743 , 743-983 , 983-1223 , 1223-23 und man erhält 6 Seiten eines 6-Eckes. Bei der Verwendung des Programms PRIMFOR2.BAS zur Berechnung der Primzahlen (Zahlen) muss man die Zahlen n = 0 * 64 + 6 = 6 ergibt Primzahl 23 n = 1 * 64 + 6 = 70 ergibt Primzahl 263 n = 2 * 64 + 6 = 134 ergibt Primzahl 503 n = 3 * 64 + 6 = 198 ergibt Primzahl 743 n = 4 * 64 + 6 = 262 ergibt Primzahl 983 n = 5 * 64 + 6 = 326 ergibt Primzahl 1223 verwenden. n = x * ( 2**6 - 0 ) + 6 Die Werte von n liegen in diesem Fall alle in der Spalte 23. Betrachtet man das Bild testhelix21pr30gross.png , sieht man oben links unterhalb der roten Null, senkrecht ( Spalte ) 3 blaue Kugeln. Die obere blaue Kugel ist die Zahl 239 . Unter der blauen Kugel 239 befinden sich senkrecht ( Spalte ) noch 2 weitere blaue Kugeln. Die 3 Kugel entsprechen den Primzahlen 239 + 0*240 = 239 , 239 + 1*240 = 479 und 239 + 2*240 = 719 . Vorgehensweise wie oben angegeben , jedoch Einteilung in 3*240 = 720 gleichlange Stücke. Nun verbindet man die Anfangspunkte 239-479 , 479-719 , 719-239 , und man erhält 3 Seiten eines 3-Eckes. Bei der Verwendung des Programms PRIMFOR2.BAS zur Berechnung der Primzahlen (Zahlen) muss man die Zahlen n = 1 * ( 64 - 1 ) + 0 = 63 ergibt Primzahl 239 n = 2 * ( 64 - 1 ) + 0 = 127 ergibt Primzahl 479 n = 3 * ( 64 - 1 ) + 0 = 191 ergibt Primzahl 719 verwenden. n = x * ( (2**6) - 1 ) + 0 Die Werte von n liegen in diesem Fall alle in der Spalte 29. Achtung !!! 1. Kugel liegt bei diesen Beispielen im Zahlenbereich 1-239 . Die Lage der Primzahlen ,die ein Vieleck ergeben, hängen also mit ( 2**n ) oder ( 2**n ) - 1 zusammen. Nochmal zur Kontrolle. * -> keine Primzahl n = ( 0 * 8 ) + 1 = 1 ergibt Primzahl 7 n = ( 1 * 8 ) + 1 = 9 ergibt Primzahl 37 n = ( 2 * 8 ) + 1 = 16 ergibt Primzahl 67 n = ( 3 * 8 ) + 1 = 25 ergibt Primzahl 97 n = ( 4 * 8 ) + 1 = 33 ergibt Primzahl 127 n = ( 5 * 8 ) + 1 = 41 ergibt Primzahl 157 n = ( 6 * 8 ) + 1 = 49 ergibt Zahl 187 * n = ( 1 * 8 ) - 1 = 7 ergibt Primzahl 29 n = ( 2 * 8 ) - 1 = 15 ergibt Primzahl 59 n = ( 3 * 8 ) - 1 = 23 ergibt Primzahl 89 n = ( 4 * 8 ) - 1 = 31 ergibt Zahl 119 * Die Endziffern sind in einer Spalte immer gleich. Es ist eine sich wiederholende Folge von 1 , 7 , 1 , 3 , 7 , 9 , 3 , 9 . Zu Beachten ist auch, das die Summe von 2 Endziffer aus bestimmten Spalten die Summe 10 ergibt. Spalte 0 + Spalte 7 ergibt 1 + 9 = 10 Spalte 1 + Spalte 6 ergibt 7 + 3 = 10 Spalte 2 + Spalte 5 ergibt 1 + 9 = 10 Spalte 3 + Spalte 4 ergibt 3 + 7 = 10 ----------------------------------------------------------------------- Berechnung der Endziffer: ------------------------- # Hans-Peter Kuberna # E-Mail # hans-peter@kuberna.de # FnEndZiffer1.ari 01.08.2003 # fuer ARIBAS von Otto Forster # http://www.mathematik.uni-muenchen.de/~forster function EndZiffer(nEndZiff: integer): integer; var EndZiff,EndZiffDiv10 : integer; DivEndZiff: array of integer; begin DivEndZiff:=divide(nEndZiff,10); EndZiff :=DivEndZiff[1]; #EndZiffDiv10 :=DivEndZiff[0]; return EndZiff; end. ----------------------------------------------------------------------- Berechnung der Quersumme: ------------------------- # Hans-Peter Kuberna # E-Mail # hans-peter@kuberna.de # FnQuerSumme1.ari 01.08.2003 # fuer ARIBAS von Otto Forster # http://www.mathematik.uni-muenchen.de/~forster function QuerSumme(nQuerAlt: integer): integer; var nQuer,QSumme : integer; QRest: array of integer; begin nQuer :=nQuerAlt; QSumme :=0; while nQuer >= 10 do QSumme :=0; while nQuer > 0 do QRest:=divide(nQuer,10); QSumme :=QSumme+QRest[1]; nQuer :=QRest[0]; end; nQuer :=QSumme; end; if nQuerAlt <10 then QSumme :=nQuerAlt; end; return QSumme; end. ----------------------------------------------------------------------- 21.08.2003 Die gebrochene Symmetrie und das Atom. ----------------------------------------------------------------- Mit Hilfe der Primzahlen lassen sich nur regelmässige Vielecke mit der Seitenanzahl 3,4,5 oder 6 erzeugen. ( 3,4,5 -> siehe Platonische Körper ) ( 6 ergibt Fläche ) Behauptung!!! Regelmässige Vielecke mit mehr als 6 Seiten sind unter ausschliesslicher Verwendung von Primzahlen, für die Eckpunkte, nicht möglich!!! Bei 7 Seiten fehlt für den einen Eckpunkt die Primzahl. Aufgrund dieser Behauptung kann ich jetzt auch Verstehen warum beim Atom hauptsächlich nur 6 Bahnen benutzt werden. Mehr als 6 Elektronen pro Elektronenbahn sind möglich, wenn: Die Primzahlen, die zum Beispiel ein 6-Eck ergeben,müssen genügend gross sein. Wie zum Beispiel, weiter oben im Abschnitt "Nochmal zur Kontrolle", die Primzahlen 7, 37, 67, 97, 127, 157 . Den Abstand zwischen 37 und 7 teilt man durch 2, und erhält dann 12 Elektronen pro Elektronenbahn. Die Zahlen lauten dann * -> keine Primzahl 7+ 0 = 7 7+15 = 22 * 37+ 0 = 37 37+15 = 52 * 67+ 0 = 67 67+15 = 82 * 97+ 0 = 97 97+15 = 112 * 127+ 0 = 127 127+15 = 142 * 157+ 0 = 157 157+15 = 172 * . Teilt man den Abstand durch 3,dann erhält man 18 Elektronen pro Elektronenbahn. Die Zahlen lauten dann * -> keine Primzahl 7+ 0 = 7 7+10 = 17 7+20 = 27 * 37+ 0 = 37 37+10 = 47 37+20 = 57 * 67+ 0 = 67 67+10 = 77 * 67+20 = 87 * 97+ 0 = 97 97+10 = 107 97+20 = 117 * 127+ 0 = 127 127+10 = 137 127+20 = 147 * 157+ 0 = 157 157+10 = 167 157+20 = 177 * . Hierbei ergeben sich wiederum Primzahlen mit Ausnahme von 27, 57, 77, 87, 117, 147, 177 . Das POV-Ray Programm Kugelpackung3Home1.pov zeigt die Rot makierten Primzahlen. Es entsteht kein Quadrat, weil die gegenüberliegenden Linien zwar gleich lang sind, aber nicht alle Linien gleich lang sind. Die Vielecke sind nicht regelmässig, weil beim Ausdruck vom Bild Kugelpackung3Home1Gross.png, das Verhältnis von der Höhe zur Breite des Kreises <> 1 ist , müssten es aber sein. Muss ein Programmierfehler sein!!! ----------------------------------------------------------------------- 03.01.2004 Die gebrochene Symmetrie und das 3 Realitäten-Problem. ----------------------------------------------------------------- Für die Berechnung von Körpern ( z.B. einem Würfel ), und deren Größe ist es wichtig, daß die 1 eine Primzahl ist. Man nehme an, das es 3 Realitäten gibt. 1. Die Erste richtet sich nur nach Kuberna's Primzahlenfolge. 2. Die Zweite richtet sich nicht nach Kuberna's Primzahlenfolge. 3. Die Dritte vereinigt 1. und 2. . Wenn ich in der 1. Realität lebe, könnte ich Teile der 3. Realität wahrnehmen. Die 2. Realität währe für mich unsichtbar, weil alles was ich tun würde sich nach 1. richtet. Wenn ich in der 2. Realität lebe, könnte ich Teile der 3. Realität wahrnehmen. Die 1. Realität währe für mich unsichtbar, weil alles was ich tun würde sich nach 2. richtet. Wenn ich in der 3. Realität lebe, könnte ich abhängig davon wie ich es betrachte, entweder Teile der 1. Realität oder Teile der 2. Realität wahrnehmen. Ich möchte gerne Wissen, in welcher Realität ich mich gerade befinden könnte, zu dem Zeitpunkt wo ich diesen Text schreibe. Währe es nicht fazinierend oder auch gefährlich, wenn man eine "Tür" öffnen könnte, um von der 1. Realität, über die 3. Realität, in die 2. Realität zu sehen oder zu gehen ? Ich stelle mir auch jetzt die Frage, ob manchmal etwas Unsinniges gemacht werden muß, damit es sich zum späteren Zeitpunkt als Sinnvoll herausstellt. ----------------------------------------------------------------------- Kuberna's Primzahlenfolge und die Seitenlänge beim Würfel ( Cube ) ----------------------------------------------------------------- # Hans-Peter Kuberna # E-Mail # hans-peter@kuberna.de # fuer ARIBAS von Otto Forster # http://www.mathematik.uni-muenchen.de/~forster # CubePrim01.ari 27.01.2004 set_floatprec(4096). var Zeilef,Spaltef,Wertf : integer; Dif,n,nf,Zahl : integer; s,obers,vols : integer; end. function Zahlf(nf: integer): integer; var nfmod8,nfmod8p1,nfmod8p6,nfmod8p1mod2: integer; nfmod8div7,nfmod8p6div7,nfdiv8: integer; Zeilef,Spaltef,Wertf,Mul6,VorZei,MiPl4,w6: integer; begin nfmod8 := nf mod 8; nfmod8p1 := nfmod8+1; nfmod8p6 := nfmod8+6; nfmod8p1mod2 :=nfmod8p1 mod 2; nfmod8div7 :=nfmod8 div 7; nfmod8p6div7 :=nfmod8p6 div 7; nfdiv8 := nf div 8; Zeilef := nfdiv8; Mul6 := (nfmod8 div 2)*6; # Vorzeichen berechnen VorZei := 1-(nfmod8p1mod2*2); # -/+ 4 addieren bei nf=0 / nf=7 MiPl4 := (nfmod8div7-nfmod8p6div7+1)*4*VorZei; # Wert fuer Ergebnisanpassung w6 := 6; Spaltef := Mul6+VorZei+MiPl4+w6; Wertf := Zeilef*30+Spaltef; return Wertf; end. # Betrachtung der Werte: Volumen / Oberfläche ( beim Würfel ) # Seite um 1 ansteigend # Endziffer 0 ist vorhanden write(" ":78); write("n":5,"Seitenlänge":15," ":4,"Volumen":15," ":4,"Oberfläche":15," ":20); Dif:=000; for n:=0+Dif to 13+Dif by 1 do s:=n; vols:=s*s*s; obers:=s*s*6; write(n:5,s:15," ":4,vols:15," ":4,obers:15," ":20); if (n mod 6) = 0 then write(" ":78); end; end; # Betrachtung der Werte: Volumen / Oberfläche ( beim Würfel ) # Seite aus Kuberna's Primzahlenfolge # Endziffer 0 ist nicht vorhanden write(" ":78); write("n":5,"Seitenlänge":15," ":4,"Volumen":15," ":4,"Oberfläche":15," ":20); #Dif:=0; for n:=0+Dif to 13+Dif by 1 do s:=Zahlf(n); vols:=s*s*s; obers:=s*s*6; write(n:5,s:15," ":4,vols:15," ":4,obers:15," ":20); if (n mod 6) = 0 then write(" ":78); end; end; Bildschirmausgabe: ------------------ ==> load("C:\Programme\aribasw144\hpk\CubePrim01.ari"). (** loading file C:\Programme\aribasw144\hpk\CubePrim01.ari **) 4096 var Zahlf 1 n Seitenlänge Volumen Oberfläche 7 0 0 0 0 0 1 1 1 6 2 2 8 24 3 3 27 54 4 4 64 96 5 5 125 150 6 6 216 216 7 7 343 294 8 8 512 384 9 9 729 486 10 10 1000 600 11 11 1331 726 12 12 1728 864 13 13 2197 1014 1 n Seitenlänge Volumen Oberfläche 7 0 1 1 6 1 7 343 294 2 11 1331 726 3 13 2197 1014 4 17 4913 1734 5 19 6859 2166 6 23 12167 3174 7 29 24389 5046 8 31 29791 5766 9 37 50653 8214 10 41 68921 10086 11 43 79507 11094 12 47 103823 13254 13 49 117649 14406 -: true ==> Ergebnis: --------- Oberhalb der Seitenlänge 6, also bei 7, nimmt das eingeschlossene Volumen zu, im Verhältnis zur Oberfläche. Bei der Verwendung der Seitenlänge aus Kuberna's Primzahlenfolge ist die Endziffer 0, bei der Oberfläche, nicht vorhanden. Lassen sich die Abstände der Atome, z.B. im Metall ( Kubisch (raumzentriert) ) ganzzahlig durch 10 teilen, richtet sich die Anordnung nicht nach Kuberna's Primzahlenfolge. Man Beachte auch: Seitel. Volum. Oberfl. Dif. Dif. Ergebnis 7 343 - 294 = 49 49 / ( 7* 7) = 1 11 1331 - 726 = 605 605 / (11*11) = 5 13 2197 - 1014 = 1183 1183 / (13*13) = 7 17 4913 - 1734 = 3179 3179 / (17*17) = 11 19 6859 - 2166 = 4693 4693 / (19*19) = 13 23 12167 - 3174 = 8993 8993 / (23*23) = 17 29 24389 - 5046 = 19343 19343 / (29*29) = 23 31 29791 - 5766 = 24025 24025 / (31*31) = 25 37 50653 - 8214 = 42439 42439 / (37*37) = 31 .. ..... .... ..... ..... ..... .. Hat die Seitenlänge die Endziffer 1, dann ist bei dem Volumen auch die Endziffer 1. Hat die Seitenlänge die Endziffer 1, dann ist das Ergebnis ganzzahlig durch 5 teilbar. Es ergibt sich dann die Folge: Seitel. Ergebnis 11 ergibt 1 * 5 = 5 31 ergibt 5 * 5 = 25 41 ergibt 7 * 5 = 35 61 ergibt 11 * 5 = 55 71 ergibt 13 * 5 = 65 91 ergibt 17 * 5 = 85 101 ergibt 13 * 5 = 95 Über die oben angegebenen Ergebnisse, bei den Seitenlängen 11 , 31,... ist noch weiter nachzudenken. ----------------------------------------------------------------------- Die Anzahl der Elektronen, und die Primzahlen 7 und 11. ------------------------------------------------------ REM ATOMBAH1.BAS REM 09.11.2003 REM Hans-Peter Kuberna REM hans-peter@kuberna.de REM Germany cls print " n", "w=2*n*n ","w*10 mod 7 ", print "w*10 mod 11 ","w mod 7 " print for n= 1 to 18 w=2*n*n wm10=w*10 wm10mod7=(wm10) mod 7 wm10mod11=(wm10) mod 11 wmod7=(w) mod 7 print n,w,wm10mod7,wm10mod11,wmod7 if n=0 or n= 6 or n=7 then print end if next n Bildschirmausgabe: ------------------ n w=2*n*n w*10 mod 7 w*10 mod 11 w mod 7 1 2 6 9 2 2 8 3 3 1 3 18 5 4 4 4 32 5 1 4 5 50 3 5 1 6 72 6 5 2 7 98 0 1 0 8 128 6 4 2 9 162 3 3 1 10 200 5 9 4 11 242 5 0 4 12 288 3 9 1 13 338 6 3 2 14 392 0 4 0 15 450 6 1 2 16 512 3 5 1 17 578 5 5 4 18 648 5 1 4 ----------------------------------------------------------------------- Die Anzahl der Elektronen und die Primzahl 29. ---------------------------------------------- REM ATOMBAH3.BAS REM 10.11.2003 cls locate 3,1 nw=29 for n= 1 to 64 w=2*n*n wmnw=w*nw wmnwmod7=(wmnw) mod 7 wmnwmodnw2m1=(wmnw) mod (nw*2-1) if n<8 or n>49 then print n,w,wmnwmodnw2m1,,int(wmnw/(nw*2-1)) end if next n locate 1,1 print " n", "w=2*n*n " locate 1,24:print "w*";nw;"mod(";nw;"*2-1)"; locate 1,45:print "int(w*";nw;"/(";nw;"*2-1))" Bildschirmausgabe ----------------- n w=2*n*n w* 29 mod( 29 *2-1) int(w* 29 /( 29 *2-1)) 1 2 1 1 2 8 4 4 3 18 9 9 4 32 16 16 5 50 25 25 6 72 36 36 7 98 49 49 50 5000 49 2543 51 5202 36 2646 52 5408 25 2751 53 5618 16 2858 54 5832 9 2967 55 6050 4 3078 56 6272 1 3191 57 6498 0 3306 58 6728 1 3423 59 6962 4 3542 60 7200 9 3663 61 7442 16 3786 62 7688 25 3911 63 7938 36 4038 64 8192 49 4167 Man Beachte auch. 2543 - 1 = 2542 2646 - 4 = 2642 2751 - 9 = 2742 2858 - 16 = 2842 2967 - 25 = 2942 3078 - 36 = 3042 3191 - 49 = 3142 3306 - 64 = 3242 ----------------------------------------------------------------------- Das ( 2**i ) - 1 Problem ------------------------------------------------------------ Bei der Frage ob ( 2**i ) - 1 eine Primzahl ist, entstand das Programm Test2hoch.ari . Bei diesem Programm wird berechnet ob 2 ** Primzahl - 1 = Primzahl ist. Um die Rechenzeit zu begrenzen wurde nur die Berechnung bis ( 2 ** 3217 ) - 1 durchgeführt ! Beim Betrachten der Zahlen ergab sich folgendes. Die Endziffern der Werte von i sind 1 , 3 , 7 oder 9. Die Endziffern 4 und 6 liegen nicht in einer erlaubten Spalte. Die Endziffern von den Ergebnissen sind 1 oder 7. Die Quersummen der Werte von i sind 1, 2, 4, 5, 7 oder 8. Die Quersummen von den Ergebnissen sind 1 oder 4. 2 ** ( 0 + ( x * 6 ) ) - 1 ergibt beim Ergebnis Quersumme 9 2 ** ( 1 + ( x * 6 ) ) - 1 ergibt beim Ergebnis Quersumme 1 2 ** ( 2 + ( x * 6 ) ) - 1 ergibt beim Ergebnis Quersumme 3 2 ** ( 3 + ( x * 6 ) ) - 1 ergibt beim Ergebnis Quersumme 7 2 ** ( 4 + ( x * 6 ) ) - 1 ergibt beim Ergebnis Quersumme 6 2 ** ( 5 + ( x * 6 ) ) - 1 ergibt beim Ergebnis Quersumme 4 bei x > 0 2 ** ( 0 + ( x * 6 ) ) - 0 ergibt Quersumme 1 2 ** ( 1 + ( x * 6 ) ) - 0 ergibt Quersumme 2 2 ** ( 2 + ( x * 6 ) ) - 0 ergibt Quersumme 4 2 ** ( 3 + ( x * 6 ) ) - 0 ergibt Quersumme 8 2 ** ( 4 + ( x * 6 ) ) - 0 ergibt Quersumme 7 2 ** ( 5 + ( x * 6 ) ) - 0 ergibt Quersumme 5 bei x >= 0 Man Beachte auch ! wertx1=(1+x*6) 1 + 536*6 = 3217 y=x*1.5 werty11=(1+y*4) 1 + (536*1.5)*4 = 3217 y=x*1.5-0.5 3 + ((536*1.5)-0.5)*4 = 3217 werty31=(3+y*4) wertx5=(5+x*6) y=x*1.5+0.5 werty12=(1+y*4) y=x*1.5+1 werty32=(3+y*4) Siehe auch : Berechnung der erlaubten Spalten und Zahlen -> Lösungsweg 3 ----------------------------------------------------------------------- # Hans-Peter Kuberna # E-Mail # hans-peter@kuberna.de # fuer ARIBAS von Otto Forster # http://www.mathematik.uni-muenchen.de/~forster # QuerEndZiff1.ari 22.07.2003 var hoch2zahl,hoch2zahlm1,n,nalt,n2,n2alt : integer; Offsg,Zeile,Wert,Wertm1,Wert1,Wert2,nmax : integer; ndivxx,ndiv2,ndiv30,nmod2,nmod30,imod900,imod30,idiv30 : integer; Wertm1div30,WertOffs : integer; x,y,wertx1,wertx5,werty1,werty3 : integer; ZeigeXY : integer; end. # # Berechnung der zulaessigen Primzahlspalten und addieren der # Primzahlzeilen*30 und berechnen der Zahl. # Die Zahlen 2, 3 und 5 kommen hierin nicht vor. # 1 7 11 13 17 19 23 29 31 .... # Die Zahlen 49 ( 7*7) bei n=13, # 77 (11*7) bei n=20, # 91 (13*7) bei n=24, # 119 (17*7) bei n=31, # 121 (11*11) bei n=32, # 143 (13*11) bei n=38, # 187 (17*11) bei n=49, ...... # werden auch !!!! noch !!!! mit ausgegeben. function Zahl(n: integer): integer; var nmod8,nmod8p1,nmod8p1div2,nmod8div4,nmod8div4mod2: integer; nmod8div4p1,divnd8: integer; Offsg,Zeile,ZahlN: integer; Bit0,Bit1,Bit2,Bit3,Bit4: integer; begin nmod8 := n mod 8; nmod8p1 := nmod8+1; nmod8p1div2 := nmod8p1 div 2; nmod8div4 := nmod8 div 4; nmod8div4mod2 := nmod8div4 mod 2; nmod8div4p1 := nmod8div4+1; divnd8 := n div 8; Bit4 := nmod8div4mod2*16; Bit3 := (((nmod8+nmod8div4p1 ) div 3) mod 2)*8; Bit2 := ((nmod8 div nmod8div4p1) mod 2)*4; Bit1 := (nmod8p1div2 mod 2)*2; Bit0 :=1; Offsg := Bit4+Bit3+Bit2+Bit1+Bit0; Zeile := divnd8; ZahlN := Zeile*30+Offsg; return ZahlN; end. write(" ":78); nAnfang:=1; nAnzahl:=250; nMax:=20; ZeigeXY:=0; #write("n":6,"ndiv30":11," nmod30":11,"i":10,"idiv900":10,"idiv30":10,"imod30":10,"WertOffs":10); for n := nAnfang to nAnfang+nAnzahl by 1 do ndiv2:=n div 2; #nmod2:=n mod 2; #i:=(1+nmod2*6)+(ndiv2*30); x:=n; wertx1:=(1+x*6); wertx5:=(5+x*6); werty1:=(1+x*4); werty3:=(3+x*4); #wertx1:=wertx1*(((x+0) div 4) mod 2); #wertx5:=wertx5*(((x+0) div 2) mod 2); #werty1:=werty1*((x+1) mod 2); #werty3:=werty3*((x+0) mod 2); #wertx1:=wertx1+wertx5; #ndivxx:=n div 24; #nmod30:=n mod 30; #i := Zahl(i); #imod30:=i mod 30; #idiv900:=i div 900; #idiv30:=i div 30; # Ausgabe des Wertes # write(Wertm1:20); if prime32test(wertx1) then if ZeigeXY =1 then write(x:12); else write(wertx1:12); end; else write("":12); end; if prime32test(wertx5) then if ZeigeXY =1 then write(x:12); else write(wertx5:12); end; else write("":12); end; if prime32test(werty1) then if ZeigeXY =1 then write(x:12); else write(werty1:12); end; else write("":12); end; if prime32test( werty3) then if ZeigeXY =1 then write(x:12); else write(werty3:12); end; else write("":12); end; write("":22); end. Bildschirmausgabe: ------------------ ==> load("C:\Programme\aribasw142\hpk\QuerEndZiff1.ari"). (** loading file C:\Programme\aribasw142\hpk\QuerEndZiff1.ari **) var Zahl 1 1 250 20 0 7 11 5 7 13 17 11 19 23 13 29 17 19 31 23 37 41 43 47 29 31 53 59 37 ...... ...... ...... ...... ...... ...... ...... ...... 977 1471 983 1481 1483 1487 991 1489 1493 1499 997 1511 -: true ==> ----------------------------------------------------------------------- # Hans-Peter Kuberna # E-Mail # hans-peter@kuberna.de # TestMersenne1neu.ari 03.08.2003 # fuer ARIBAS von Otto Forster # http://www.mathematik.uni-muenchen.de/~forster function QuerSumme(nQuerAlt: integer): integer; var nQuer,QSumme : integer; QRest: array of integer; begin nQuer :=nQuerAlt; QSumme :=0; while nQuer >= 10 do QSumme :=0; while nQuer > 0 do QRest:=divide(nQuer,10); QSumme :=QSumme+QRest[1]; nQuer :=QRest[0]; end; nQuer :=QSumme; end; if nQuerAlt <10 then QSumme :=nQuerAlt; end; return QSumme; end. function EndZiffer(nEndZiff: integer): integer; var EndZiff,EndZiffDiv10 : integer; DivEndZiff: array of integer; begin DivEndZiff:=divide(nEndZiff,10); EndZiff :=DivEndZiff[1]; #EndZiffDiv10 :=DivEndZiff[0]; return EndZiff; end. function ZahlDiv30(nZahlDiv30: integer): integer; var ZahlDiv30: array of integer; DivZahl30: array of integer; begin DivZahl30:=divide(nZahlDiv30,30); ZahlDiv30 :=DivZahl30[0]; return ZahlDiv30; end. function ZahlDiv30Rest(nZahlDiv30Rest: integer): integer; var ZahlDiv30Rest: integer; DivZahl30Rest: array of integer; begin DivZahl30Rest:=divide(nZahlDiv30Rest,30); ZahlDiv30Rest :=DivZahl30Rest[1]; return ZahlDiv30Rest; end. function Zahl1(n: integer): integer; var nmod8,nmod8div4,ndiv8,ZahlN,ZahlN1,ZahlN2,F1,F2,n1: integer; begin nmod8 := n mod 8; nmod8div4 :=nmod8 div 4; ndiv8 := n div 8; F1 := (nmod8div4+0) mod 2; F2 := (nmod8div4+1) mod 2; n1 := ((F1*7+(0-F1)*nmod8)+(nmod8*F2)); ZahlN1 := ((((((n1+3) div 4) mod 2)+(2*n1)-(n1 div 3))*2)+1); ZahlN2 := (F1*30)+((0-F1)+F2)*ZahlN1; ZahlN := (ndiv8*30)+ZahlN2; return ZahlN; end. var Wertm1,Wertm2 : integer; n,nMax,x,y,wertx1,wertx3,wertx5,werty1,werty2,werty3 : integer; end. for n := 0 to 31 by 1 do #for n := 314400 to 314500 by 1 do x:=(2*n) div 3; wertx1:=(1+x*6); #Ergebnis-QuerSumme 1 => Q1 0=>Q9 2=>Q3 4=>Q6 wertx3:=(3+x*6); #Ergebnis-QuerSumme 3 => Q7 wertx5:=(5+x*6); #Ergebnis-QuerSumme 5 => Q4 y:=n; werty1:=(1+y*4); #Ergebnis-Endziffer 1 bei n => 1,5,9,13,.... werty2:=(2+y*4); werty3:=(3+y*4); #Ergebnis-Endziffer 7 bei n => 3,7,11,15,.... #if wertx1 = werty3 then #write(" ":78); write(n:5,wertx1:10,wertx3:10,wertx5:10,werty1:10,werty2:10,werty3:10," ":13); #write("n":5,wertx1:10,werty1:10,QuerSumme(2**wertx1-1):10,EndZiffer(2**werty1-1):10," ":33); #write(n:10,wertx5:15,werty3:15,x:15,y:15," ":8); #write(" ":78); #end; end; write(" ":78); end. Bildschirmausgabe: ------------------ ==> load("C:\Programme\aribasw142\hpk\TestMersenne1neu.ari"). (** loading file C:\Programme\aribasw142\hpk\TestMersenne1neu.ari **) QuerSumme EndZiffer ZahlDiv30 ZahlDiv30Rest Zahl1 var 0 1 3 5 1 2 3 1 1 3 5 5 6 7 2 7 9 11 9 10 11 3 13 15 17 13 14 15 4 13 15 17 17 18 19 5 19 21 23 21 22 23 6 25 27 29 25 26 27 7 25 27 29 29 30 31 8 31 33 35 33 34 35 9 37 39 41 37 38 39 10 37 39 41 41 42 43 11 43 45 47 45 46 47 12 49 51 53 49 50 51 13 49 51 53 53 54 55 14 55 57 59 57 58 59 15 61 63 65 61 62 63 16 61 63 65 65 66 67 17 67 69 71 69 70 71 18 73 75 77 73 74 75 19 73 75 77 77 78 79 20 79 81 83 81 82 83 21 85 87 89 85 86 87 22 85 87 89 89 90 91 23 91 93 95 93 94 95 24 97 99 101 97 98 99 25 97 99 101 101 102 103 26 103 105 107 105 106 107 27 109 111 113 109 110 111 28 109 111 113 113 114 115 29 115 117 119 117 118 119 30 121 123 125 121 122 123 31 121 123 125 125 126 127 1 end -: true == ----------------------------------------------------------------------- Dieses gehört mit zum Abschnitt: Das ( 2**i ) - 1 Problem REM ISMERS01.BAS REM 25.12.2003 REM Hans-Peter Kuberna REM hans-peter@kuberna.de cls for i#= 1 to 50 step 2 if (i#/5)<> int(i#/5) then Wert#=(2^i#)-1 IntWertd3p75#=int(Wert#/3.75) IntIntWertd3p75d8#=Int(IntWertd3p75#/8) IntWertd30#=Int(Wert#/30) WertMod30#=Wert# mod 30 Imod10#=i# mod 10 rem print i#,Wert#,IntWertd3p75# rem print i#, IntWertd30# rem print i#, Imod10#, print using"################";Wert#,WertMod30# rem if IntIntWertd3p75d8#*8 = (IntIntWertd3p75d8# mod 8)*8 then rem print IntIntWertd3p75d8#*8 rem ,IntIntWertd3p75d8#*8 rem end if end if next i# Bildschirmausgabe: ------------------ 1 1 1 1 3 3 7 7 7 7 127 7 9 9 511 1 11 1 2047 7 13 3 8191 1 17 7 131071 1 19 9 524287 7 21 1 2097151 1 23 3 8388607 7 27 7 134217727 7 29 9 536870911 1 31 1 2147483647 7 33 3 8589934591 1 37 7 137438953471 1 39 9 549755813887 7 41 1 2199023255551 1 43 3 8796093022207 7 47 7 140737488355327 7 49 9 562949953421311 1 Man Beachte: ------------ Die Werte ( für i# ) 3,9,21,27,33,39 ..... sind nicht erlaubt, den Sie liegen nicht in einer erlaubten Spalte. ----------------------------------------------------------------------- Dieses gehört mit zum Abschnitt: Das ( 2**i ) - 1 Problem Datei$="ISMERS02.BAS" REM 27.12.2003 N$="Hans-Peter Kuberna" EMail$="hans-peter@kuberna.de" REM Germany cls print Date$,Time$:print N$,EMail$,Datei$ print goto test1 for i=0 to 17 intid4=int(i/4) intid4m5=intid4*5 imod4=i mod 4 intimod4d2=int(imod4/2) wert=intimod4d2+imod4+intid4m5 wertm2p1=wert*2+1 wertm2p1mod4=wertm2p1 mod 4 wertm2p1mod6=wertm2p1 mod 6 wertm2p1mod30=wertm2p1 mod 30 print i,wertm2p1mod4,wertm2p1mod6,wertm2p1 :rem mod30 rem 2^wertm2p1-1 if wertm2p1=0 then print i,imod4,intimod4d2,wertm2p1 rem ,2^wertm2p1-1 end if next i end test1: print "n","w","intnmod8d4", print "nmod4","i" for n=0 to 18 intnd8=int(n/8) nmod4=n mod 4 nmod8=n mod 8 intnmod8d4=int(nmod8 /4) Reihenfolge=intnmod8d4*2 w=int(((nmod4+Reihenfolge)*2+1)/7) mod 2 i=((intnmod8d4*3)+nmod4)*2-w i=i+(intnd8*12) print n,w,intnmod8d4,nmod4,i next n Bildschirmausdruck ( ohne goto test1 ): --------------------------------------- 12-27-2003 13:04:37 Hans-Peter Kuberna hans-peter@kuberna.de ISMERS02.BAS 0 1 1 1 1 3 3 3 2 3 1 7 3 1 3 9 4 3 5 11 5 1 1 13 6 1 5 17 7 3 1 19 8 1 3 21 9 3 5 23 10 3 3 27 11 1 5 29 12 3 1 31 13 1 3 33 14 1 1 37 15 3 3 39 16 1 5 41 17 3 1 43 Man Beachte: ------------ Berechnung der Werte für wertm2p1. Die Werte ( für wertm2p1 ) 3,9,21,27,33,39 ..... sind nicht erlaubt, den Sie liegen nicht in einer erlaubten Spalte. i = 1 ergibt 3 i = 1*12 + 1 ergibt 33 i = 3 ergibt 9 i = 1*12 + 3 ergibt 39 i = 8 ergibt 21 i = 1*12 + 8 ergibt ? i = 10 ergibt 27 i = 1*12 + 10 ergibt ? und so weiter. ----------------------------------- Bildschirmausdruck ( mit goto test1 ): ---------------------------------------- 12-27-2003 13:08:12 Hans-Peter Kuberna hans-peter@kuberna.de ISMERS02.BAS n w intnmod8d4 nmod4 i 0 0 0 0 0 1 0 0 1 2 2 0 0 2 4 3 1 0 3 5 4 0 1 0 6 5 1 1 1 7 6 1 1 2 9 7 1 1 3 11 8 0 0 0 12 9 0 0 1 14 10 0 0 2 16 11 1 0 3 17 12 0 1 0 18 13 1 1 1 19 14 1 1 2 21 15 1 1 3 23 16 0 0 0 24 17 0 0 1 26 18 0 0 2 28 Man Beachte: ------------ Im Abschnitt test1: wird der Wert von n Umgesetzt in den Wert von i, ohne die Werte 1,3,8,10,13,15,20,22 ..... . ----------------------------------------------------------------------- Dieses gehört mit zum Abschnitt: Das ( 2**i ) - 1 Problem Datei$="ISMERS03.BAS" REM 27.12.2003 N$="Hans-Peter Kuberna" EMail$="hans-peter@kuberna.de" REM Germany cls print Date$,Time$:print N$,EMail$,Datei$ print for n=0 to 18 intnd8=int(n/8) nmod4=n mod 4 nmod8=n mod 8 intnmod8d4=int(nmod8 /4) Reihenfolge=intnmod8d4*2 w=int(((nmod4+Reihenfolge)*2+1)/7) mod 2 i=((intnmod8d4*3)+nmod4)*2-w i=i+(intnd8*12) intid4=int(i/4) intid4m5=intid4*5 imod4=i mod 4 intimod4d2=int(imod4/2) wert=intimod4d2+imod4+intid4m5 wertm2p1=wert*2+1 wertm2p1mod4=wertm2p1 mod 4 wertm2p1mod6=wertm2p1 mod 6 wertm2p1mod30=wertm2p1 mod 30 print using "####";n; :print " "; print using "####"; i; :print " ",wertm2p1mod4, print wertm2p1mod6,wertm2p1, 2^wertm2p1-1 next n Bildschirmausdruck: ------------------- 12-27-2003 13:35:24 Hans-Peter Kuberna hans-peter@kuberna.de ISMERS03.BAS 0 0 1 1 1 1 1 2 3 1 7 127 2 4 3 5 11 2047 3 5 1 1 13 8191 4 6 1 5 17 131071 5 7 3 1 19 524287 6 9 3 5 23 8388607 7 11 1 5 29 536870911 8 12 3 1 31 2147483647 9 14 1 1 37 137438953471 10 16 1 5 41 2199023255551 11 17 3 1 43 8796093022207 12 18 3 5 47 140737488355327 13 19 1 1 49 562949953421311 14 21 1 5 53 9.00719925474099E+15 15 23 3 5 59 5.76460752303423E+17 16 24 1 1 61 2.30584300921369E+18 17 26 3 1 67 1.47573952589676E+20 18 28 3 5 71 2.36118324143482E+21 Man Beachte: ------------ Beide Programmteile von ISMERS02.BAS zusammengefügt. Ergebnis ist für wertm2p1 die bekannte Zahlenfolge 1,7,11,13,17 ..... . Schlußfolgerung: Die Mersenne Primzahlen müßte also 1,127,8191,131071 ..... sein. ----------------------------------------------------------------------- Dieses gehört mit zum Abschnitt: Das ( 2**i ) - 1 Problem rem DIGIH2N1.BAS rem 04.01.2004 rem Hans-Peter Kuberna cls locate 2,4 : print date$,,time$ xpos=1 : ypos=5 locate 4,3:print "i"; locate 4,16:print "2^i"; locate 4,38:print "Dezimalstellen"; for i= 0 to 49 wh2#=2^i abswh2#=abs(wh2#) strabswh2$=str$(abswh2#) lenstrabswh2#=len(strabswh2$)-1 if lenstrabswh2#> altlenstrabswh2# then locate ypos+1,1 print using "###";i; locate ypos+1,7 print using "###############";wh2#; xpos=1 : ypos=ypos+1 end if xpos=xpos+8 locate ypos,20+xpos print using "#####";lenstrabswh2#; altlenstrabswh2#=lenstrabswh2# next i Bildschirmausgabe: ------------------ 01-04-2004 13:19:16 i 2^i Dezimalstellen 0 1 1 1 1 1 4 16 2 2 2 7 128 3 3 3 10 1024 4 4 4 4 14 16384 5 5 5 17 131072 6 6 6 20 1048576 7 7 7 7 24 16777216 8 8 8 27 134217728 9 9 9 30 1073741824 10 10 10 10 34 17179869184 11 11 11 37 137438953472 12 12 12 40 1099511627776 13 13 13 13 44 17592186044416 14 14 14 47 140737488355328 15 15 15 ----------------------------------------------------------------------- Dieses gehört mit zum Abschnitt: Das ( 2**i ) - 1 Problem Die Anzahl der Stellen ( Basis 10 ) ändert sich bei (2**103)-1. --------------------------------------------------------------- # Hans-Peter Kuberna # E-Mail # hans-peter@kuberna.de # Dezst2v1.ari 07.01.2004 # fuer ARIBAS von Otto Forster # http://www.mathematik.uni-muenchen.de/~forster function Digits(nDigits: integer): integer; var DRest: array of integer; DigitsZahl : integer; begin DigitsZahl :=0; while nDigits > 0 do DRest:=divide(nDigits,10); nDigits :=DRest[0]; DigitsZahl :=DigitsZahl+1; end; return DigitsZahl; end. var DigiArray: array[10] of integer; DigitsRest: array of integer; ND,Dig: integer; end. DigiArray[0..9] := (1,1,1,1,2,2,2,3,3,3); n := 1 Dig := 0; nDigits1 := 0; # for n := 88 to 112 by 1 do #while Dig = nDigits1 do #while Dig <32 do WertMers:=2**n; WertMersm1:=WertMers-1; Dig:=Digits(WertMersm1); DigitsRest:=divide(n,10); nDigits :=DigitsRest[0]; nDigitsM3 :=nDigits*3; nDigits1 :=DigiArray[DigitsRest[1]]; nDigits2 :=nDigits*3+DigiArray[DigitsRest[1]]; write(n :10,Dig:15,nDigits :10,nDigits :10," * 3 + ":7); write(nDigits1 :1," = ":3,nDigits2:10," ":9); #n := n+1; end; write(" ":78); for n := 95 to 105 by 1 do WertMers:=2**n; WertMersm1:=WertMers-1; write(n :10,WertMersm1:45," ":23); end; write(" ":78); Bildschirmausgabe: ------------------ ==> load("C:\Programme\aribasw142\hpk\Dezst2v2.ari"). (** loading file C:\Programme\aribasw142\hpk\Dezst2v2.ari **) Digits var (1, 1, 1, 1, 2, 2, 2, 3, 3, 3) 0 0 88 27 8 8 * 3 + 3 = 27 89 27 8 8 * 3 + 3 = 27 90 28 9 9 * 3 + 1 = 28 91 28 9 9 * 3 + 1 = 28 92 28 9 9 * 3 + 1 = 28 93 28 9 9 * 3 + 1 = 28 94 29 9 9 * 3 + 2 = 29 95 29 9 9 * 3 + 2 = 29 96 29 9 9 * 3 + 2 = 29 97 30 9 9 * 3 + 3 = 30 98 30 9 9 * 3 + 3 = 30 99 30 9 9 * 3 + 3 = 30 100 31 10 10 * 3 + 1 = 31 101 31 10 10 * 3 + 1 = 31 102 31 10 10 * 3 + 1 = 31 103 32 10 10 * 3 + 1 = 31 104 32 10 10 * 3 + 2 = 32 105 32 10 10 * 3 + 2 = 32 106 32 10 10 * 3 + 2 = 32 107 33 10 10 * 3 + 3 = 33 108 33 10 10 * 3 + 3 = 33 109 33 10 10 * 3 + 3 = 33 110 34 11 11 * 3 + 1 = 34 111 34 11 11 * 3 + 1 = 34 112 34 11 11 * 3 + 1 = 34 1 95 3961_40812_57132_16879_67719_75167 96 7922_81625_14264_33759_35439_50335 97 15845_63250_28528_67518_70879_00671 98 31691_26500_57057_35037_41758_01343 99 63382_53001_14114_70074_83516_02687 100 1_26765_06002_28229_40149_67032_05375 101 2_53530_12004_56458_80299_34064_10751 102 5_07060_24009_12917_60598_68128_21503 103 10_14120_48018_25835_21197_36256_43007 104 20_28240_96036_51670_42394_72512_86015 105 40_56481_92073_03340_84789_45025_72031 1 -: true ==> ----------------------------------------------------------------------- Dieses gehört mit zum Abschnitt: Das ( 2**i ) - 1 Problem Die Anzahl der Stellen ( Basis 30 ) ändert sich bei (2**54)-1. --------------------------------------------------------------- # Hans-Peter Kuberna # E-Mail # hans-peter@kuberna.de # Z30st2v1.ari 08.01.2004 # fuer ARIBAS von Otto Forster # http://www.mathematik.uni-muenchen.de/~forster function Digits(nDigits: integer): integer; var DRest: array of integer; DigitsZahl : integer; begin DigitsZahl :=0; while nDigits > 0 do DRest:=divide(nDigits,30); nDigits :=DRest[0]; DigitsZahl :=DigitsZahl+1; end; return DigitsZahl; end. var DigiArray: array[50] of integer; DigitsRest: array of integer; ND,Dig: integer; end. DigiArray[00..09] := (1,1,1,1,1,2,2,2,2,2); DigiArray[10..19] := (3,3,3,3,3,4,4,4,4,4); DigiArray[20..29] := (5,5,5,5,5,6,6,6,6,6); n := 1 Dig := 0; nDigits1 := 0; # for n := 44 to 64 by 1 do #while Dig = nDigits1 do #while Dig <32 do WertMers:=2**n; WertMersm1:=WertMers-1; Dig:=Digits(WertMersm1); DigitsRest:=divide(n,30); nDigits :=DigitsRest[0]; nDigitsM3 :=nDigits*6; nDigits1 :=DigiArray[DigitsRest[1]]; nDigits2 :=nDigits*6+DigiArray[DigitsRest[1]]; write(n :10,Dig:15,nDigits :10,nDigits :10," * 6 + ":7); write(nDigits1 :1," = ":3,nDigits2:10," ":9); #n := n+1; end; write(" ":78); for n := 50 to 60 by 1 do WertMers:=2**n; WertMersm1:=WertMers-1; write(n :10,WertMersm1:45," ":23); end; write(" ":78); Bildschirmausgabe: ------------------ ==> load("C:\Programme\aribasw142\hpk\Z30st2v2.ari"). (** loading file C:\Programme\aribasw142\hpk\Z30st2v2.ari **) Digits var (1, 1, 1, 1, 1, 2, 2, 2, 2, 2) (3, 3, 3, 3, 3, 4, 4, 4, 4, 4) (5, 5, 5, 5, 5, 6, 6, 6, 6, 6) 0 0 44 9 1 1 * 6 + 3 = 9 45 10 1 1 * 6 + 4 = 10 46 10 1 1 * 6 + 4 = 10 47 10 1 1 * 6 + 4 = 10 48 10 1 1 * 6 + 4 = 10 49 10 1 1 * 6 + 4 = 10 50 11 1 1 * 6 + 5 = 11 51 11 1 1 * 6 + 5 = 11 52 11 1 1 * 6 + 5 = 11 53 11 1 1 * 6 + 5 = 11 54 12 1 1 * 6 + 5 = 11 55 12 1 1 * 6 + 6 = 12 56 12 1 1 * 6 + 6 = 12 57 12 1 1 * 6 + 6 = 12 58 12 1 1 * 6 + 6 = 12 59 13 1 1 * 6 + 6 = 12 60 13 2 2 * 6 + 1 = 13 61 13 2 2 * 6 + 1 = 13 62 13 2 2 * 6 + 1 = 13 63 13 2 2 * 6 + 1 = 13 64 14 2 2 * 6 + 1 = 13 1 50 1_12589_99068_42623 51 2_25179_98136_85247 52 4_50359_96273_70495 53 9_00719_92547_40991 54 18_01439_85094_81983 55 36_02879_70189_63967 56 72_05759_40379_27935 57 144_11518_80758_55871 58 288_23037_61517_11743 59 576_46075_23034_23487 60 1152_92150_46068_46975 1 -: true ==> ----------------------------------------------------------------------- Die Dielektrizitätskonstante und die Zahl 7. --------------------------------------------- Die Dielektrizitätskonstante e0 laut Lexikon 8.85419 +- 0.00002 Achtung ! n**2 = n*n Frage warum nicht 2*pi* 2**(1/2) ? -> Bleibt unbeanwortet ! 2*pi* 2**(1/2) = 8.88576587631673249403176198012139 Frage wieviel weicht der angegebene Wert vom neu berechneten Wert ab ? Antwort ! 0,000000058458561301067949688536 Folgende Berechnung ergibt 2 * pi * (2**(1/2)) -------------------------------------- = 8,85418994154143869893205031146425 1 1 + -------------------------------- (0.75**(1/2)) + 2 + 1960 -------------------------- 7 8.85419 - 8,85418994154143869893205031146425 = 0,000000058458561301067949688536 Folgende Berechnung ergibt 2 * pi * (2**(1/2)) --------------------------------------------- = 8,85418994154143869893205031146425 1 1 + --------------------------------------------------------- (0.75**(1/2)) + 2 + ( (7*7*7 * 5)+1 + (7*7 * 5)+1 ) ------------------------------------------------------- 7 Der Weg zur Berechnung . ----------------------------- 1. 2 * pi * (2**(1/2)) ----------------------- = 1,003566207221296639673619154335 8.85419 2. 1,003566207221296639673619154335 - 1 = 0,003566207221296639673619154335 3. 1 ---------------------------------- = 280,409953192907654371353629591111 0,003566207221296639673619154335 4. 280,409953192907654371353629591111-280 = 0,409953192907654371353629591111 5. 0,409953192907654371353629591111/(1/7)=2,8696723503535805994754071377787 6. 2,8696723503535805994754071377787-2 = 0,8696723503535805994754071377787 7. Man betrachte den Wert 0,86967235 .... ,erinnere sich an 0,86602540 .... und wähle (0.75**(1/2)). sin(60) = 0,86602540 .... (0.75**(1/2)) = 0,86602540 .... ----------------------------------------------------- 7R. Der Weg zurück . ----------------------------- 6R. 0,866025403784438646763723170752936+2=2,866025403784438646763723170752936 5R. 2,866025403784438646763723170752936/7=0,409432200540634092394817595821848 4R. 0,409432200540634092394817595821848+280=280,409432200540634092394817595821848 3R. 1 ---------------------------------- = 0,00356621384720336088328426557212 280,409432200540634092394817595822 2R. 0,00356621384720336088328426557212+1 = 1,00356621384720336088328426557212 1R. 2 * pi * (2**(1/2)) ------------------------------------- = 8,85418994154143869893205031146425 1,00356621384720336088328426557212 Abweichung ergibt 8.85419-8,85418994154143869893205031146425=0,000000058458561301067949688536 Die Zahl 1960. ----------------------- 280 = 7 * 40 280 = 7 * ( 7*5 + 5 ) 1960 = 7* ( 7 * ( 7*5 + 5 ) ) 1960 = 7*7 * ( 7*5 + 5 ) 1960 = (7*7*7)*5 + (7*7)*5 Die Zahl 5. ----------------------- 5 = ( 7*7 + 1 ) / ( 2*5 ) ----------------------------------------------------------------------- REM DIELEKT2.BAS REM 11.08.2003 REM Hans-Peter Kuberna REM hans-peter@kuberna.de cls pi#=4*atn(1) pim2msqr2#=pi#*2*sqr(2) dim x#(10),y#(10) x#(1)=pim2msqr2#:y#(1)=8.85419 x#(2)=9.8065:y#(2)=pim2msqr2# x#(3)=9.1091:y#(3)=pim2msqr2# x#(4)=pim2msqr2#:y#(4)=8.3144 x#(5)=pim2msqr2#:y#(5)=6.6256 x#(6)=9.6487:y#(6)=pim2msqr2# for i= 1 to 6 xdy#=x#(i)/y#(i) intxdy#=int(xdy#) w1#=intxdy#/(xdy#-intxdy#) intw1#=int(w1#) w2#=w1#-intw1# w2m7#=w2#*7 intw2m7#=int(w2m7#) w3#=w2m7#-intw2m7# print w3#,atn(w3#) next i Bildschirmausgabe ----------------- .861733338508373 .711266554682752 .555149913760726 .506788479453782 .507667862610653 .469763065624944 .862522506170789 .711719249987641 .520262103176327 .479725585330235 .52785245072557 .485680495927064 ----------------------------------------------------------------------- Berechnung der Zahlennummer; Positionsnummer innerhalb der Zeile. ------------------------------------ Nur zum Testen verwendet, also nicht vollständig ! REM ZAHLOFN1.BAS REM 01.10.2003 REM Hans-Peter Kuberna cls locate 2,10:print "ZAHLOFN1.BAS" locate 2,50:print "01.10.2003"; Dim Z(10) Z(0)=1:Z(1)=7:Z(2)=11:Z(3)=13: Z(4)=17:Z(5)=19:Z(6)=23:Z(7)=29: for i=0 to 7 rem n=Z(i)*1 rem n=i+0 nmod30= (n mod 30) rem intnd4=int(nmod30/4) intnd4=int(n/4) Zahl0=intnd4 Zahl1=Zahl0+int (n/19) Zahl2=Zahl1-int (n/27) Zahl3=Zahl2-int(nmod30/4) locate i+5,3: print i locate i+5,8: print Zahl0 locate i+5,18: print Zahl1 locate i+5,28: print Zahl2 locate i+5,38: print Zahl3 next i Bildschirmausgabe: ------------------ ZAHLOFN1.BAS 01.10.2003 0 0 0 0 0 1 1 1 1 0 2 2 2 2 0 3 3 3 3 0 4 4 4 4 0 5 4 5 5 1 6 5 6 6 1 7 7 8 7 0 ----------------------------------------------------------------------- Bestimmung der Werte für n , die eine Quadratzahl ergeben. ---------------------------------------------------------- z. B. 7*7 , 11*11 , 13*13 , 17*17 ......... Datei$="NSQR13Z1.BAS" REM 15.12.2003 N$="Hans-Peter Kuberna" EMail$="hans-peter@kuberna.de" REM Germany cls print Date$,Time$:print N$,EMail$,Datei$ shared Spaltef, Zeilef, Zahlf function Zahlf(nf,Spaltef,Zeilef) nfmod8=nf mod 8 intnfd8=int(nf/8) Zeilef=intnfd8 Mul6=int(nfmod8/2)*6 REM Vorzeichen berechnen VorZei=1-((nfmod8+1) mod 2)*2 REM -/+ 4 addieren bei nf=0 / nf=7 MiPl4=(((int(nfmod8/7))-int((nfmod8+6)/7)+1)*4)*VorZei REM Wert fuer Ergebnisanpassung w6=6 Spaltef=Mul6+VorZei+MiPl4+w6 Zahlf=(Zeilef*30)+Spaltef end function Anzahl=18 for schleife=0 to Anzahl y=schleife+0 n=schleife+0 Zahl=Zahlf(n,Spaltef,Zeilef) locate 5+y,1:print using "###"; y; locate 5+y,8:print using "###"; Zahl; SqrZahl=Zahl*Zahl IntSqrZahld30=int(SqrZahl/30) ModSqrZahl30=SqrZahl mod 30 Wert0=int(((n*3+3)/4+0) mod 2) Wert0m5=Wert0*5 Wert0m13=Wert0*13 NSqrZahl=IntSqrZahld30*8+Wert0m5 N32=NSqrZahl-Wert0m13 locate y+5,4+3*4:print using "####"; SqrZahl; locate y+5,4+5*4:print using "####"; IntSqrZahld30; locate y+5,4+7*4:print using "####"; ModSqrZahl30; locate y+5,4+9*4:print using "####"; Wert0m5; locate y+5,4+11*4:print using "####"; NSqrZahl; locate y+5,4+13*4:print using "####"; N32; locate y+5,4+15*4:print using "####"; Wert0m13; next schleife end Bildschirmausgabe: ------------------ 12-15-2003 20:00:09 Hans-Peter Kuberna hans-peter@kuberna.de NSQR13Z1.BAS 0 1 1 0 1 0 0 0 0 1 7 49 1 19 5 13 0 13 2 11 121 4 1 0 32 32 0 3 13 169 5 19 5 45 32 13 4 17 289 9 19 5 77 64 13 5 19 361 12 1 0 96 96 0 6 23 529 17 19 5 141 128 13 7 29 841 28 1 0 224 224 0 8 31 961 32 1 0 256 256 0 9 37 1369 45 19 5 365 352 13 10 41 1681 56 1 0 448 448 0 11 43 1849 61 19 5 493 480 13 12 47 2209 73 19 5 589 576 13 13 49 2401 80 1 0 640 640 0 14 53 2809 93 19 5 749 736 13 15 59 3481 116 1 0 928 928 0 16 61 3721 124 1 0 992 992 0 17 67 4489 149 19 5 1197 1184 13 18 71 5041 168 1 0 1344 1344 0 ----------------------------------------------------------------------- Von Kuberna's Primzahlenfolge, die Quadratzahlen und der Satz des Pythagoras. ---------------------------------------------------------- z. B. 7*7 , 11*11 , 13*13 , 17*17 ......... # Hans-Peter Kuberna # E-Mail # hans-peter@kuberna.de # fuer ARIBAS von Otto Forster # http://www.mathematik.uni-muenchen.de/~forster # TestKub1Quadrat01.ari 17.02.2004 set_floatprec(64). var Zeilef,Spaltef,Wertf : integer; AnzahlMax,AnzeigeModus: integer; Block,Dif : integer; n,ndiv30,nmod30,nf,ns : integer; Zahl,ZahlSqrt,ZahlWertZaehler : integer; Wert0,Wert1,Wert2 : integer; ZahlWert: array[9] of integer; end. function Zahlf(nf: integer): integer; var nfmod8,nfmod8p1,nfmod8p6,nfmod8p1mod2: integer; nfmod8div7,nfmod8p6div7,nfdiv8: integer; Zeilef,Spaltef,Wertf,Mul6,VorZei,MiPl4,w6: integer; begin nfmod8 := nf mod 8; nfmod8p1 := nfmod8+1; nfmod8p6 := nfmod8+6; nfmod8p1mod2 :=nfmod8p1 mod 2; nfmod8div7 :=nfmod8 div 7; nfmod8p6div7 :=nfmod8p6 div 7; nfdiv8 := nf div 8; Zeilef := nfdiv8; Mul6 := (nfmod8 div 2)*6; # Vorzeichen berechnen VorZei := 1-(nfmod8p1mod2*2); # -/+ 4 addieren bei nf=0 / nf=7 MiPl4 := (nfmod8div7-nfmod8p6div7+1)*4*VorZei; # Wert fuer Ergebnisanpassung w6 := 6; Spaltef := Mul6+VorZei+MiPl4+w6; Wertf := Zeilef*30+Spaltef; return Wertf; end. # Dif:=0; #Dif:=96; write(" ":78); AnzahlMax:=8; for AnzeigeModus:=0 to 2 by 1 do write("":78); if (AnzeigeModus=0) then write("":2,"Wert von N:":11,"":63); end; if (AnzeigeModus=1) then write("":2,"QuadratZahl:":12,"":62); end; if (AnzeigeModus=2) then write("":2,"Zahl:":5,"":71); end; writeln("":78); write(" Folge" :6); for ZahlWertZaehler:=0 to 7 by 1 do ZahlWert[8]:=(((ZahlWertZaehler*3+3) div 4)+0) mod 2; write(ZahlWert[8] :8); end; write("":7); write("":78); for ns:=0+Dif to AnzahlMax+Dif by 1 do ne := ns * 8; Block := ns*8; # Zahl 1 (n=0) n := ne+0; Zahl:=Zahlf(n); Wert1:=Zahl*0; Wert2:=Wert1+n; Wert3:=Wert2+Block*Zahl; ZahlWert[0]:=Wert3; # Zahl 7 (n=1) n := ne+1; Zahl:=Zahlf(n); Wert1:=Zahl*2; Wert2:=Wert1-((n div 2)+1); Wert3:=Wert2+Block*Zahl; ZahlWert[1]:=Wert3; # Zahl 11 (n=2) n := ne+2; Zahl:=Zahlf(n); Wert1:=Zahl*3; Wert2:=Wert1-((n div 4)+1); Wert3:=Wert2+Block*Zahl; ZahlWert[2]:=Wert3; # Zahl 13 (n=3) n := ne+3; Zahl:=Zahlf(n); Wert0:=(((n*3+1) div 4)+0) mod 2; Wert1:=Zahl*3; Wert2:=Wert1+2*n+Wert0-(n div 4)*2+(n div 8)*2; Wert3:=Wert2+Block*Zahl; ZahlWert[3]:=Wert3; # Zahl 17 (n=4) n := ne+4; Zahl:=Zahlf(n); Wert0:=(((n*3+1) div 4)+1) mod 2; Wert1:=Zahl*4; Wert2:=Wert1+(n*2)+1-Wert0; Wert3:=Wert2+Block*Zahl; ZahlWert[4]:=Wert3; # Zahl 19 (n=5) n := ne+5; Zahl:=Zahlf(n); Wert1:=Zahl*5; Wert2:=Wert1+(n div 4); Wert3:=Wert2+Block*Zahl; ZahlWert[5]:=Wert3; # Zahl 23 (n=6) n := ne+6; Zahl:=Zahlf(n); Wert1:=Zahl*6; Wert2:=Wert1+(n div 2); Wert3:=Wert2+Block*Zahl; ZahlWert[6]:=Wert3; # Zahl 29 (n=7) n := ne+7; Zahl:=Zahlf(n); Wert1:=Zahl*8; Wert2:=Wert1-(n+1); Wert3:=Wert2+Block*Zahl; ZahlWert[7]:=Wert3; write("" :6); for ZahlWertZaehler:=0 to 7 by 1 do if (AnzeigeModus=0) then write(ZahlWert[ZahlWertZaehler] :8); end; if (AnzeigeModus=1) or (AnzeigeModus=2) then ZahlSqrt:=Zahlf(ZahlWert[ZahlWertZaehler]); if (AnzeigeModus=2) then ZahlSqrt:=trunc(sqrt(ZahlSqrt)); end; write(ZahlSqrt:8); end; end; write("":8); end; end; Bildschirnausgabe: ------------------ ==> load("C:\Programme\aribasw144\hpk\TestKub1Quadrat01.ari"). (** loading file C:\Programme\aribasw144\hpk\TestKub1Quadrat01.ari **) 64 var Zahlf 0 1 8 Wert von N: Folge 0 1 0 1 1 0 1 0 0 13 32 45 77 96 141 224 256 365 448 493 589 640 749 928 992 1197 1344 1421 1581 1664 1837 2112 2208 2509 2720 2829 3053 3168 3405 3776 3904 4301 4576 4717 5005 5152 5453 5920 6080 6573 6912 7085 7437 7616 7981 8544 8736 9325 9728 9933 10349 10560 10989 11648 11872 12557 13024 13261 13741 13984 14477 15232 15488 16269 16800 17069 17613 17888 18445 19296 QuadratZahl: Folge 0 1 0 1 1 0 1 0 1 49 121 169 289 361 529 841 961 1369 1681 1849 2209 2401 2809 3481 3721 4489 5041 5329 5929 6241 6889 7921 8281 9409 10201 10609 11449 11881 12769 14161 14641 16129 17161 17689 18769 19321 20449 22201 22801 24649 25921 26569 27889 28561 29929 32041 32761 34969 36481 37249 38809 39601 41209 43681 44521 47089 48841 49729 51529 52441 54289 57121 58081 61009 63001 64009 66049 67081 69169 72361 Zahl: Folge 0 1 0 1 1 0 1 0 1 7 11 13 17 19 23 29 31 37 41 43 47 49 53 59 61 67 71 73 77 79 83 89 91 97 101 103 107 109 113 119 121 127 131 133 137 139 143 149 151 157 161 163 167 169 173 179 181 187 191 193 197 199 203 209 211 217 221 223 227 229 233 239 241 247 251 253 257 259 263 269 -: true ==> Innerhalb von Kuberna's Primzahlenfolge hat die Summe von zwei Quadratzahlen die Endziffern 0 , 2 oder 8. Z.B. 1 + 49 = 50 Endziffern 0 50 = 0 * 120 + 50 49 + 121 = 170 Endziffern 0 170 = 1 * 120 + 50 1 + 121 = 122 Endziffern 2 122 = 1 * 120 + 2 121 + 361 = 482 Endziffern 2 482 = 4 * 120 + 2 49 + 169 = 218 Endziffern 8 218 = 1 * 120 + 98 169 + 289 = 458 Endziffern 8 458 = 3 * 120 + 98 Folge 0 oder Folge 1 ergibt eine Summe mit der Endziffer 0 Folge 0 und Folge 0 ergibt eine Summe mit der Endziffer 2 Folge 1 und Folge 1 ergibt eine Summe mit der Endziffer 8 Die Folge 0 1 0 1 1 0 1 0 Binär ergibt 5 A Hexa-Dezimal. 5A Hexa-Dezimal ergibt 5*16 + 10*1 = 80 + 10 = 90 Dezimal. Siehe auch: 1. Die Farbe der umkreisten diagonalen Werte im Bild TEILN301gross.png . 2. In dem Basic Programm NSQR13Z1.BAS (Siehe weiter oben in dieser Datei) den Wechsel von 1 19 1 19 1 19 .... ,oder 0 5 0 5 0 5 ..... oder 0 13 0 13 0 13 . Es gibt für den Satz des Pythagoras , a*a + b*b = c*c , unter der Verwendung von Zahlen aus Kuberna's Primzahlenfolge , keine Lösung. (a*a) + (b*b) <> (c*c) (Primzahl*Primzahl) + (Primzahl*Primzahl) <> (Primzahl*Primzahl) ----------------------------------------------------------------------------- Von Kuberna's Primzahlenfolge und die Ecken eines Würfels. Kuberna's prime numbers follow and the corners of a cube. ---------------------------------------------------------- Siehe auch die POV-Ray Programme unter /Mathe/PrimeKube32.pov vom 15.02.2004 unter /Mathe/Primzahl/KubeEcke0.pov vom 22.02.2004 # Hans-Peter Kuberna # E-Mail # hans-peter@kuberna.de # fuer ARIBAS von Otto Forster # http://www.mathematik.uni-muenchen.de/~forster # TestKubEckeQuadrat02.ari 19.02.2004 set_floatprec(64). var Zeilef,Spaltef,Wertf : integer; AnzahlMax,AnzeigeModus: integer; Block,Dif : integer; n,ndiv30,nmod30,nf,ns : integer; Zahl,ZahlSqrt,ZahlWertZaehler : integer; Wert0,Wert1,Wert2,Wert3 : integer; ZahlWert: array[15] of integer; nmax,nmaxmn : integer; end. function Zahlf(nf: integer): integer; var nfmod8,nfmod8p1,nfmod8p6,nfmod8p1mod2: integer; nfmod8div7,nfmod8p6div7,nfdiv8: integer; Zeilef,Spaltef,Wertf,Mul6,VorZei,MiPl4,w6: integer; begin nfmod8 := nf mod 8; nfmod8p1 := nfmod8+1; nfmod8p6 := nfmod8+6; nfmod8p1mod2 :=nfmod8p1 mod 2; nfmod8div7 :=nfmod8 div 7; nfmod8p6div7 :=nfmod8p6 div 7; nfdiv8 := nf div 8; Zeilef := nfdiv8; Mul6 := (nfmod8 div 2)*6; # Vorzeichen berechnen VorZei := 1-(nfmod8p1mod2*2); # -/+ 4 addieren bei nf=0 / nf=7 MiPl4 := (nfmod8div7-nfmod8p6div7+1)*4*VorZei; # Wert fuer Ergebnisanpassung w6 := 6; Spaltef := Mul6+VorZei+MiPl4+w6; Wertf := Zeilef*30+Spaltef; return Wertf; end. #Dif:=0; # Dif:=0*8; write(" ":78); AnzahlMax:=5; write("":78); #for AnzeigeModus:=0 to 2 by 1 do for AnzeigeModus:=0 to 0 by 1 do write("":78); for ns:=0 to AnzahlMax by 1 do nmax=5; n:=ns; nmaxmn:=nmax-n; intnd3mod2:=trunc(n/3) mod 2; intnd2p1mod2:=trunc((n/2)+1) mod 2; intnd3p1mod2:=trunc((n/3)+1) mod 2; nmaxmnmod3:=nmaxmn mod 3; nmaxmnp1mod3:=(nmaxmn+1) mod 3; nmaxmnp2mod3:=(nmaxmn+2) mod 3; nmod3:=n mod 3; intnmod3p2d3mod2:=trunc((nmod3+2)/3) mod 2; npintnd3p1mod2mod3:=(n+intnd3p1mod2) mod 3; WertBit527:=trunc((nmaxmnp2mod3+2)/3) mod 2; Wert527:=2*nmaxmnp2mod3+WertBit527+2; Wert527:=Wert527*intnd3mod2; Wert134:=nmod3+intnmod3p2d3mod2+1; Wert134:=Wert134*intnd3p1mod2+(intnd3mod2*6); WertBit257:=trunc((nmaxmnp1mod3+2)/3) mod 2; Wert257:=2*nmaxmnp1mod3+WertBit257+2; Wert341:=npintnd3p1mod2mod3+intnd2p1mod2+1; write(Wert527:6,Wert134:6); write(Wert257:6,Wert341:6,"":6); if (AnzeigeModus=0) then Wert0:=Zahlf(Wert527+Dif)**2; Wert1:=Zahlf(Wert134+Dif)**2; Wert2:=Zahlf(Wert257+Dif)**2; Wert3:=Zahlf(Wert341+Dif)**2; end; if (AnzeigeModus=1) then Wert0:=2**Zahlf(Wert527+Dif); Wert1:=2**Zahlf(Wert134+Dif); Wert2:=2**Zahlf(Wert257+Dif); Wert3:=2**Zahlf(Wert341+Dif); end; if (AnzeigeModus=2) then Faktor:=Zahlf(1); Wert0:=Faktor*(Wert527+Dif); Wert1:=Faktor*(Wert134+Dif); Wert2:=Faktor*(Wert257+Dif); Wert3:=Faktor*(Wert341+Dif); end; ZahlWert[ns]:=Wert0+Wert1+Wert2+Wert3; write(Wert0:10,Wert1:10); write(Wert2:10,Wert3:10,"":8); write("":78); write(ZahlWert[ns]:8,"":70); write("":78); end; write("":78); for ns:=0 to 5 by 1 do write(ZahlWert[ns]:10); end; write("":18); ZahlBasis:=40; write("":78); ZahlWert[6+0]:=ZahlWert[0]+ZahlWert[5]; ZahlWert[9+0]:=ZahlWert[6+0] div ZahlBasis; ZahlWert[12+0]:=ZahlWert[6+0] mod ZahlBasis; #ZahlWert[6+0]:=ZahlWert[6+0]+1; #ZahlWert[6+0]:=ZahlWert[6+0] div 60; write("":78); ZahlWert[6+1]:=ZahlWert[1]+ZahlWert[3]; ZahlWert[9+1]:=ZahlWert[6+1] div ZahlBasis; ZahlWert[12+1]:=ZahlWert[6+1] mod ZahlBasis; #ZahlWert[6+1]:=ZahlWert[6+1]+1; #ZahlWert[6+1]:=ZahlWert[6+1] div 60; write("":78); ZahlWert[6+2]:=ZahlWert[2]+ZahlWert[4]; ZahlWert[9+2]:=ZahlWert[6+2] div ZahlBasis; ZahlWert[12+2]:=ZahlWert[6+2] mod ZahlBasis; #ZahlWert[6+2]:=ZahlWert[6+2]+1; #ZahlWert[6+2]:=ZahlWert[6+2] div 60; for ns:=0 to 2 by 1 do write(ZahlWert[6+ns]:10); write(ZahlWert[9+ns]:10); write(ZahlWert[12+ns]:10); write("":78); end; write("":78); end; Bildschirmausgabe: ------------------ ==> load("C:\Programme\aribasw144\hpk\TestKubEckeQuadrat02.ari"). (** loading file C:\Programme\aribasw144\hpk\TestKubEckeQuadrat02.ari **) 64 var Zahlf 0 1 5 1 0 1 5 3 1 49 361 169 580 0 3 2 4 1 169 121 289 580 0 4 7 1 1 289 841 49 1180 7 6 5 1 841 529 361 49 1780 5 6 2 3 361 529 121 169 1180 2 6 7 4 121 529 841 289 1780 580 580 1180 1780 1180 1780 2360 59 0 2360 59 0 2360 59 0 -: true ==> -------------------------------------------- Versieht man die Ecken eines Würfels ( Cube ) , in der richtigen Reihenfolge, mit Nummern , so ergibt sich aus der Summe von 2 gegenüberliegenden Seiten, die gleiche Summe. Siehe auch: 1. Das Bild KubeEcke0Gross.png 2. Das POV-Ray Programm KubeEcke0.pov vom 22.02.2004 Es berechnet das POV-Ray Programm, für den entsprechenden AnzeigeModus, die Werte für die Seiten, die Summe für die Seiten und die Summe für 2 gegenüberliegenden Seiten. Zahl ist eine Zahl aus Kuberna's Primzahlenfolge. Berechnung von Zahl**2 bis Zahl**5 AnzeigeModus=0 Zahl ** ExpoModus0 Berechnung von 2**Zahl AnzeigeModus=1 BasisModus1 ** Zahl Berechnung von Faktor*Zahl ( Faktor ist eine Zahl aus Kuberna's Primzahlenfolge ) ( NFaktorWahlModus2 = 919100 ist noch anzeigbar ) AnzeigeModus=2 Faktor * Zahl Berechnung der Ecken-Nummern bei Faktor=1 AnzeigeModus=3 Faktor * Eckennummer ----------------------------------------------------------------------- Bestimmung der Werte für n , die keine Primzahl ergeben. ---------------------------------------------------------- # Hans-Peter Kuberna # E-Mail # hans-peter@kuberna.de # fuer ARIBAS von Otto Forster # http://www.mathematik.uni-muenchen.de/~forster # Test2FnPrimOffN1.ari 10.10.2003/14.10.2003 var nz: integer; Zeile,Spalte,Wert : integer; Wert1 : real; end. function Zahl(n: integer): integer; var nmod8,nmod8p1,nmod8p6,nmod8p1mod2: integer; nmod8div7,nmod8p6div7,ndiv8: integer; Zeile,Spalte,Wert,Mul6,VorZei,MiPl4,w6: integer; begin nmod8 := n mod 8; nmod8p1 := nmod8+1; nmod8p6 := nmod8+6; nmod8p1mod2 :=nmod8p1 mod 2; nmod8div7 :=nmod8 div 7; nmod8p6div7 :=nmod8p6 div 7; ndiv8 := n div 8; Zeile := ndiv8; Mul6 := (nmod8 div 2)*6; # Vorzeichen berechnen VorZei := 1-(nmod8p1mod2*2); # -/+ 4 addieren bei n=0 / n=7 MiPl4 := (nmod8div7-nmod8p6div7+1)*4*VorZei; # Wert fuer Ergebnisanpassung w6 := 6; Spalte := Mul6+VorZei+MiPl4+w6; Wert := Zeile*30+Spalte; return Wert; end. set_floatprec(128) Anzahl:=8; for j := 0 to Anzahl by 1 do Wert1 := Zahl(j)*11; Wert2 := Wert1-((j div 4)+1); write(j:5," ":5,Zahl(j):10," ":5,Wert1:10," ":5,Wert2:10," ":5," ":23); end; write(" ":78); for j := 0 to Anzahl by 1 do Wert1 := Zahl(j)*10; Wert2 := Wert1-((j div 2)+1); write(j:5," ":5,Zahl(j):10," ":5,Wert1:10," ":5,Wert2:10," ":5," ":23); end; write(" ":78); for j := 0 to Anzahl by 1 do Wert1 := Zahl(j)*8; Wert2 := (Wert1+j); write(j:5," ":5,Zahl(j):10," ":5,Wert1:10," ":5,Wert2:10," ":5," ":23); end; write(" ":78); for j := 0 to Anzahl by 1 do Wert1 := Zahl(j)*8; Wert2 := (Wert1-(j+1)); write(j:5," ":5,Zahl(j):10," ":5,Wert1:10," ":5,Wert2:10," ":5," ":23); end; Bildschirmausgabe: ------------------ ==> load("C:\Programme\aribasw142\hpk\Test2FnPrimOffN1.ari"). (** loading file C:\Programme\aribasw142\hpk\Test2FnPrimOffN1.ari **) var Zahl 8 0 1 11 10 1 7 77 76 2 11 121 120 3 13 143 142 4 17 187 185 5 19 209 207 6 23 253 251 7 29 319 317 8 31 341 338 1 0 1 10 9 1 7 70 69 2 11 110 108 3 13 130 128 4 17 170 167 5 19 190 187 6 23 230 226 7 29 290 286 8 31 310 305 1 0 1 8 8 1 7 56 57 2 11 88 90 3 13 104 107 4 17 136 140 5 19 152 157 6 23 184 190 7 29 232 239 8 31 248 256 1 0 1 8 7 1 7 56 54 2 11 88 85 3 13 104 100 4 17 136 131 5 19 152 146 6 23 184 177 7 29 232 224 8 31 248 239 -: true ==> ----------------------------------------------------------------------- Bestimmung der Werte für n , die keine Primzahlzahl ergeben. ---------------------------------------------------------- Unvollendet, also Testversion Bemerkung: Die einzige For/Next Schleife wird nur zum Testen benötigt! Datei$="ISPRIM01.BAS" REM 14.12.2003 N$="Hans-Peter Kuberna" EMail$="hans-peter@kuberna.de" REM Germany cls print Date$,Time$:print N$,EMail$,Datei$ shared Spaltef, Zeilef, Zahlf function Zahlf(nf,Spaltef,Zeilef) nfmod8=nf mod 8 intnfd8=int(nf/8) Zeilef=intnfd8 Mul6=int(nfmod8/2)*6 REM Vorzeichen berechnen VorZei=1-((nfmod8+1) mod 2)*2 REM -/+ 4 addieren bei nf=0 / nf=7 MiPl4=(((int(nfmod8/7))-int((nfmod8+6)/7)+1)*4)*VorZei REM Wert fuer Ergebnisanpassung w6=6 Spaltef=Mul6+VorZei+MiPl4+w6 Zahlf=(Zeilef*30)+Spaltef end function Anzahl=18 for schleife=0 to Anzahl y=schleife n=schleife Zahl=Zahlf(n,Spaltef,Zeilef) locate 4+y,1:print using "###"; y; locate 4+y,7:print using "###"; Zahl; REM Zahl 1 (n=0) Wert1=Zahl*0 Wert=Wert1+n locate y+4,18+(x+0)*5:print using "###"; Wert; REM Zahl 7 (n=1) Wert1=Zahl*2 Wert=Wert1-((int(n/2)+1)) locate y+4,18+(x+1)*5:print using "###"; Wert; REM Zahl 11 (n=2) Wert1=Zahl*3 Wert=Wert1-((int(n/4)+1)) locate y+4,18+(x+2)*5:print using "###"; Wert; REM Zahl 13 (n=3) Wert0=int(((n*3+1)/4+0) mod 2) Wert1=Zahl*3 Wert=Wert1+2*n+Wert0-int(n/4)*2+int(n/8)*2 locate y+4,18+(x+3)*5:print using "###"; Wert; REM Zahl 17 (n=4) Wert0=int(((n*3+1)/4+1) mod 2) Wert1=Zahl*4 Wert=Wert1+(n*2)+1-Wert0 locate y+4,18+(x+4)*5:print using "###"; Wert; REM Zahl 19 (n=5) Wert1=Zahl*5 Wert=Wert1+int(n/4) locate y+4,18+(x+5)*5:print using "###"; Wert; REM Zahl 23 (n=6) Wert1=Zahl*6 Wert=Wert1+int(n/2) locate y+4,18+(x+6)*5:print using "###"; Wert; REM Zahl 29 (n=7) Wert1=Zahl*8 Wert=Wert1-(n+1) locate y+4,18+(x+7)*5:print using "###"; Wert; next schleife end Bildschirmausgabe: ------------------ 12-15-2003 20:02:22 Hans-Peter Kuberna hans-peter@kuberna.de ISPRIM01.BAS 0 1 0 1 2 3 4 5 6 7 1 7 1 13 20 24 31 35 42 54 2 11 2 20 32 38 49 55 67 85 3 13 3 24 38 45 58 65 79 100 4 17 4 31 49 58 77 86 104 131 5 19 5 35 55 65 86 96 116 146 6 23 6 42 67 79 104 116 141 177 7 29 7 54 85 100 131 146 177 224 8 31 8 57 90 107 140 157 190 239 9 37 9 69 108 128 167 187 226 286 10 41 10 76 120 142 185 207 251 317 11 43 11 80 126 149 194 217 263 332 12 47 12 87 137 162 213 238 288 363 13 49 13 91 143 169 222 248 300 378 14 53 14 98 155 183 240 268 325 409 15 59 15 110 173 204 267 298 361 456 16 61 16 113 178 211 276 309 374 471 17 67 17 125 196 232 303 339 410 518 18 71 18 132 208 246 321 359 435 549 ----------------------------------------------------------------------- Bestimmung der Werte für n , die keine Primzahlzahl ergeben. ---------------------------------------------------------- Unvollendet, also Testversion Unterschied ISPRIM01.BAS ist die Erweiterte Ausgabe Datei$="ISPRIM04.BAS" REM 20.12.2003 N$="Hans-Peter Kuberna" EMail$="hans-peter@kuberna.de" REM Germany cls print Date$,Time$:print N$,EMail$,Datei$ shared Spaltef, Zeilef, Zahlf function Zahlf(nf,Spaltef,Zeilef) nfmod8=nf mod 8 intnfd8=int(nf/8) Zeilef=intnfd8 Mul6=int(nfmod8/2)*6 REM Vorzeichen berechnen VorZei=1-((nfmod8+1) mod 2)*2 REM -/+ 4 addieren bei nf=0 / nf=7 MiPl4=(((int(nfmod8/7))-int((nfmod8+6)/7)+1)*4)*VorZei REM Wert fuer Ergebnisanpassung w6=6 Spaltef=Mul6+VorZei+MiPl4+w6 Zahlf=(Zeilef*30)+Spaltef end function Anzahl=15 for Block= 0 to 1 Blockm8=Block*8 for schleifey=0 to Anzahl Zahl=Zahlf(schleifey,Spaltef,Zeilef) locate 4+schleifey,1:print using "###"; schleifey; locate 4+schleifey,6:print using "###"; Zahl; next schleifey for schleifex=0 to Anzahl SchleifemodAnz=schleifex mod (Anzahl+1) x=SchleifemodAnz IntSchleifedAnz=int(schleifex/(Anzahl+1)) y=IntSchleifedAnz n=schleifex REM Zahl 1 (n=0) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*0 Wert2=Wert1+n Wert3=Wert2+Block*Zahl*8 locate y+4+0+Blockm8,12+x*4: print using "###"; Wert3; REM Zahl 7 (n=1) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*2 Wert2=Wert1-((int(n/2)+1)) Wert3=Wert2+Block*Zahl*8 locate y+4+1+Blockm8,12+x*4: print using "###"; Wert3; REM Zahl 11 (n=2) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*3 Wert2=Wert1-((int(n/4)+1)) Wert3=Wert2+Block*Zahl*8 locate y+4+2+Blockm8,12+x*4: print using "###"; Wert3; REM Zahl 13 (n=3) Zahl=Zahlf(n,Spaltef,Zeilef) Wert0=int(((n*3+1)/4+0) mod 2) Wert1=Zahl*3 Wert2=Wert1+2*n+Wert0-int(n/4)*2+int(n/8)*2 Wert3=Wert2+Block*Zahl*8 locate y+4+3+Blockm8,12+x*4: print using "###"; Wert3; REM Zahl 17 (n=4) Zahl=Zahlf(n,Spaltef,Zeilef) Wert0=int(((n*3+1)/4+1) mod 2) Wert1=Zahl*4 Wert2=Wert1+(n*2)+1-Wert0 Wert3=Wert2+Block*Zahl*8 locate y+4+4+Blockm8,12+x*4: print using "###"; Wert3; REM Zahl 19 (n=5) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*5 Wert2=Wert1+int(n/4) Wert3=Wert2+Block*Zahl*8 locate y+4+5+Blockm8,12+x*4: print using "###"; Wert3; REM Zahl 23 (n=6) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*6 Wert2=Wert1+int(n/2) Wert3=Wert2+Block*Zahl*8 locate y+4+6+Blockm8,12+x*4: print using "###"; Wert3; REM Zahl 29 (n=7) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*8 Wert2=Wert1-(n+1) Wert3=Wert2+Block*Zahl*8 locate y+4+7+Blockm8,12+x*4: print using "###"; Wert3; next schleifex next block end Bildschirmausgabe 12-20-2003 18:09:08 Hans-Peter Kuberna hans-peter@kuberna.de ISPRIM04.BAS 0 1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 1 7 1 13 20 24 31 35 42 54 57 69 76 80 87 91 98 110 2 11 2 20 32 38 49 55 67 85 90 108 120 126 137 143 155 173 3 13 3 24 38 45 58 65 79 100 107 128 142 149 162 169 183 204 4 17 4 31 49 58 77 86 104 131 140 167 185 194 213 222 240 267 5 19 5 35 55 65 86 96 116 146 157 187 207 217 238 248 268 298 6 23 6 42 67 79 104 116 141 177 190 226 251 263 288 300 325 361 7 29 7 54 85 100 131 146 177 224 239 286 317 332 363 378 409 456 8 31 8 57 90 107 140 157 190 239 256 305 338 355 388 405 438 487 9 37 9 69 108 128 167 187 226 286 305 365 404 424 463 483 522 582 10 41 10 76 120 142 185 207 251 317 338 404 448 470 513 535 579 645 11 43 11 80 126 149 194 217 263 332 355 424 470 493 538 561 607 676 12 47 12 87 137 162 213 238 288 363 388 463 513 538 589 614 664 739 13 49 13 91 143 169 222 248 300 378 405 483 535 561 614 640 692 770 14 53 14 98 155 183 240 268 325 409 438 522 579 607 664 692 749 833 15 59 15 110 173 204 267 298 361 456 487 582 645 676 739 770 833 928 ----------------------------------------------------------------------- Bestimmung der Werte für n , die keine Primzahlzahl ergeben. ---------------------------------------------------------- Unvollendet, also Testversion Unterschied ISPRIM04.BAS ist die Berechnung von Block=int(nz/8) Datei$="ISPRIM05.BAS" REM 20.12.2003 N$="Hans-Peter Kuberna" EMail$="hans-peter@kuberna.de" REM Germany cls print Date$,Time$:print N$,EMail$,Datei$ shared Spaltef, Zeilef, Zahlf function Zahlf(nf,Spaltef,Zeilef) nfmod8=nf mod 8 intnfd8=int(nf/8) Zeilef=intnfd8 Mul6=int(nfmod8/2)*6 REM Vorzeichen berechnen VorZei=1-((nfmod8+1) mod 2)*2 REM -/+ 4 addieren bei nf=0 / nf=7 MiPl4=(((int(nfmod8/7))-int((nfmod8+6)/7)+1)*4)*VorZei REM Wert fuer Ergebnisanpassung w6=6 Spaltef=Mul6+VorZei+MiPl4+w6 Zahlf=(Zeilef*30)+Spaltef end function Anzahl=15 rem for Block= 0 to 1 rem for nz=0 to 15*8 rem Block=int(nz/8) rem Blockm8=Block*8 for schleifey=0 to Anzahl Zahl=Zahlf(schleifey,Spaltef,Zeilef) locate 4+schleifey,1:print using "###"; schleifey; locate 4+schleifey,6:print using "###"; Zahl; next schleifey rem for schleifex=0 to Anzahl for nz=0 to 15 Block=int(nz/8) Blockm8=Block*8 schleifex=nz mod 8 SchleifemodAnz=schleifex mod (Anzahl+1) x=SchleifemodAnz IntSchleifedAnz=int(schleifex/(Anzahl+1)) y=IntSchleifedAnz n=schleifex REM Zahl 1 (n=0) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*0 Wert2=Wert1+n Wert3=Wert2+Block*Zahl*8 locate y+4+0+Blockm8,12+x*4: print using "###"; Wert3; REM Zahl 7 (n=1) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*2 Wert2=Wert1-((int(n/2)+1)) Wert3=Wert2+Block*Zahl*8 locate y+4+1+Blockm8,12+x*4: print using "###"; Wert3; REM Zahl 11 (n=2) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*3 Wert2=Wert1-((int(n/4)+1)) Wert3=Wert2+Block*Zahl*8 locate y+4+2+Blockm8,12+x*4: print using "###"; Wert3; REM Zahl 13 (n=3) Zahl=Zahlf(n,Spaltef,Zeilef) Wert0=int(((n*3+1)/4+0) mod 2) Wert1=Zahl*3 Wert2=Wert1+2*n+Wert0-int(n/4)*2+int(n/8)*2 Wert3=Wert2+Block*Zahl*8 locate y+4+3+Blockm8,12+x*4: print using "###"; Wert3; REM Zahl 17 (n=4) Zahl=Zahlf(n,Spaltef,Zeilef) Wert0=int(((n*3+1)/4+1) mod 2) Wert1=Zahl*4 Wert2=Wert1+(n*2)+1-Wert0 Wert3=Wert2+Block*Zahl*8 locate y+4+4+Blockm8,12+x*4: print using "###"; Wert3; REM Zahl 19 (n=5) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*5 Wert2=Wert1+int(n/4) Wert3=Wert2+Block*Zahl*8 locate y+4+5+Blockm8,12+x*4: print using "###"; Wert3; REM Zahl 23 (n=6) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*6 Wert2=Wert1+int(n/2) Wert3=Wert2+Block*Zahl*8 locate y+4+6+Blockm8,12+x*4: print using "###"; Wert3; REM Zahl 29 (n=7) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*8 Wert2=Wert1-(n+1) Wert3=Wert2+Block*Zahl*8 locate y+4+7+Blockm8,12+x*4: print using "###"; Wert3; rem next schleifex rem next block next nz end 12-23-2003 10:01:40 Hans-Peter Kuberna hans-peter@kuberna.de ISPRIM05.BAS 0 1 0 1 2 3 4 5 6 7 1 7 1 13 20 24 31 35 42 54 2 11 2 20 32 38 49 55 67 85 3 13 3 24 38 45 58 65 79 100 4 17 4 31 49 58 77 86 104 131 5 19 5 35 55 65 86 96 116 146 6 23 6 42 67 79 104 116 141 177 7 29 7 54 85 100 131 146 177 224 8 31 8 57 90 107 140 157 190 239 9 37 9 69 108 128 167 187 226 286 10 41 10 76 120 142 185 207 251 317 11 43 11 80 126 149 194 217 263 332 12 47 12 87 137 162 213 238 288 363 13 49 13 91 143 169 222 248 300 378 14 53 14 98 155 183 240 268 325 409 15 59 15 110 173 204 267 298 361 456 ----------------------------------------------------------------------- Ausgabe der Werte für n , die keine Primzahl ergeben. ---------------------------------------------------------- Unvollendet, also Testversion Bemerkung: Die einzige For/Next Schleife wird nur zum Testen benötigt! Datei$="NXPROFF7.BAS" REM 07.12.2003 N$="Hans-Peter Kuberna" EMail$="hans-peter@kuberna.de" REM Germany cls print Date$,Time$:print N$,EMail$,Datei$ shared Spaltef, Zeilef, Zahlf function Zahlf(nf,Spaltef,Zeilef) nfmod8=nf mod 8 intnfd8=int(nf/8) Zeilef=intnfd8 Mul6=int(nfmod8/2)*6 REM Vorzeichen berechnen VorZei=1-((nfmod8+1) mod 2)*2 REM -/+ 4 addieren bei nf=0 / nf=7 MiPl4=(((int(nfmod8/7))-int((nfmod8+6)/7)+1)*4)*VorZei REM Wert fr Ergebnisanpassung w6=6 Spaltef=Mul6+VorZei+MiPl4+w6 Zahlf=(Zeilef*30)+Spaltef end function option base 0 dim Werte(25) Anzahl=7 rem nz=56 for nz= 1 to 167 color 15,0 IsPrime=1 intnzd56=int(nz/56) intnzd56m56=intnzd56*56 nzmod56=nz mod 56 REM Zahl 1 (n=0) if nz>0 then n=int((nzmod56)/7)+1 Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*0 Wert=Wert1+n rem Wert=Wert+intnzd56*Zahl*8 rem if Wert=nz then IsPrime=0 Werte(0)=Wert Werte(8)=IsPrime Werte(16)=Zahl end if REM Zahl 7 (n=1) n=int((nzmod56)/14)+1 Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*2 Wert=Wert1-((int(n/2)+1)) Wert=Wert+intnzd56*Zahl*8 rem if Wert=nz then IsPrime=0 Werte(1)=Wert Werte(9)=IsPrime Werte(17)=Zahl REM Zahl 11 (n=2) n=int((nzmod56)/21)+1 Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*3 Wert=Wert1-((int(n/4)+1)) Wert=Wert+intnzd56*Zahl*8 rem if Wert=nz then IsPrime=0 Werte(2)=Wert Werte(10)=IsPrime Werte(18)=Zahl REM Zahl 13 (n=3) n=int((nzmod56)/28)+1 Zahl=Zahlf(n,Spaltef,Zeilef) Wert0=int(((n*3+1)/4+0) mod 2) Wert1=Zahl*3 Wert=Wert1+2*n+Wert0-int(n/4)*2+int(n/8)*2 Wert=Wert+intnzd56*Zahl*8 rem if Wert=nz then IsPrime=0 Werte(3)=Wert Werte(11)=IsPrime Werte(19)=Zahl REM Zahl 17 (n=4) n=int((nzmod56)/35)+1 Zahl=Zahlf(n,Spaltef,Zeilef) Wert0=int(((n*3+1)/4+1) mod 2) Wert1=Zahl*4 Wert=Wert1+(n*2)+1-Wert0 Wert=Wert+intnzd56*Zahl*8 rem if Wert=nz then IsPrime=0 Werte(4)=Wert Werte(12)=IsPrime Werte(20)=Zahl REM Zahl 19 (n=5) n=int((nzmod56)/42)+1 Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*5 Wert=Wert1+int(n/4) Wert=Wert+intnzd56*Zahl*8 rem if Wert=nz then IsPrime=0 Werte(5)=Wert Werte(13)=IsPrime Werte(21)=Zahl REM Zahl 23 (n=6) n=int((nzmod56)/49)+1 Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*6 Wert=Wert1+int(n/2) Wert=Wert+intnzd56*Zahl*8 rem if Wert=nz then IsPrime=0 Werte(6)=Wert Werte(14)=IsPrime Werte(22)=Zahl REM Zahl 29 (n=7) n=int((nzmod56)/56)+1 Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*8 Wert=Wert1-(n+1) Wert=Wert+intnzd56*Zahl*8 rem if Wert=nz then IsPrime=0 Werte(7)=Wert Werte(15)=IsPrime Werte(23)=Zahl locate int(nz/14)+1+8,(nz mod 14)*5+6: rem Zahl=Zahlf(nz,Spaltef,Zeilef) rem print using "###"; Zahl; if Isprime= 1 then rem color 4,0 rem print using "###"; nz; print using "###"; Zahl; else rem color 2,0 rem print using "###"; nz; end if rem print using "###"; nz; next nz color 15,0 for i=0 to 7 locate y+4,18+i*5:print using "###"; Werte(i); locate y+5,18+i*5:print using "###"; Werte(i+8); locate y+6,18+i*5:print using "###"; Werte(i+16); next i end Bildschirmausgabe: ------------------ 12-15-2003 20:19:52 Hans-Peter Kuberna hans-peter@kuberna.de NXPROFF7.BAS 504 303 246 214 225 231 243 166 1 1 1 1 1 1 1 1 31 17 13 11 11 11 11 7 1 13 20 24 31 32 35 38 42 49 54 55 57 69 76 80 87 91 98 110 113 125 132 136 143 147 154 166 Es werden nur die Zahlen für die Werte von n, im Bereich von 2 bis 57 , fehlerfrei ausgegeben. Oberhalb von 57 fehlt zum Beispiel 58, 65, 67, 77, 85, 86, 90, 96, 100, 104, 107, 108 ...... Bildschirmausgabe: ------------------ 12-15-2003 20:46:00 Hans-Peter Kuberna hans-peter@kuberna.de NXPROFF7.BAS 504 303 246 214 225 231 243 166 1 1 1 1 1 1 1 1 31 17 13 11 11 11 11 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 169 173 179 181 191 193 197 199 211 221 223 227 229 233 239 241 247 251 253 257 263 269 271 277 281 283 289 293 299 307 311 313 317 319 323 331 337 341 347 349 353 359 361 367 373 377 379 383 389 391 397 401 403 407 409 419 421 431 433 437 439 443 449 451 457 461 463 467 473 479 481 487 491 493 499 503 509 517 521 523 527 529 533 541 547 551 557 559 563 569 571 577 583 587 589 593 599 601 607 611 613 617 619 629 Anstatt der Ausgabe der Werte für n , werden die entsprechenden Zahlen ausgegeben. Die Fehler bestehen weiterhin, wie etwas höher angegeben wurde. Meine Meinung ist, das es ein Programm geben muß, welches auch bei sehr großen Werten für n einmal durchlaufen wird, und ausgibt ob n eine Primzahl ergibt. Es soll das Programm keine Programmschleifen enthalten. Die Umsetzung der zu Prüfenden Zahl in den entsprechenden Wert für n dürfte vergleichsweise einfach sein. ----------------------------------------------------------------------- Ausgabe der Werte für n , die keine Primzahl ergeben. ---------------------------------------------------------- REM Unvollendet, also Testversion Datei$="PRIFOR01.BAS" REM 22.12.2003 N$="Hans-Peter Kuberna" EMail$="hans-peter@kuberna.de" REM Germany gosub DateTime shared Spaltef, Zeilef, Zahlf function Zahlf(nf,Spaltef,Zeilef) nfmod8=nf mod 8 intnfd8=int(nf/8) Zeilef=intnfd8 Mul6=int(nfmod8/2)*6 REM Vorzeichen berechnen VorZei=1-((nfmod8+1) mod 2)*2 REM -/+ 4 addieren bei nf=0 / nf=7 MiPl4=(((int(nfmod8/7))-int((nfmod8+6)/7)+1)*4)*VorZei REM Wert fuer Ergebnisanpassung w6=6 Spaltef=Mul6+VorZei+MiPl4+w6 Zahlf=(Zeilef*30)+Spaltef end function REM Berechnung der Spalten locate 5,8:print "Die zul„ssigen Spaltennummern" locate 8,8:print "Die zul„ssigen Spaltenzahlen" for schleifex=0 to 7 Spalte(schleifex)=Zahlf(schleifex,Spaltef,Zeilef) locate 6,8+schleifex*5:print using "###"; schleifex; locate 9,8+schleifex*5:print using "###"; Spalte(schleifex); next schleifex REM Berechnung von Block56Nr0 locate 12,8:print "Die Nummern innerhalb von Block56Nr0" for schleifey=0 to 7 Zahl=Zahlf(schleifey,Spaltef,Zeilef) locate 13+schleifey,8:print using "###"; schleifey; locate 13+schleifey,13:print using "###"; Zahl; next schleifey for schleifex=0 to 7 x=schleifex mod 8 y=Int(schleifex/8) n=schleifex REM Zahl 1 (n=0) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*0 Wert2=Wert1+n Wert3=Wert2 locate y+13+0,19+x*4: print using "###"; Wert3; REM Zahl 7 (n=1) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*2 Wert2=Wert1-((int(n/2)+1)) Wert3=Wert2 locate y+13+1,19+x*4: print using "###"; Wert3; REM Zahl 11 (n=2) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*3 Wert2=Wert1-((int(n/4)+1)) Wert3=Wert2 locate y+13+2,19+x*4: print using "###"; Wert3; REM Zahl 13 (n=3) Zahl=Zahlf(n,Spaltef,Zeilef) Wert0=int(((n*3+1)/4+0) mod 2) Wert1=Zahl*3 Wert2=Wert1+2*n+Wert0-int(n/4)*2+int(n/8)*2 Wert3=Wert2 locate y+13+3,19+x*4: print using "###"; Wert3; REM Zahl 17 (n=4) Zahl=Zahlf(n,Spaltef,Zeilef) Wert0=int(((n*3+1)/4+1) mod 2) Wert1=Zahl*4 Wert2=Wert1+(n*2)+1-Wert0 Wert3=Wert2 locate y+13+4,19+x*4: print using "###"; Wert3; REM Zahl 19 (n=5) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*5 Wert2=Wert1+int(n/4) Wert3=Wert2 locate y+13+5,19+x*4: print using "###"; Wert3; REM Zahl 23 (n=6) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*6 Wert2=Wert1+int(n/2) Wert3=Wert2 locate y+13+6,19+x*4: print using "###"; Wert3; REM Zahl 29 (n=7) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*8 Wert2=Wert1-(n+1) Wert3=Wert2 locate y+13+7,19+x*4: print using "###"; Wert3; next schleifex REM Neue Seite aufbauen NeueZahl: gosub Taste gosub DateTime REM Zahl eingeben locate 5,8:print "Bitte zu prüfende Zahl eingeben" locate 6,8:print "Abbruch mit Eingabe von 0" locate 7,8:input PZahl PZahl=int(PZahl) if PZahl=0 then goto Programmende IntPZahld30=Int(PZahl/30) locate 9,8:print "Int(PZahl/30)" locate 10,11:print using "######";IntPZahld30 PZahlmod30=PZahl mod 30 locate 9,28:print "(PZahl mod 30)" locate 10,31:print using "######";PZahlmod30 IntPZahld30m8=Int(PZahl/30*8) locate 9,48:print "Int(PZahl/30*8)" REM Int(PZahl/3.75) locate 10,51:print using "######";IntPZahld30m8 Block56Nr=Int(PZahl/56) locate 12,8:print "Int(PZahl/56)" locate 13,11:print using "######";Block56Nr Zahl=Zahlf(IntPZahld30m8,Spaltef,Zeilef) locate 14,38:print "ZahlenNummer ";IntPZahld30m8;"ergibt" locate 15,41:print using "######";Zahl REM Testen auf Primzahlspalte PrimSpalte=0 PSpalte=0 while (PSpalte < 8) and (PrimSpalte=0) if Spalte(PSpalte)=PZahlmod30 then PrimSpalte=1 end if PSpalte=PSpalte+1 wend locate 15,8:print "PSpalte" locate 16,11:print using "###";PrimSpalte if PrimSpalte=0 then locate 20,8 print "Die Zahl ";PZahl;"ist keine Primzahl." locate 21,8:print "Zur Eingabe einer neuen Zahl" goto NeueZahl else locate 20,8 print "Die Zahl ";PZahl;"kann eine Primzahl sein." locate 21,8:print "Zum Überprüfen auf eine Primzahl" gosub Taste gosub DateTime gosub TestAufPrim goto NeueZahl end if Programmende: gosub DateTime locate 11,18:print "Programm wird beendet." end DateTime: cls locate 1,3: print Date$,Time$ locate 2,3: print N$,EMail$ locate 3,3: print Datei$ return Taste: locate 23,8:print "Bitte eine Taste bet„tigen" Taste1: if inkey$="" then goto Taste1 return TestAufPrim: Anzahl=7 rem nzOderZahl=1 BlockNr=0 BlockNrm8=BlockNr*8 Block56Nrm8=Block56Nr*8 rem IntBlock56Nrd8=int(Block56Nr/8) rem IntBlock56Nrd8=IntPZahld30m8/8 IntBlock56Nrd8=int(Block56Nr/16) for schleifex=0 to Anzahl SchleifemodAnz=schleifex mod (Anzahl+1) x=SchleifemodAnz IntSchleifedAnz=int(schleifex/(Anzahl+1)) y=IntSchleifedAnz n=schleifex REM Zahl 1 (n=0) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*0 Wert2=Wert1+n Wert3=Wert2+IntBlock56Nrd8*Zahl*8 locate y+4+0+BlockNrm8,12+x*6: print using "#####"; Wert3; WertA(0,schleifex)=Wert3 REM Zahl 7 (n=1) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*2 Wert2=Wert1-((int(n/2)+1)) Wert3=Wert2+IntBlock56Nrd8*Zahl*8 locate y+4+1+BlockNrm8,12+x*6: print using "#####"; Wert3; WertA(1,schleifex)=Wert3 REM Zahl 11 (n=2) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*3 Wert2=Wert1-((int(n/4)+1)) Wert3=Wert2+IntBlock56Nrd8*Zahl*8 locate y+4+2+BlockNrm8,12+x*6: print using "#####"; Wert3; WertA(2,schleifex)=Wert3 REM Zahl 13 (n=3) Zahl=Zahlf(n,Spaltef,Zeilef) Wert0=int(((n*3+1)/4+0) mod 2) Wert1=Zahl*3 Wert2=Wert1+2*n+Wert0-int(n/4)*2+int(n/8)*2 Wert3=Wert2+IntBlock56Nrd8*Zahl*8 locate y+4+3+BlockNrm8,12+x*6: print using "#####"; Wert3; WertA(3,schleifex)=Wert3 REM Zahl 17 (n=4) Zahl=Zahlf(n,Spaltef,Zeilef) Wert0=int(((n*3+1)/4+1) mod 2) Wert1=Zahl*4 Wert2=Wert1+(n*2)+1-Wert0 Wert3=Wert2+IntBlock56Nrd8*Zahl*8 locate y+4+4+BlockNrm8,12+x*6: print using "#####"; Wert3; WertA(4,schleifex)=Wert3 REM Zahl 19 (n=5) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*5 Wert2=Wert1+int(n/4) Wert3=Wert2+IntBlock56Nrd8*Zahl*8 locate y+4+5+BlockNrm8,12+x*6: print using "#####"; Wert3; WertA(5,schleifex)=Wert3 REM Zahl 23 (n=6) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*6 Wert2=Wert1+int(n/2) Wert3=Wert2+IntBlock56Nrd8*Zahl*8 locate y+4+6+BlockNrm8,12+x*6: print using "#####"; Wert3; WertA(6,schleifex)=Wert3 REM Zahl 29 (n=7) Zahl=Zahlf(n,Spaltef,Zeilef) Wert1=Zahl*8 Wert2=Wert1-(n+1) Wert3=Wert2+IntBlock56Nrd8*Zahl*8 locate y+4+7+BlockNrm8,12+x*6: print using "#####"; Wert3; WertA(7,schleifex)=Wert3 next schleifex REM Testen auf Wert im Block WertNr=0 IstPrimZahl=1 IstPrimZahlNr=0 while (WertNr < 64) and (IstPrimZahl=1) WertNrmod8=WertNr mod 8 IntWertNrd8=Int(WertNr/8) if WertA(IntWertNrd8,WertNrmod8)=IntPZahld30m8 then IstPrimZahlNr=WertA(IntWertNrd8,WertNrmod8) IstPrimZahl=0 end if WertNr=WertNr+1 wend locate 14,8:print "IstPrimZahl" locate 15,11:print using "####";IstPrimZahl locate 14,28:print "IstPrimZahlNr" locate 15,31:print using "####";IstPrimZahlNr return Bilschirmausgabe ---------------- 12-23-2003 09:27:25 Hans-Peter Kuberna hans-peter@kuberna.de PRIFOR01.BAS Die zulässigen Spaltennummern 0 1 2 3 4 5 6 7 Die zulässigen Spaltenzahlen 1 7 11 13 17 19 23 29 Die Nummern innerhalb von Block56Nr0 0 1 0 1 2 3 4 5 6 7 1 7 1 13 20 24 31 35 42 54 2 11 2 20 32 38 49 55 67 85 3 13 3 24 38 45 58 65 79 100 4 17 4 31 49 58 77 86 104 131 5 19 5 35 55 65 86 96 116 146 6 23 6 42 67 79 104 116 141 177 7 29 7 54 85 100 131 146 177 224 Bitte eine Taste betätigen Bilschirmausgabe ---------------- 12-23-2003 09:30:44 Hans-Peter Kuberna hans-peter@kuberna.de PRIFOR01.BAS Bitte zu prüfende Zahl eingeben Abbruch mit Eingabe von 0 ? 2003 Int(PZahl/30) (PZahl mod 30) Int(PZahl/30*8) 66 23 534 Int(PZahl/56) 35 ZahlenNummer 534 ergibt PSpalte 2003 1 Die Zahl 2003 kann eine Primzahl sein. Zum Überprüfen auf eine Primzahl Bitte eine Taste betätigen Bilschirmausgabe ---------------- 12-23-2003 09:32:02 Hans-Peter Kuberna hans-peter@kuberna.de PRIFOR01.BAS 16 113 178 211 276 309 374 471 17 125 196 232 303 339 410 518 18 132 208 246 321 359 435 549 19 136 214 253 330 369 447 564 20 143 225 266 349 390 472 595 21 147 231 273 358 400 484 610 22 154 243 287 376 420 509 641 23 166 261 308 403 450 545 688 IstPrimZahl IstPrimZahlNr 1 0 Bitte eine Taste betätigen -------------------------------------------------- Die Berechnung von Block56Nr gelingt mir nicht richtig, deshalb ist die Ausgabe von > IstPrimZahl < nicht immer richtig. Siehe auch den Abschnitt: Die Ausschliessung Die Frage : Warum gelingt mir nicht die richtige Berechnung ? Die Antwort : Man muß einfach etwas weglassen ! ----------------------------------------------------------------------- Ein weiterer Versuch wurde erstellt mit ARIBAS ! --------------------------------------------------- Ich habe jetzt Wert3:=Wert2............ weglassen ! Es werden nur die Zahlen für die Werte von n, im Bereich von 8 bis 255 , fehlerfrei ausgegeben. Unterhalb von n = 8 und oberhalb von n = 255 gibt es Fehler! Oberhalb von n = 255 werden die Fehler mehr ! Oberhalb von n = 1073741824 gibt es 115 Fehler, wenn 258 Zahlen getestet werden ! Es wird aber z. B. die Zahl 4026532799 als Primzahl richtig erkannt. Die einzige Programm-Schleife ---> for ns:=0+Dif to AnzahlMax+Dif by 1 do wird nur zum Testen benötigt! Das folgende Programm ist eine Testversion, also nicht fertig ! --------------------------------------------------------------- # Hans-Peter Kuberna # E-Mail # hans-peter@kuberna.de # fuer ARIBAS von Otto Forster # http://www.mathematik.uni-muenchen.de/~forster # TestKub1Isprim06V1.ari 14.01.2004 set_floatprec(4096). var Zeilef,Spaltef,Wertf : integer; AnzahlMax,FehlerProzent : integer; Dif,Difm8,Difm8div30,n : integer; ndiv30,nmod30,nf,nz,nzm30,nzm30div8 : integer; Zahl,Wert0,Wert1,Wert2,FehlerAnzahl : integer; FlagIsprim,IstPrimzahl : boolean; end. function Zahlf(nf: integer): integer; var nfmod8,nfmod8p1,nfmod8p6,nfmod8p1mod2: integer; nfmod8div7,nfmod8p6div7,nfdiv8: integer; Zeilef,Spaltef,Wertf,Mul6,VorZei,MiPl4,w6: integer; begin nfmod8 := nf mod 8; nfmod8p1 := nfmod8+1; nfmod8p6 := nfmod8+6; nfmod8p1mod2 :=nfmod8p1 mod 2; nfmod8div7 :=nfmod8 div 7; nfmod8p6div7 :=nfmod8p6 div 7; nfdiv8 := nf div 8; Zeilef := nfdiv8; Mul6 := (nfmod8 div 2)*6; # Vorzeichen berechnen VorZei := 1-(nfmod8p1mod2*2); # -/+ 4 addieren bei nf=0 / nf=7 MiPl4 := (nfmod8div7-nfmod8p6div7+1)*4*VorZei; # Wert fuer Ergebnisanpassung w6 := 6; Spaltef := Mul6+VorZei+MiPl4+w6; Wertf := Zeilef*30+Spaltef; return Wertf; end. #Dif:=0; # Dif:=2**30; # Difm8:=Dif*8; # Difm8div30:=Difm8 div 30; # Dif:=Difm8div30; write(" ":78); # Difm8:=Dif*8; # Difm8div30:=Difm8 div 30; write(" ":78); FehlerAnzahl:=0; #for nz:=0+Dif to 7+Dif by 1 do AnzahlMax:=257; for ns:=0+Dif to AnzahlMax+Dif by 1 do nz:=Zahlf(ns); IstPrimzahl:=1; # nzm8:=nz*8; # nzm8div30:=nzm8 div 30; nzm8div30:=ns; nmod30 := nz mod 30; # Zahl 1 (n=0) Zahl:=Zahlf(n); Wert1:=Zahl*0; Wert2:=Wert1+n; if nzm8div30 = Wert2 then IstPrimzahl:=0; end; # Zahl 7 (n=1) n := nzm8div30 div 7; Zahl:=Zahlf(n); Wert1:=Zahl*2; Wert2:=Wert1-((n div 2)+1); if nzm8div30 = Wert2 then IstPrimzahl:=0; end; # Zahl 11 (n=2) n := nzm8div30 div 11; Zahl:=Zahlf(n); Wert1:=Zahl*3; Wert2:=Wert1-((n div 4)+1); if nzm8div30 = Wert2 then IstPrimzahl:=0; end; # Zahl 13 (n=3) n := nzm8div30 div 13; Zahl:=Zahlf(n); Wert0:=(((n*3+1) div 4)+0) mod 2; Wert1:=Zahl*3; Wert2:=Wert1+2*n+Wert0-(n div 4)*2+(n div 8)*2; if nzm8div30 = Wert2 then IstPrimzahl:=0; end; # Zahl 17 (n=4) n := nzm8div30 div 17; Zahl:=Zahlf(n); Wert0:=(((n*3+1) div 4)+1) mod 2; Wert1:=Zahl*4; Wert2:=Wert1+(n*2)+1-Wert0; if nzm8div30 = Wert2 then IstPrimzahl:=0; end; # Zahl 19 (n=5) n := nzm8div30 div 19; Zahl:=Zahlf(n); Wert1:=Zahl*5; Wert2:=Wert1+(n div 4); if nzm8div30 = Wert2 then IstPrimzahl:=0; end; # Zahl 23 (n=6) n := nzm8div30 div 23; Zahl:=Zahlf(n); Wert1:=Zahl*6; Wert2:=Wert1+(n div 2); if nzm8div30 = Wert2 then IstPrimzahl:=0; end; # Zahl 29 (n=7) n := nzm8div30 div 29; Zahl:=Zahlf(n); Wert1:=Zahl*8; Wert2:=Wert1-(n+1); if nzm8div30 = Wert2 then IstPrimzahl:=0; end; #write(" ":78); FlagIstprim := prime32test(nz); if IstPrimzahl = 1 then if FlagIstprim = 1 then # write(ns :20,nz :20," Ist Primzahl ":20,IstPrimzahl:5,FlagIstprim:5," ":8); end; end; # else if IstPrimzahl = 0 then if FlagIstprim = 0 then # write(ns :20,nz :20," Keine Primzahl":20,IstPrimzahl:5,FlagIstprim:5," ":8); end; end; if IstPrimzahl = 1 then if FlagIstprim = 0 then FehlerAnzahl:=FehlerAnzahl+1; # write(ns :20,nz :20," Fehler":20,IstPrimzahl:5,FlagIstprim:5," ":8); end; end; if IstPrimzahl = 0 then if FlagIstprim = 1 then FehlerAnzahl:=FehlerAnzahl+1; # write(ns :20,nz :20," Fehler":20,IstPrimzahl:5,FlagIstprim:5," ":8); end; end; #write(ns :20,nz :20," Fehler":20,IstPrimzahl:5,FlagIstprim:5," ":8); end; write(" ":78); write(FehlerAnzahl :20," Fehler Anzahl":20," ":38); write(AnzahlMax+1 :20," Getestete Zahlen":20," ":38); Bildschirmausgabe: ------------------ ==> load("C:\Programme\aribasw142\hpk\TestKub1Isprim06V1.ari"). (** loading file C:\Programme\aribasw142\hpk\TestKub1Isprim06V1.ari **) 4096 var Zahlf 0 1 1 0 257 0 1 Keine Primzahl 0 0 1 7 Fehler 0 1 2 11 Fehler 0 1 3 13 Fehler 0 1 4 17 Fehler 0 1 5 19 Fehler 0 1 6 23 Fehler 0 1 7 29 Fehler 0 1 8 31 Ist Primzahl 1 1 9 37 Ist Primzahl 1 1 10 41 Ist Primzahl 1 1 11 43 Ist Primzahl 1 1 12 47 Ist Primzahl 1 1 13 49 Keine Primzahl 0 0 14 53 Ist Primzahl 1 1 15 59 Ist Primzahl 1 1 16 61 Ist Primzahl 1 1 17 67 Ist Primzahl 1 1 18 71 Ist Primzahl 1 1 19 73 Ist Primzahl 1 1 20 77 Keine Primzahl 0 0 ...... ...... ...... ...... ...... ...... ...... ...... 250 941 Ist Primzahl 1 1 251 943 Keine Primzahl 0 0 252 947 Ist Primzahl 1 1 253 949 Keine Primzahl 0 0 254 953 Ist Primzahl 1 1 255 959 Keine Primzahl 0 0 256 961 Fehler 1 0 257 967 Ist Primzahl 1 1 1 8 Fehler Anzahl 3 258 Getestete Zahlen 3 -: true ==> Bildschirmausgabe: ------------------ ==> load("C:\Programme\aribasw142\hpk\TestKub1Isprim06V1.ari"). (** loading file C:\Programme\aribasw142\hpk\TestKub1Isprim06V1.ari **) 4096 var Zahlf 1073741824 1 1 0 257 1073741824 4026531841 Fehler 1 0 1073741825 4026531847 Keine Primzahl 0 0 1073741826 4026531851 Keine Primzahl 0 0 1073741827 4026531853 Ist Primzahl 1 1 1073741828 4026531857 Ist Primzahl 1 1 1073741829 4026531859 Keine Primzahl 0 0 1073741830 4026531863 Ist Primzahl 1 1 1073741831 4026531869 Keine Primzahl 0 0 1073741832 4026531871 Fehler 1 0 1073741833 4026531877 Fehler 1 0 1073741834 4026531881 Fehler 1 0 1073741835 4026531883 Keine Primzahl 0 0 1073741836 4026531887 Keine Primzahl 0 0 1073741837 4026531889 Keine Primzahl 0 0 1073741838 4026531893 Fehler 1 0 1073741839 4026531899 Keine Primzahl 0 0 1073741840 4026531901 Keine Primzahl 0 0 1073741841 4026531907 Fehler 1 0 1073741842 4026531911 Fehler 1 0 1073741843 4026531913 Fehler 1 0 1073741844 4026531917 Fehler 1 0 ...... ...... ...... ...... ...... ...... ...... ...... 1073742074 4026532781 Ist Primzahl 1 1 1073742075 4026532783 Keine Primzahl 0 0 1073742076 4026532787 Fehler 1 0 1073742077 4026532789 Keine Primzahl 0 0 1073742078 4026532793 Fehler 1 0 1073742079 4026532799 Ist Primzahl 1 1 1073742080 4026532801 Keine Primzahl 0 0 1073742081 4026532807 Keine Primzahl 0 0 1 115 Fehler Anzahl 3 258 Getestete Zahlen 3 -: true ==> ----------------------------------------------------------------------- Die Berechnung der Zahl 1 (n=0) in die Berechnung der Zahl 31 (n=8) geändert. ----------------------------------------------- # Hans-Peter Kuberna # E-Mail # hans-peter@kuberna.de # fuer ARIBAS von Otto Forster # http://www.mathematik.uni-muenchen.de/~forster # TestKub1Isprim06V4bis365.ari 18.01.2004 set_floatprec(4096). var Zeilef,Spaltef,Wertf : integer; AnzahlMax,FehlerProzent,FehlerIn : integer; Block,Dif,Difm8,Difm8div30,n,noffset : integer; ndiv30,nmod30,nf,ns,nz,nzm30,nzm30div8 : integer; Zahl,Wert0,Wert1,Wert2,FehlerAnzahl : integer; ZahlWertZaehler : integer; ZahlWert: array[8] of integer; FlagIsprim,IstPrimzahl : boolean; end. function Zahlf(nf: integer): integer; var nfmod8,nfmod8p1,nfmod8p6,nfmod8p1mod2: integer; nfmod8div7,nfmod8p6div7,nfdiv8: integer; Zeilef,Spaltef,Wertf,Mul6,VorZei,MiPl4,w6: integer; begin nfmod8 := nf mod 8; nfmod8p1 := nfmod8+1; nfmod8p6 := nfmod8+6; nfmod8p1mod2 :=nfmod8p1 mod 2; nfmod8div7 :=nfmod8 div 7; nfmod8p6div7 :=nfmod8p6 div 7; nfdiv8 := nf div 8; Zeilef := nfdiv8; Mul6 := (nfmod8 div 2)*6; # Vorzeichen berechnen VorZei := 1-(nfmod8p1mod2*2); # -/+ 4 addieren bei nf=0 / nf=7 MiPl4 := (nfmod8div7-nfmod8p6div7+1)*4*VorZei; # Wert fuer Ergebnisanpassung w6 := 6; Spaltef := Mul6+VorZei+MiPl4+w6; Wertf := Zeilef*30+Spaltef; return Wertf; end. # Dif:=0; #Dif:=2**30; #Dif:=240*1+1; #Dif:=240*107+0; # Difm8:=Dif*8; # Difm8div30:=Difm8 div 30; # Dif:=Difm8div30; #noffset := 0; write(" ":78); FehlerAnzahl:=0; #AnzahlMax:=257; #AnzahlMax:=720; # AnzahlMax:=256*2+1; #AnzahlMax:=256*1+1; # Block:=0; #Block:=ns div 256; for ns:=0+Dif to AnzahlMax+Dif by 1 do noffset:=ns div 256; FehlerIn:=0; nz:=Zahlf(ns); FlagIstprim := prime32test(nz); IstPrimzahl:=1; # nzm8:=nz*8; # nzm8div30:=nzm8 div 30; nzm8div30:=ns+0; nmod30 := nz mod 30; # Zahl 31 (n=8) war Zahl 1 (n=0) n := nzm8div30 div 31; Zahl:=Zahlf(n); Wert1:=Zahl*8; Wert2:=Wert1+n; # Wert3:=Wert2+Block*Zahl*8; if nzm8div30 = Wert3 then IstPrimzahl:=0; ZahlWert[0]:=0; else ZahlWert[0]:=Wert3; end; # Zahl 7 (n=1) n := nzm8div30 div 7; Zahl:=Zahlf(n); Wert1:=Zahl*2; Wert2:=Wert1-((n div 2)+1); # Wert3:=Wert2+Block*Zahl; if nzm8div30 = Wert3 then IstPrimzahl:=0; ZahlWert[1]:=0; else ZahlWert[1]:=Wert3; end; # Zahl 11 (n=2) n := nzm8div30 div 11; Zahl:=Zahlf(n); Wert1:=Zahl*3; Wert2:=Wert1-((n div 4)+1); # Wert3:=Wert2+Block*Zahl; if nzm8div30 = Wert3 then IstPrimzahl:=0; ZahlWert[2]:=0; else ZahlWert[2]:=Wert3; end; # Zahl 13 (n=3) n := nzm8div30 div 13; Zahl:=Zahlf(n); Wert0:=(((n*3+1) div 4)+0) mod 2; Wert1:=Zahl*3; Wert2:=Wert1+2*n+Wert0-(n div 4)*2+(n div 8)*2; # Wert3:=Wert2+Block*Zahl; if nzm8div30 = Wert3 then IstPrimzahl:=0; ZahlWert[3]:=0; else ZahlWert[3]:=Wert3; end; # Zahl 17 (n=4) n := nzm8div30 div 17; Zahl:=Zahlf(n); Wert0:=(((n*3+1) div 4)+1) mod 2; Wert1:=Zahl*4; Wert2:=Wert1+(n*2)+1-Wert0; # Wert3:=Wert2+Block*Zahl; if nzm8div30 = Wert3 then IstPrimzahl:=0; ZahlWert[4]:=0; else ZahlWert[4]:=Wert3; end; # Zahl 19 (n=5) n := nzm8div30 div 19; Zahl:=Zahlf(n); Wert1:=Zahl*5; Wert2:=Wert1+(n div 4); # Wert3:=Wert2+Block*Zahl; if nzm8div30 = Wert3 then IstPrimzahl:=0; ZahlWert[5]:=0; else ZahlWert[5]:=Wert3; end; # Zahl 23 (n=6) n := nzm8div30 div 23; Zahl:=Zahlf(n); Wert1:=Zahl*6; Wert2:=Wert1+(n div 2); # Wert3:=Wert2+Block*Zahl; if nzm8div30 = Wert3 then IstPrimzahl:=0; else ZahlWert[6]:=0; ZahlWert[6]:=Wert3; end; # Zahl 29 (n=7) n := nzm8div30 div 29; Zahl:=Zahlf(n); Wert1:=Zahl*8; Wert2:=Wert1-(n+1); # Wert3:=Wert2+Block*Zahl; if nzm8div30 = Wert3 then IstPrimzahl:=0; ZahlWert[7]:=0; else ZahlWert[7]:=Wert3; end; #write(" ":78); if IstPrimzahl = FlagIstprim then #write(ns :20,nz :20," Test OK":20,IstPrimzahl:5,FlagIstprim:5," ":8); end; if IstPrimzahl <> FlagIstprim then FehlerAnzahl:=FehlerAnzahl+1; if Dif < (240*107+1) then write(ns :6,nz :6); for ZahlWertZaehler:=0 to 7 by 1 do write(ZahlWert[ZahlWertZaehler] :6); end; write(" Fehler":9,IstPrimzahl:4,FehlerIn:4," ":1); end; end; end; write(" ":78); write(FehlerAnzahl :20," Fehler Anzahl":20," ":38); write(AnzahlMax+1 :20," Getestete Zahlen":20," ":38); Bildschirmausgabe bei Dif:=0: ----------------------------- ==> load("C:\Programme\aribasw144\hpk\TestKub1Isprim06V4bis365.ari"). (** loading file C:\Programme\aribasw144\hpk\TestKub1Isprim06V4bis365.ari **) 4096 var Zahlf 0 1 0 513 0 0 1 8 1 2 3 4 5 6 7 Fehler 1 0 1 7 8 0 2 3 4 5 6 7 Fehler 0 0 2 11 8 1 0 3 4 5 6 7 Fehler 0 0 3 13 8 1 2 0 4 5 6 7 Fehler 0 0 4 17 8 1 2 3 0 5 6 7 Fehler 0 0 5 19 8 1 2 3 4 0 6 7 Fehler 0 0 6 23 8 1 2 3 4 5 6 7 Fehler 0 0 7 29 8 13 2 3 4 5 6 0 Fehler 0 0 8 31 0 13 2 3 4 5 6 7 Fehler 0 0 365 1369 355 367 372 370 358 369 361 363 Fehler 1 0 404 1517 405 405 401 412 403 400 410 378 Fehler 1 0 424 1591 405 423 419 419 412 420 435 409 Fehler 1 0 448 1681 438 449 442 454 457 450 447 456 Fehler 1 0 463 1739 438 468 472 461 466 461 472 456 Fehler 1 0 470 1763 487 472 472 474 466 461 472 471 Fehler 1 0 493 1849 487 490 489 481 494 491 484 518 Fehler 1 0 513 1927 504 517 507 516 512 521 509 518 Fehler 1 0 1 17 Fehler Anzahl 3 514 Getestete Zahlen 3 -: true ==> Bildschirmausgabe bei Dif:=2**30: --------------------------------- ==> load("C:\Programme\aribasw144\hpk\TestKub1Isprim06V4bis365.ari"). (** loading file C:\Programme\aribasw144\hpk\TestKub1Isprim06V4bis365.ari **) 4096 var Zahlf 0 1073741824 1 0 513 257 0 1 108 Fehler Anzahl 3 258 Getestete Zahlen 3 -: true ==> ------------------------------------------------------ ----------------------------------------------------------------------- ------------------------------------------------------ Ich habe mir weitere Fragen gestellt! ------------------------------------- Ob sich die Zahl PI durch 9 teilen läßt. ----------------------------------------------- 14*1000*9 688*9 --------- + ----- +2 = 16526 8 8 1*1000*9 688*9 --------- + ----- +2 = 1901 8 8 16526*1901 = 31415926 688*9 ----- = 774 = 2 * 9 * 43 8 ---------------------------- 628*1000*9 688*9 --------- + ----- +2 = 707276 8 8 888*1000*9 688*9 --------- + ----- +2 = 999776 8 8 --------------------------------------------------------------- Oder: Welche Ausmaße hat die Cheops Pyramide. ----------------------------------------------- Neue Version vom 12.12.2003 --------------------------- Sie soll circa 146,6 m hoch gewesen sein. (11*8+1) + (7*8+1)= 146 89 + 57 = 146 146,6 146,6 --------------------- = --------------------- = 1,6367..... (88+1)+((56+1)/100) 89,57 1,63670871943731159986602657139667 - 1 = 0,63670871943..... 1 ---------------------------------- = 1,570576889356479..... 0,63670871943731159986602657139667 1,570576889356479..... - (PI/2) = 0,000219437438417573..... -------------------- ( 57 + (1/40) * 1 ) + ( 89 + (1/40) * 23 ) = 57,025 + 89,575 = 146,6 89,575 ------ = 1,57080227970188513809732573432705 57,025 89*40 + 23 3560 + 23 Primzahl 3583 ---------- = ---------- = -------------- = 1,5708022797..... 57*40 + 1 2280 + 1 Primzahl 2281 (119 * 30) + 13 = 3583 ( 76 * 30) + 1 = 2281 1,5708022797018851380..... - (PI/2) = 0,000005952906988518 ----------------------------------------------------------- Eine Seite der quadratischen Grundfläche hat circa 9 2 * - * 100 m = 2 * 1.125 * 100 m = 225 m 8 --------------------------------------------------------------- Suche nach einer Vereinfachung der Sinusberechnung. --------------------------------------------------- Siehe auch weiter unten SIN_X.BAS vom 02.02.2001 Zahl X hoch 5. Betrachtung der Differenzen. 4 Fakultaet = 24. Programm Xhoch4.bas vom 07.11.1995 CLS DIM x%(20) xmax% = 10: n% = 5: REM (n% min=4,max=6) z% = 0: s% = 5 f% = n% - 1: Fakultaet% = 1 FOR i% = 1 TO f% Fakultaet% = Fakultaet% * i% Fakultaet%(i%) = Fakultaet% NEXT i% LOCATE 1, 1: PRINT "X"; " hoch"; n% FOR x% = 0 TO xmax% z% = z% + 1: IF z% < 12 THEN GOTO weiter: z% = 1: PRINT : PRINT "Bitte eine Taste bet„tigen." taste: IF INKEY$ = "" THEN GOTO taste CLS weiter: LOCATE z% * 2, 1: PRINT x%; x10# = x% ^ n% x11# = (x% + 1) ^ n% x12# = (x% + 2) ^ n% x13# = (x% + 3) ^ n% x14# = (x% + 4) ^ n% LOCATE z% * 2, s%: PRINT USING "#######"; x10# x20# = x11# - x10# x21# = x12# - x11# x22# = x13# - x12# x23# = x14# - x13# IF x% > (xmax% - 1) THEN GOTO weiter1 LOCATE z% * 2 + 1, s% + 9: PRINT USING "#######"; x20# LOCATE z% * 2 + 1, s% + 7: PRINT "}" weiter1: x30# = x21# - x20# x31# = x22# - x21# x32# = x23# - x22# x40# = x31# - x30# x41# = x32# - x31# x50# = x41# - x40# IF x% > (xmax% - 2) THEN GOTO weiter2 LOCATE z% * 2 + 2, s% + 17: PRINT "}" LOCATE z% * 2 + 2, s% + 20: PRINT USING "#######"; x30#; PRINT "("; LOCATE z% * 2 + 2, s% + 28: PRINT USING "#######"; x30# / Fakultaet%(n% - 3); PRINT "*"; Fakultaet%(n% - 3); ")"; IF x% > (xmax% - 3) THEN GOTO weiter2 LOCATE z% * 2 + 3, s% + 28: PRINT "}"; LOCATE z% * 2 + 3, s% + 36: PRINT USING "#######"; x40#; PRINT "("; LOCATE z% * 2 + 3, s% + 41: PRINT USING "#######"; x40# / Fakultaet%(n% - 2); PRINT "*"; Fakultaet%(n% - 2); ")"; IF x% > (xmax% - 4) THEN GOTO weiter2 LOCATE z% * 2 + 4, s% + 50: PRINT "}"; LOCATE z% * 2 + 4, s% + 53: PRINT USING "#######"; x50#; PRINT "("; LOCATE z% * 2 + 4, s% + 61: PRINT USING "#######"; x50# / Fakultaet%(n% - 1); PRINT "*"; Fakultaet%(n% - 1); ")": weiter2: NEXT x% Bildschirmausgabe: ------------------ X hoch 5 0 0 } 1 1 1 } 30( 15* 2 ) } 31 } 1 25* 6 ) 2 32 } 180( 90* 2 ) } 240( 10* 24 ) } 211 } 3 65* 6 ) 3 243 } 570( 285* 2 ) } 360( 15* 24 ) } 781 } 7 125* 6 ) 4 1024 } 1320( 660* 2 ) } 480( 20* 24 ) } 2101 } 12 205* 6 ) 5 3125 } 2550( 1275* 2 ) } 600( 25* 24 ) } 4651 } 18 305* 6 ) 6 7776 } 4380( 2190* 2 ) } 720( 30* 24 ) } 9031 } 25 425* 6 ) 7 16807 } 6930( 3465* 2 ) } 840( 35* 24 ) } 15961 } 33 565* 6 ) 8 32768 } 10320( 5160* 2 ) } 960( 40* 24 ) } 26281 } 43 725* 6 ) 9 59049 } 14670( 7335* 2 ) } 40951 10 100000 ----------------------------------------------------------------------- x ^ 3 = x*x*x 3! = 1*2*3 x ^ 1 x ^ 3 x ^ 5 x ^ 7 sin x = ----- - ----- + ----- - ----- + ..... 1! 3! 5! 7! x ^ 3 x ^ 4 x ^ 6 x ^ 8 cos x = 1 - ----- - ----- + ----- - ----- + ..... 2! 4! 6! 8! REM SIN_X.BAS REM 02.02.2001 REM Hans-Peter Kuberna CLS n% = 13 pi# = 4 * ATN(1) DIM fakultaet#(n%) fakultaet# = 1 FOR i% = 1 TO n% fakultaet# = fakultaet# * i% fakultaet#(i%) = fakultaet# PRINT i%, fakultaet#(i%) NEXT i% PRINT INPUT "Bitte Winkel im Gradmass eingeben"; gg# gg#=gg# mod 360 gb# = (gg# / 180) * pi# vz# = -1 FOR i% = 1 TO n% STEP 2 vz# = vz# * -1 sx# = sx# + (gb# ^ i% / fakultaet#(i%)) * vz# PRINT i%, sx#*2-pi# NEXT i% PRINT PRINT sx# Bildschirmausgabe: ------------------ 1 1 2 2 3 6 4 24 5 120 6 720 7 5040 8 40320 9 362880 10 3628800 11 39916800 12 479001600 13 6227020800 Bitte Winkel im Gradmass eingeben? 51.42857142 1 -1.34639685183768 3 -1.58745633999937 5 -1.57774547557287 7 -1.57793175815839 9 -1.5779296736511 11 -1.57792968891883 13 -1.57792968883998 .781831482374907 -----------------------------------------------------------------------