2016-11-09 2 views
-3

Ich versuche zuerst, eine Funktion primeTest :: [Bool] zu schreiben, die eine solche erzeugt, dass die n-te Position der Liste True ist, wenn n prim ist, und andernfalls False. Dann möchte ich die Funktion anpassen, um eine unendliche Liste zu erzeugen, so dass die n-te Position das Paar (n; b) ist, wobei der Wert b Wahr ist, wenn n prim ist und andernfalls Falsch.primeTest Funktion Haskell

Hier ist mein Versuch so weit:

primeTest :: [Bool] 
primeTest = if prime then True else False 
+4

Versuchen Sie, eine Funktion 'isPrime :: Int -> Bool 'zu schreiben und dann diese über die natürlichen Zahlen wie folgt abzubilden:' map isPrime [0 ..] '. Das wäre wahrscheinlich nicht sehr effizient (je nachdem, wie Sie es tun), aber es wäre ein Anfang. – jpath

+0

Ihr Versuch funktioniert nicht, weil: 1. Wenn es funktionieren würde, würde es keine Liste von Bools erstellen, aber nur einen Bool. 2. Es gibt keine Konstante (noch Funktion in diesem Sinne) 'prime'. Du meinst wahrscheinlich etwas wie "Ist diese Nummer Prime?". Aber welche Nummer? Schau dir meinen obigen Kommentar an, wie du das ausdrücken kannst. – jpath

+0

jpath Ich habe bereits eine Hauptfunktion und es funktioniert. prime :: Ganze Zahl -> Bool Primzahl n = n> 1 && und [nicht (teilt x n) | x <- [2 .. (n-1)]]] –

Antwort

1

Ich bin nicht sicher, was genau sind Sie mit Ihrem prime Funktion zu tun. Soweit ich weiß, gibt es keine divides Funktion (zumindest in Prelude). Beginnen wir damit, es zu reparieren. Für relativ Primzahlen a und b:

a `mod` b == 0 

Und eine Primzahl n relativ prim ist mit allen Zahlen 2-n-1. Wenn diese Bedingung für jedes a-b Paar gilt, wobei a die betreffende Nummer ist und b die jeweilige Nummer von 2 bis n-1 ist, wissen wir, dass die Nummer prim ist. Sie können dies tatsächlich verkürzen, wenn Sie wollen, aber ich werde das weglassen, da unser Ziel nicht Effizienz ist. So schreiben wir die primes Funktion:

primes :: Integer -> Bool 
primes n = n > 1 && and [ prime n = n > 1 && and [ (n `mod` x) /= 0 | x <- [2..(n-1)] ] 

Wir können dann map unsere Funktion über den Unendlichen eine unendliche Liste von Bools zu produzieren:

map primes [1..] 

Und überprüfen, ob es wie erwartet funktioniert, wir Überprüfen Sie bestimmte Indizes in der Liste:

Um die Funktion anzupassen, um eine Liste von Tupeln mit dem Wert entlang w zurückzugeben

primeTest :: [(Integer,Bool)] 
primeTest = [ (x,prime x) | x <- [1..] ] 

Verwendungsbeispiel: it die Bool, können wir eine Liste Verständnis und unsere aktuelle Funktion

ghci>> primeTest !! 12 -- expecting (13,True) 
(13,True) 

An diesem Punkt, weil ich der Off-by-one-Index macht die Dinge verwirrend denken, ich ‚d primeTest in eine Funktion machen, wie so:

primeTest :: Int -> (Integer, Bool) 
primeTest n = [ (x,prime x) | x <- [1..] ] !! (n-1) 

so können wir es verwenden, um als Argument übergeben die Zahl, die wir überprüfen möchten:

ghci>> primeTest 13 
(13,True)