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::str::FromStr;
use std::fmt::Debug;
fn read_as_vec<T>() -> Vec<T>
where T: FromStr, <T as FromStr>::Err : Debug{
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().split_whitespace().map(|c| T::from_str(c).unwrap()).collect()

}

fn read_as_string() -> String{
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().to_string()
}

fn are_all_true(status: &Vec<bool>) -> bool{
    for x in status{
        if *x == false{return false}
    }
    true
}

fn solve(n: u64, status: &mut Vec<bool>, m: u64) -> u64{
    //println!("n = {}, status =  {:?},  m={}", n, status, m);
    let tmp = vec![3, 5, 7];
    let mut counter = 0;
    if are_all_true(status) && n >= m{
        //println!("m = {} is answer!", m);
        counter += 1;
    }

    if n < 10*m{
        //println!("n < m*10, so stop searching");
        return counter;
    }
    for i in 0..tmp.len(){
        //status[i] = true;
        let mut tmp_status = status.clone();
        tmp_status[i] = true;
        counter += solve(n, &mut tmp_status.clone(), m*10+tmp[i]);
    }
    counter

}

fn main(){
    let n: u64 = read_as_vec()[0];

    //get the nubmer of digits
    //let num_digits = get_digits(n);
    
    let mut status = vec![false;3];
    let answer = solve(n, &mut status, 0);
    println!("{}", answer);
}