Haskell

--1.a ket szam osszege
osszeg :: (Num x, Ord x ) => x -> x ->x
--osszeg :: Int -> Int-> Int
osszeg x y = x+y

--1.b ket szam kulonbsege
kivonas :: (Num x, Ord x ) => x -> x ->x
kivonas x y = x-y

--1.c ket szam szorzata
szor :: (Num x, Ord x ) => x -> x ->x
szor x y = x*y

--1.d hanyados
--h :: Double -> Double -> Double
h :: (Floating x ) => x -> x ->x
h x y = x / y

--1.e ket szam osztasi maradeka
om ::  (Integral x ) => x -> x ->x
om x y = x `rem` y

--ket szam osztasi egesz resze
oe :: (Integral x ) => x -> x ->x
oe x y = x `div` y

--2. elsofoku egyenlet gyokei
elsof :: (Floating a, Ord a) => a -> a -> a
elsof a b
    |a==0 = error "nem ertelmezett"
    |otherwise=(-b)/a

--3. abszolut ertek
absz :: (Num a, Ord a) => a -> a
absz x
    | x < 0 = -x
    |otherwise = x

--4. szam elojele
my_sign :: Int -> Int
my_sign x
    | x < 0 = -1
    | x > 0 = 1
    | x == 0 = 0

--5. ket argumentum maximuma
maxi :: (Num a, Ord a) => a -> a -> a
maxi a b
        | b > a = b
        | b < a = a
        |otherwise = a

--6. ket argumentum minimuma
mini :: (Num a, Ord a) => a -> a -> a
mini a b
        | b < a = b
        | b > a = a
        |otherwise = a

-- 7. masodfoku egyenlet gyokei
masodf :: (Floating a, Ord a) => a -> a -> a -> (a, a)
masodf a b c
    | delta < 0 = error "Nem ertelmezett"
    | delta >= 0 =( (-b + sqrt delta) / n, (-b - sqrt delta) / n )
        where
            delta =  b * b - 4 * a * c
            n = 2*a

--faktorialis 1.modszer
fakt1 :: Int -> Int
fakt1 0 = 1
fakt1 n = n * fakt1 (n-1)

--faktorialis 2.modszer
fakt2 :: Int -> Int
fakt2 n
    | n < 0 = -1
    | n == 0 = 1
    |otherwise = n * fakt2 (n-1)

--faktorialis 3.modszer
fakt3 :: Int -> Int -> Int
fakt3 res n
    | n < 0 = -1
    | n == 0 = res
    |otherwise = fakt3 (n*res) (n-1)
{-
FUGGVENYHIVAS
Prelude> fakt1 10
Prelude> fakt2 10
Prelude> fakt3 1 10
-}


--1.Egy szam szamjegyeinek a szorzata
szor_2 :: Integer -> Integer
szor_2 x
    |x < 10 = x
    |otherwise =(x `rem` 10) * szor_2 (x `div` 10)

--2.masodik modszer szamjegyek szorzatra
szor1 :: Integer -> Integer -> Integer
szor1 x res
    |x < 10 = x * res
    |otherwise = szor1(x `div` 10)  (res * (x`rem` 10))

--2.masodik modszer szamjegyek szorzatra
szor2 :: Integer -> Integer
szor2 x = szor1_1 x 1
    where
    szor1_1 :: Integer -> Integer -> Integer
    szor1_1 x res
        |x < 10 = x * res
        |otherwise = szor1_1(x `div` 10) (res * (x`rem` 10))


--3.Egy szam szamjegyeinek az osszege
ossz :: Integer -> Integer
ossz x
    |x < 10 = x
    |otherwise = (x `rem` 10) + ossz (x `div` 10)

--4.Egy szam szamjgyeinek osszege. 2. modszer
isum1 :: Integer -> Integer
isum1 x = isum1_1 x 0
    where
    isum1_1 :: Integer -> Integer -> Integer
    isum1_1 x res
        |x < 10 = x + res
        |otherwise = isum1_1(x `div` 10) (res +(x `rem` 10))

--5.szamjegyek szamainak a szamai
szam :: Integer -> Integer
szam x
    |x < 10 = 1
    |otherwise = 1 + szam(x `div` 10)


