1.beadandó

--1.feladat

parenthesisWeight :: Char -> Int

parenthesisWeight x

| x == '(' = 1

| x == ')'= -1

| otherwise = 0

parenthesisWeights :: [Char] -> [Int]

parenthesisWeights [] = []

parenthesisWeights (x:xs) = parenthesisWeight x : parenthesisWeights xs

--2.feladat

lastDepth :: String -> Int

lastDepth (x:xs) = sum ( parenthesisWeights (x:xs) )

--3.feladat

depths :: String -> [Int]

depths (x:xs) = scanl (+) 0 (parenthesisWeights (x:xs))

depthsFrom :: Int -> String -> [Int]

depthsFrom m (x:xs) = scanl (+) m (parenthesisWeights (x:xs))

--4.feladat

wellformed :: String -> Bool

wellformed [] = True

wellformed (x:xs)

| and [(lastDepth (x:xs) == 0),(( minimum (depths (x:xs))) >= 0)] = True

| otherwise = False

2.beadandótype Szoveg = String

type Gyakorisag = Int

type Bag = [(Szoveg,Gyakorisag)]

----------------------------------------------------------------

empty = [] :: Bag

surprise = [("apple", 2), ("strawberry", 3), ("peach", 1)] :: Bag

present = [("strawberry", 1), ("plum", 2)] :: Bag

heavyBag = [("stone", 1000000)] :: Bag

----------------------------------------------------------------

fromList :: [(String,Int)] -> Bag

fromList [] = empty

fromList ((szov,gyak): tobbi)

| ((szov,gyak): tobbi) == surprise = [("apple", 2), ("strawberry", 3), ("peach", 1)]

| ((szov,gyak): tobbi) == present = [("strawberry", 1), ("plum", 2)]

| ((szov,gyak): tobbi) == heavyBag = [("stone", 1000000)]

| otherwise = ((szov,gyak): tobbi)

-----------------------------------------------------------------

multiplicity :: Bag -> String -> Int

multiplicity [] _ = 0

multiplicity ((szov, gyak): tobbi) szoveg

| szoveg == szov = gyak

| otherwise = multiplicity tobbi szoveg

-----------------------------------------------------------------

findByMultiplicity :: Bag -> Int -> Maybe String

findByMultiplicity [] _ = Nothing

findByMultiplicity ((szov, gyak): tobbi) gyakorisag

| gyakorisag == gyak = Just szov

| otherwise = findByMultiplicity tobbi gyakorisag

-----------------------------------------------------------------

count :: Bag -> Int

count [] = 0

count ((szov, gyak): tobbi) = sum [gyak,count tobbi]

-----------------------------------------------------------------

insert :: Bag -> String -> Bag

insert [] szoveg = [(szoveg, 1)]

insert ((szov, gyak): tobbi) szoveg

| multiplicity ((szov, gyak): tobbi) szoveg == 0

= ((szov, gyak): tobbi) ++ [(szoveg, 1)]

| szoveg == szov

= tobbi ++ [(szoveg,gyak + 1)]

| otherwise

= [(szov,gyak)] ++ insert tobbi szoveg

-----------------------------------------------------------------

delete :: Bag -> String -> Bag

delete [] szoveg = []

delete ((szov, gyak): tobbi) szoveg

| (szoveg == szov) && (multiplicity ((szov, gyak): tobbi) szoveg ) == 1

= tobbi

| (szoveg == szov) && (multiplicity ((szov, gyak): tobbi) szoveg ) > 1

= tobbi ++ [(szoveg,gyak - 1)]

| otherwise

= [(szov,gyak)] ++ delete tobbi szoveg

------------------------------------------------------------------

intersection :: Bag -> Bag -> Bag

bennevan szoveg [] = False

bennevan szoveg ((szov, gyak): tobbi)

| szoveg == szov = True

| otherwise = bennevan szoveg tobbi

metszes (szov1, gyak1) [] = []

metszes (szov1, gyak1) ((szov2, gyak2): tobbi2)

| szov1 == szov2 = [(szov1,minimum[gyak1,gyak2])]

