import Data.List (maximumBy, inits)

repstring :: String -> Maybe String
-- empty strings are not rep strings
repstring [] = Nothing
-- strings with only one character are not rep strings
repstring (_:[]) = Nothing
repstring xs
    | any (`notElem` "01") xs = Nothing
    | otherwise = longest xs
    where
        -- length of the original string
        lxs = length xs
        -- half that length
        lq2 = lxs `quot` 2
        -- make a string of same length using repetitions of a part
        -- of the original string, and also return the substring used
        subrepeat x = (x, take lxs $ concat $ repeat x)
        -- check if a repeated string matches the original string
        sndValid (_, ys) = ys == xs
        -- make all possible strings out of repetitions of parts of
        -- the original string, which have max. length lq2
        possible = map subrepeat . take lq2 . tail . inits
        -- filter only valid possibilities, and return the substrings
        -- used for building them
        valid = map fst . filter sndValid . possible
        -- see which string is longer
        compLength a b = compare (length a) (length b)
        -- get the longest substring that, repeated, builds a string
        -- that matches the original string
        longest ys = case valid ys of
            [] -> Nothing
            zs -> Just $ maximumBy compLength zs

main :: IO ()
main = do
    mapM_ processIO examples
    where
        examples = ["1001110011", "1110111011", "0010010010",
            "1010101010", "1111111111", "0100101101", "0100100",
            "101", "11", "00", "1"]
        process = maybe "Not a rep string" id . repstring
        processIO xs = do
            putStr (xs ++ ": ")
            putStrLn $ process xs