main :: IO ()
main = do
    print $ "Hello world"
    print $ "Common, let's go!"


dominates f g xs = and [abs (f x) >= abs (g x) | x <- xs]

seriesSum :: Double -> Int -> Double
seriesSum n x = [s | i <- [1..n], s <- [x^i + fromIntegral (i^2) + 1]]

listOfIndexes lst = (\x -> [xi + 10 | xi <- lst, xi == x])

findNb :: Integer -> Integer
findNb m = helper m 1
    where
        helper :: Integer -> Integer -> Integer
        helper m i
            | m < i = -1
            | otherwise = helper (m - 1 ^ 3) (i+1)

kthNumber p xs = (\k -> if length filtered > k then error "No such number" else filtered!!(k-1))
    where
        filtered = filter p xs

applyEveryKth f k xs = helper 1 xs
    where
        helper :: Int -> [Int] -> [Int]
        helper _ [] = []
        helper i (x:xs)
            | i == k = f x : helper 1 xs
            | otherwise = x : helper (i+1) xs

speak :: String -> (Char -> String)
speak str c = foldl (\ acc (pos, x) -> if x == c then acc ++ show pos else acc ++ [x]) [] $ zip str $ reverse [0 .. length str - 1]

iterator f xs = helper xs
    where
        helper :: [Int] -> Bool
        helper [] = True
        helper (x:xs)
            | null xs = 0
            | head xs == f x = helper xs
            | otherwise = helper xs

getIndices xs = (\x -> [(pos1, pos2) | (x1, pos1) <- zip xs [0..], (x2, pos2) <- zip xs [0..], x = x1 + x2 && pos1 /= pos2])

removeKth :: Int -> [Int] -> [Int]
removeKth n xs = helper xs 1
    where
        helper :: [Int] -> Int -> [Int]
        helper (x:xs) index
            | index == n = helper xs 1
            | otherwise = x : helper xs (index+1)

factorize :: Int -> [Int]
factorize num = helper num 2
    where
        helper :: Int -> Int -> [Int]
        helper 1 _ = []
        helper leftover divs
            | mod leftover divs == 0 = divs : helper (div leftover 10) divs
            | otherwise = helper leftover (divs+1)

poly xs = (\x -> sum [n * (x^i) | (n, i) <- zip xs [0 .. length xs]])

digits :: Int -> [Int]
digits = map digitToInt . show

decreasing :: [Int] -> Bool
decreasing [] = False
decreasing (x:xs)
    | null xs = True
    | head xs == f x = helper xs
    | otherwise = False

decDigits :: Int -> Bool
decDigits n = decreasing (digits n)