Mithilfe der map zu ersetzen Elemente einer Liste mit (x-y)*(x-y), wobei y das erste element

Ich habe ein bisschen Hausaufgaben zu tun, und ich bin ein absoluter Neuling auf Haskell. Die Frage, die ich habe Probleme mit ist das schreiben einer Funktion, die eine gegebene ganze Zahl x und eine Liste von ganzen zahlen gelten (x-y)*(x-y) auf jedes element in der Liste und die Ausgabe der neuen Liste, mit y wird jedes element der Eingangs-Liste.

Habe ich eine sehr grobe Idee, die ich mit der map Funktion, aber ich bin mir nicht sicher wie Sie gehen über es.

Schaue ich Beispiele für die Quadratur jedes element in einer Liste und die Art verstehen, wie das funktioniert, aber wie würde ich die Umsetzung der (x-y)*(x-y) mit y wird das aktuelle element komplett verwirrt mich.

squares :: [Int] -> [Int]
squares (x:xs) = x * x : squares xs
squares [] = []

die genaue Frage, die ich mir gesetzt worden ist,

Schreiben Sie eine Funktion rela nimmt als Argumente ein integer - x und eine Liste von Ganzzahlen. Es gibt eine ähnliche Liste, aber wo jedes element y wurde ersetzt durch (x-y)*(x-y) z.B.
Main> rela 2 [3,5,7]
[1,9,25]

Ich habe es geschafft es zum laufen zu bringen nach dem Lesen durch einige Bücher, aber der code, den ich gemacht habe, findet sich das erste element in der Liste. Keine Erklärung warum?

equation1 :: Int -> Int -> Int
equation1 x y = (x-y)*(x-y)
rela :: Int -> [Int] -> [Int]
rela x [] =[]
rela x (y:ys) = [ equation1 x y | y <- ys ]

InformationsquelleAutor blane clorley | 2012-04-14

10

Erste von allen, sollten Sie wahrscheinlich erstellen Sie eine separate Funktion, die tut, was Sie wollen.

z.B.
```
f x y = (x-y)*(x-y)
```
Nun, jedes mal, wenn Sie erstellen eine Funktion in Haskell mit mehreren Parametern, die es eigentlich "Currys" die Funktion, die bedeutet, dass Sie eine neue Funktion, wenn Sie das erste argument für Sie.

So, Sie würden eine neue Funktion dadurch
```
g = f 5
```
Den Ausdruck f 5 ist eigentlich eine Funktion

Und können Sie anwenden eine Anzahl an 'g' und x immer '5'

Also, wenn wir wollen, erstellen Sie eine Funktion, die zwei Parameter nimmt, 'x' und 'y', und gilt (x-y)*(x-y) zu einer Liste, wo y ist das aktuelle element, dann ist alles, was wir tun müssen, ist folgende:
```
f x y = (x-y)*(x-y)
squareDifference x = map (f x) [1,2,3,4]
```
Die Sie verwenden können, durch aufrufen squareDifference 5 oder jede andere Zahl als argument

