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 provides
//
// File:  d.go
// Author: ymiyamoto
//
// Created on Sat Feb 16 21:46:31 2019
//
package main

import (
	"fmt"
	"sort"
	"strconv"
	"strings"
)

type pair struct {
	n, m int
}

type pairs []pair

func (ps pairs) Len() int {
	return len(ps)
}

func (ps pairs) Swap(i, j int) {
	ps[i], ps[j] = ps[j], ps[i]
}

func (ps pairs) Less(i, j int) bool {
	if ps[i].m == ps[j].m {
		return ps[i].n > ps[j].n
	}
	return ps[i].m < ps[j].m
}

func main() {
	var n, m int
	fmt.Scan(&n, &m)
	arr := make([]int, m)

	for i := range arr {
		fmt.Scan(&arr[i])
	}
	nums := []int{2, 5, 5, 4, 5, 6, 3, 7, 6}
	ps := make(pairs, 0)

	for _, a := range arr {
		ps = append(ps, pair{a, nums[a-1]})
	}
	sort.Sort(ps)
	minVal, minNum := ps[0].n, ps[0].m
	ans := []string{}
	for i := 0; i < n/minNum; i++ {
		ans = append(ans, strconv.Itoa(minVal))
	}

	rem := n % minNum
	index := len(ans) - 1

	for rem > 0 && index >= 0 {
		init, _ := strconv.Atoi(ans[index])
		next := init
		val := nums[init-1]
		for _, p := range ps {
			if p.n > next && rem >= p.m-nums[init-1] {
				next = p.n
				val = p.m
			}
		}
		rem = rem + nums[init-1] - val
		ans[index] = strconv.Itoa(next)
		index--
	}

	index = 0
	for rem > 0 && index < len(ans) {
		init, _ := strconv.Atoi(ans[index])
		next := 0
		val := nums[init-1]
		for _, p := range ps {
			if p.m >= val && rem >= p.m-nums[init-1] {
				next = p.n
				val = p.m
			}
		}
		rem = rem + nums[init-1] - val
		ans[index] = strconv.Itoa(next)
		index++
	}

	for i, j := 0, len(ans)-1; i < j; i, j = i+1, j-1 {
		ans[i], ans[j] = ans[j], ans[i]
	}
	fmt.Println(strings.Join(ans, ""))
}