--6.szamjegyek szamainak a szama. 2 modszer
szam1 :: Integer -> Integer -> Integer
szam1 0 sz = sz
szam1 x sz =  szam1(x `div` 10)(sz + 1)

--7 egy szam azon szamjegyenek osszeget, mely parameterkent van megadva
posszeg :: Integer -> Integer -> Integer
posszeg x y
    | x < 10 && (x == y) = 1
    | x < 10 && (x /= y) = 0
    | szj == y = 1 + posszeg (div x 10) y
    | szj /= y = posszeg (div x 10) y
    where
        szj = mod x 10

--8.paros szamjegyek szama
parosszj :: Integer -> Integer
parosszj x
    |x < 10 && ( mod szj 2 == 0) = 1 --(even szj)
    |x < 10 && (mod szj 2/=0) = 0 --(not.even)szj
    |mod szj 2 == 0 = 1 + parosszj (div x 10)
    |mod szj 2/=0 = parosszj (div x 10)
    where
        szj = mod x 10

--9.legnagyobb szamjegy
maxisz :: Integer -> Integer
maxisz x
    |x < 10 = x
    |rx > szj = rx
    |otherwise = szj

    where
        rx = maxisz(div x 10)
        szj = mod x 10

--10. n-edik Fibonacci szam
--fib :: Integer -> Integer
--fib0 = 0
--fib1 = 1
--fibn = fib(n-1) + fib (n-2)

--11. n-wdik Fibonacci szam
fib1 :: Integer -> Integer -> Integer -> Integer
fib1 n a b
    |n == 1 = b
    |otherwise = fib1 (n-1) b (a+b)

--12. n-wdik Fibonacci szam 2.modszer
fib2 :: Integer -> Integer
fib2 n = alfib1 n 0 1
    where
    alfib1 :: Integer -> Integer -> Integer -> Integer
    alfib1 n a b
        |n == 1 = b
        |otherwise = alfib1 (n-1) b (a+b)

--13.Egy szam kettes szamrendszerbeli alakjaban az 1esek szama
bin :: Integer -> Integer
bin x
    |x < 0 = error "Ez negativ szam!"
    |x == 0 = 0
    |maradek == 1 = 1 + bin (div x 2)
    |maradek == 0 = bin (div x 2)
    where
        maradek = mod x 2

-- Egy x szam n-ik hatvanya, ha a kitevo pozitiv szam
--1.
hatv1 :: Integer -> Integer -> Integer
hatv1 szam 0 = 1
hatv1 szam n = szam * (hatv1 szam (n-1))

--2.
hatvany ::  Integer -> Integer -> Integer
hatvany szam n
    | n < 0 = error "Negativ hatvany!!"
    | n == 0 = 1
    |otherwise = szam * hatvany szam (n-1)

--3.
hatv3 :: Integer -> Integer -> Integer -> Integer
hatv3 szam n res
    | n < 0 = error "Negativ hatvany nem helyes!!"
    | n == 0 = res
    |otherwise = hatv3 szam (n-1) (res * szam)



--14 egy szam paros osztoinak a listajat

osztok2 :: Int -> [ Int ]
osztok2 n = [ i | i <- [1..n] , n `mod` i ==0 && mod i 2 == 0]

--15 az első n természetes szám köbét
kob :: Integer -> Integer -> Integer
kob n x
    | n < 0 = error "Negativ kitevo"
    | n == 0 = 1
    | mod n 2 == 0 = kob (div n 2) (x*x)
    | otherwise = x * kob (div n 2) (x*x)

-- elso n szam negyzetgyoke
gyok :: Float -> [Float]
gyok n = gyok_1 [1..n]
    where
        gyok_1 :: [Float] -> [Float]
        gyok_1 [] = []
        gyok_1 (n:ns) = (sqrt n) : gyok_1 ns


--n-nel kisebb Pitagoraszi szamharmasok
pithar :: Int -> [(Int,Int,Int)]
pithar x = [(a,b,c)|a<-[1..x], b<-[1..x], c<-[1..x], (a^2)+(b^2) == (c^2)]

-- x szam hatvanyai n-ig --map (hatv1 2) [1 .. 10]
hatvany1 :: [Integer] -> [Integer]
hatvany1 [] = []
hatvany1 (n:ns) = (n*n) : hatvany1 ns

