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 Go (1.6) (judge verdict: Wrong Answer)

package main

import (
	"fmt"
	"sort"
)

type num struct {
	key   int
	value int
}

type nums []num

var numList = []num{
	{0, 0},
	{1, 2},
	{2, 5},
	{3, 5},
	{4, 4},
	{5, 5},
	{6, 6},
	{7, 3},
	{8, 7},
	{9, 6},
}

func (n nums) Len() int {
	return len(n)
}

func (n nums) Less(i, j int) bool {
	if n[i].value == n[j].value {
		return n[i].key < n[j].key
	}
	return n[i].value < n[j].value
}

func (n nums) Swap(i, j int) {
	n[i], n[j] = n[j], n[i]
}

func (n nums) Reduce() nums {
	var newN nums
	var currentVal int
	for i := 0; i < len(n); i++ {
		if currentVal < n[i].value {
			currentVal = n[i].value
			newN = append(newN, n[i])
		} else {
			newN[len(newN)-1] = n[i]
		}
	}
	return newN
}

func (n nums) FindMax(mod int) num {
	found := n[0]
	for i := 0; i < len(n); i++ {
		if n[i].value-n[0].value > mod {
			break
		}
		if found.key < n[i].key {
			found = n[i]
		}
	}
	return found
}

func (n nums) FindNext(mod int) num {
	found := n[0]
	for i := 0; i < len(n); i++ {
		if n[i].value-n[0].value > mod {
			break
		}
		found = n[i]
	}
	return found
}

func main() {
	var n, m int
	fmt.Scan(&n, &m)

	var a int
	b := make(nums, m)
	for i := 0; i < m; i++ {
		fmt.Scan(&a)
		b[i] = numList[a]
	}
	sort.Sort(b)
	b = b.Reduce()

	digits := n / b[0].value
	mod := n % b[0].value
	var lastNums nums
	for i := 0; i < digits; i++ {
		if mod > 0 {
			found := b.FindMax(mod)
			if found == b[0] {
				for mod > 0 {
					next := b.FindNext(mod)
					if next == b[0] {
						break
					}
					lastNums = append(lastNums, next)
					mod -= next.value - b[0].value
				}
				fmt.Print(b[0].key)
				continue
			}
			mod -= found.value - b[0].value
			fmt.Print(found.key)
			continue
		}
		if digits-i <= len(lastNums) {
			fmt.Print(lastNums[digits-i-1].key)
			continue
		}
		fmt.Print(b[0].key)
	}
	fmt.Println()
}