Collatz Schleife |
|
Kann sein das ich mich verzählt habe...
Eine Idee wie man das schön plotten kann ausser mit excel?
__________________ Gruß blindmessenger
|
|
20.11.2016 18:11 |
|
|
|
Bei mir klappt das nicht, weil Mono eine NotImplemented Exception wirft. Da du unter Windows arbeitest, könnte es aber klappen.
code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
|
using System;
using System.Linq;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;
using System.Windows.Forms.DataVisualization.Charting;
class Collatz
{
static int Steps(long n) {
int result = 0;
while (n > 1) {
if (n % 2 == 0)
n /= 2;
else {
n = 3 * n + 1;
result++;
}
}
return result;
}
static void Main() {
List<int> zerfall = new List<int> ();
for (int i = 1; i < 1024; i += 2) {
int tmp = Steps (i);
while (zerfall.Count <= tmp)
zerfall.Add (0);
zerfall [tmp]++;
}
Chart chart = new Chart ();
Series series = new Series ();
for (int i = 0; i < zerfall.Count; i++) {
Console.WriteLine (i + ": " + zerfall [i]);
series.Points.AddXY (i, zerfall [i]);
}
chart.Series.Add (series);
Form form = new Form ();
chart.Dock = DockStyle.Fill;
chart.Parent = form;
form.Width = zerfall.Count;
form.Height = zerfall.Max ();
form.ShowDialog ();
}
} |
|
__________________ Syntax Highlighting fürs Board (Link)
|
|
20.11.2016 18:29 |
|
|
|
Hallo,
um die Mengen, Gruppen und Klassen noch ein wenig weiter durchsuchen zu können suche ich ein einfaches Programm folgender Struktur für c-sharp
1. Ich starte mit einer beliebigen positiven ganzen Zahl n.
2. Nun werden nacheinander die 3 Operationen , und durchprobiert bis die erste Operation gefunden ist die auf eine neue ganze Zahl führt.
3. Nun wird mit dieser neuen gefunden Zahl wieder wie in Schritt 2 verfahren.
In der Konsole sollen dann diese ganzen Zahlen aufgelistet werden.
Parameter des Algorithmus sind dann die Startzahl n und wie oft Schritt 2 wiederholt wird...
__________________ Gruß blindmessenger
|
|
23.11.2016 16:16 |
|
|
|
Wäre es nicht einfacher, selbst die Grundlagen des Programmierens zu lernen?
code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
|
using System;
using System.Linq;
using System.Collections.Generic;
class Player
{
static void Main(string[] args)
{
Console.Write ("Startwert: ");
long n = long.Parse (Console.ReadLine ());
Console.Write ("maximale Schritte: ");
int steps = int.Parse (Console.ReadLine ());
HashSet<long> numbers = new HashSet<long>();
for (int i = 0; i < steps && !numbers.Contains(n); i++) {
numbers.Add (n);
if ((2 * n - 1) % 3 == 0)
n = (2 * n - 1) / 3;
else if ((4 * n - 1) % 3 == 0)
n = (4 * n - 1) / 3;
else
n = 4 * n + 1;
Console.Write (n + " ");
}
Console.WriteLine ();
}
} |
|
__________________ Syntax Highlighting fürs Board (Link)
|
|
23.11.2016 22:16 |
|
|
|
Ich gebe Dir recht... Ich muss mich da mal ein bisschen reinarbeiten...
__________________ Gruß blindmessenger
|
|
23.11.2016 23:07 |
|
|
|
Ich habe mir ein Streichalgorithmus überlegt, den ich aber nicht beweisen kann der aber bisher für kleinere Zahlen bis 1024"empirisch" funktioniert.
Es geht darum Collatzreihen auf andere Collatzreihen zurückzuführen, genauer gesagt gemeinsame Elemente zu finden. Sobald also zwei Reihen ein gemeinsames Element besitzen, dann haben sie auch dasselbe Ende, und man bracht nicht mehr beide Reihen zu testen sondern nur noch eine von beiden.
Als aller erstes streichen wir mal alle geraden Zahlen, weil wir ja wissen, dass diese immer nach endlichen Schritten bei einer ungeraden Zahl landen.
Nun teilen wir die verbleibenden ungeraden Zahlen in zwei Restklassen ein. Einmal in die Restklasse 4k+1 und einmal in die Restklasse 4k+3.
Mit dem Bild 4k+3 möchte ich zeigen, dass die Reihen der StartZahlen der Form 4k+3 immer auch in Reihen der Startzahlen der Form 4k+1 landen. Folgende Schritte werden hier angewendet:
1. Zahlen der Form 4k+3 werden einer Spalte aufgelistet und nach rechts gemäß des Collatzalgorithmus (nur mit ungeraden Zahlen) aufgereiht, bis ein Zahl entsteht die kleiner ist als ihre VorgängerZahl.
2. Es entstehen somit Verschieden lange Reihen. Jede zweite Reihe hat genau 3 Elemente. Nun ist die Idee, dass man die Folgen die mehr als drei Elemente besitzen streichen kann, weil sie immer auch in Folgen mit genau drei Elementen landen.
3. Nachdem wir diese längeren Folgen gestrichen haben, bleiben also nur Folgen mit genau drei Elementen. Nun wird die komplette erste Spalte gestrichen. Also immer das erste Element jeder Folge.
Nun ist zu sehen, dass die ersten Elemente dieser verbleibenden Folgen alle von der Form 8k+1 sind. Da lassen sich somit alle Zahlen der Form 4k+3 auf die Zahlen der Form 4k+1 zurückführen.
Also können wir 4k+3 auch abhacken und uns auf 4k+1 konzentrieren. Mit Bild 4k+1 will ich nun zeigen, dass durch mehrmaliges Wiederholen eines Streichzykluses Folgen auf immer größere Restklassen zurückgeführt werden.
Vorbereitung:
Zahlen der Form 4k+1 werden in einer Spalte aufgelistet und nach rechts gemäß des Collatzalgorithmus (nur mit ungeraden Zahlen) aufgereiht, bis ein Zahl entsteht die kleiner ist als ihre VorgängerZahl.
In diesem Fall (Und wohl in keinem anderen...) brechen alle Folgen beim zweiten Element ab. Interessanterweise: Wenn man diese zweiten Elemente auflisten würde, ergibt sich die OEIS Folge A067745.
Nun wird in 3 Schritten vorgegangen:
1. Schritt: Folgen neu aufbauen
Wir streichen das erste Element (somit die komplette erste Spalte) dieser 2er Folgen und lassen wieder nach dem Collatzalgorithmus neu entwickeln bis eine Zahl erreicht ist die kleiner als ihr Vorgänger ist.
2. Schritt: Gleiche Folgen streichen
Im zweiten Schritt werden aus den gerade neu aufgebauten Folgen, Folgen heraus gestrichen die mehrfach vorkommen. In diesem Fall ergibt sich, dass jede 4. Folge gestrichen werden kann.
3. Schritt: Folgen mit mehr als 2 Elementen streichen
Der dritte Schritt besteht darin, Folgen zu streichen die mehr als 2 Elemente beinhalten. Die Idee dahinter: Man kann empirisch für ein endliches Intervall nachweisen, dass alle Folgen mit mehr als 2 Elementen in Folgen mit genau 2 Elementen übergehen.
Nun ist ein Zyklus abgeschlossen. Nach mehrmaligen Wiederholen dieses Zykluses lassen sich so für beliebig große Restklassen zeigen, dass sie gemeinsame Elemente haben.
Mit diesem Siebalgorithmus ist natürlich noch keine Aussage darüber zu treffen ob alle Zahlen immer bei der 1 landen, aber es ist schon interessant, dass man im Grenzwert beliebig viel Folgen auf immer größere (im Grenzwert unendlich große) Restklassen zurückführen kann.
Das Problem an der ganzen Sache ist, dass ich mir nicht sicher bin, ob es zulässig ist immer Folgen zu streichen die mehr als zwei Elemente haben. Ich habe das nur empirisch für wenige Zahlen mit Excel überprüft.
Hat jemand eine Idee wie man den Streichalgorithmus programmieren kann, der dann aber auch gleichzeitig überprüft, ob und wie man Folgen mit mehr als zwei Elementen auch immer streichen kann?
Die Challenge wäre also ein Beweis, dass das Sieb auch immer zulässig ist...
blindmessenger hat diese Bilder (verkleinerte Versionen) angehängt:
__________________ Gruß blindmessenger
Dieser Beitrag wurde 3 mal editiert, zum letzten Mal von blindmessenger: 02.12.2016 13:35.
|
|
02.12.2016 13:26 |
|
|
|