Die Mathe-Redaktion - 19.04.2018 15:30 - Registrieren/Login
Auswahl
ListenpunktHome
ListenpunktAktuell und Interessant ai
ListenpunktArtikelübersicht/-suche
ListenpunktAlle Links / Mathe-Links
ListenpunktFach- & Sachbücher
ListenpunktMitglieder / Karte
ListenpunktRegistrieren/Login
ListenpunktArbeitsgruppen
ListenpunktSchwätz / Top 15
ListenpunktWerde Mathe-Millionär!
ListenpunktAnmeldung MPCT Juli
ListenpunktFormeleditor fedgeo
Aktion im Forum
Suche
Stichwortsuche in Artikeln und Links von Matheplanet
Suchen im Forum
Suchtipps

Bücher
Englische Bücher
Software
Suchbegriffe:
Mathematik bei amazon
Naturwissenschaft & Technik
In Partnerschaft mit Amazon.de
Kontakt
Mail an Matroid
[Keine Übungsaufgaben!]
Impressum

Bitte beachten Sie unsere Nutzungsbedingungen, die Distanzierung, unsere Datenschutzerklärung und
die Forumregeln.

Sie können Mitglied werden oder den Newsletter bestellen.

Der Newsletter Okt. 2017

Für Mitglieder
Mathematisch für Anfänger
Wer ist Online
Aktuell sind 617 Gäste und 26 Mitglieder online.

Sie können Mitglied werden:
Klick hier.

Über Matheplanet
 
Zum letzten Themenfilter: Themenfilter:
Matroids Matheplanet Forum Index
Moderiert von matph
Informatik » Programmieren » PARI/GP: Sieb für eine modifizierte Collatzsequenz
Druckversion
Druckversion
Antworten
Antworten
Autor
Kein bestimmter Bereich PARI/GP: Sieb für eine modifizierte Collatzsequenz
blindmessenger
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2016
Mitteilungen: 806
Aus: NRW
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Themenstart: 2018-03-29 19:29

\(\begingroup\)
Hallo,
ich würde gerne diesen Standard Collatz Code

PARI
show(n)={
  my(t=1);
  while(n>1,
    print1(n",");
    n=if(n%2,
      3*n+1
    ,
      n/2
    );
    t++
  );
  print(1);
  t
};
 
len(n)={
  my(t=1);
  while(n>1,
    if(n%2,
      t+=2;
      n+=(n>>1)+1
    ,
      t++;
      n>>=1
    )
  );
  t
};
 
show(27)
r=0;for(n=1,1e5,t=len(n);if(t>r,r=t;ra=n));print(ra"\t"r)

etwas modifizieren.

Es sollen nur die ungeraden Zahlen einer Collatzsequenz ausgegeben werden und über einen Parameter $a$ soll die Länge der Sequenz definierbar sein. Wenn für $a=1$ eingegeben wird, dann stoppt die Sequenz genau dann wenn das erste Mal eine ungerade Zahl erreicht ist die kleiner ist als ihr Vorgänger. Wenn für $a=2$ eingegeben wird, dann stoppt die Sequenz wenn das zweite Mal eine ungerade Zahl erreicht wird die kleiner ist als ihr Vorgänger usw.. Zu guter Letzt soll der Code dann entscheiden (mit einer 1 oder 0 ) ob die Sequenz einen bestimmte Länge überschreitet oder nicht:

Für $a=1$ darf die Sequenz maximal 2 Elemente besitzen.

Für $a=2$ darf die Sequenz maximal 3 Elemente besitzen.

Für $a=3$ darf die Sequenz maximal 4 Elemente besitzen.

usw.

Also wenn die Sequenz länger ist soll die Ausgabe 0 sein ansonsten 1.

Um eventuell ein Collatz-Pattern zu erkennen müsste man dann Intervalle betrachten können wie z.B.

Gebe mir für $a=3$ die Ausgabe für die Startzahlen 1 bis 1.000.000 als Liste...

Hat jemand eine Idee dazu?



-----------------
Gruß blindmessenger
\(\endgroup\)


  Profil  Quote  Link auf diesen Beitrag Link
blindmessenger
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2016
Mitteilungen: 806
Aus: NRW
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.1, vom Themenstarter, eingetragen 2018-04-01 12:07


