Problem:
Score : 300 points

Problem Statement

You are given an integer N. Among the integers between 1 and N (inclusive), how many Shichi-Go-San numbers (literally "Seven-Five-Three numbers") are there?

Here, a Shichi-Go-San number is a positive integer that satisfies the following condition:

When the number is written in base ten, each of the digits 7, 5 and 3 appears at least once, and the other digits never appear.

Constraints

1 \leq N < 10^9

N is an integer.

Input

Input is given from Standard Input in the following format:

N

Output

Print the number of the Shichi-Go-San numbers between 1 and N (inclusive).

Sample Input 1

575

Sample Output 1

4

There are four Shichi-Go-San numbers not greater than 575: 357, 375, 537 and 573.

Sample Input 2

3600

Sample Output 2

13

There are 13 Shichi-Go-San numbers not greater than 3600: the above four numbers, 735, 753, 3357, 3375, 3537, 3557, 3573, 3575 and 3577.

Sample Input 3

999999999

Sample Output 3

26484

Solution in Rust (1.15.1) (judge verdict: Accepted)

use std::fmt::Debug;
use std::io;
use std::collections::{VecDeque};
use std::io::Write;

#[cfg(test)]
mod tests;

fn main() {
    // a();
    // b();
    c();
    // d();
}

fn c() { 
    let mut buf = String::new();
    let handle = io::stdin();
    handle.read_line(&mut buf).unwrap();
    let n: isize = buf.trim().parse().unwrap();

    let num_length = format!("{}", n).len() as isize;


    let options = vec![3, 5, 7];
    let mut sets = Vec::new();
    let mut bases = VecDeque::new();
    bases.push_front(vec![]);

    let ans_vec: Vec<isize> = permutation(
        options, bases, sets, num_length as usize
    ).into_iter()
    .filter(|a| include_sichigosan(a))
    .map(|a| vec_to_int(a))
    .filter(|a| a <= &n ).collect();

    println!("{}", ans_vec.len());
}


fn vec_to_int(v: Vec<isize>) -> isize {
    let mut total = 0;
    for (i, v) in v.into_iter().enumerate() {
        total += v * 10_i32.pow(i as u32) as isize; 
    }
    total
}

fn permutation<T: Clone + Debug + Copy>(
    options: Vec<T>,
    mut bases: VecDeque<Vec<T>>,
    mut sets: Vec<Vec<T>>, 
    length: usize
) -> Vec<Vec<T>> {
    let bases_len = bases.len();
    if bases[0].len() == length {
        return sets;
    }
    for b in 0..bases_len {
        let target = bases.pop_back().unwrap();
        for i in &options {
            let mut new_v = target.clone();
            new_v.push(i.clone());
            bases.push_front(new_v.clone());
            sets.push(new_v);
        }
    }
    permutation(options, bases, sets, length) 
}

fn include_sichigosan(v: &Vec<isize>) -> bool {
    let mut check = [false, false, false, true];
    for i in v {
        match *i {
            3 => check[0] = true,
            5 => check[1] = true,
            7 => check[2] = true,
            _ => check[3] = false,
        }
    }
    
    !(check.into_iter().any(|&a| a == false))
}