ll cal(ll x, ll lim)
{
    ll res = x;
    do {
        int t = x % 10;
        if (res > lim / t) return -1; /// (x * f(x) > N)
        res *= t;
    } while (x /= 10);
    return res;
}

ll brute(ll n)
{
    ll res = 0;
    for (ll x = 1; x <= n; ++x)
        res += cal(x, n) > 0; /// 1 <= x * f(x) <= N

    return res;
}

/// Run 2e13 under 1 secs in (-O2) flag
/// X: current X
/// Y: f(X)
/// T: X * f(X)

ll N;
int res = 0;
vector<int> d;
void build(ll X = 0, ll Y = 1, ll T = 0)
{
    if (T >= 1) ++res; /// 1 <= x * f(x) <= N
    for (int v = 1; v <= 9; ++v) /// if (v = 0) then f(x) = 0
    {
        ll NX = X * 10 + v; /// Insert rightmost digits
        ll NY = Y * v;      /// Calculate digits production
        ll NT = NX * NY;
        if (NT > N) break;  /// x * f(x) > N
        build(NX, NY, NT);
    }
}   

/// [L, R] = [1, N]
/// lim = sqrt(N)
ll solve(int p2 = 0, int p3 = 0, int p5 = 0, int p7 = 0, ll P = 1)
{
    if (P > lim) return 0; /// Dont care such tuples whose P > sqrt(N)

    VL = (L + val - 1) / val; ///  ceil(L / P)
    VR = R / val;             /// floor(R / P)
    ll res = magic(0, 18, p2, p3, p5, p7); /// Calculating subproblem

    /// By doing these if-condition, it is guarantee that all tuples generated are all unique
    if (!p3 && !p5 && !p7) res += solve(p2 + 1, p3, p5, p7, P * 2); /// Continue increasing a
    if (       !p5 && !p7) res += solve(p2, p3 + 1, p5, p7, P * 3); /// Continue increasing b
    if (              !p7) res += solve(p2, p3, p5 + 1, p7, P * 5); /// Continue increasing c
                           res += solve(p2, p3, p5, p7 + 1, P * 7); /// Continue increasing d

    return res;
}

• $$$VL, VR$$$ means the range of $$$x$$$ needed to get $$$1 \leq x \times f(x) \leq N$$$
• Current prefix of building number is $$$X$$$
• We $$$N$$$ digits left to build to the right of $$$X$$$
• $$$p2, p3, p5, p7$$$ means the left factors in $$$f(x)$$$
• $$$min(X, N) = X \times 10^N = \overline{X\underbrace{00000\dots}_{N}}$$$ means the smallest possible number with prefix $$$X$$$ and $$$N$$$ left digits
• $$$max(X, N) = X \times 10^N + 10^N - 1 = \overline{X\underbrace{99999\dots}_{N}}$$$ means the greatest possible number with prefix $$$X$$$ and $$$N$$$ left digits
• $$$cost[v][p]$$$ means greatest divisor $$$p^k$$$ in $$$v$$$ is when $$$k = cost[v][p]$$$
• $$$memo$$$ means current $$$x$$$ is in range $$$[VL, VR]$$$ so we can use memorization
• $$$save = f[N][p2][p3][p5][p7]$$$ means dp-table the numbers of valid number $$$X$$$ with current states
• $$$l_x$$$ means maximum $$$k$$$ that $$$x^k \leq 10^{18}$$$. Where $$$l2, l3, l5, l7, l10$$$ are such those variables we use
• $$$pw10[x] = 10^x$$$

• Initially, $$$X = 0$$$, $$$N = 18$$$, $$$(p2, p3, p5, p7)$$$ is such tuple generated by above function
• $$$X = 0$$$ means it is not build yet
• $$$VL \leq X \leq VR$$$ means $$$1 \leq x \times f(x) \leq N$$$
• $$$N = 0$$$ means $$$X$$$ is built completely
• $$$p2 = p3 = p5 = p7 = 0$$$ means $$$f(x) = P$$$
• $$$max(X) < VL$$$ means $$$x \times f(x) < L$$$ always satisfy which is not desired $$$x$$$ we are considering
• $$$min(X) > VR$$$ means $$$x \times f(x) > R$$$ always satisfy which is not desired $$$x$$$ we are considering
• Building such digit $$$v$$$ will reduce each $$$p2, p3, p5, p7$$$ by $$$cost[v][2], cost[v][3], cost[v][5], cost[v][7]$$$
• $$$memo = false$$$ means if we take memorization here, it is not guarantee that $$$1 \leq x \times f(x) \leq N$$$
• $$$save = -1$$$ means this dp-state it is not calculated yet