Interessant dabei ist, dass nach jedem Siebdurchgang immer ganz bestimmte Restklassen überbleiben sollten...

Nach einem Siebdurchgang sollte eine Restklasse überbleiben...

Nach zwei Siebdurchgängen sollten 3 Restklassen überbleiben...

Nach drei Siebdurchgängen sollten 13 Restklassen überbleiben...

Um die Sequenz 1, 3, 13,... weiter zu führen bräuchte man diesen Code...

Dann könnte man die Sequenz mal im oeis nachschlagen...

Vielleicht ergibt sich etwas...


-----------------
Gruß blindmessenger



  Profil  Quote  Link auf diesen Beitrag Link
matph
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 20.11.2006
Mitteilungen: 5333
Aus: A
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.2, eingetragen 2018-04-05 17:48

\(\begingroup\)
Hallo,

Wenn ich dich richtig verstehe, möchtest du eine Liste aller ungeraden Zahlen einer Collatz-Folge so filtern, dass nur jene Elemente enthalten sind, welche kleiner sind als ihr Vorgänger, dies geht z.B. wie folgt: smile
Haskell
main = mapM_ print $ take 20 $ yourEval $ oddCol 27
 
yourEval (x:xs) = f x xs where
  f y (x:xs) 
    | x<=y      = x:f x xs
    | otherwise =   f x xs
  f _ _ = []
 
oddCol = filter odd . col
 
col = iterate f where
  f n | even n    = n`quot`2 
      | otherwise = 3*n+1

31
121
91
103
175
445
167
283
319
911
577
433
325
61
23
5
1
1
1
1
Ausgabe

--
mfg
matph


-----------------
Wir müssen wissen, wir werden wissen. Hilbert
Das Buch der Natur ist in der Sprache der Mathematik geschrieben. Galilei
\(\endgroup\)


  Profil  Quote  Link auf diesen Beitrag Link
blindmessenger
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2016
Mitteilungen: 806
Aus: NRW
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.3, vom Themenstarter, eingetragen 2018-04-05 18:16


O.K. Sorry... Ich glaube ich habe mich nicht klar genug ausgedrückt... Es ist eigentlich noch einfacher:

Zur Ein und Ausgabe:

Die Eingabe ist die Startzahl und ein Parameter.

Die Ausgabe soll nur Wahr (1) oder falsch (0) sein!



Beispiel 1:

Eingabe:

Startzahl: n=27 Parameter: a=1

Ausgabe:

0

Warum?

Wir überprüfen ob die Collatzsequenz in einem ungeraden Schritt (a=1) bei einer kleineren Zahl endet. Nach der 27 kommt die 41 deshalb ist die Ausgabe falsch also 0.



Beispiel 2:

Eingabe:

Startzahl: n=17 Parameter: a=1

Ausgabe:

1

Wir überprüfen ob die Collatzsequenz in einem ungeraden Schritt (a=1) bei einer kleineren Zahl endet. Nach der 17 kommt die 13 deshalb ist die Ausgabe wahr also 1.



Beispiel 3:

Eingabe:

Startzahl: n=45 Parameter: a=2

Ausgabe:

1

Wir überprüfen ob die Collatzsequenz in zwei aufeinander folgenden ungeraden Schritten (a=2) beide Male bei einer Zahl endet die kleiner ist als ihr Vorgänger. Nach der 45 kommt die 17 und dann die 13. Zweimal hintereinander entsteht also eine kleinere Zahl deshalb ist die Ausgabe wahr also 1.

Anders gesprochen: Für z.B. a=5 muss 5 mal hintereinander eine ungerade Zahl entstehen die kleiner ist als ihre Vorgängerzahl damit die Ausgabe wahr also 1 ist. Das trifft z.B. auf die 321 zu:

321, 241, 181, 17, 13, 5




-----------------
Gruß blindmessenger



  Profil  Quote  Link auf diesen Beitrag Link
matph
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 20.11.2006
Mitteilungen: 5333
Aus: A
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.4, eingetragen 2018-04-05 20:01

\(\begingroup\)
Hallo,

In diesem Falls liefert:
Haskell
import Control.Applicative
import System.Environment
 
