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 C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApp1
{
    class Program
    {
        static readonly long[] TenPows =
        {
            1,
            10,
            100,
            1000,
            10000,
            100000,
            1000000,
            10000000,
            100000000,
            1000000000,
            10000000000,
            100000000000,
            1000000000000,
        };

        static int GetDigit(long value, int digit) => (int)((value / TenPows[digit]) % 10);

        static long Solve(long n, long?[,,,] memo, int digit = 12, int pattern = 0, bool restricted = true, bool zero = true)
        {
            if (digit < 0)
            {
                return pattern == ((1 << 3) - 1) ? 1 : 0;
            }

            if (memo[digit, pattern, restricted ? 1 : 0, zero ? 1 : 0] != null)
            {
                return memo[digit, pattern, restricted ? 1 : 0, zero ? 1 : 0].GetValueOrDefault();
            }

            long answer = 0;
            int thisDigitNum = GetDigit(n, digit);
            int maxDigit = restricted ? thisDigitNum : 9;
            for (int num = 0; num <= maxDigit; num++)
            {
                int nextPattern = pattern;
                switch (num)
                {
                    case 3:
                        nextPattern |= 1 << 0;
                        break;
                    case 5:
                        nextPattern |= 1 << 1;
                        break;
                    case 7:
                        nextPattern |= 1 << 2;
                        break;
                    default:
                        continue;
                }

                answer += Solve(n, memo, digit - 1, nextPattern, restricted && num == thisDigitNum, false);
            }

            if (zero)
            {
                answer += Solve(n, memo, digit - 1, pattern, thisDigitNum == 0, zero);
            }

            return (memo[digit, pattern, restricted ? 1 : 0, zero ? 1 : 0] = answer).GetValueOrDefault();
        }

        static void Main(string[] args)
        {
            long n = long.Parse(Console.ReadLine());
            Console.WriteLine(Solve(n, new long?[14, 8, 2, 2]));
        }
    }
}