├── .gitignore ├── livescript └── one.ls ├── haskell ├── one1.hs~ ├── one1.hs ├── exercise.edn ├── one.hs ├── two.hs └── three.hs ├── tutorials ├── exercises │ ├── two.edn │ └── one.edn └── haskell │ ├── two.hs │ ├── four.hs │ ├── one.hs │ └── three.hs └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | *.o 2 | *.hi -------------------------------------------------------------------------------- /livescript/one.ls: -------------------------------------------------------------------------------- 1 | sqr = (x) -> x * x 2 | 3 | -------------------------------------------------------------------------------- /haskell/one1.hs~: -------------------------------------------------------------------------------- 1 | module One1 where 2 | 3 | import Data.List 4 | 5 | sqr x = x * x 6 | 7 | -------------------------------------------------------------------------------- /haskell/one1.hs: -------------------------------------------------------------------------------- 1 | module One1 where 2 | 3 | import Data.List 4 | 5 | sqr x = x * x 6 | 7 | cube x = x * (sqr x) -------------------------------------------------------------------------------- /haskell/exercise.edn: -------------------------------------------------------------------------------- 1 | 2 | Re-implement these functions: 3 | 4 | head, tail, cons :, append ++ 5 | 6 | take, drop, product, init, last, reverse, head, tail 7 | (delete1 e ls), (deleteAll e ls), length, concat, splitAt, elem, notElem, (sempilin n i ls) 8 | 9 | : ++ 10 | -------------------------------------------------------------------------------- /haskell/one.hs: -------------------------------------------------------------------------------- 1 | import Data.List 2 | 3 | sqr x = x * x 4 | 5 | add2 x = x + 2 6 | 7 | sum' xs 8 | | null xs = 0 9 | | otherwise = (head xs) + (sum (tail xs)) 10 | 11 | sum'' [] = 0 12 | sum'' (x:xs) = x + (sum'' xs) 13 | 14 | faktorial n 15 | | n == 0 = 1 16 | | otherwise = n * (faktorial (pred n)) 17 | 18 | fakt 0 = 1 19 | fakt n = n * (fakt (pred n)) 20 | 21 | 22 | sum''' [] = 0 23 | sum''' (x:xs) = x + sum''' xs 24 | 25 | prod' [] = 1 26 | prod' (x:xs) = x * prod' xs 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | -------------------------------------------------------------------------------- /tutorials/exercises/two.edn: -------------------------------------------------------------------------------- 1 | Exercises: 2 | take, drop, init, last, tail, ++, reverse, length 3 | 4 | 1. fn third element 5 | 2. fn third from last 6 | 3. bagi 2, tempel lagi tapi yang terakhir dibalik 7 | 4. fn (ntake i n ls) (ntake 3 5 [1,2,3,4,5,6..]) 8 | => [3,4,5,6,7] 9 | 5. fn (first n even numbers) => (even_take n) 10 | => even_take 5 => [2,4,6,8,10] 11 | 6. fn (first n kel a) => (nkel a i) 12 | => nkel a i => nkel 7 5 => [7,14,21,28,35] 13 | 7. product & sum dari n even numbers, mulai dari i 14 | => prod_even 3 5 = [6,8,10,12,14] 15 | => sum_even 3 5 = 16 | 17 | Exercise : 18 | 19 | 1. factors p => factors 20 = [1,2,4,5,10,20] 20 | 2. projecteuler.net => no.1 => jumlah semua kel 3 or 5 dari 1..999 21 | 3. f1 i j => list semua x yang memenuhi syarat 5 < | x+5 | < 20 22 | 4. prima_kah n ?? Num a => a -> Bool 23 | 24 | 25 | -------------------------------------------------------------------------------- /tutorials/haskell/two.hs: -------------------------------------------------------------------------------- 1 | module Two where 2 | import Data.List 3 | 4 | test x = x * x 5 | 6 | sqr x = x * x 7 | 8 | -- sqr (sqr 10) 9 | -- (sqr 10) * (sqr 10) 10 | -- 10 * 10 * 10 * 10 11 | 12 | -- n! = 1 kalo n=0 13 | -- n! = n * (n-1)! <= n > 0 14 | 15 | -- 10.9.8.7.6.5.4.3.2.1 16 | 17 | fak 0 = 1 18 | fak 1 = 1 19 | fak 2 = 2 20 | fak n = n * (fak (n - 1)) 21 | 22 | fact 0 = 1 23 | fact n = n * (fact (n-1)) 24 | 25 | pangkat4 x = (sqr (sqr x)) 26 | 27 | abs' x = if x >= 0 28 | then x 29 | else (-x) 30 | 31 | abs'' x 32 | | x >= 0 = x 33 | | otherwise = -x 34 | 35 | pkt4' x = (sqr x) * (sqr x) 36 | 37 | pkt4 x = a * a 38 | where a = (sqr x) 39 | 40 | prima = [2,3,5,7] 41 | 42 | -- Int, Integer => Integral 43 | -- Bool True & False 44 | 45 | fako y = sum [x^4| x <- [1..y]] 46 | 47 | -- x => quantity 48 | 49 | basis10 x 50 | | x < 10 = [x] 51 | | otherwise = sisa ++ [mod x 10] 52 | where sisa = basis10 (div x 10) 53 | 54 | 55 | 56 | -- 1234 x 4 => 1,2,3,4 57 | -- 1250 - 16 (* 4) 58 | -- 1000 + 200 + 30 + 4 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | -------------------------------------------------------------------------------- /tutorials/haskell/four.hs: -------------------------------------------------------------------------------- 1 | import Data.List 2 | 3 | sample = [1..20] 4 | 5 | -- list comprehension!!! 6 | 7 | -- { x | x E A , x genap } 8 | 9 | lista = [ x | x <- [1..10], odd x] 10 | 11 | listb = [x*x | x <- [1..20], even x] 12 | 13 | cube i = i*i*i 14 | 15 | listc = [cube x | x <- [-10..10], x > 0] 16 | 17 | kel35 i = (mod i 3 == 0) || (mod i 5 == 0) 18 | 19 | listd = [x | x <- [1..100], kel35 x] 20 | 21 | kels35 i j = [x| x <- [i..j], kel35 x] 22 | 23 | kels37 lim = [x^3 | x <- [1..lim], 24 | (mod x 3 == 0) || (mod x 7 == 0)] 25 | 26 | kurangdari10 i = if i < 10 27 | then True 28 | else False 29 | 30 | abs' x 31 | | x >= 0 = x 32 | | otherwise = -x 33 | 34 | kecap a b c i 35 | | i == 1 = ((-b) - (sqrt disk)) / (2 * a) 36 | | i == 2 = ((-b) + (sqrt disk)) / (2*a) 37 | where disk = (b^2) - (4*a*c) 38 | 39 | factors n = [x | x <- [1..n], mod n x == 0] 40 | 41 | prime p = (factors p) == [1,p] 42 | 43 | kels35' i j= [x | x <- [i..j], 44 | (mod x 3 == 0) || (mod x 5 == 0)] 45 | 46 | euler1 = sum $ kels35' 1 999 47 | 48 | f1 i j = [x | x <- [i..j], 49 | (abs' (x+5)) > 5, (abs' (x+5)) < 20] 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | -------------------------------------------------------------------------------- /haskell/two.hs: -------------------------------------------------------------------------------- 1 | import Data.List 2 | 3 | -- Basic recursion 4 | 5 | fak 0 = 1 6 | fak n = n * fak (n-1) 7 | 8 | -- pure recursion => tail recursive functions. 9 | 10 | sum' [] = 0 11 | sum' ls = (head ls) + (sum' $ tail ls) 12 | 13 | -- terima adalah bil di basis 10 jadi basis 7 14 | 15 | basis7 n 16 | | n < 7 = [n] 17 | | otherwise = (basis7 (div n 7)) ++ [mod n 7] 18 | 19 | last'' ls 20 | | length ls == 1 = head ls 21 | | otherwise = last'' $ tail ls 22 | 23 | -- Pattern matching 24 | 25 | head' (x:xs) = x 26 | 27 | second' (_:y:_) = y 28 | 29 | last' (x:xs) 30 | | null xs = x 31 | | otherwise = last' xs 32 | 33 | my_last (x: []) = x 34 | my_last (x:xs) = my_last xs 35 | 36 | -- head, tail, init, last, product, sum,... 37 | -- ++ : 38 | 39 | prod [] = 1 40 | prod (x:xs) = x * (prod xs) 41 | 42 | rev [] = [] 43 | rev (x:xs) = (rev xs) ++ [x] 44 | 45 | -- [1,2,3,4,5] 46 | -- rev [2,3,4,5] ++ [1] 47 | 48 | kali2elm (x:y: []) = [x*y] 49 | kali2elm (x:y:xs) = (x*y) : (kali2elm (y:xs)) 50 | 51 | 52 | kali2elm' (x:y: []) = [x*y] 53 | kali2elm' (x:y:xs) = (x*y) : (kali2elm' xs) 54 | 55 | take' 1 (x:xs) = [x] 56 | take' n (x:xs) = x : (take' (n-1) xs) 57 | 58 | -- take' 3 [1,2,3,4,5] 59 | -- 1 : (take' 2 [2,3,4,5]) 60 | -- 1 : 2 : (take' 1 [3,4,5]) 61 | -- 1 : 2 : [3] 62 | 63 | tailTake n ls = helperTake n ls [] 64 | where helperTake n (x:xs) res 65 | | n == 1 = res ++ [x] 66 | | otherwise = helperTake (pred n) xs hasil 67 | where hasil = res ++ [x] 68 | 69 | 70 | 71 | 72 | 73 | 74 | -------------------------------------------------------------------------------- /tutorials/haskell/one.hs: -------------------------------------------------------------------------------- 1 | import Data.List 2 | 3 | test1 x = x * x * x 4 | 5 | -- y = f(x) = x^2 + x 6 | 7 | -- f(x) => (f x) 8 | 9 | cube x = (sqr x) * x 10 | 11 | sqr x = x * x 12 | 13 | -- sqr 10 = 10 * 10 14 | 15 | akar x = x * x* x 16 | 17 | our_pi = 3.141332424243 18 | 19 | -- data + functions 20 | -- data => domains 21 | -- data types Int, Integer, Char, Float 22 | -- data type Bool 23 | 24 | lista = [1,3..30] 25 | 26 | mutlak x = if x >= 0 then x else (-x) 27 | 28 | -- 0 <= x <= 10 -> x 29 | 30 | mut x = if (x >= 0) && (x <= 10) then x else (-x) 31 | 32 | mutLaK' x 33 | | x >= 0 = x 34 | | otherwise = (-x) 35 | 36 | fun1 x 37 | | (x > 10) = x + 2 38 | | ((0 <= x) && (x <= 10)) = 3 * x 39 | | otherwise = (-x) 40 | 41 | even' p = (0 == (mod p 2)) 42 | 43 | genap lim = [x | x <- [1..lim], even' x] 44 | 45 | lista2 lim = [x | x <- [1..lim], 46 | (0 == (mod x 3)) || (0 == (mod x 7))] 47 | 48 | -- { x | x E bulat, x itu genap } 49 | -- DRY -> dont repeat yourself 50 | 51 | is_div a m = (0 == (mod a m)) 52 | 53 | sol1a lim = sum [x | x <- [1..lim], 54 | (is_div x 3) || (is_div x 5)] 55 | 56 | -- latihan 1. Bikin factorial 57 | -- latihan 2. jumlah sebuah deret aritmatika 58 | -- latihan2 a b n 59 | -- latihan 3. rata2x deret di lat2 60 | 61 | fak1 n = product [1..n] 62 | 63 | fak 0 = 1 64 | fak n = n * (fak $ pred n) 65 | 66 | jum_der a b n = sum $ take n [a,(a+b)..] 67 | 68 | rata2x_der a b n = jumDer `div` n 69 | where jumDer = jum_der a b n 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | -------------------------------------------------------------------------------- /haskell/three.hs: -------------------------------------------------------------------------------- 1 | import Data.List 2 | 3 | max' (x: []) = x 4 | max' (x:xs) 5 | | x > xsmax = x 6 | | otherwise = xsmax 7 | where xsmax = max' xs 8 | 9 | bikin_DA un b lim 10 | | un > lim = [] 11 | | otherwise = un : bikin_DA (un+b) b lim 12 | 13 | delete1 e [] = [] 14 | delete1 e (x:xs) 15 | | e == x = xs 16 | | otherwise = x : (delete1 e xs) 17 | 18 | deleteAll e [] = [] 19 | deleteAll e (x:xs) 20 | | e == x = deleteAll e xs 21 | | otherwise = x : deleteAll e xs 22 | 23 | fact n 24 | | n <= 1 = 1 25 | | otherwise = n * fact (pred n) 26 | 27 | fact' n = fhelper n 1 28 | where fhelper n res 29 | | n <= 1 = res 30 | | otherwise = fhelper (pred n) (n * res) 31 | 32 | -- fact' 5 = fhelper 5 1 33 | -- fhelper 5 1 = fhelper 4 (5*1) 34 | -- fehlper 4 5 = fhelper 3 (4 * 5) 35 | -- fhelper 3 20 = fhelper 2 (3*20) 36 | -- fhelper 2 60 = fhelper 1 (2*60) 37 | -- fhelper 1 120 = 120 38 | 39 | sum' ls = help ls 0 40 | where help [] res = res 41 | help (x:xs) res = help xs (x + res) 42 | 43 | -- sum' [2,3,4] = help [2,3,4] 0 44 | -- help [2,3,4] 0 = help [3,4] (2+0) 45 | -- help [3,4] 2 = help [4] (3+2) 46 | -- help [4] 5 = help [] (4+5) 47 | -- help [] 9 = 9 48 | 49 | -- Utama accumulator 50 | -- (Utama => elemen 1) (elemen 1 => acc) 51 | 52 | -- lambda function 53 | 54 | square x = x * x 55 | sqr = \x -> x * x 56 | 57 | -- higher order function => f input 58 | 59 | -- map f ls => [f e1,f e2, f e3..] 60 | 61 | -- foldl1 (+) [1,2,3,4] 62 | -- ((1 + 2) + 3) + 4 63 | 64 | max2 a b = if a > b then a else b 65 | 66 | prime' n 67 | | n < 10 = elem n [2,3,5,7] 68 | | even n = False 69 | | otherwise = factor n == [1,n] 70 | where factor n = [x|x <- [1..n], mod n x == 0] 71 | 72 | primes = filter prime' [1..] 73 | 74 | -- map f ls => 75 | 76 | -- iterate succ 1 77 | -- [1] 78 | -- [1] ++ [succ 1] => [1,2] 79 | -- [1,2] ++ [succ 2] => [1,2,3] 80 | -- [1,2,3] ++ [succ 3] => [1,2,3,4] 81 | 82 | fibolist i = reverse $ res !! (i - 2) 83 | where res = iterate fhelper [1,1] 84 | fhelper (x:y:xs) = x+y : (x:y:xs) 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | -------------------------------------------------------------------------------- /tutorials/haskell/three.hs: -------------------------------------------------------------------------------- 1 | import Data.List 2 | 3 | -- functional programming 4 | 5 | -- x -> y 6 | -- y = f(x) = x^5 + x^3 + 10 7 | 8 | -- data trans. (data & fn) 9 | -- data : types 10 | -- fn : domain & codomain 11 | -- fn : input & output 12 | 13 | -- Predicates => pengujian (True/False) 14 | 15 | -- Identity!!!!!!!!! -> fn & value 16 | 17 | my_pi = 6.28 18 | bilangan_e = 123.24234344 19 | 20 | -- f(x) = x^2 21 | -- f y = y^2 22 | -- f z = x^2 + y^2 23 | 24 | kuadrat_njing x = x * x 25 | 26 | -- (19*3) * (19*3) => 27 | 28 | square n = n * n 29 | 30 | -- f (x,y) => program linear 31 | 32 | add a b = a + b 33 | 34 | -- Tipe 1: => Num -> Num => 10 fns 35 | -- Tipe 2: => predicate => Num => Bool 36 | -- Ngecek even' n, odd' n, kel3kah n, 37 | -- kel3dan5kah n, kel3atau5kah n, 38 | -- pos_kah n, neg_kah n 39 | 40 | kecap a b c = ((-b) + (sqrt disk)) / duaA 41 | where disk = (b^2) - (4*a*c) 42 | duaA = 2*a 43 | 44 | tigatambah5 = 3+5 45 | 46 | even' n = (mod n 2) == 0 47 | 48 | faktor a m = (mod a m) == 0 49 | 50 | pos_kah n = n > 0 51 | 52 | kel3atau5 n = (faktor n 3) || (faktor n 5) 53 | 54 | kel3or5 n = (mod n 3 == 0) || (mod n 5 == 0) 55 | 56 | -- Primitive Num, Char, Bool 57 | -- List & tuples => List 58 | 59 | lista = [1,2,3,4,5,2,34,243,423,243] 60 | 61 | second xs = head $ tail xs 62 | 63 | snd_last xs = last $ init xs 64 | snd_last' xs = head $ tail $ reverse xs 65 | snd_last'' xs = second $ reverse xs 66 | 67 | -- Exercises: 68 | 69 | listb = [1..20] 70 | third xs = xs !! 2 71 | third' xs = head $ tail $ tail xs 72 | 73 | last_third xs = last $ init $ init xs 74 | last_third' xs = xs !! ((length xs) - 3) 75 | l_t xs = head $ tail $ tail $ reverse xs 76 | 77 | stglist xs = take stg xs 78 | where stg = div (length xs) 2 79 | 80 | tail_stg xs = drop stg xs 81 | where stg = div (length xs) 2 82 | 83 | bagi2tempel xs = (stglist xs) ++ (reverse $ tail_stg xs) 84 | 85 | ntake i n xs = take n buang 86 | where buang = drop (pred i) xs 87 | 88 | evens = [2,4..] 89 | 90 | even_take n = take n evens 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | -------------------------------------------------------------------------------- /tutorials/exercises/one.edn: -------------------------------------------------------------------------------- 1 | Haskell curriculum 2 | 3 | 1. Haskell REPL as calculator => operators +,-,/,*,div,mod 4 | 2. Basic concept of identity and functions, global scope & local scope using where (gotchas "tab") 5 | => gotchas (left to right postulat 3, tab yang bener, identity cuma boleh huruf kecil depannya) 6 | 7 | Exercise-1 8 | - bikin luas lingkaran, jari-jari lingkaran, nyari akar kuadrat, nyari s berdasarkan t 9 | 10 | 3. Data types => num, bool, string => operators for specific data types (bool && || not) 11 | 4. predicates => algebraic operators that produces boolean (==, >,<,/=) 12 | => gotchas (function liat input type and output type) 13 | 14 | Exercise-2 15 | - Bikin function yang ngecheck apakah suatu x (genap, ganjil, kel 3/5, kel 3&5, berada pada rentang tertentu) 16 | - bikin function utk ngecheck bil neg/pos 17 | 18 | 5. Conditional evaluation using if and guards => dont forget the tab and identations 19 | 20 | Exercise-3 21 | - Bikin fn untuk nentuin absolute value (mutlak x) 22 | - bikin fn untuk nentuin akar pers kuadrat (akar a b c x) 23 | - bikin fn untuk nentuin fungsi bercabang 24 | - bikin fn perpangkatan yang beda untuk pangkat genap/ganjil (pangkat x n) 25 | 26 | 6. List and ranges, its type notations => [1,2,3], [1..10], [1,3..10], [5,4..1] => [Int] 27 | 7. fns on lists => head, last, tail, init, reverse, : , ++, take, drop 28 | 29 | Exercise-4 30 | - bikin fn utk ngambil element ke n dari sebuah list (pake head and drop) => (elmn n list) 31 | - bikin fn utk ngambil element kedua dari terakhir (last2 list) 32 | - bikin fn utk ngambil n element starting from i-th position (ntake n i ls) 33 | - bikin fn utk ngambil n first even positive integers (pake infinite list) 34 | - bikin fn utk ngambil n first kelipatan a 35 | 36 | 8. More fns on lists => sum, product, sort, length 37 | 38 | Exercise-5 39 | - bikin fn utk jumlahin n first kelipatan a & b 40 | - bikin fn utk jumlahin n first keliatan a or b 41 | - bikin fn utk nyari faktorial n => pake product dan guards 0! = 1 42 | 43 | 9. List comprehensions basic => [result | domain , predicates] 44 | 45 | Exercise-6 46 | - bikin fn yg bikin [1,2,3,4..] => [1,3,5,7,2,4,6,8] 47 | - bikin fn yg isinya kumpulan kuadrat 48 | - bikin fn yg isinya kumpulan 2^n 49 | - bikin infinite list yg isinya daftar genap kelipatan 7 atau 5 50 | - bikin fn (faktor n) yg inputnya suatu pos integer, outputnya list of n factors 51 | 52 | 10. Introduction to type classes 53 | 11. Basic recursion 54 | 55 | Exercise-7 56 | 57 | - reimplement sum, product, take, init, last, fak, drop, and other haskell functions 58 | - reimplement length, tail, average, nub 59 | 60 | 12. Pattern matching and recursions 61 | 62 | Exercise-8 63 | 64 | - Rewrite those functions using pattern matching 65 | 66 | 13. Tail-recursion with accumulator 67 | 68 | Exercise-9 69 | 70 | - Function to sum, product, gathering kel-a, calculating length, fibonacci 71 | 72 | 14. Introduction to problem solving involving recursion 73 | 74 | - Prime-checking algorithm 75 | - fibonacci 76 | - exponent 77 | - [1 1] => [1 2 1] => [1 3 3 1] 78 | 79 | 15. Higher order function => map, filter, foldl, takeWhile, dropWhile, sortBy, groupBy 80 | 81 | Exercise-10 82 | 83 | - efficient summation of fibonacci list 84 | 85 | 86 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | zenx-integrated-learning 2 | ======================== 3 | 4 | Integrated Fundamentals learning for Zenius-X 2015 5 | Learning Thinking, logic, set theory, problem-solving, mathematics, physics, and economics through functional programming in Haskell. 6 | 7 | ### READ THIS FIRST 8 | 9 | ### And watch this 10 | ### And this 11 | 12 | ### This course is now officially available at ZeniusLeague.com 13 | 14 | Note: You have to signup to view the tutorials and works on the exercises 15 | 16 | 17 | ### Steps to follow: 18 | 19 | 1. Install haskell platform from This site 20 | 2. Download heat from This site 21 | 3. Install haskell platform according to your operating system, and remember where you install them 22 | 4. If you don't have java installed, install java 23 | 5. Put your heat.jar in a friendly folder and create a shortcut for easy access to heat 24 | 6. Double click the heat.jar file 25 | 7. You will be asked at setup to connect heat with your haskell, click browse and find the haskell folder, once in there goto bin folder and select ghci.exe 26 | 8. For mac users, come to me for assistance 27 | 9. If you're not asked to connect haskell with heat, then choose from heat menu program-option and follow the step 7 28 | 10. Successful installation will produce a prelude> prompt in heat where you can do things in haskell 29 | 30 | ### List of you and your github repo for this course: 31 | 32 | (This is where you can update this readme directly here) 33 | For those whose name haven't been listed, update this readme asap. 34 | 35 | Example: 36 | 37 | 1. Joni blagoo Repo 38 | 2. UBX INi elo 39 | 3. ubay INi gue 40 | 4. Egi Chrisna INi siapa? :trollface: :trollface: 41 | 5. Aries Y AY 42 | 6. Dhiya Ulhaq Repo 43 | 7. Fadhil Z Repo 44 | 8. Yessy Y Repo 45 | 9. Sonia Capirosi Repo 46 | 10. Gideon Saputra Repo 47 | 11. Dini Nur Anisa Repo 48 | 12. Win Repo 49 | 13. Davin sok asik 50 | 14. Vigo Soambaton Repo 51 | 15. Aminu Rohman Repo 52 | 16. Dea S Putri Repo 53 | 17. Shofura Tsabita Repo 54 | 18. Roberto G. Bartle Cendol gan 55 | 19. Ridho A Pangestu Repo 56 | 20. Gilang Ardya Click and Go 57 | 21. Icha Farihah Repo 58 | 22. A. Abdul Aziz Repo 59 | 23. Tasha Hadianty D Repo 60 | 24. xnomics Repo