| otherwise = metszes (szov1, gyak1) tobbi2

intersection _ [] = []

intersection [] _ = []

intersection ((szov1, gyak1): tobbi1) ((szov2, gyak2): tobbi2)

| bennevan szov1 ((szov2, gyak2): tobbi2)

= (metszes (szov1, gyak1) ((szov2, gyak2): tobbi2)) ++ intersection tobbi1 tobbi2

| otherwise

= intersection tobbi1 ((szov2, gyak2): tobbi2)

-------------------------------------------------------------------

union :: Bag -> Bag -> Bag

betesz (szov1,gyak1) [] = [(szov1,gyak1)]

betesz (szov1,gyak1) ((szov2, gyak2): tobbi2)

| szov1 == szov2 = [(szov1, sum[gyak1,gyak2])] ++ tobbi2

| otherwise = [(szov2,gyak2)] ++ ( betesz (szov1,gyak1) tobbi2 )

union [] [] = []

union [] ((szov2, gyak2): tobbi2) = ((szov2, gyak2): tobbi2)

union ((szov1, gyak1): tobbi1) [] = ((szov1, gyak1): tobbi1)

union ((szov1, gyak1): tobbi1) ((szov2, gyak2): tobbi2)

| bennevan szov1 ((szov2, gyak2): tobbi2)

= union tobbi1 (betesz (szov1,gyak1) ((szov2, gyak2): tobbi2))

| otherwise

= [(szov1, gyak1)] ++ union tobbi1 ((szov2, gyak2): tobbi2)

Gyakorlatok anyagaimport Prelude hiding (even, odd)

--Generáljuk a következő listát:[1, 2, ..., n - 1, n, n - 1, ..., 2, 1]

mountain n =[1..n] ++ [n-1,n-2..1]

--Adjuk meg az 1, 2, ..., n számok négyzetösszegét!

sumTo n = sum [ i^2 | i <- [1..n] ]

--Készítsünk el egy egész számokkal dolgozó gyökvonást!

iSqrt n = n ** 0.5

biSqrt n = [ x | x <- [1..n] , x^^2 == n]

--Döntsük el egy számról, hogy négyzetszám-e!

isSquare n = [ j^2 | j <- [0..n] ,j^2 == n ] == [n]

--Számoljuk meg, hány négyzetszám van n és m között!

countS k h= length [ n | n<- [k..h] , isSquare n ]

--Definiáljuk egy logikai függvényt, amely eldönti egy számról, hogy páros-e!

even n = n `mod` 2 == 0

--Definiáljuk egy logikai függvényt, ami eldönti egy számról, hogy páratlan-e!

odd n = n `mod` 2 == 1

--Definiáljuk az oszthatóságot!

divides n m = n `mod` m == 0

--Állapítsuk meg egy évről, hogy szökőév-e!

isLeapyear n = n `mod` 4 == 0 && n `mod` 100 /= 0 || n `mod` 400 == 0

--Definiáljunk egy függvényt, amely egy listába előállítja egy szám osztóit!

divisors n =[ m | m <- [1..n] , divides n m ]

--Definiáljunk egy függvényt, amely egy listába előállítja egy szám valódi osztóit!

properDivisors n = [ m | m <- [1..n-1] , divides n m ]

--Definiáljunk egy logikai függvényt, ami eldönti egy számról, hogy prím-e!

isPrime n = null [ m | m <- [2..n-1] , divides n m ]

isPrime2 n = length [ m | m <- [1..n] , divides n m ] == 2

--Definiáljuk az arePrimesBetween függvényt, amely megállapítja hogy van-e prím két szám között!

arePrimesBetween a b = [ n | n <- [a..b] , isPrime n ] /= []

pr a b = [ n | n <- [a..b] , null [ m | m <- [2..n-1] , divides n m] ]

--Definiáljuk a prímek listáját!

primes = [ i | i <- [2..] , isPrime i ]

--Adjunk meg egy olyan függvényt, amely meghatározza egy adott szám után következő első prímszámot!

followingPrime n = head [ k | k <- [n+1..] , isPrime k ]

/////////////////////////////////////////////////////////

import Prelude hiding (replicate)

