i'mstillanoobs

-- First Assignment
-- Reimplement Haskell function
-- DON'T USE GOOGLE
module Noobs where

import Data.List

-- 1.a

null' x
  | x == [] = True
  | otherwise = False

--pembatas

take' 0 x = []
take' x [] = []
take' n (x:xs) = x : take' (n-1) (xs)

--pembatas

drop' 0 x = x
drop' x [] = []
drop' n (x:xs) = drop' (n-1) (xs)

--pembatas

fst' (x,y) = x

--pembatas

snd' (x,y) = y

--pembatas

map' f [] = []
map' f (x:xs) = (f x) : map' f (xs)

--pembatas

filter' _ [] = []
filter' a (x:xs)
  | a x == True = x : filter' a (xs)
  | a x == False = filter' a (xs)

--pembatas

delete' _ [] = []
delete' 0 (x:xs) = (x:xs)
delete' y (x:xs)
  | y == x = xs
  | otherwise = x : delete' y xs

--pembatas

deleteAll' x = x

--pembatas

foldl' x = x

--pembatas

foldl1' x = x

--pembatas

zip' _ [] = []
zip' [] _ = []
zip' (x:xs) (y:ys) = (x,y) : zip' xs ys

--pembatas

zipWith' _ [] _ = []
zipWith' _ _ [] = []
zipWith' f (x:xs) (y:ys) = f x y : zipWith' f xs ys

--pembatas

nth' x = x

--pembatas

scanl' x = x

--pembatas

scanl1' x = x

--pembatas

elem' _ [] = False
elem' a (x : xs)
  | a == x = True
  | a /= x = elem' a (xs)
  | otherwise = True

--pembatas

notElem' _ [] = True
notElem' a (x : xs)
  | a == x = False
  | a /= x = notElem' a (xs)
  | otherwise = False

--pembatas

head' (x:xs) = x

--pembatas

length' [] = 0
length' (x:xs) = 1 + (length' xs)

--pembatas

reverse' [] = []
reverse' (x:xs) = (reverse' xs) ++ [x]

--pembatas

last' [x] = x
last' (x:xs) = last' xs

--pembatas

tail' (x:xs) = xs

--pembatas

init' [x] = []
init' (x:xs) = x : init' xs

--pembatas

max' x y
  | x > y = x
  | otherwise = y

--pembatas

min' x y
  | x > y = y
  | otherwise = x

--pembatas

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

--pembatas

intersperse' a [] = []
intersperse' a [x] = [x]
intersperse' a (x:xs) = x : a : intersperse' a (xs)

--pembatas

intercalate' (x:xs) (y:ys) = (y:ys)

--pembatas

and' [] = True
and' (x:xs)
  | x == False = False
  | otherwise = and' xs

--pembatas

or' [] = False
or' (x:xs)
  | x == True = True
  | otherwise = or' xs

--pembatas

zip3' [] _ _ = []
zip3' _ [] _ = []
zip3' _ _ [] = []
zip3' (x:xs) (y:ys) (z:zs) = (x,y,z) : zip3' xs ys zs

--pembatas

sum' [] = 0
sum' (x:xs) = x + (sum' xs)

--pembatas

product' [] = 1
product' (x:xs) = x * (product' xs)

--pembatas

words' x = x

--pembatas

lines' x = x

--pembatas

unlines' x = x

--pembatas

unwords' x = x

--pembatas

takeWhile' _ [] = []
takeWhile' a (x:xs)
  | a x == False = []
  | a x == True = x : takeWhile' a xs
  | otherwise = takeWhile' a xs

--pembatas

dropWhile' _ [] = []
dropWhile' a (x:xs)
  | a x == False = (x:xs)
  | a x == True = dropWhile' a (xs)
  | otherwise = dropWhile' a (xs)

--pembatas

concatMap' x = x

--pembatas

all' x = x

--pembatas

any' x = x

--pembatas

insert' x = x

--pembatas

zipWith3' x = x

--pembatas

-- 1.b

nub' x = x

--pembatas

sort' x = x

--pembatas

minimum' x = x

--pembatas

maximum' x = x

--pembatas

inits' x = x

--pembatas

tails' x = x

--pembatas

union' x = x

--pembatas

intersect' x = x

--pembatas

group' x = x

--pembatas

splitAt' x = x

--pembatas

partition' x = x

--pembatas

replicate' 0 _ = []
replicate' x y = y : replicate' (x-1) y

--pembatas
-- First Assignment
-- Reimplement Haskell function
-- DON'T USE GOOGLE