hatvanyoz :: Integer -> Integer -> [Integer]
hatvanyoz szam 0 = []
hatvanyoz szam n = hatv1_2 szam [1..n]
    where
    hatv1_2 :: Integer -> [Integer] -> [Integer]
    hatv1_2 szam [] = []
    hatv1_2 szam (x:xs) = szam^x : hatv1_2 szam xs

--a következõ listát: [('a',0), ('b',1), ..., ('z', 25)] alakitsuk ki
myzip :: [a] -> [b] -> [(a,b)]
myzip _ [] = []
myzip [] _ = []
myzip (x:xs) (y:ys) = (x,y) :myzip xs ys

--a következõ listát: [(0, 5), (1, 4), (2, 3), (3, 2), (4, 1), (5, 0)]
myzip2 :: [a] -> [b] -> [(a,b)]
myzip2 _ [] = []
myzip2 [] _ = []
myzip2 (x:xs) (y:ys)= (x,y) :myzip2 xs ys
    where
        rev :: [a] -> [a]
        rev xs = [xs !! k | k <- [(length xs-1), (length xs -2)..0]]


--a fugggvenyargumentum elojelenek meghatarozasa
my_sign2 :: Int -> Int
my_sign2 x
    | x < 0 = -1
    | x > 0 = 1
    | x == 0 = 0

--ket szam legnagyobb kozos osztojanak meghatarozasa
lnko :: Int -> Int -> Int
lnko a b
    | a > b = lnko (a-b) b
    | a < b = lnko a (b-a)
    | otherwise = a

--egy szam szamjegyeinek osszege
isum :: Int -> Int
isum 0 = 0
isum x = ( x `rem` 10 ) + isum (x `div` 10)

--egy 4 elemu lista elemeinek osszege
osszeg2 :: [Int] -> Int
osszeg2 [] = 0
osszeg2 [x] = x
osszeg2 [x,y] = x + y
osszeg2 [x,y,z] = x + y + z
osszeg2 [x,y,z,a] = x + y + z + a

--abszolut ertek
abszolut1 x
    |x < 0 = -x
    |otherwise = x

abszolut2 :: Int -> Int
abszolut2 x
    | x < 0 = -x
    |otherwise = x

abszolut3 :: Float -> Float
abszolut3 x
    | x < 0 = -x
    |otherwise = x

abszolut4 :: (Num a, Ord a) => a -> a
abszolut4 x
    | x < 0 = -x
    |otherwise = x

--egy szam osztoinak a listája
osztok :: Int -> [ Int ]
osztok n = [ i | i <- [1..n] , n `rem` i==0]
{-
fuggveny kiertekelese
Prelude> osztok 60
Prelude> length (osztok 60)
-}

--lista paros elemeinek meghatarozasa
parosList :: (Integral a) => [a] -> [a]
parosList list = filter even list

-- a lista paratlan elemeinek meghatarozasa
paratlanList :: (Integral a) => [a] -> [a]
paratlanList list = filter (not . even) list


--a megadott parametert noveli 1-el
my_add :: (Num a) => a -> a
my_add = \x -> x + 1

--a lista minden elemet noveli eggyel
list_add :: (Num a) => [a] -> [a]
list_add list = map (\x -> x + 1) list

--Adott szam hatvanyertekei 0-10 -ig
hatv_1 :: Integer -> Integer -> Integer
hatv_1 x n
    | n < 0 = error "Negativ kitevo"
    | n == 0 = 1
    | mod n 2 == 0 = hatv_1 (x*x) (div n 2)
    | otherwise = x * hatv_1 (x*x) (div n 2)

fugv1 :: Integer -> [Integer]
fugv1 x = map (hatv_1 x) [0..10]

--szamok kobei 0-10 -ig
hatv_2 :: Integer -> Integer -> Integer
hatv_2 n x
    | n < 0 = error "Negativ kitevo"
    | n == 0 = 1
    | mod n 2 == 0 = hatv_2 (div n 2) (x*x)
    | otherwise = x * hatv_2 (div n 2) (x*x)
fugv2 :: Integer -> [Integer]
fugv2 x = map (hatv_2 x) [0..10]

-- valasszuk ki egy adott listabol az x -el oszthato szamokat
oszthato :: Int -> Int -> Bool
oszthato x y
    | mod y x == 0 = True
    | otherwise = False
