Gabriel Medina rhaseven7h

Super Digit

We define super digit of an integer x using the following rules:

If x has only 1 digit, then its super digit is x.
Otherwise, the super digit of x is equal to the super digit of the digit-sum of x. Here, digit-sum of a number is defined as the sum of its digits.

For example, super digit of 9875 will be calculated as:

Filter Elements

Given a list of N integers A = [a1, a2, ..., aN], you have to find those integers which are repeated at least K times. In case no such element exists you have to print -1.

If there are multiple elements in A which are repeated at least K times, then print these elements ordered by their first occurrence in the list.

Let's say A = [4, 5, 2, 5, 4, 3, 1, 3, 4] and K = 2. Then the output is

4 5 3

Sequence Full Of Colors

You are given a sequence of N balls in 4 colors: red, green, yellow and blue. The sequence is full of colors if and only if all of the following conditions are true:

There are as many red balls as green balls.
There are as many yellow balls as blue balls.
Difference between the number of red balls and green balls in every prefix of the sequence is at most 1.
Difference between the number of yellow balls and blue balls in every prefix of the sequence is at most 1.

Your task is to write a program, which for a given sequence prints True if it is full of colors, otherwise it prints False.

Captain Prime

Captain Prime is going on a trip to Primeland and needs support of his troops to make this voyage successful. To prevent the wrath of evil spirits, he has to throw out some people from his troop into the sea. This decision will depend on the identification number of the troop member.

His ship is divided into three parts: Left, right, and central. Every person on the ship is assigned an identification number (referred as id), and according to their id they get to work in one part of the ship, or end up getting thrown out of the ship.

A person's fate depends on the following conditions:

	main = do
	raw <- getContents -- readFile "input.txt"
	let toInts a = map (\e -> read e :: Int) a
	noded = map toInts $ map words $ tail $ lines raw
	nodec = length noded
	xdata = map head noded
	ydata = map last noded
	sum1x = xdata
	sum1y = (tail ydata) ++ [head ydata]
	sum2x = (tail xdata) ++ [head xdata]

	slv n "" _ = n
	slv n _ "" = n
	slv n a b
	\| fa == fb = slv (n + 1) (tail a) (tail b)
	\| otherwise = n
	where fa = head a
	fb = head b

	main = do
	raw <- readFile "input.txt"

	import qualified Data.Map.Strict as MS
	import Data.List

	-- Basically a valid function is that which
	-- always return the same output for a given input,
	-- that is, a function that one time returns 3 for f(1)
	-- and the next returns 5 for the same f(1) is NOT
	-- a valid function
	--
	-- This algorithm checks we have unique outputs for

	solve n m = sum times
	where oSize = fromIntegral $ n * m
	oIndices = [ 1 .. oSize ]
	singleProb = (\x -> x / oSize)
	singleTime = (\n -> 1 / (singleProb n))
	times = map singleTime oIndices

	main = do
	raw <- readFile "input.txt"
	let inStrArr = words $ head $ lines raw

	---- Remove Duplicates and return characters in the order they were found

	import Data.List

	solve :: String -> String -> String
	solve b "" = b
	solve b (s:st)
	\| isInfixOf (s : "") b = solve b st
	\| otherwise = solve (s : b) st

	-- Rotate Strings

	import Data.List

	rotate s r = drop r s ++ take r s

	solve s = intercalate " " (tail rss ++ [ head rss ])
	where rss = [ rs \| r <- [ 0 .. (length s - 1) ], let rs = rotate s r ]

	main = do