Wenn man die Glieder der Fibonacci-Folge

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233 ...

entsprechend nachfolgendem Schema anordnet

0.0
0.01
0.001
0.0002
0.00003
0.000005
0.0000008
0.00000013
0.000000021
0.0000000034
0.00000000055
0.000000000089
0.0000000000144
.
.

und die Glieder aufaddiert, ergibt sich

----------------
0.01123595505...

Diese rationale Zahl beginnt mit den gleichen Nachkommadigits wie 1/89:

1/89 = 0.0112359550561798... (16 Nachkommastellen (Double))
= 0.01123595505617977528089887640449... (Taschenrechner (Abb. 1), 32 Nachkommastellen)

Berücksichtigt man bei obiger Addition quasi alle Summanden, so wird vermutet, dass sich in der Tat 1/89 exakt ergibt, unglaublich, wenn wahr, oder?

Diese Eigenschaft der Fibonacci-Folge wurde erst 1994 entdeckt (von einem Herrn Cody Birsner, damals Student in Oklahoma). Also, auch heute
ist noch genügend Platz für grandiose und phantastische Entdeckungen in der Zahlentheorie.

Man zeige mittels Programmierung, dass die Vermutung (die mittlerweile bewiesen ist) selbst bis zur Taschenrechnergenauigkeit mit 32 Nachkommastellen nicht widerlegt wird.

Gegeben seien zwei unabhängige Zufallsereignisse A und B, wobei A mit einer
Wahrscheinlichkeit von 70 % eintritt und B mit eine Wahrescheinlichkeit von 10 %.

Durch (MontoCarlo-) Simulation schätze man ab, mit welchen Wahrscheinlichkeiten das Doppelereignis (A, B)
vorkommt für die Fälle

a) weder A noch B sind eingetreten,
b) entweder A oder B (oder beide) ist (sind) eingetreten.

Man kann das natürlich auch ausrechnen, aber grau ist bekanntlich alle Theorie.

Beim Chess960, auch Fischer-Random-Chess genannt, wird die
Ausgangsposition der acht weißen Offiziere ausgelost, wobei
zwei Regeln zu beachten sind:

1.) der König muss zwischen den zwei Türmen stehen (damit Rochaden möglich bleiben) und
2.) die zwei Läufer müssen ungleichfarbig sein.

Die schwarzen Offiziere werden spiegelsymmetrisch angeordnet (Bild 1, Beispielaufstellung),
alle anderen Schachspielregeln bleiben erhalten.

Man schreibe ein (vorzugsweise GUI-) Programm, das diesen Auslosungsregeln entspricht und eine
der möglichen 960 zufälligen Startpositionen rückgibt.

Die Felder eines "unendlich" großen 2D-Arrays seien nach folgendem "Diagonal-Schema" nummeriert:

1 2 4 7 . . .
3 5 8 . . . .
6 9 . . . . .
10 . . . . . .
. . . . . . usw.

Man schreibe ein Programm, das für eine gegebene Feldnummer N die Zeilen- (ZN) und die Spaltennummer (SN) zurückgibt.
Zeilen- und Spaltennummerierungen beginnen wie üblich mit 0.

Beispiele:
N = 8 -> ZN = 1, SN = 2
N = 31 -> ZN = 2, SN = 5

Man schreibe eine GUI-Anwendung, die einen 52er Kartensatz mischt und die entstandene Reihenfolge anzeigt (BILD 2).
Die Anwendung soll zwei Befehlsknöpfe haben: MISCHEN und RESET. Mit RESET soll die Default-Reihenfolge angezeigt werden (BILD 1).

Einen Satz von Image-Dateien der Spielkarten könnt ihr z. B. unter http://www.nongnu.org/cardpics/cardpics.en.html herunterladen und darüber frei verfügen, sofern ihr eure Lösung nicht für kommerzielle Zwecke vermarkten wollt.

In mathebord regt man sich u. a. darüber auf,
dass man bei einer Monte-Carlo-Simulation zur Berechnung des mittleren Abstandes
zweier Punkte in einem Rechteck über 4 Sekunden benötigt (bei 1 Mio. zufälligen Experimenten).
Außerdem wird in der Antwort vom 22.10.2013 (23:10) auch noch ein falsches Ergebnis unkommentiert präsentiert.

Nun gut, das war vor etwa 5 Jahren und Hard- sowie verwendete Software waren auch nicht Stand der damaligen Technik.
Wir wollen versuchen, es hier schneller und besser zu bewerkstelligen.