fugv :: Int -> [Int] -> [Int]
fugv x li = filter (oszthato x) li

--masodfoku egyenlet gyokei
gyok_2 :: Double -> Double -> Double -> (String, Double, Double)
gyok_2 a b c =
    if delta < 0 then error "Komplex gyokok" else
        if delta == 0 then ("egyforma gyokok, ", x1, x1) else
            ("ket gyok", x1, x2)
    where
        x1 = (-b + sqrt delta) / nev
        x2 = (-b - sqrt delta) / nev
        delta = b * b - 4 * a * c
        nev = 2 * a
{-fuggvenyhivas gyok 1 3 2-}

{-
--fuggvenyek listakon
sum [3, 2, 10, 7, 5]
length [3, 2, 10, 7, 5]
reverse [3, 2, 10, 7, 5]

--listak letrehozasa
t1 = [1,2,3,4]
t1_1 = (1: (2: (3: (4: []))))
-- > t1_1

t2 = [ [1, 2, 3], [1, 2], [1, 2, 3, 4] ]
t2_1 = ([1, 2, 3]: ([1, 2]: ([1, 2, 3, 4]: [])))
-- > t2_1

t3 x = [ 2^x, length [1, 2], length[1, 2, 3] ]
t3_1 x = (2^x: (length[1, 2]: (length[1, 2, 3]: [])))

t4 = [1..10]
-- > t4

t5 = [0,5..50]
 -- > t5

t6 = [-3, -6.. -20]
-- > t6
t7 = [`a` .. `f1`]
-- > t7
-}

--1.meghatározza egy lista utolsó elemét.
my_last :: [a] -> a
my_last [] = error "ures lista"
my_last[k] = k
my_last(k:ve) = my_last ve

--2.meghatároz egy listát mely tartalmazza a paraméterként megadott lista elemeit, kivéve az utolsót.
my_init :: [a] -> [a]
my_init [] = error "ures lista"
my_init [k] = []
my_init(k:ve) = k: my_init ve

--3.meghatározza egy lista legnagyobb elemét.
my_maximum :: (Ord a ) => [a] -> a
my_maximum [] = error "ures lista"
my_maximum [k] = k
my_maximum(k:ve)
    |k > temp = k
    |otherwise = temp
    where
        temp = my_maximum ve

--4.meghatározza egy lista legkisebb elemét.
my_minimum :: (Ord a ) => [a] -> a
my_minimum [] = error "ures lista"
my_minimum [k] = k
my_minimum(k:ve)
    |k < temp = k
    |otherwise = temp
    where
        temp = my_minimum ve
--5.maghatározza egy egész elemű lista elemeinek átlagértékét.
my_atlag :: [Double ] -> Double
my_atlag li = osszeg/db
    where
        osszeg = my_sum1 li
        db = my_length1 li

my_sum1 :: [Double] -> Double
my_sum1 [] = 0
my_sum1 (k: ve) = k + my_sum1 ve

my_length1 :: [a] -> Double
my_length1 [] = 0
my_length1 (k: ve) = 1 + my_length1 ve

--5. maghatározza egy egész elemű lista elemeinek átlagértékét.
--2.modszer
atlag1 :: [Double ] -> Double
atlag1 li = osszeg1/db1
    where
        (osszeg1, db1) = satlag li

--segedlista
satlag :: [Double ] -> (Double, Double)
satlag [] = error "ures lista"
satlag [k] = (k,1)
satlag (k:ve) = (k+tempk, 1+tempdb)
    where
        (tempk, tempdb) = satlag ve


--6. megállapítja egy karakter listáról, hogy az palindrom-e vagy sem.
palindrom :: [Char] -> Bool
palindrom [] = True
palindrom [k] = True
palindrom li
    |(head li) /= (my_last li) = False
    |otherwise = palindrom( my_init(tail li))

--7. meghatározza egy szám  számrendszerbeli alakját
szamr :: Integer -> Integer -> [Integer]
szamr nr p = sszamr nr p []
    where
        sszamr nr p res
            |nr < p = (nr : res)
            |otherwise = sszamr (div nr p) p ((mod nr p) : res)