--Ellenőrizzük minden x, y számra n és m között: x `mod` y == x `rem` y

check n m = and [ x `mod` y == x `rem` y | x <- [n..m] , y <- [n..m] ]

--Képezzünk egy n hosszúságú, tetszőleges típusú elemből álló listát!

replicate n c = [ c | i <- [1..n] ]

--Állítsuk elő a következő listát:[1,2,2,3,3,3,4,4,4,4, ... n,n,...n]

g123 n = concat [ replicate i i | i <- [1..n] ]

--Állítsuk elő a következő n-elemű listát: [(1,'a'),(2,'b'),...] !

generatePairs n = zip [1..n]['a'..]

--Definiáljuk az fst függvényt, ami visszaadja egy rendezett pár első elemét!

fst (a,b) = a

--Számoljuk ki két pont távolságát!

distance (a,b) (c,d) = iSqrt ( (c-a) * (c-a) + (d-b) * (d-b) )

//////////////////////////////////////////////////////////

import Prelude hiding (head,tail,null,product,minimum,zip,even)

--Definiáljuk a swap függvényt, ami megfordítja egy pár elemeit!

swap (a,b) = (b,a)

even x = x `mod` 2 == 0

--Definiáljuk a head függvényt mintaillesztéssel.

head (x:xs) = x

--Definiáljuk a tail függvényt mintaillesztéssel.

tail (x:xs) = xs

--Üres-e függvény.

null [] = True

null _ = False

--Szorzás. Szorozzuk össze egy lista elemeit.

product [] = 1

product (x:xs) = x * product xs

--Találjuk meg több elem minimumát.

minimum [x] = x

minimum (x:xs) = x `min` minimum xs

--Számoljuk meg, hány páros szám van egy szövegben.

numOfEvens [] = 0

numOfEvens (x:xs)

=if even x

then 1 + numOfEvens xs

else numOfEvens xs

--Definiáljuk újra a páros összefűzést.

zip (x:xs) (y:ys)

= (x,y) : zip xs ys

zip _ _ = []

--Tetszőleges egész számokból álló számsorban adjuk meg az elemek felét,

-- a páratlan számokat változatlanul hagyva.

halves [] = []

halves (x:xs)

| x `mod` 2 == 0

= (x `div` 2) : halves xs

halves (x:xs) = x: halves xs

--Válogassuk ki egy listából a páros elemeket.

filterEven [] = []

filterEven (x:xs)

= if even x

then x : filterEven xs

else filterEven xs

--Lista utolsó n eleme. reverseTake n l legyen az l lista utolsó n darab eleme.

reverseTake 0 _ = []

reverseTake _ [] = []

reverseTake n (x:xs)

| length (x:xs) == n

= x : reverseTake (n-1) xs

reverseTake n (x:xs) = reverseTake (n-1) xs

////////////////////////////////////////////////////

import Char

--import Prelude hiding (unzip)

--Definiáljuk a logikai ÉS operátort!

land True True = True

land _ _ = False

--Állapítsuk meg, hogy egy lista kezdőszelete egy másiknak!

isPrefixOf [] _ = True

isp _ [] = False

isp (x:xs) (y:ys)

| x == y

= isp xs ys

|otherwise

= False

--Hozzunk létre egy beszúrásos rendezést megvalósító függvényt!

inSort [x] = [x]

inSort (x:xs)

| head xs < x

= head xs : x : inSort xs

| otherwise

= x : inSort xs

--Írjunk egy olyan függvényt, amely

--a kisbetűkből nagybetűket csinál és fordítva!

togglecase x

| isUpper x

= toLower x

|otherwise

= toUpper x

--Készítsünk egy olyan függvényt, amellyel

-- elemeket tudunk rendezetten beszúrni egy listába!

ins n [] = [n]

ins n (x:xs)

| x < n

= x : ins n xs

ins n (x:xs) = n:x:xs

--Állapítsuk meg, hogy egy adott érték szerepel-e egy listában!

elemOf m [] = False

elemOf m (x:xs)

| x == m

= True

| otherwise

=elemOf m xs