main = do 
  [n,a] <- getArgs
  let a1 = read a + 1
  print $ allSorted $ take a1 $ oddCol $ read n
 
allSorted = and . (zipWith (>=) <*> tail)
 
oddCol = filter odd . col
 
col = iterate f where
  f n | even n    = n`quot`2 
      | otherwise = 3*n+1
das gewünschte Ergebnis smile

--
mfg
matph


-----------------
Wir müssen wissen, wir werden wissen. Hilbert
Das Buch der Natur ist in der Sprache der Mathematik geschrieben. Galilei
\(\endgroup\)


  Profil  Quote  Link auf diesen Beitrag Link
blindmessenger
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2016
Mitteilungen: 806
Aus: NRW
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.5, vom Themenstarter, eingetragen 2018-04-05 20:30


Ja besten Dank...


-----------------
Gruß blindmessenger



  Profil  Quote  Link auf diesen Beitrag Link
blindmessenger
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2016
Mitteilungen: 806
Aus: NRW
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.6, vom Themenstarter, eingetragen 2018-04-06 15:19

\(\begingroup\)
Ich habe mir Haskell heruntergeladen und in die Kommandozeile folgendes hineinkopiert und mit return bestätigt:
Haskell
import Control.Applicative
import System.Environment
 
main = do 
  [27,4] <- getArgs
  let a1 = read a + 1
  print $ allSorted $ take a1 $ oddCol $ read n
 
allSorted = and . (zipWith (>=) <*> tail)
 
oddCol = filter odd . col
 
col = iterate f where
  f n | even n    = n`quot`2 
      | otherwise = 3*n+1
Hat nicht funktioniert... Was mache ich falsch?

Wäre es möglich, dass in der Eingabe nicht nur eine Startzahl eingegeben werden kann sondern ein Intervall. Z.B.: Gebe mir die Ausgabe für die Startzahlen 1-1.000.000 für a=4... Ist das möglich? Am Besten in einer txt Datei ausgegeben?


-----------------
Gruß blindmessenger
\(\endgroup\)


  Profil  Quote  Link auf diesen Beitrag Link
matph
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 20.11.2006
Mitteilungen: 5333
Aus: A
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.7, eingetragen 2018-04-06 15:38


Hallo,
Haskell
import Control.Applicative
import System.Environment
 
main = do 
  [n1,n2,a] <- getArgs
  let a1 = read a + 1
  mapM_ (print . allSorted . take a1 . oddCol) [read n1..read n2]
 
allSorted = and . (zipWith (>=) <*> tail)
 
oddCol = filter odd . col
 
col = iterate f where
  f n | even n    = n`quot`2 
      | otherwise = 3*n+1
prog.hs

Erstelle Executable via:
ghc --make prog.hs
Aufruf mittels:
prog.exe nLowerBound nUpperBound a
oder
prog.exe nLowerBound nUpperBound a > ausgabe.txt

--
mfg
matph


-----------------
Wir müssen wissen, wir werden wissen. Hilbert
Das Buch der Natur ist in der Sprache der Mathematik geschrieben. Galilei



  Profil  Quote  Link auf diesen Beitrag Link
blindmessenger
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2016
Mitteilungen: 806
Aus: NRW
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.8, vom Themenstarter, eingetragen 2018-04-09 20:42


O.K. Ich habe jetzt das Programm in eine txt. Datei kopiert und dann mit speichern unter als .hs Datei abgespeichert... Wenn ich nun diese Datei öffne dann schreibt er folgendes:

GHCi, version 8.2.2: www.haskell.org/ghc/  :? for help
[1 of 1] Compiling Main             ( C:\Program Files\Haskell Platform\8.2.2\bin\collatz.hs, interpreted )
Ok, one module loaded.
*Main>

Wie lasse ich ihn jetzt berechnen? Ich habe folgendes probiert:

do [1,1000,4]

oder nur

[1,1000,4]

...



-----------------
Gruß blindmessenger



  Profil  Quote  Link auf diesen Beitrag Link
Slash
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 23.03.2005
Mitteilungen: 6394
Aus: New York
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.9, eingetragen 2018-04-09 21:43


@ bm

