Problem:
Score : 400 points

Problem Statement

Find the largest integer that can be formed with exactly N matchsticks, under the following conditions:

Every digit in the integer must be one of the digits A_1, A_2, ..., A_M (1 \leq A_i \leq 9).

The number of matchsticks used to form digits 1, 2, 3, 4, 5, 6, 7, 8, 9 should be 2, 5, 5, 4, 5, 6, 3, 7, 6, respectively.

Constraints

All values in input are integers.

2 \leq N \leq 10^4

1 \leq M \leq 9

1 \leq A_i \leq 9

A_i are all different.

There exists an integer that can be formed by exactly N matchsticks under the conditions.

Input

Input is given from Standard Input in the following format:

N M
A_1 A_2 ... A_M

Output

Print the largest integer that can be formed with exactly N matchsticks under the conditions in the problem statement.

Sample Input 1

20 4
3 7 8 4

Sample Output 1

777773

The integer 777773 can be formed with 3 + 3 + 3 + 3 + 3 + 5 = 20 matchsticks, and this is the largest integer that can be formed by 20 matchsticks under the conditions.

Sample Input 2

101 9
9 8 7 6 5 4 3 2 1

Sample Output 2

71111111111111111111111111111111111111111111111111

The output may not fit into a 64-bit integer type.

Sample Input 3

15 3
5 4 6

Sample Output 3

654

Solution in Haskell (GHC 7.10.3) (judge verdict: Wrong Answer)

import Control.Arrow
import Control.Monad
import Data.List
import qualified Data.ByteString.Char8 as B
import Data.Ord
import Data.Char
import Data.Function
import Control.Monad.State (State, evalState, gets, modify)
import Data.Map.Strict (Map, lookup, insert, empty)
import Data.Maybe

main :: IO ()
main = readLine >>= main'
    where
        main' [n, m] = readLine >>= putStrLn . solve n

solve :: Int -> [Int] -> String
solve n = build . choose n . map head . groupBy ((==) `on` snd) . sortBy cmpf . map acf
    where
        cmpf lhs rhs = comparing snd lhs rhs `mappend` comparing fst rhs lhs

        build = map (\x -> chr $ ord '0' + x) . sortBy (flip compare)

choose :: Int -> [(Int, Int)] -> [Int]
choose n ((a, ac) : as) = snd . maxFst $ map ans [0..r]
    where
        (r, m) = n `divMod` ac
        ninf = -100000

        maxFst = maximumBy (comparing fst)
        safeMaxFst xs@(_ : _) = return $ maxFst xs 
        safeMaxFst _ = Nothing

        ans x = edit . run memo $ m + y * ac
            where
                y = r - x
                edit (Just (c, res)) = (x + c, replicate x a ++ res)
                edit _ = (ninf, [])

        memo f i
            | i > 0 = safeMaxFst . map fromJust . filter (/= Nothing) <$> mapM next as
            | i < 0 = return Nothing
            | otherwise = return $ Just (0, [])
            where
                next (b, bc) = safeEdit b <$> f (i - bc)
                safeEdit b = fmap (first succ . second (b :))


acf :: Int -> (Int, Int)
acf a
    | a == 1 = (a, 2)
    | a == 7 = (a, 3)
    | a == 4 = (a, 4)
    | a `elem` [2, 3, 5] = (a, 5)
    | a `elem` [6, 9] = (a, 6)
    | otherwise = (a, 7)

type Memoizer a b = a -> State (Map a b) b

run :: (Ord a) => (Memoizer a b -> Memoizer a b) -> a -> b
run f = flip evalState empty . memoizeFix f

memoizeFix :: (Ord a) => (Memoizer a b -> Memoizer a b) -> Memoizer a b
memoizeFix f x = gets (Data.Map.Strict.lookup x) >>= maybe (f (memoizeFix f) x >>= ((<$) <*> (modify . Data.Map.Strict.insert x))) return

readLine :: IO [Int]
readLine = unfoldr (\s -> second (maybe B.empty snd . B.uncons) <$> B.readInt s) <$> B.getLine

readContents :: Int -> IO [[Int]]
readContents = flip replicateM readLine