4lab_fp

--1 задание
 
--import Data.Array
--main1 :: IO()
--main1 = do
	--contents <- readFile "input.txt"
	--writeFile "output.txt"(process contents)
	
--process :: String -> String
--process = 
	--unlines.map foo.lines
	
	--foo1::IO()
	--foo1 = readFile "input.txt" >>= writeFile "output.txt" . unlines . map (\s -> (replicate(div(80 - length s)1)' ')++s)
	
	
--foo s =(replicate(div(80 - length s)1)' ')++s

--------------------
import Data.List
import Char
import List
foooo :: IO ()
foooo = do
    contents <- readFile "input.txt"
    writeFile "output.txt" (process contents)

process :: String -> String	
process = unlines.map foo.lines
foo s =(replicate(div(80 - length s)1)' ')++s


--2 задание
-- Способ 1
 
--sumd :: Integer -> Integer
--sumd n = hsd n 2 (n+1)
            -- where hsd n k c | k*k>n          = c
                                  -- | n `mod` k == 0 = if k*k==n then c+k else hsd n (k+1) (c+k+n `div` k)
                                  -- | otherwise      = hsd n (k+1) c
 
-- Способ 2
 
--nsumd :: Integer -> Integer
--nsumd n = 0 + (sum $ filter (\x -> (n `mod` x == 0)&&(n/=x)) [1..n `div` 2 + 1])

--sumd :: Integer -> Integer
--sumd n = hsd n 2 (n+1)
            -- where hsd n k c 	| k*k>n = c
						--		| (n `mod` k == 0) = if k*k==n then c+k else hsd n (k+1) (c+k+n `div` k)
						--		| otherwise= hsd n (k+1) c

--foo_main = foo [1,2,3] 

--foo[]= []
--foo(x:xs) = nsumd x:foo xs

--summ_list [] = 0
--summ_list (x:xs) = nsumd x + summ_list xs



-- Primes from problem 3
primes = 2:filter isPrime [3,5..]
isPrime = null . tail . primeFactors
primeFactors n = factor n primes
    where
        factor n (p:ps)
            | p * p > n    = [n]
            | mod n p == 0 = p:factor (div n p) (p:ps)
            | otherwise    = factor n ps


-- Количество множителей "n"
-- Вычислить простые множители
-- Произведение каждой экспоненты + 1
-- 120 = 2 * 2 * 2 * 3 * 5 = 2 ^ 3 * 3 ^ 1 * 5 ^ 1
-- количество = (3 + 1) * (1 + 1) * (1 + 1) = 16
divisor = product . map ((1+) . length) . group . primeFactors
-- sum = (1+2^1+2^2+2^3) * (1+3^1) * (1+5^1)
sigma = product . map ((+1).foldl1 (\a x -> x+a*x)).group.primeFactors
aliquot n = sigma n - n

amicablePairs = [(a,b) | a <- [1..], let b = aliquot a, a < b, aliquot b == a]

solution = sum . map addTup.takeWhile under10k $ amicablePairs
  where
    addTup (a,b) = a+b
    under10k (a,b) = a < 10000

main = do
    putStr "Solution: "
    putStrLn $ show solution
	
	
	
-- 3 задание
--Find the smallest positive integer, x, such that 2x, 3x, 4x, 5x, and 6x, 
--contain the same digits in some order.
has_same_digits a b = (show a) \\ (show b) == []

check n = all (has_same_digits n) (map (n*) [2..6])

problem_52 = head $ filter check [1..]

--------------------------
--Considering natural numbers of the form, ab, finding the maximum digital sum.
digitalSum 0 = 0
digitalSum n = 
    let (d,m) = quotRem n 10 in m + digitalSum d 
 
problem_56 = 
    maximum [digitalSum (a^b) | a <- [99], b <- [90..99]]