{- 1. Határozzuk meg egy lista legnagyobb elemeinek pozícióit, két módszerrel:
      a.) - úgy hogy a lista elemeit kétszer járjuk be,
      b.)- úgy hogy a lista elemeit csak egyszer járjuk be.
-}
--1.a.)
mymax :: (Num a, Ord a) => [a] -> (a, [Integer])
mymax lista = (m, poz m lista)
    where
        m = smax lista
        smax :: (Num a, Ord a ) => [a] -> a
        smax [] = error "ures lista"
        smax [k] = k
        smax(k:ve)
            |k > temp = k
            |otherwise = temp
            where
                temp = smax ve

        poz :: (Num a, Ord a) => a -> [a] -> [Integer]
        poz m lista = spoz m lista 0
            where
                spoz :: (Num a, Ord a) => a -> [a] -> Integer -> [Integer]
                spoz m[] ind = []
                spoz m (k:ve) ind
                    |m == k =(ind : spoz m ve (ind +1))
                    |otherwise = spoz m ve (ind +1)

--1.b.)
mymax2 :: (Ord a) => [a] -> (a, [Int])
mymax2 [] = error "Ures lista"
mymax2 (k:ve) = seged_mymax2 k ve 1 [0]
    where
        seged_mymax2 :: (Ord a) => a -> [a] ->Int ->[Int] -> (a,[Int])
        seged_mymax2 m [] ind res = (m, res)
        seged_mymax2 m (k:ve) ind res
            |m < k = seged_mymax2 k ve (ind+1) [ind]
            |m > k = seged_mymax2 m ve (ind+1) res
            |m == k = seged_mymax2 m ve (ind+1)(ind:res)

--1.c.) Határozzuk meg a P(x) = a0 + a1·x + a2·x2 +...+ an·xn polinom adott x0értékre való behelyettesítési értékét
poli :: [Integer] -> Integer -> Integer ->Integer
poli [] x0 temp = error "Polinom egyutthatoi nincsenek megadva!"
poli [k] x0 temp = k * temp
poli (k: ve) x0 temp = poli ve x0 (temp*x0) + k * temp

--1.d.)Határozzuk meg egy p számrendszerben megadott szám számjegyei alapján a megfelelo 10-es számrendszerbeli számot.
ptiz :: [Integer] -> Integer -> Integer ->Integer
ptiz [] p temp = error "Nincs megadva szam"
ptiz [k] p temp = k*temp
ptiz (k:ve) p temp = ptiz ve p temp*p + k*temp



--2.Írjuk meg az elem, reverse, product függvényeket a foldl függvény segítségével.
--Írjuk meg az elem, reverse, product függvényeket és a ++ operátort (a két lista összefúzése függvényt) a foldr függvény segítségével.
--Határozzuk meg a P(x) = a0 + a1·x + a2·x2 +...+ an·xn polinom adott x0értékre való behelyettesítési értékét a foldr függvény segítségével:
--a0 + x0·(a1 + x0·(a2 + x0·(a3 + ...+ x0·(an-1+ x0·an)

my_max = foldr (\x y -> if x > y then x else y) 0 [1,2,3,11,5, 7, 12]

my_sum = foldl (\x y -> x + y) 0 [1,2,3,4,5] -- a lista elemeinek osszege, lehet foldr-rel is

elemek_szamal = foldl (\x y -> x + 1 ) 0 [1,2,3,4,5]
elemek_szamar = foldr (\x y -> y + 1 ) 0 [1,2,3,4,5]

my_productl = foldl (\x y -> x * y) 1 [1,2,3,4]
my_productr = foldr (\x y -> x * y) 1 [1,2,3,4]

my_eleml x li = foldl (\y1 y2 -> if y2 == x then True else y1) False li
my_elemr x li = foldr (\y1 y2 -> if y1 == x then True else y2) False li

horner :: (Num a) => a -> [a] -> a
horner x = foldr (\a b -> a + b*x) 0




--3. Hozzunk létre egy konstans listát.
data Fesztivalok =
 Fesztivalok {  egyuttes :: String,
                fesztival :: String,
                ar :: Int,
                kod :: Int } deriving (Show, Eq)

--3.a.) határozzuk meg egy adott fesztiválon szereplo eggyütteseket,
fesztival_lista :: [Fesztivalok]
fesztival_lista = [ Fesztivalok "Tankcsapda" "Felsziget" 45 1,
                    Fesztivalok "Rihanna" "RoskildeFestival" 300 2,
                    Fesztivalok "Roxette" "RoskildeFestival" 300 3,
                    Fesztivalok "ImagineDragons" "SummerMusicFestival" 250 4]

--3.b.)  határozzuk meg azokat az együtteseket, melyek egy adott értéknél olcsóbban árulják koncertjegyeiket,
szerepelnek :: String -> [Fesztivalok] -> [String]
szerepelnek e [] = []
szerepelnek e (x : xs)
    | egyuttes x == e = ( fesztival x: szerepelnek e xs )
    | otherwise = szerepelnek e xs

--3.c.) határozzuk meg, hogy hány olyan együttes szerepel a listában, mely egy adott értéknél olcsóbban árulja koncertjegyét,
olcsobb_jegyek :: Int -> [Fesztivalok] -> [String]
olcsobb_jegyek jegyar [] = []
olcsobb_jegyek jegyar (x:xs)
    | ar x < jegyar = ( fesztival x : olcsobb_jegyek jegyar xs )
    | otherwise = olcsobb_jegyek jegyar xs

