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::io;
use std::cmp;
use std::collections::BinaryHeap;
use std::collections::HashMap;

fn read_line() -> String {
    let mut buf = String::new();
    io::stdin().read_line(&mut buf).ok();
    buf
}

fn get_order(n: usize) -> usize {
    let mut m = n;
    let mut order = 1;
    while m/10 > 0 {
        order += 1;
        m /= 10;
    }
    order
}

fn get_count(n: usize) -> Option<(bool,bool,bool)> {
    let mut a = false;
    let mut b = false;
    let mut c = false;

    let mut m = n;

    while m > 0 {
        let p = m%10;
        if p==3 {
            a = true;
        } else if p==5 {
            b = true;
        } else if p==7 {
            c = true;
        } else {
            return None;
        }
        m /= 10
    }

    Some((a,b,c))
}

fn func(n: usize, a: bool, b: bool, c: bool) -> usize {
    let mut ans = 0;

    let mut tmp = 1;
    while n >= tmp {
        tmp *= 10;
    }
    tmp /= 10;

    for i in tmp..n+1 {
        match get_count(i) {
            Some((a2, b2, c2)) => {
                if (!a || a2) && (!b || b2) && (!c || c2) {
                    ans += 1
                }
            },
            None => {},
        }
    }

    ans
}

fn func2(n: usize, a: bool, b: bool, c: bool) -> usize{
    let mut ans = 0;

    for i in 0..n+1 {
        match get_count(i) {
            Some((a2, b2, c2)) => {
                if (a == a2) && (b == b2) && (c == c2) {
                    ans += 1
                }
            },
            None => {},
        }
    }

    ans
}

fn main() {
    let n: usize = read_line().trim().parse().unwrap();
    
    let order = get_order(n);

    if order < 3 {
        println!("{}", 0);
    } else {
        let mut ans = 0;
        let higher = n / 1000;
        let lower = n % 1000;

        match get_count(higher) {
            Some((a,b,c)) => {
                ans += func(lower, !a, !b, !c);
            }
            _ => {}
        }

        if higher > 0 {
            ans += func(999, true, true, true);
            ans += func2(higher - 1, false, false, true) * func(999, true, true, false);
            ans += func2(higher - 1, false, true, false) * func(999, true, false, true);
            ans += func2(higher - 1, false, true, true) * func(999, true, false, false);
            ans += func2(higher - 1, true, false, false) * func(999, false, true, true);
            ans += func2(higher - 1, true, false, true) * func(999, false, true, false);
            ans += func2(higher - 1, true, true, false) * func(999, false, false, true);
            ans += func2(higher - 1, true, true, true) * func(999, false, false, false);
        }
        println!("{}", ans);
    }
}