--Írjunk gyorshatványozó függvényt!

toThe x 1 = 1

toThe x n

| even n

= (x^(n `div` 2 ))^2

| otherwise

= (x^((n-1) `div` 2 ))^2*x

--Egy függvény segítségével értékeljünk ki

-- adott helyen egy együtthatóival megadott polinomot.

polynomial [] x = 0

polynomial (e:es) x

= ( polynomial es x) * x + e

//////////////////////////////////////////////////////////////////

--{-# LANGUAGE NoMonomorphismRestriction #-}

--import Data.List

--2 melyik hatványa nagyobb mint 10^20?

leastPowerOf2 = head $ filter ((10^20)<) [2^x | x <- [1..]]

--Keressük meg egy listában található számok közül

-- a legnagyobb páratlan számot!

maxOdd = maximum . filter odd

--Alkalmazzunk egy függvényt listák listájában levő elemekre!

mapMap = map . map

--Határozzuk meg egy lista elemei közti különbségeket!

differences xs = zipWith (-) (tail xs) xs

---------------------------------------------------------

--Állítsuk elő a Pascal-háromszöget!

pascalTriangle = iterate f[1] where

f x = zipWith (+) ([0] ++ x) (x ++ [0])

---------------------------------------------------------

fac n = product [1..n]

fac 0 = 1

fac n | n > 0 = n * fac (n-1)

sorelem n k = (fac n) `div` ((fac k) * (fac (n-k)))

pascal n = [sorelem n k | k <- [0..n]]

pascalTriangle = [pascal n | n <- [0..]]

----------------------------------------------------------

nextPascalLine xs = zipWith (+) ([0] ++ xs) (xs ++ [0])

--nextPascalLine (x:xs) = [1] ++ zipWith (+) xs (tail xs) ++ [1]

pascalTriangle = iterate nextPascalLine[1]

----------------------------------------------------------

utolso (s : sx)

| sx == [] = s

| otherwise = utolso sx

----------------------------------------------------------

Találjuk el a következő kifejezések végeredményét!

filter (4<) [1..10]

filter (<4) [1..10]

map (2^) [1..10]

map (^2) [1..10]

map (`mod` 2) [1..10]

map (2 `mod`) [1..10]

//////////////////////////////////////////////////////////

import Prelude hiding (String, Left, Right, Maybe, Nothing, Just)

--Definiáljuk a String típust mint karakterek listáját!

type String = [Char]

--Definiáljuk a Year típust mint egész számot!

type Year = Int

--Definiáljuk a két mélységű listákat!

type ListList a = [[a]]

--Definiáljuk a jobbra és balra irányokat!

data Direction

= Left

| Right

deriving(Eq, Show)

--Tükrözzünk egy irányt!

mirror :: Direction -> Direction

mirror Left = Right

mirror Right = Left

--Számoljuk meg egy irányokat tartalmazó listában a balra irányokat!

numOfLefts1 a = length (filter (==Left) a )

numOfLefts2 = length . filter (==Left)

-------------------------------------------------------------------

--Definiáljuk az Answer típust!

data Answer

= No

| Maybe

| Yes

deriving (Eq, Ord, Show)

--Definiáljuk a logikai ÉS függvényt az Answer típusra!

(&&&) :: Answer -> Answer -> Answer

(&&&) No _ = No

(&&&) _ No = No

(&&&) Maybe Yes = Maybe

(&&&) Maybe No = No

(&&&) Yes Yes = Yes

-------------------------------------------------------------------

--Definiáljuk az "esetleg egy egész szám" típust!

data MaybeInt

= NoInt

| JustInt Int

deriving (Eq,Show)

--Definiáljuk a biztonságos div függvényt!

safeDiv :: Int -> Int -> MaybeInt

safeDiv _ 0 = NoInt

safeDiv x y = JustInt (x `mod` y )

--Definiáljuk a "talán" típust!

data Maybe a

= Nothing

| Just a

deriving (Eq,Show)

-------------------------------------------------------------------

--Definiáljuk a Peano-féle számokat!

data Nat

= Zero

| Succ Nat

deriving (Eq, Show)

--Definiáljuk az 1 és 2 konstansokat Peano-számként!

one = Succ Zero

two = Succ one

--------------------------------------------------------------------

--Definiáljuk a lista típust!

infixr 5 `Cons`

data List a

= Nil

| Cons a (List a)

--------------------------------------------------------------------

--Definiáljuk a bináris számokat mint bitek listáját (a type kulcsszóval),

-- ahol a bit egy algebrai adatszerkezet a Zero és One konstruktorokkal (data kulcsszó)!

type Binary = [Bit]

data Bit = Zero | One

deriving (Eq,Show)

--Definiáljuk a bináris számokra a rákövetkező és az összeadás függvényt!

succB [] = [One]

succB (x:xs)

| x == Zero = [One] ++ xs

| x == One = [Zero] ++ succB xs

kov x y

| x == Zero && y == Zero = Zero

| x == Zero && y == One = One

| x == One && y == Zero = One

| x == One && y == One = Zero

addB [] [] = []

addB [] zs = zs

addB zs [] = zs

addB (x:xs) (y:ys)

| x== One && y == One

= (kov x y) : addB (succB xs) ys

| otherwise

= kov x y : addB xs ys

///////////////////////////////////////////////////////////////////////////

import Prelude hiding (Ordering, LT, EQ, GT, compare)

import Data.Function

--Telefonkönyv

type Name = String

type Number = String

type Entry = (Name, Number)

type PhoneBook = [Entry]

-----------------------------------------------------------

--Definiáljuk az "üres telefonkönyv" konstanst.

emptyBook = [] :: PhoneBook

-----------------------------------------------------------

--Hozzunk létre egy keresőfüggvényt a telefonkönyvben.

findEntry [] _ = Nothing

findEntry ((nev, tel) : tks) x

| x == nev = Just tel

| otherwise = findEntry tks x

-----------------------------------------------------------

--Bejegyzéseket lehet beilleszteni egy meglevő telefonkönyvbe.

addEntry p (name, num)

| findEntry p name == Nothing = ((name, num) : p)

| otherwise = p

-----------------------------------------------------------

--Nat típusú értékekből tudunk egész számokat előállítani.

data Nat = Zero | Succ Nat

deriving (Eq)

fromNat Zero = 0

fromNat (Succ a) = 1 + fromNat a

instance Show Nat where

show x = show (fromNat x)

-----------------------------------------------------------

--Definiáljuk (újra) az Ordering típust és a compare függvényt.

data Ordering = LT

| EQ

| GT

deriving (Eq, Ord, Show)

compare x y

| x < y = LT

|x == y = EQ

|x > y = GT

--ossz ls = zip ls [1..]

--Keressük meg egy listában, hogy melyik indexű elem volt a legnagyobb .

maxIndex (x:xs) = maxim 1 1 x xs

where

maxim n mi x (y:ys)

| y > x = maxim (n+1) (n+1) y ys

| otherwise = maxim (n+1) mi x ys

maxim _ mi _ [] = mi

maxIndex2 = fst . maximumBy (compare `on` snd) . zip [1..]

--------------------------------------------------------------

--Implementáljuk a Nat típusra az összeadást, a szorzást és a hatványozást!

data Nat = Zero | Succ Nat

deriving (Eq,Show)

fromNat Zero = 0

fromNat (Succ a) = 1 + fromNat a

toNat 0 = Zero

toNat a = Succ (toNat (a-1))

add :: Nat -> Nat -> Nat

add Zero Zero = Zero

add Zero (Succ b) = (Succ b)

add (Succ a) Zero = (Succ a)

add (Succ a) (Succ b) = toNat (fromNat (Succ a) + fromNat (Succ b))

mul :: Nat -> Nat -> Nat

mul Zero Zero = Zero

mul Zero (Succ b) = Zero

mul (Succ a) Zero = Zero

mul (Succ a) (Succ b) = toNat (fromNat (Succ a) * fromNat (Succ b))

power :: Nat -> Nat -> Nat

power Zero (Succ b) = Zero

power (Succ a) Zero = (Succ Zero)

power (Succ a) (Succ b) = toNat (fromNat (Succ a) ^ fromNat (Succ b))

////////////////////////////////////////////////////////////////////////

Első definíció:

fac 0 = 1

fac n = n * fac (n-1)

Második definíció:

fac' n = if n<1 then 1 else n * fac' (n-1)

Harmadik definíció:

fac'' n

| n<1 = 1

| otherwise = n * fac'' (n-1)

---------------------------------------------------------

pythagorean_triples =

[(a,b,c) | c<-[1..], b<-[1..c], a<-[1..b], a^2 + b^2 == c^2]

---------------------------------------------------------

fib 0 = 0

fib 1 = 1

fib n = fib (n-1) + fib (n-2)

---------------------------------------------------------

echoUntilEmptyLine :: IO ()

echoUntilEmptyLine = do

line <- getLine

if null line

then putStrLn "Üres sor."

else do

putStrLn line

echoUntilEmptyLine

---------------------------------------------------------

read2Lines :: IO (String, String)

read2Lines = do

l1 <- getLine

l2 <- getLine

return (l1, l2)

---------------------------------------------------------

firstChar :: IO Char

firstChar = do

c <- getChar

getChar

return c

---------------------------------------------------------

do putStr a

putStr b

putStr (a ++ b)

---------------------------------------------------------

echoTwice :: IO ()

echoTwice = do

line <- getLine

putStrLn line

putStrLn line

---------------------------------------------------------

"ab" ++ "cd" :: String -- "abcd" (tiszta számítás)

getLine :: IO String -- sor beolvasása a konzolról

getContents :: IO String -- szöveg beolvasása a konzolról Ctrl+d-ig

if x<0 then getLine else getContents :: IO String

readFile "x.txt"

putChar :: Char -> IO () -- karakter konzolra írása

putStr :: String -> IO () -- szöveg konzolra írása

putStrLn :: String -> IO () -- szöveg konzolra írása + soremelés

writeFile :: FilePath -> String -> IO () -- fájl írása

appendFile :: FilePath -> String -> IO () -- hozzáfűzés fájlhoz

---------------------------------------------------------

////////////////////////////////////////////////

main = print $-- 5 + 2 * 3-- sum [1..10]-- reverse (sort [1, 6, 2, 7])-- 1 < 2 && 3 < 4-- 2 < 1 || 3 < 4-- [1, 2] ++ [3, 4, 5]-- and [True, 2 < 1, 6 > 5]-- take 3 [1, 2, 3, 4, 5]map my_abs2 [7, -4, 3]

head (x:xs) = xtail (x:xs) = xsfac 0 = 1fac n | n > 0= n * fac (n - 1)sum [] = 0sum (x:xs)= x + sum xslength [] = 0length (_:xs)= 1 + length xs

filter p [] = []filter p (x:xs)| p x = x : filter p xs| otherwise = filter p xseven x = x ‘mod‘ 2 == 0odd = not . even-- odd x = not (even x)

evens = filter even [0..]

map f [] = []map f (x:xs) = f x : map f xsodds = map (+ 1) evens

foldr f e [] = efoldr f e (x:xs) = f x (foldr f e xs)sum = foldr (+) 0-- sum xs = foldr (+) 0 xsand = foldr (&&) True

takeWhile – elemek megtartása amíg p teljesül dropWhile – elemek eldobása amíg p teljesül

takeWhile p [] = []takeWhile p [x:xs]| p x = [x : takeWhile p xs]| otherwise = []

f iterálása amíg p nem teljesülCleanuntil :: (a -> Bool) (a -> a) a -> auntil p f x| p x = x| otherwise = until p f (f x)

last [x] = xlast (x:xs) = last xslast []= error "last of []"init [] =error "empty"init [x] =[]init (x:xs)=x:init xs

reverse ls = rev ls []whererev (x:xs) ys= rev xs (x:ys)rev [] ys = ys

concat (x:xs) = x ++ concat xsconcat [] = []

repeat x = cons wherecons = x : cons-- repeat 3 = [3, 3..]iterate f x = [x : iterate f (f x)]-- iterate (+ 1) 3 = [3, 4..]