Aufgabenstellung: Für die fünf (euklidischen) Formen gerade Linie, Quadrat, Rechteck, Kreis und Ellipse
schätze man den mittleren Abstand zweier Punkte innerhalb der genannten geometrischen Formen ab, bezogen auf den Umfang der entsprechenden Form. Die Umfangspunkte gehören mit zu der Form. Für die Linie sei der Umfang die doppelte Linienlänge
(Rechteck mit zwei verschwindend kleinen Parallelseiten).

Die Simulation soll mittels 1.000.000 Zufallsexperimenten vorgenommen werden.

Ich bin im Haushalt ein ziemlich fauler Hund. Meine Frau weiß das und so hielt sie mich deshalb kürzlich an, wenigstens hin und wieder das Wohnzimmer zu saugen. Nun gut, mir kam die geniale Idee, dafür einen Staubsaug-Roboter zu kaufen. Gesagt, getan. Meine Frau runzelte zwar, aber letzt­lich war ihr das egal, wichtig war ja nur, dass sie etwas von der Hausarbeit entlastet wird.

Das Gerät überraschte mich von Anfang an. Es fährt immer geradeaus bis es irgendwo anstößt. Dann dreht es sich auf der Stelle in eine zufällige andere Richtung und fährt wieder weiter gerade­aus bis zum nächsten Hindernis. Es teilt mir auch sprachlich z. B. mit, wenn der Akku fast leer ist, es jetzt eine Pause machen wird und zur Ladestation fährt. Andermal sagte es, dass sein Haupt­speicher (sprich Staubsammeltüte) voll ist und ich ihn leeren solle. Das übernimmt natürlich meine Frau, denn bei einem solchen mechanischen Eingriff hat sie kein Vertrauen zu mir.

Der Gipfel war aber, als der Roboter mir bei der gestrigen Arbeit mitteilte, dass er fertig sei und im Zimmer der gesamten Fußboden gereinigt ist.

Das ist doch unmöglich, woher will er das wissen. Und "der gesamte Fußboden" geht schon gar­nicht, denn in die Ecken kommt er ja sowieso nicht. Ich war immer der Meinung, dass er erst fertig zu sein hat, wenn er abgeschaltet wird. Aber Nein sagte meine Frau, das macht er immer so, ich soll­te ihn, wie vereinbart war, nur hin und wieder selbst einsetzen und beobachten (beobachtet wird das Gerät bisweil immer nur von unserer Hauskatze).

Ich wurde neugierig und las entgegen meinen Gewöhnheiten auch die Betriebsanleitung. In der Tat stand darin, dass der Roboter anhält, wenn er mehr als 95 % der Fußbodenfläche gesaugt hat.

Ich dachte, nun gut, 95 % ist okay, aber, wie will er das wissen. Da muss schon eine ziemlich clevere Software im Roboter stecken. Prinzipiell kann man zwar die besaugte Fläche bei Kenntnis der Fahr­geschwindigkeit, der Anstoßpunkte und der neuen Fahrtrichtungen berechnen. Die Flächenseg­mente, die durch das Zufallsprinzip bereits besaugt worden ware, sind entsprechend zu berücksich­tigen (abzuziehen). Alles mathematisch recht kom­pliziert.

Der Gedanke, es statt einer mathematischen Berechnung durch eine informathematische Simulation abzuschätzen, legt auf der Hand. Dies soll daher die Aufgabenstellung sein.

Ausgehend von einer beliebigen Startposition auf einer leeren, rechteckigen Fläche F = LX x LY, mit LX und LY als Seitenlängen des Rechtecks, einer vorgegebenen Fahrgeschwindigkeit V und einer zufälli­gen Richtungsände­rung bei Zusammenstoß mit einem Hindernis (Wand) ist der Anteil besaugter Fläche bzgl. der Gesamtfußbodenfläche wie folgt anzuschätzen:

Auf einem zu Beginn 100 % mit "Staubpixeln" belegten Rechteck wird ein Staubsaug-Roboter mit dem Radius R gesetzt und fährt per Zufall gewählter Richtung staubsaugend geradeaus (Geschwin­digkeit V). Bei Berührung einer Wand ändert er zufällig seine Fahrtrichtung. Während der Fahrt werden alle überfahrenen "Staubpixeln" durch "Reinpixel" ersetzt (siehe Abb. 1). Die Fahrt endet, wenn P_okay = 95 % der Rechtecksfläche mit "Reinpixeln" belegt ist.

Schreibe ein Programm, welches das Spiel "Onkel Otto sitzt in der Badewanne" simuliert. Dabei geht es darum, dass jeder der Spieler ein gefaltetes Blatt mit 6 aufgezeichnete Spalten vor sich hat und in einer etwas eintragen muss. Danach wird das Blatt weitergereicht und der nächste Spieler füllt die nächste Spalte aus, solange bis keine mehr frei ist; dann werden die enstandenen Sätze vorgelesen.