Verräts du uns worauf du hinaus willst, oder ist das nur eine allgemeine Untersuchung?


-----------------
Difficilia quae pulchra



  Profil  Quote  Link auf diesen Beitrag Link
blindmessenger
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2016
Mitteilungen: 806
Aus: NRW
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.10, vom Themenstarter, eingetragen 2018-04-09 21:59


Es geht um diesen Thread hier:

LinkCollatzsieb

Nach jedem Siebschritt bleiben bestimmte Restklassen übrig... Mit einem Programm kann man dann weitaus tiefer sieben... Ich wollte nur mal sehen was dann noch für Restklassen entstehen...


-----------------
Gruß blindmessenger



  Profil  Quote  Link auf diesen Beitrag Link
matph
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 20.11.2006
Mitteilungen: 5333
Aus: A
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.11, eingetragen 2018-04-11 13:30


Hallo,

Du kannst im Interpreter die Funktionen direkt aufrufen, oder du gehst vor wie in Beitrag No.7 beschienen smile
Eingabeaufforderung: Start <math>\rightarrow</math> Ausführen <math>\rightarrow</math> cmd <Return> und wechselst du in das entsprechende Verzeichnis in dem du das Programm abgespeichert hast und erstellst das fertige Programm ghc --make prog.hs...

--
mfg
matph


-----------------
Wir müssen wissen, wir werden wissen. Hilbert
Das Buch der Natur ist in der Sprache der Mathematik geschrieben. Galilei



  Profil  Quote  Link auf diesen Beitrag Link
blindmessenger
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2016
Mitteilungen: 806
Aus: NRW
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.12, vom Themenstarter, eingetragen 2018-04-11 22:38


2018-04-11 13:30 - matph in Beitrag No. 11 schreibt:
Hallo,

Du kannst im Interpreter die Funktionen direkt aufrufen, oder du gehst vor wie in Beitrag No.7 beschienen smile
Eingabeaufforderung: Start <math>\rightarrow</math> Ausführen <math>\rightarrow</math> cmd <Return> und wechselst du in das entsprechende Verzeichnis in dem du das Programm abgespeichert hast und erstellst das fertige Programm ghc --make prog.hs...

--
mfg
matph

Klasse... Habe das Programm zum laufen bekommen...

Wäre es möglich noch eine kleine Änderung vorzunehmen?

Es geht um folgendes:

Beispiel:

Startzahl n = 53 Parameter a = 3

In Deinem Code wird bei dieser Eingabe als Ausgabe True angegeben...

Es müsste aber eigentlich False sein ...

Warum?

Die Sequenz ergibt in 3 Schritten:

53, 5, 1, 1

Sobald eine Sequenz aber das zweite mal die 1 erreicht hat müsste sie dann False sein, weil ja nach der ersten 1 auch keine kleinere Zahl mehr erreicht wird.

Wenn für dieses Beispiel allerdings a = 2 wäre, also folgende Sequenz betrachtet würde

53, 5, 1

dann wäre die Ausgabe dann True...






-----------------
Gruß blindmessenger



  Profil  Quote  Link auf diesen Beitrag Link
matph
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 20.11.2006
Mitteilungen: 5333
Aus: A
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.13, eingetragen 2018-04-12 15:56


Hallo,

Schreibe > statt >= in allSorted: smile
allSorted = and . (zipWith (>) <*> tail)

--
mfg
matph


-----------------
Wir müssen wissen, wir werden wissen. Hilbert
Das Buch der Natur ist in der Sprache der Mathematik geschrieben. Galilei



  Profil  Quote  Link auf diesen Beitrag Link
blindmessenger
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2016
Mitteilungen: 806
Aus: NRW
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.14, vom Themenstarter, eingetragen 2018-04-12 17:32


Ja... Das sieht sehr gut aus... Funkioniert... Danke Dir!


-----------------
Gruß blindmessenger



  Profil  Quote  Link auf diesen Beitrag Link
blindmessenger
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2016
Mitteilungen: 806
Aus: NRW
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.15, vom Themenstarter, eingetragen 2018-04-14 11:28


Sorry, das ich hier so rumnerve aber es gibt noch eine Sache die fehlt (Und ich will auch später erklären warum das wichtig ist...)

