www.jammni.de

Gepostet:
18.07.2012 21:42

Listenelement miteinander multiplizieren

Wie kann man die Liste [1,2,3,4] so multipliezieren 1*2 3*4 -> [2,12] ?

Gepostet:
19.07.2012 08:47

Eine Möglichkeit wäre (gerade Listenlänge vorausgesetzt):


multPairs = snd . foldr f (Nothing,[]) where
  f x (Nothing, rest) = (Just x, rest) 
  f x (Just y, rest) = (Nothing, x*y:rest)

Oder


uninterleave [] = ([],[])
uninterleave [x] = ([x],[])
uninterleave (x:y:zs) = let (xs,ys) = uninterleave zs in (x:xs, y:ys)

multPairs = uncurry (zipWith (*)) . uninterleave

Oder


import Data.List
import Data.Function

multPairs = map (product . (map snd)) . groupBy ((/=) `on` fst) . zip (cycle \"hi\")

Zum Seitenanfang

IKT

Gepostet:
19.07.2012 10:23

Etwas naives, (Voraussetzung ist, dass sich eine gerade Anzahl an Zahlen in der Liste befindet):

foo : [Int,Int] -> [Int,Int]
foo [] = []
foo list = product (take 2 list ) : foo (drop 2 list)

Zum Seitenanfang

Landei

Gepostet:
19.07.2012 23:01

Die Signatur stimmt nicht, und mit Pattern Matching wird es hübscher:


foo :: [Int] -> [Int]
foo (x:y:zs) = x*y : foo zs
foo xs = xs

Oder


multPairs xs = jump $ zipWith (*) xs (tail xs) where
  jump (x:_:xs) = x : jump xs
  jump  xs = xs

Oder


import Data.List

multPairs = unfoldr f where
  f (x:y:zs) = Just (x*y, zs) 
  f _ = Nothing

Die letzte Version gefällt mir bis jetzt am besten, auch wenn es mich etwas wurmt, dass ich noch keinen eleganten Einzeiler gefunden habe.

Zum Seitenanfang

Landei

Gepostet:
20.07.2012 12:51

Auch sehr stylish:


import Control.Applicative

multPairs = zipWith (*) <$> filterIndex even <*> filterIndex odd  where
  filterIndex f = map snd . filter (f . fst) . zip [0..]

Zum Seitenanfang

Xan

Gepostet:
21.07.2012 15:04

vielen Dank

Zum Seitenanfang

Haskell-Forum