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.42.0) (judge verdict: Runtime Error)

#![allow(
    non_snake_case,
    unused_variables,
    unused_assignments,
    unused_mut,
    unused_imports,
    dead_code
)]
//use permutohedron::LexicalPermutation as _;
use proconio::{fastout, input, marker::*};
use std::collections::*;
//use std::cmp::*;
//use std::num;
//use petgraph::unionfind::UnionFind;

#[fastout()]
fn main() {
    input! {
        N:i64
    }
    let mut n = N.clone();
    let mut S = Vec::with_capacity(10);
    while n > 0 {
        S.push(N % 10);
        n = n / 10;
    }
    let l = S.len();
    let mut A = vec![0; l];
    A[0] = 7;
    A[1] = 5;
    A[2] = 3;
    if N < 357 {
        println!("0");
        return;
    }
    let mut ans = 0;
    let mut m = 3;
    //println!("n={}", N);
    while m <= N {
        //  println!("A={:?},m={}", A, m);
        ans += 1;
        match next(A) {
            Some((B, c)) => {
                A = B;
                m = c
            }
            None => break,
        };
    }
    println!("{}", ans);
}
fn next(X: Vec<i64>) -> Option<(Vec<i64>, i64)> {
    let mut max_flag = true;
    let mut A = X.clone();
    for i in 0..A.len() {
        if A[i] == 3 || A[i] == 5 {
            A[i] = A[i] + 2;
            max_flag = false;
            break;
        } else if A[i] == 7 {
            A[i] = 3;
        } else {
            // A[i] == 0
            A[i] = 3;
            max_flag = false;
            break;
        }
    }
    if max_flag {
        return None;
    }
    let mut sevens = 0;
    let mut fives = 0;
    let mut threes = 0;
    for i in 0..A.len() {
        match A[i] {
            3 => threes += 1,
            5 => fives += 1,
            7 => sevens += 1,
            _ => (),
        };
    }
    if sevens == 0 || fives == 0 || threes == 0 {
        return next(A);
    }
    let mut ans = 0;
    for i in 0..A.len() {
        ans += A[i] * 10i64.pow(i as u32);
    }
    Some((A, ans))
}