Zuerst eine kleine Änderung vorab: Damit diese Änderung funktioniert müssten wir den Code so ändern, dass nur ungerade Startzahlen betrachtet werden...  

Sehen wir uns die ersten Sequenzen mit ungeraden Startzahlen für a = 1 und a = 2 an (Intervall 1-53: Wichtig: Eine sinnvolle Ausgabe für diesen geänderten Code wird es hinterher nur geben, wenn die Intervalle der Startzahlen die mit einer 1 beginnen, betrachtet werden...):



Wie zu sehen entsteht  für a = 1 ein regelmäßiges False-True pattern. Ab a = 2 aber entstehen Mehrfachwerte (siehe rot markierte Felder). Damit wie bei a = 1 für andere a auch ein regelmäßiges Pattern entsteht müssen diese Mehrfachwerte zwingend herausgefischt werden... Der Code muss also für das jeweilige Intervall an Startzahlen einmal nach jedem a auf Mehrfachwerte überprüfen und die Mehrfachwerte dann als False deklarieren sonst entsteht kein pattern...

Hier der Vergleich zwischen pattern für a = 2  mit und ohne Mehrfachwerte:



Bei der Mehrfachwertebereinigten Liste entsteht ein regelmäßiges 2-1 Pattern... Bei dem anderen nicht...

Wäre das möglich diese Mehrfachwerte noch herauszufischen?


-----------------
Gruß blindmessenger



  Profil  Quote  Link auf diesen Beitrag Link
matph
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 20.11.2006
Mitteilungen: 5333
Aus: A
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.16, eingetragen 2018-04-14 14:55


Hallo,

2018-04-14 11:28 - blindmessenger in Beitrag No. 15 schreibt:
Wäre das möglich diese Mehrfachwerte noch herauszufischen?

Was verstehst du unter Mehrfachwerte und was unter herauszufischen confused

--
mfg
matph


-----------------
Wir müssen wissen, wir werden wissen. Hilbert
Das Buch der Natur ist in der Sprache der Mathematik geschrieben. Galilei



  Profil  Quote  Link auf diesen Beitrag Link
blindmessenger
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2016
Mitteilungen: 806
Aus: NRW
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.17, vom Themenstarter, eingetragen 2018-04-14 15:13


Beispiel:

Mit dem bisherigen Code würde für die Startzahl 53 und a = 2 also

53, 5, 1

die Ausgabe True sein, weil zweimal hintereinander eine kleinere Zahl erreicht wird...

Eigentlich müsste es aber False sein!

Warum?

Weil schon die Startzahl 13 für a = 2 auf 5, 1 endet

13, 5, 1

Der Mehrfachwert ist also 5...

Beispiel 2:

Startzahl 69 und a = 2

69, 13, 5

Normalerweise auch wieder True, aber weil für

Startzahl 17 und a = 2

17, 13, 5

auch schon die 13 auftritt muss hier die Ausgabe False sein... Mehrfachwert 13...



-----------------
Gruß blindmessenger



  Profil  Quote  Link auf diesen Beitrag Link
matph
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 20.11.2006
Mitteilungen: 5333
Aus: A
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.18, eingetragen 2018-04-14 16:29


Hallo,

Du möchtest also für jeden Wert einer Folge ni für ein gegebenes a überprüfen, ob der Wert in einer der Folgen für nmin bis ni-1 enthalten ist confused

--
mfg
matph


-----------------
Wir müssen wissen, wir werden wissen. Hilbert
Das Buch der Natur ist in der Sprache der Mathematik geschrieben. Galilei



  Profil  Quote  Link auf diesen Beitrag Link
blindmessenger
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2016
Mitteilungen: 806
Aus: NRW
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.19, vom Themenstarter, eingetragen 2018-04-14 17:51




Für den bisherigen Code reicht es zu überprüfen ob z.B. nach 2 Schritten (a = 2) 3 Elemente existieren oder mehr... Wenn es genau 3 sind dann ist die Ausgabe True ansonsten False...

Wir brauchen aber zusätzlich noch für jeden einzelnen Schritt (a) eine Überprüfung ob wir uns in einer gleichen Sequenz befinden:

