@sara_n/

work1

Haskell

No description

fork
loading
Files
  • main.hs
main.hs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
--5.	Trojka (x,y,z) pozitivnih celih brojeva je pitagorejska ako vazi x^2+y^2=z^2. Definisati funkciju koja vraca listu svih pitagorejskih trojki do date granice.
pitagorine3 :: Int -> [(Int,Int,Int)]
pitagorine3 n = [(a,b,c) | a<-[1..n] , b<-[1..a], c<-[1..n], c^2==a^2+b^2]

--6.	Definisati funkciju  koja vraca listu svih pitagorejskih trojki  ciji je obim dati broj.

--7.	Koriscenjem funkcije filter izdvoji sve pozitivne elemente iz liste brojeva
poz :: [Int] -> [Int]
poz l = filter (\a -> a>0) l

--8.	Kreiraj listu apsolutnih vrednosti svih negativnih elemenata date liste brojeva.
apsn :: [Int] -> [Int]
apsn [] = []
apsn (x:xs) | x>0 = x : apsn xs
            | x<0 = (-x) : apsn xs
            | x==0 = x : apsn xs

apsd :: [Int] -> [Int]
apsd l = p
    where
      a= filter (\a -> a<0) l
      p= map (*(-1)) a

-- 9.	Napisati funkciju kojom se proverava da li je a element liste l (zadatak resiti na dva nacina:pisanjem rekurzivne funkcije i koriscenjem filtera)

element :: Int -> [Int] -> Bool
element _ [] = False
element a l = if a== head l then True else element a (tail l)

element1 :: Int -> [Int] -> Bool
element1 a l = if filter (\b -> b==a) l == [] then False else True 

--10.	Napisati funkciju koja sumira kvadrate parnih brojeva iz date liste (koriscenjem funkcija ugrađenih funkcija I rekurrzivno).
sumkp :: [Int] -> Int
sumkp l = sum b
  where
    --a= map(^2) (filter (\ c -> c `mod` 2 ==0) l)

    b= [x | x<-l, a<-l, a `mod` 2 ==0, x==a^2]

--11.	Suma kvadarta brojeva deljivih sa 5 iz date liste
sumk5 :: [Int] -> Int
sumk5 l = sum (map(^2)(filter (\a-> a `mod` 5 ==0) l))

--12.	Ukloni k-ti element iz liste ( rekurzivno i koriscenjem gotovih funkcija), ako elemente liste brojimo od 0.
brisik :: Int -> [Int] -> [Int]
brisik k l = (take (k) l) ++ (drop (k+1) l)

brisik1 :: Int -> [Int] -> [Int]
brisik1 _ [] = []
brisik1 k (x:xs) | k==0 = xs
                 | otherwise = x : (brisik1 (k-1) xs)

--13.	Dodaj x na k-to mesto u listi(rekurzivno i koriscenjem gotovih funkcija),ako elemente liste brojimo od 1)
dodaj :: Int -> Int -> [Int] -> [Int]
dodaj _ _ [] = []
dodaj x k (y:ys) | k==1 = x:(y:ys)
                 | otherwise = y: dodaj x (k-1) ys

dodaj1 :: Int -> Int -> [Int] -> [Int]
dodaj1 x k l = (take (k-1) l) ++ [x] ++ (drop (k-1) l)

--14.	Zbir svih elemanta liste deljivih sa 5 na dva nacina koriscenjem funkcija,rekurzivno
zbir5 :: [Int] -> Int
zbir5 l = sum (filter (\a-> a `mod` 5 == 0) l)

zbir51 :: [Int] -> Int
zbir51 [] = 0
zbir51 (x:xs) | x `mod` 5 ==0 = x + zbir51 xs
              | otherwise = zbir51 xs

--15.	Zbir kvadrata svih elemanat liste deljivih sa 10 na dva nacina koriscenjem funkcija,rekurzivno
zbir210 :: [Int] -> Int
zbir210 l = sum (map(^2) (filter (\a-> a `mod` 10 ==0) l))

zbir2101 :: [Int] -> Int
zbir2101 [] = 0
zbir2101 (x:xs) | x `mod` 10 ==0 = x^2 + zbir2101 xs
                | otherwise = zbir2101 xs

--Racunamo sve pozicije broja a u listi. Na dva nacina rekurzivno i koriscenjem gotovih funkcija
razbij :: [(Int,Int)] -> [Int]
razbij [] = []
razbij ((x1,x2):xs) = [x1]++[x2]++ razbij xs

pozicija :: Int -> [Int] -> [Int]
pozicija a l = g
  where
    j= zip l [1..(length l)]
    k= filter (\(x,y)-> x==a) j
    h= razbij k
    g= filter (\s-> s/=a) h

--pozicija1 :: Int -> [Int] -> [Int]
--pozicija1 _ [] = []
--pozicija1 a (x:xs) | x==a = [i]++ pozicija a xs
--                   | otherwise = pozicija a xs

--19.	Od date liste napravi listu bez uzastopnih ponavljanja [1,1,1,1,1,2,2,1,3,3]  [1,2,1,3]. Zadatak resitii rekurzivno i koriscenjem gotovih funkcija
--bezp :: [Int] -> [Int]
--bezp [] = []
--bezp [x] = [x]
--bezp (x:y)  
             --x==y = [x]
             --otherwise = (x:y)
--bezp (x:(y:r)) | x==y = bezp (y:r)
               --| --otherwise = [x]++ bezp r

--21.	Od date dve liste naparvi novu u kojoj naizmenicno upisujemo elemente datih lista za [1,2,3] [10,11,12,13,14]   dobijamo [1,10,2,11,3,12,13,14]
naizm :: [Int] -> [Int] -> [Int]
naizm [] l = l
naizm l [] = l
naizm (x:xs) (y:ys) = x:(naizm (y:ys) xs)
GHCi, version 8.6.5