Einer allgemeineren version, die Ihnen erlauben würde, eine Liste als auch
```
squareDifference x xs = map (f x) xs
```
Denen man call-by-doing squareDifference 3 [1,2,3]
- Vielen Dank für die Beantwortung so schnell, aber nach ein paar versuchen bin ich immer noch ratlos. bin ich auf dem richtigen Weg durch die Nutzung dieser? rela :: (a -> [b]) -> [a] -> [b] f x y = (x-y)*(x-y)
- Was Sie tun möchten, ist das schreiben einer Funktion map, ruft eine Funktion f :: a → b als parameter und wendet Sie auf alle Elemente der Liste, so dass map f [x₀, x₁, x₂, x₃ ..] ≡ [f x₀, f x₁, f x₂, f x₃ ..]. Dann erstellen Sie einfach partiell angewandte Funktion (siehe oben), und rufen Sie map mit ihm. Die Typ-Signatur von rela entspricht concatMap - und das ist nicht wirklich das, was Sie brauchen in diesem Fall.
- Immer noch verloren, Wenn ich Brutal ehrlich muss ich sagen, laienhaft ausgedrückt, ich habe immer nur getan, ein bisschen Programmieren und das war vor Jahren. Ich dachte, Karte fest? wenn ich meine eigene map-Funktion wie würde ich es machen, Holen Sie sich die Funktion?
- Aktualisiert meine Antwort. Hilft das?
- Sie haben bereits f x y = (x - y)^2, das ist eine Funktion vom Typ (für die Einfachheit) Int → Int → Int, map erwartet, dass eine Funktion vom Typ a → b für einige a und b eine Liste von Werten des Typs a (d.h. [a]) und gibt eine Liste von bs. Seit Sie beginnen mit [Int] und wollen, um am Ende mit [Int] zu, haben Sie, um eine Funktion Int → Int. Wenn Sie nur ein argument zu f (wie f 5), erhalten Sie eine Funktion Int → Int mit dem ersten argument fest (in diesem Beispiel 5).
- ja, die Hilfe cheers, nahm nur durch Sie. Gerade bearbeitete meine Frage zu zeigen, die eigentliche Frage, die ich mir gesetzt wurden
- Der entscheidende Punkt zu erinnern ist, dass in Haskell-Funktionen nehmen kann Funktionen Ihre parameter und Funktionen return Funktionen. Wenn Sie sich bewerben weniger Parameter an eine Funktion als Ihr Typ gibt an, Sie bekommen eine Funktion als Wert zurückgeben. z.B. squareDifference 10 :: Num b => [b] -> [b]
InformationsquelleAutor Wes
10

verstehen Sie, lambda-Funktionen?
```
map (\val -> the function) xs
```
ist, was Sie brauchen.

currying ist noch besser, aber nicht so einfach.

edit:

mehr konzeptionelle...

map iteriert durch eine Liste anwenden einer Funktion.
```
map (+ 3) xs
```
verwendet das currying-Technik, die oben erwähnt. man könnte auch:
```
map (\x -> x + 3) xs
```
dasselbe erreichen.
- nope, sorry, das macht keinen Sinn für mich, ich habe versucht, herauszufinden, wie man eine Funktion schreiben, die aufgerufen rela nimmt als Argumente eine ganze Zahl x und eine Liste von Ganzzahlen. Es gibt eine ähnliche Liste, aber wo jedes element y ersetzt werden durch (x-y)*(x-y), und wenn rela 2 [3,5,7] eingegeben wird, in das terminal gibt die neue Liste zurück [1,9,25]. Ich habe über die Hilfe, die oben gegeben aber kann es nicht funktionieren, kannst du helfen?
- warten in den Terminals oder in ghci?
- mit Umarmungen in der Klemme
- paar... Sie hätte-code repa x xs = map (lambda function) xs
- Ich habe gerade ran f x y = (x-y)*(x-y) repa x xs = map f) xs und das hat nicht funktioniert, konnte ich so frech, Sie zu Fragen, für die vollständige Antwort auf die obige Frage und sprechen mich durch Sie? nur mein Dozent ist Weg, die ganze Woche und die Zuordnungen durch die Mitte der Woche und ich habe andere Fragen zu tun, und das ist die Grundlage
- oder zeigen Sie mir eine gute Anleitung für dummy-Neuling Programmierer für haskell?
- learnyouahaskell.com/chapters
InformationsquelleAutor bbrittain

Einfaches Beispiel:

rela :: Int -> [Int] -> [Int]
rela x = map (\y -> (x-y)*(x-y))

Oder vielleicht möchten Sie alle Perversionen? -) Hier sind Sie mit Applicatives:

import Control.Applicative
rela :: Int -> [Int] -> [Int]
rela x = map $ (*) <$> (x-) <*> (x-)

InformationsquelleAutor Danil Onishchenko

Hallo, ich denke mal du meinst diese:

Prelude> let rela n = map (\ x -> (x - n)^2)
Prelude> rela 2  [3,5,7] 
[1,9,25]

InformationsquelleAutor Zacharie 007

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.