--3.d.) rendezzük a lista tartalmát az együttesek nevei alapján ábécé sorrendbe (mergeSort)
hany_olcsobb :: Int -> [Fesztivalok] -> Int
hany_olcsobb jegyar [] = 0
hany_olcsobb jegyar (x:xs)
    | ar x < jegyar = 1 + hany_olcsobb jegyar xs
    | otherwise = hany_olcsobb jegyar xs

--3.e.)  rendezzük a lista tartalmát a jegyárak szerint csökkeno sorrendbe (qSort)
quickSort_jegyar :: [Fesztivalok] -> [Fesztivalok]
quickSort_jegyar [] = []
quickSort_jegyar (x:xs) = quickSort_jegyar gt_list ++ [x] ++ quickSort_jegyar lt_list
    where
        lt_list = [ y | y <- xs , ar y >= ar x]
        gt_list = [ y | y <- xs, ar y < ar x ]

--3.f.) határozzuk, meg, hogy agy adott fesztiválon mennyi a jegyek átlagértéke
atlag_jegyar :: String -> [Fesztivalok] -> Double
atlag_jegyar feszt li = (fromIntegral sum) / (fromIntegral nr)
    where
    (sum, nr) = satlag feszt li
    satlag :: String -> [Fesztivalok] -> (Int, Int)
    satlag feszt [] = (0, 0)
    satlag feszt (x:xs)
        | fesztival x == feszt = (ar x + temp1, 1 + temp2)
        | otherwise = (temp1, temp2)
        where
        (temp1,temp2) = satlag feszt xs

--4 Hasonlítsuk össze a tanult hatvany függvények idoigényét (3 verzió) a ^ predefiniált operátorral: mind a négy esetben határozzuk meg 2100000 mod 10 értékét.
hatvany0 :: Integer -> Integer -> Integer
hatvany0 x n
    | n < 0 = error "negativ kitevo"
    | n == 0 = 1
    | otherwise = x * hatvany0 x (n-1)

hatvany_1 :: Integer -> Integer -> Integer
hatvany_1 x n
    | n < 0 = error "negativ kitevo"
    | n == 0 = 1
    | mod n 2 == 1 = x* hatvany_1 (x*x) (div n 2)
    | otherwise = hatvany_1 (x*x) (div n 2)

hatvany2 :: Integer -> Integer -> Integer
hatvany2 x n
    | n < 0 = error "negativ kitevo"
    | n == 0 = 1
    | mod n 2 == 1 = x * h * h
    | otherwise = h * h
        where h = hatvany2 x (div n 2)

-- idomeres-> :set +s

--Paratlan n gyok
toDouble :: (Real n) => n -> Double
toDouble = fromRational . toRational
elso_n_gyok :: Int -> [Double]
elso_n_gyok n
    | n<1 = error "hiba"
    | otherwise =[sqrt (toDouble i ) | i<-[1..n], (i`mod` 2) /=0 ]

