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 Ruby (2.3.3) (judge verdict: Accepted)

DBG = !true
n,m = gets.split.map{|z| z.to_i}
a = gets.split.map{|z| z.to_i}

a.reject!{|z| z==6} if a.include?(9)
a.reject!{|z| z==3} if a.include?(5)
a.reject!{|z| z==2} if a.include?(5)
a.reject!{|z| z==2} if a.include?(3)
a.sort!
$a = a
use = [ 0,2,5,5,4,5,6,3,7,6 ]
$use = use
$sortu = a.map{|z| use[z]}.sort
base = $sortu[0]
mass = (n-(base)*(a[-1]))/base
rest = n - mass*base
$ans = Array.new(a.size, 0)
$best = Array.new(a.size, 0)
$best[0] = -1

$a2ssuf = Array.new(10, -1)
for i in 0...a.size
  for j in 0...a.size
    $a2ssuf[a[i]] = j if $sortu[j] == use[a[i]]
  end
end

if DBG
  print a
  print $sortu
  print $a2ssuf
  puts "base #{base} mass #{mass} rest #{rest}"
end

def better(ans, best)
  return true if best[0] == -1
  asum = ans.inject(:+)
  bsum = best.inject(:+)
  return true if asum > bsum
  return false if bsum > asum
  ($a.size-1).downto(0) { |i|
    s = $a2ssuf[$a[i]]
    return true if ans[s] > best[s]
    return false if ans[s] < best[s]
  }
  return false # either ok
end

def srch(i,r)
  sz = $sortu.size
  puts "srch i #{i} r #{r} called sz #{sz}" if DBG
  if i == sz-1
    return if r % $sortu[-1] != 0
    $ans[sz-1] = r / $sortu[-1]
    if better($ans, $best)
      $best = $ans.map{|z|z}
      if DBG
        print $best
        puts "updated best"
      end
    end
  else
    for j in 0..(r/$sortu[i])
      $ans[i] = j
      srch(i+1, r - j*$sortu[i])
    end
  end
end

srch(0,rest)
print $best if DBG
(a.size-1).downto(0) { |i|
  rpt = $best[$a2ssuf[a[i]]] + (use[a[i]] == base ? mass : 0)
  puts "i #{i} ai #{a[i]} asuf #{$a2ssuf[a[i]]} " +
       "use #{use[a[i]]}" if DBG
  rpt.times { print a[i] }
}
puts ""