const int l2 = 30, l3 = 18, l5 = 12, l7 = 10, l10 = 19;
int       pw2[l2], pw3[l3], pw5[l5], pw7[l7]; ll pw10[l10];
int       cost[10][10];
void precal()
{
    pw2[0] = pw3[0] = pw5[0] = pw7[0] = pw10[0] = 1; 
    for (int i2 = 1; i2 < l2; ++i2) pw2[i2] = pw2[i2 - 1] * 2;
    for (int i3 = 1; i3 < l3; ++i3) pw3[i3] = pw3[i3 - 1] * 3;
    for (int i5 = 1; i5 < l5; ++i5) pw5[i5] = pw5[i5 - 1] * 5;
    for (int i7 = 1; i7 < l7; ++i7) pw7[i7] = pw7[i7 - 1] * 7;
    for (int i  = 1; i  <l10; ++i ) pw10[i] = pw10[i - 1] * 10;                            
                                                                                 /// 2357
    cost[1][2] = 0;     cost[1][3] = 0;     cost[1][5] = 0;     cost[1][7] = 0; /// 0000 1
    cost[2][2] = 1;     cost[2][3] = 0;     cost[2][5] = 0;     cost[2][7] = 0; /// 1000 2
    cost[3][2] = 0;     cost[3][3] = 1;     cost[3][5] = 0;     cost[3][7] = 0; /// 0100 3
    cost[4][2] = 2;     cost[4][3] = 0;     cost[4][5] = 0;     cost[4][7] = 0; /// 2000 4
    cost[5][2] = 0;     cost[5][3] = 0;     cost[5][5] = 1;     cost[5][7] = 0; /// 0010 5
    cost[6][2] = 1;     cost[6][3] = 1;     cost[6][5] = 0;     cost[6][7] = 0; /// 1100 6
    cost[7][2] = 0;     cost[7][3] = 0;     cost[7][5] = 0;     cost[7][7] = 1; /// 0001 7
    cost[8][2] = 3;     cost[8][3] = 0;     cost[8][5] = 0;     cost[8][7] = 0; /// 3000 8
    cost[9][2] = 0;     cost[9][3] = 2;     cost[9][5] = 0;     cost[9][7] = 0; /// 0200 9
}

ll VL, VR;
ll f[l10][l2][l3][l5][l7];
ll magic(ll X, int N, int p2, int p3, int p5, int p7)
{
    if (p2 < 0 || p3 < 0 || p5 < 0 || p7 < 0) return 0;
    if (N == 0) return (p2 + p3 + p5 + p7 == 0) && (VL <= X && X <= VR);

    ll mn = X * pw10[N];
    ll mx = mn + pw10[N] - 1;
    if (mx < VL || mn > VR) return 0;

    ll &save = f[N][p2][p3][p5][p7];
    bool memo = (VL <= mn) && (mx <= VR);
    if (memo) if (save != -1) return save;
    
    ll res = 0;
    if (X == 0) res = magic(0, N - 1, p2, p3, p5, p7);
    for (int v = 1; v <= 9; ++v)
    {
        int c2 = cost[v][2];
        int c3 = cost[v][3];
        int c5 = cost[v][5];
        int c7 = cost[v][7];
        res += magic(X * 10 + v, N - 1, p2 - c2, p3 - c3, p5 - c5, p7 - c7);
    }
    if (memo) save = res;
    
    return res;
}

With (N = 1) -> Found 1 valid tuples || compared to expected 1
With (N = 10) -> Found 3 valid tuples || compared to expected 1
With (N = 100) -> Found 10 valid tuples || compared to expected 3
With (N = 1000) -> Found 22 valid tuples || compared to expected 5
With (N = 10000) -> Found 46 valid tuples || compared to expected 10
With (N = 100000) -> Found 83 valid tuples || compared to expected 17
With (N = 1000000) -> Found 141 valid tuples || compared to expected 31
With (N = 10000000) -> Found 225 valid tuples || compared to expected 56
With (N = 100000000) -> Found 338 valid tuples || compared to expected 100
With (N = 1000000000) -> Found 493 valid tuples || compared to expected 177
With (N = 10000000000) -> Found 694 valid tuples || compared to expected 316
With (N = 100000000000) -> Found 951 valid tuples || compared to expected 562
With (N = 1000000000000) -> Found 1273 valid tuples || compared to expected 1000
With (N = 10000000000000) -> Found 1670 valid tuples || compared to expected 1778
With (N = 100000000000000) -> Found 2155 valid tuples || compared to expected 3162
With (N = 1000000000000000) -> Found 2736 valid tuples || compared to expected 5623
With (N = 10000000000000000) -> Found 3427 valid tuples || compared to expected 10000
With (N = 100000000000000000) -> Found 4246 valid tuples || compared to expected 17782
With (N = 1000000000000000000) -> Found 5194 valid tuples || compared to expected 31622

#include <iostream>
#include <cmath>

using namespace std;

typedef long long ll;

ll L;
ll R;
int lim;
ll solve(int p2 = 0, int p3 = 0, int p5 = 0, int p7 = 0, ll val = 1)
{
    if (val > lim) return 0;
    
    ll res = 1;
    if (!p3 && !p5 && !p7) res += solve(p2 + 1, p3, p5, p7, val * 2);
    if (       !p5 && !p7) res += solve(p2, p3 + 1, p5, p7, val * 3);
    if (              !p7) res += solve(p2, p3, p5 + 1, p7, val * 5);
                           res += solve(p2, p3, p5, p7 + 1, val * 7);

    return res;
}

int main()
{
    for (ll t : {1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18})
    {
        L = 1;
        R = t;
        lim = sqrt(R);
        int expected = sqrt(lim);
        cout << "With (N = " << R << ") -> Found " << solve() << " valid tuples ";
        cout << "|| compared to expected " << expected<< endl;
    }

    return 0;
}