Zur Vereinfachung kann jeder Spieler jeweils nacheinander ein Wort eingeben in seinem Client. Die eingegebenen Worte sollen an einen Server geschickt, dem jeweiligen Spiel ( jedes gestartete Spiel soll einen anderen Namen bekommen ) zugeordnet und anschließend die vollständigen Sätze an alle Clients zurückschicken, die an dem jeweiligen Spiel teilgenommen haben.

Designvorschlag für Homescreen: siehe Anhang

Aufgabe: Schreibe den Code für den Client und für den Server!

Die Gaußsche Primzahlendecke soll als Textilie in den 60er Jahren in den USA ein echter Verkaufsschlager gewesen sein.
Es handelt sich dabei um ein (weißes) Tuch, das entsprechend der Verteilung der Primzahlen in der (komplexen) Gaußschen
Ebene bestickt ist. Genau ein solches Muster wollen auch wir hier mittels Coding erzeugen (Abb. 1).

Während die Sache mit den "normalen" Primzahlen recht einfach zu verstehen ist (Primzahl ist eine Ganzzahl, die nur durch
sich selbst bzw. durch EINS ohne Rest teilbar ist), ist das mit den komplexen Primzahlen schon etwas schwieriger, wir haben
es hier schließlich mit einem Zahlenpaar (Real- und Imaginärteil) zu tun. Besonders interessant ist, das einige "normale"
Primzahlen (z. B. 13 = (3 + 2 * i) * (3 - 2 * i)) keine komplexen Primzahlen sind (was sag ich einige, es sind unendlich viele).

Ohne uns vertiefend mit der Zahlentheorie zu beschäftigen, hier die wesentlichen Voraussetzungen für die Programmierung:

Eine komplexe Integerzahl Z = X + i * Y (X (Realteil), Y (Imaginärteil) Ganzahlen, i * i = -1) heißt Gaußsche Primzahl,
wenn sie eine der drei folgenden Bedingungen erfüllt:

1. Wenn sowohl X als auch Y ungleich 0 sind, dann ist Z eine Gaußsche Primzahl, wenn (X * X + Y * Y) eine "normale" Primzahl ist,
2. ist X = 0, dann ist Z = i * Y Gaußsche Primzahl, wenn Y "normale" Primzahl ist und wenn |Y| = 3 (mod 4) (oder in c#: Math.Abs(Y) % 4 == 3) ist,
3. ist Y = 0, dann ist Z = X Gaußsche Primzahl, wenn X "normale" Primzahl ist und wenn |X| = 3 (mod 4) ist.

Die Programmieraufgabe bestehe nun darin, die Gaußschen Primzahlen für {|X|, |Y|} <= N (z. B. N = 50, Abb. 2 (nur erster Quadrant))
graphisch darzustellen.

Ich möchte die Anzahl aller möglicher Objektkombinationen Z haben, die zu einer bestimmten Anzahl N möglich sind.

Eingabe:

ARRAY Z : object a, object b, object c, object d ... etc
INTEGER N: 10

Ausgabe:
a a a a a a a a a a
a a a a a a a a a b
a a a a a a a a b b
a a a a a a a b b b
a a a a a a b b b b
a a a a a b b b b b
a a a a b b b b b b
a a a b b b b b b b
a a b b b b b b b b
a b b b b b b b b b
b b b b b b b b b b
b b b b b b b b c c
b b b b b b b c c c
b b b b b b c c c c
b b b b b c c c c c
b b b b c c c c c c
....... usw.

Die Anzahl der Objektkombinationen Z kann nicht größer sein als die Anzahl N. Das ganze soll vom Benutzer eingestellt werden können.
Zusätzlich soll das Ergebnis in einem Array gespeichert werden und dann eine eindeutige Eigenschaft jedes Objektes ausgegeben werden können.

Wer will kann sich gerne Versuchen.

1) Gegeben sei ein Quadrat mit der Seitenlänge L (z. B. L = 1).

2) Man wähle zufällig N Punktepaare auf den Seitenlinien des Quadrates, wobei nicht beide Punkte auf der gleichen Seitenlinie liegen dürfen.

3) Die Punkte eines Punktepaares werden nun jeweils durch eine Linie miteinander verbunden. Auf diese Weise wird die Fläche des Quadrates
in eine Vielzahl von Flächensegmenten unterteilt - siehe exemplarisch die zwei Abb. 1 und 2 mit N = 5 bzw. N = 6.

4) Man schreibe ein Programm, das die Anzahl der auf die Weise erzeugten Flächensegmente zurückgibt.

Schreibe eine Funktion, die Zahlen aus dem Dualsystem in Zahlen des Dezimalsystems umwandelt.

Beispiel:

Binär: 11010
Dezimal: 26