--hozzunk létre egy listát amely tartalmazza az eredeti lista minden n-ik elemét
mindenNik :: (Ord a) => [a] -> Int -> [a]
mindenNik lista n
    |length lista <n =[]
    |otherwise =
        let
            elem = last (take n lista)
            ujlista = drop n lista
        in elem: (mindenNik ujlista n)

--hat meg az [x,y] intervallumban levo szamok osszeget
sumB :: (Ord a,Num a) => a -> a -> a
sumB x y =
    if x>y then error "Hiba:parameterek"
    else
        if x<y then x + sumB (x+1) y
        else x
--lista amely a következőképpen néz ki ..: [2,2,4,4,4,4,6,6,6,6,6,6.......]
generateList::Int->[Int]
generateList n
    | n<2=error "a bemenet legyen 2 vagy nala nagyobb"
    | (n `mod` 2 )==0 = sgenerateList 2 0 (n+1)
    | otherwise = sgenerateList 2 0 n
        where
            sgenerateList::Int->Int->Int->[Int]
            sgenerateList nr lv lim
                | nr>=lim =[]
                | lv<nr = (nr:sgenerateList nr (lv+1) lim)
                | otherwise = sgenerateList (nr+2) 0 lim
--lista amely a következőképpen néz ki ..: [2,2,4,4,4,4,6,6,6,6,6,6.......]     paratlan
generateList2::Int->[Int]
generateList2 n
    | n<2=error "a bemenet legyen 2 vagy nala nagyobb"
    | (n `mod` 2 )==0 = sgenerateList 1 0 (n+1)
    | otherwise = sgenerateList 1 0 n
        where
            sgenerateList::Int->Int->Int->[Int]
            sgenerateList nr lv lim
                | nr>=lim =[]
                | lv<nr = (nr:sgenerateList nr (lv+1) lim)
                | otherwise = sgenerateList (nr+2) 0 lim
--2.) Egy szám legnyagyobb paratlan osztojat
osztok_2 :: Int -> [ Int ]
osztok_2 n = [ i | i <- [1..n] , n `rem` i==0 , i`mod`2/=0 ]
maxparatlan :: Int -> Int
maxparatlan n = last(osztok2 n)
-- egy lista tartalmazzon true es false ertekeket valtakozva
valtakozva :: Int -> [Bool]
valtakozva n
    | n < 1 = error "hiba"
    | otherwise = [even i|i<-[1..n]]

valtakozva2 :: Int -> [Bool]
valtakozva2 n
    | n < 1 = error "hiba"
    | otherwise = [ i`mod`2==0|i<-[1..n]]
-- lista emely igy nez ki   [1,1,3,1,3,5,1,,3,5,7]
general:: Int->[Int]
general n
    | n<1 = error "hiba"
    |otherwise = sgeneral 1 1 n
        where
            sgeneral :: Int->Int->Int->[Int]
            sgeneral sz sl l
                | sl>l =[]
                | sz<=sl = (sz:sgeneral (sz+2) sl l)
                | otherwise = sgeneral 1 (sl+2) l

list_paratlan :: Int->[Int]
list_paratlan n = [i | i<-[1..n],i`mod`2/=0]
general2 :: Int->[Int]
general2 (-1) = []
general2 0 = []
general2 n = general2(n-2) ++ list_paratlan n

-- hat meg ,hogy tizes szamrendszerbeli szamnak melyik a legnagyobb szamjegye p szamrendszerbe
nssm :: Int -> Int-> Int
nssm n p
    | p<2 = error "hiba"
    | otherwise = maximum(szj_lista n p) --legnagyobb szamjegy visszateritese
        where
            szj_lista :: Int->Int->[Int] --p szamrendszerbeli szam szamjegyeinek lista
            szj_lista 0 p = []
            szj_lista n p = ((n`mod`p) : szj_lista(n`div`p) p)

-- hozzunk letre egy listat amely nem tartalmazza az eredeti lista minden n-ik elemet
mindenNik2 :: (Ord a) => [a] -> Int -> Int -> [a]
mindenNik2 [] n n2 = []
mindenNik2 (k:ve) n n2
    | n2<=0 =[]
    | n2`mod`n /= 0 = mindenNik2 ve n (n2-1)
    | otherwise = ( k : mindenNik2 ve n (n2-1))
{-fuggvenyhivas
mindenNik2 [1,2,3,4,5,6,7,8,9,10] 2 10
-}