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 Rust (1.15.1) (judge verdict: Runtime Error)

// Try AtCoder
// author: Leonardone @ NEETSDKASU

fn main() {
    let mut stdin = String::new();
    std::io::Read::read_to_string(
        &mut std::io::stdin(),
        &mut stdin).unwrap();
    let mut stdin = stdin.split_whitespace();
    let mut get = || stdin.next().unwrap();
    macro_rules! get {
    	($t:ty) => (get().parse::<$t>().unwrap());
        () => (get!(i64));
    }
    
    let n = get!(usize);
    let m = get!();
    let mut xs = vec![];
    for _ in 0..m {
    	let x = get!(usize);
        xs.push(x);
    }
    let tb = [0, 2, 5, 5, 4, 5, 6, 3, 7, 6];
    
    let mut ys = vec![];
    for &x in xs.iter() {
    	ys.push((tb[x], -(x as i32)));
    }
    
    ys.sort();
    
    let mut e = n;
    let mut zs = vec![];
    for y in ys.iter() {
    	while e > y.0 {
        	zs.push(-y.1);
            e -= y.0;
        }
    }
    if e > 0 {
    	let r = zs.pop().unwrap() as usize;
        e += tb[r];
        let mut best = 0;
        for y in ys.iter() {
        	if y.0 == e {
            	if -y.1 > best {
            		best = -y.1;
				}
            }
        }
        if best > 0 {
        	e = 0;
            zs.push(best);
        }
        if e > 0 && best == 0 {
    		let r = zs.pop().unwrap() as usize;
        	e += tb[r];
        	let mut best = 0;
    		for y1 in ys.iter() {
    			for y2 in ys.iter() {
            		if y1.0+y2.0 == e {
                		if -y1.1*10-y2.1 > best {
                    		best = -y1.1*10-y2.1;
                    	}
                	}
            	}
	    	}
        }
        if e > 0 && best > 0 {
        	zs.push(best / 10 as i32);
        	zs.push(best % 10 as i32);
        	e = 0;
        }
        if e > 0 && best == 0 {
    		let r = zs.pop().unwrap() as usize;
        	e += tb[r];
        	let mut best = 0;
    		for y1 in ys.iter() {
    			for y2 in ys.iter() {
            		for y3 in ys.iter() {
            		if y1.0+y2.0+y3.0 == e {
                		if -y3.1*100-y1.1*10-y2.1 > best {
                    		best = -y3.1*100-y1.1*10-y2.1;
                    	}
                	}
                	}
            	}
	    	}
        	zs.push(best / 100 as i32);
        	zs.push(best % 100 / 10 as i32);
        	zs.push(best % 10 as i32);
        }
	}
    
    zs.sort();
    zs.reverse();
    for &z in zs.iter() {
    	print!("{}", z);
    }
    println!();
}