Konkret bedeutet das wir müssen die hellblauen Spalten auf doppelte Werte überprüfen und dann wenn ein Wert das zweite mal vorkommt auf False setzen:



Ich fürchte das bedeutet eine etwas umfangreichere Änderung :-(

 




-----------------
Gruß blindmessenger



  Profil  Quote  Link auf diesen Beitrag Link
matph
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 20.11.2006
Mitteilungen: 5333
Aus: A
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.20, eingetragen 2018-04-14 17:58


Hallo,

Die Änderungen sind höchst wahrscheinlich simpel, doch ich verstehe noch nicht, um was es dir geht...

Du schreibst z.B. für Startzahl 13 Wahr, obwohl 5,1 bereits für n=3 auftritt, ebenso trivialerweise in n=5, genau wie die 1 natürlich generell bereits in n=1,... wink

Wie ist deine Definition von Mehrfachwert confused

--
mfg
matph


-----------------
Wir müssen wissen, wir werden wissen. Hilbert
Das Buch der Natur ist in der Sprache der Mathematik geschrieben. Galilei



  Profil  Quote  Link auf diesen Beitrag Link
blindmessenger
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2016
Mitteilungen: 806
Aus: NRW
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.21, vom Themenstarter, eingetragen 2018-04-14 18:18


2018-04-14 17:58 - matph in Beitrag No. 20 schreibt:

Du schreibst z.B. für Startzahl 13 Wahr, obwohl 5,1 bereits für n=3 auftritt, ebenso trivialerweise in n=5, genau wie die 1 natürlich generell bereits in n=1,... wink


Das ist richtig... Nur da die Startzahl 3 bei a = 1 schon auf False gesetzt wird, wird diese Startzahl bei a = 2 gar nicht mehr für Mehrfachwerte betrachtet


-----------------
Gruß blindmessenger



  Profil  Quote  Link auf diesen Beitrag Link
matph
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 20.11.2006
Mitteilungen: 5333
Aus: A
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.22, eingetragen 2018-04-14 18:22


Hallo,

Auch wenn du nur Zahlen aufnimmst, für welche die Sequenz strikt monoton fallend ist, erklärt z.B. deinen Wert Wahr für n=17 nicht, die Sequenz wäre 17,13,5 wobei 13 und 5 bereits in n=13 vorkommen wink

--
mfg
matph


-----------------
Wir müssen wissen, wir werden wissen. Hilbert
Das Buch der Natur ist in der Sprache der Mathematik geschrieben. Galilei



  Profil  Quote  Link auf diesen Beitrag Link
blindmessenger
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2016
Mitteilungen: 806
Aus: NRW
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.23, vom Themenstarter, eingetragen 2018-04-14 18:38


Wichtig ist, dass wir nicht alle Elemente einer Sequenz vergleichen sondern nur die Spalte die ich in Beitrag 19 hellblau markiert habe und auch nur vergleichen innerhalb einer Spalte.

Die erste Abfrage für a = 1 wäre dann also: Sind innerhalb der ungeraden Zahlen gleiche Werte? Kann ja nicht, deshalb werden für a = 1 keine gleichen Werte gefunden...

Für a = 2 allerdings tauchen in der hellblauen Spalte dann das erste Mal gleiche Werte auf... Nämlich die 1, die 7 und die 5 im Intervall 1-53 wohlgemerkt...

Die zusätzliche Abfrage zum Code für z.B. a = 3 sähe dann so aus:

Prüfe in der ersten hellblauen Spalte auf gleiche Werte...

Prüfe in der zweiten hellblauen Spalte auf gleiche Werte...

Prüfe in der dritten hellblauen Spalte auf gleiche Werte...


-----------------
Gruß blindmessenger



  Profil  Quote  Link auf diesen Beitrag Link
matph
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 20.11.2006
Mitteilungen: 5333
Aus: A
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.24, eingetragen 2018-04-14 18:57

\(\begingroup\)
Hallo,

Was ist das System hinter hellblauen Spalten confused

Falls du alle positionsabhängig vergleichen möchtest (also alle Spalten hellblau markieren), könntest du dies wie folgt schreiben:
Haskell
import Control.Applicative
import System.Environment
import qualified Data.Set as Set
 
main = do 
  [n1,n2,a] <- getArgs
  mapM_ print $ f (read a + 1) (read n1) (read n2)
 
f a n1 n2 = g [n1..n2] Set.empty where
  g [] set = []
  g (n:ns) set = (n,b):g ns setN  where
    xs = oddA n
    zxs = zip [1..] xs
    allS = allSorted xs
    setN = if allS then Set.union set $ Set.fromList zxs else set
    b = allS && all (flip Set.notMember set) zxs
  oddA = take a . oddCol
 
allSorted = and . (zipWith (>) <*> tail)
 
oddCol = filter odd . col
 
col = iterate f where
  f n | even n    = n`quot`2 
      | otherwise = 3*n+1
Deine Einschränkungen sind allerdings ziemlich willkürlich wink

--
mfg
matph


-----------------
Wir müssen wissen, wir werden wissen. Hilbert
Das Buch der Natur ist in der Sprache der Mathematik geschrieben. Galilei
\(\endgroup\)


  Profil  Quote  Link auf diesen Beitrag Link
blindmessenger
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2016
Mitteilungen: 806
Aus: NRW
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.25, vom Themenstarter, eingetragen 2018-04-14 20:01


Sorry, muss jetzt weg... Melde mich später...


-----------------
Gruß blindmessenger



  Profil  Quote  Link auf diesen Beitrag Link
blindmessenger
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2016
Mitteilungen: 806
Aus: NRW
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.26, vom Themenstarter, eingetragen 2018-04-14 23:20


2018-04-14 18:57 - matph in Beitrag No. 24 schreibt:

Deine Einschränkungen sind allerdings ziemlich willkürlich wink


Eigentlich sollten sie das nicht sein... wink

O.K. Ich versuche es nochmal anders:



In der ersten Spalte des ersten Blocks (a = 1) sind unsere Startzahlen. In der zweiten Spalte des ersten Blocks wird die nächste ungerade Zahl der Collatzsequenz eingetragen.

Wenn in der zweiten Spalte eine größere Zahl steht als in der ersten Spalte dann ist die Startzahl false. Wenn in der zweiten Spalte eine kleinere Zahl steht, dann ist die Startzahl True...

Soweit so gut...

Nun soll der Code noch prüfen ob in der ersten Spalte Werte sind die mehrfach vorkommen und diese dann auch als false deklarieren. Da wir hier aber eh nur die ungeraden Zahlen aufgeführt haben, wird in dieser Spalte natürlich nichts gefunden...

Wie entsteht nun die zweite blaue Spalte?

Ganz einfach: Wir bilden einen Block für a = 2 indem wir die Zahlen aus der zweiten Spalte des ersten Blocks in die erste Spalte des zweiten Blocks übertragen. Wichtig: Es werden nur die Zahlen übertragen, die im vorherigen Block in einer "True- Sequenz" standen. Nun wird in der nächsten Spalte wieder die nächste ungerade Zahl eingetragen und als False oder True bewertet. Jetzt wird die erste Spalte des zweiten Blocks auf Mehrfachwerte überprüft... Hier entstehen tatsächlich welche: Für das Intervall 1-53 sind das dann die 1,5 und 7...

Der nächste Block wird gebildet und es geht wieder von vorne los...


-----------------
Gruß blindmessenger



  Profil  Quote  Link auf diesen Beitrag Link
blindmessenger
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2016
Mitteilungen: 806
Aus: NRW
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.27, vom Themenstarter, eingetragen 2018-04-15 17:22


Vielleicht muss der COde auch etwas umgestrickt werden wie folgt:

Ein und Ausgabe können so bleiben...

Beispiel:

Startzahlintervall 1-54 für a = 4


Durchgang für a = 1


1. Erstelle für die ungeraden Zahlen bis 54 eine Liste 1.

2. Untersuche ob die Liste 1 doppelte Werte enthält und setze diese auf false...

3. Erstelle eine Liste 2 mit der nächsten ungeraden Zahl der Collatzfolge.

4. Untersuche ob die Zahlen der Liste 2 kleiner oder größer geworden sind als die der Liste 1 und entscheide auf false oder true.


Durchgang für a = 2

1. Baue eine neue  Liste 3 indem die Werte aus der  Liste 2 genommen werden abzgl. der False Sequenzen.

2. Untersuche ob die Liste 3 Mehrfachwerte enthält und setze diese auf false...

3. Erstelle eine Liste 4 mit der nächsten ungeraden Zahl der Collatzfolge.

4. Untersuche ob die Zahlen der Liste 4 kleiner oder größer geworden sind als die der Liste 3 und entscheide auf false oder true.


Durchgang für a = 3

1. Baue eine neue  Liste 5 indem die Werte aus der  Liste 4 genommen werden abzgl. der False Sequenzen.

2. Untersuche ob die Liste 5 Mehrfachwerte enthält und setze diese auf false...

3. Erstelle eine Liste 6 mit der nächsten ungeraden Zahl der Collatzfolge.

4. Untersuche ob die Zahlen der Liste 6 kleiner oder größer geworden sind als die der Liste 5 und entscheide auf false oder true.


Durchgang für a = 4

1. Baue eine neue  Liste 7 indem die Werte aus der  Liste 6 genommen werden abzgl. der False Sequenzen.

2. Untersuche ob die Liste 7 Mehrfachwerte enthält und setze diese auf false...

3. Erstelle eine Liste 8 mit der nächsten ungeraden Zahl der Collatzfolge.

4. Untersuche ob die Zahlen der Liste 8 kleiner oder größer geworden sind als die der Liste 7 und entscheide auf false oder true.


Die Ausgabe sollte dann sein: Bis 53 alles False mit Ausnahme der 45...















-----------------
Gruß blindmessenger



  Profil  Quote  Link auf diesen Beitrag Link
matph
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 20.11.2006
Mitteilungen: 5333
Aus: A
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.28, eingetragen 2018-04-16 01:42


Hallo,

Dieses Ergebnis erhältst du mit dem Code aus Beitrag No.24 wink

--
mfg
matph


-----------------
Wir müssen wissen, wir werden wissen. Hilbert
Das Buch der Natur ist in der Sprache der Mathematik geschrieben. Galilei



  Profil  Quote  Link auf diesen Beitrag Link
blindmessenger
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 02.08.2016
Mitteilungen: 806
Aus: NRW
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.29, vom Themenstarter, eingetragen 2018-04-16 18:19


Es ist noch ein kleiner Fehler drinne:

Für a = 2 müsste die Startzahl 113 eigentlich True sein ist aber False...

Ich glaube ich weiß warum: Damit der Algorithmus funktioniert sollten nur ungerade Startzahlen betrachtet werden... Ich habe folgendes probiert:
haskell
[2*n1-1,2*n2-1,a] <- getArgs

Hat leider nicht funktioniert...

Hast Du eine Idee?



-----------------
Gruß blindmessenger



  Profil  Quote  Link auf diesen Beitrag Link
matph
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 20.11.2006
Mitteilungen: 5333
Aus: A
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.30, eingetragen 2018-04-17 02:22


Hallo,

Falls du nur ungerade Startzahlen betrachten möchtest, schreibe
[n1,n1+2..n2] statt [n1..n2] beim Aufruf von g, vorausgesetzt n1 ist ungerade smile

--
mfg
matph


-----------------
Wir müssen wissen, wir werden wissen. Hilbert
Das Buch der Natur ist in der Sprache der Mathematik geschrieben. Galilei



  Profil  Quote  Link auf diesen Beitrag Link
blindmessenger hat die Antworten auf ihre/seine Frage gesehen.
Neues Thema [Neues Thema] Antworten [Antworten]    Druckversion [Druckversion]

 


Wechsel in ein anderes Forum:
 Suchen    
 
All logos and trademarks in this site are property of their respective owner. The comments are property of their posters, all the rest © 2001-2018 by Matroids Matheplanet
This web site was made with PHP-Nuke, a web portal system written in PHP. PHP-Nuke is Free Software released under the GNU/GPL license.
Ich distanziere mich von rechtswidrigen oder anstößigen Inhalten, die sich trotz aufmerksamer Prüfung hinter hier verwendeten Links verbergen mögen.
Lesen Sie die Nutzungsbedingungen, die Distanzierung, die Datenschutzerklärung und das Impressum.
[Seitenanfang]