Count of integers having difference with its reverse equal to D

Given an integer D, the task is to find the count of all possible positive integers N such that reverse(N) = N + D.

Examples:

Input: D = 63
Output: 2
Explanation:
For N = 18, 18 + 63 = 81, which satisfies the condition N + D = reverse(N).
For N = 29, 29 + 63 = 92, which satisfies the condition N + D = reverse(N).
Therefore, the required output is 2
Input: D = 75
Output: 0

Approach: The problem can be solved based on the following observations:

N + D = reverse(N) => N – reverse(N) = D
=> D = ?_{(i=0 to [L/2]-1)}(10^L-1-i -10ⁱ )*( n_i– n_L-1-i), L = Count of digits in N.
If d_i = n_i ? n_L?1?i(0 ? i ? ?L/2? ? 1)
reverse(N) ? N = ?_{(i=0 to [L/2]-1)}(10^L-1-i -10ⁱ )*d_i

Follow the steps below to solve the problem:

Let f(L, D) = reverse(N) ? N. Finding the count of N that satisfy the given formula is almost equivalent to enumerating the pairs of L and a sequence of integers in the range [?9, 9], { d₀, d₁, . . ., d_?L/2??1 } (take into account that there is more than one N that corresponds to a sequence of d_i, though). Here, for any i such that 0 ? i < ?L/2? ? 1, the following holds:

10^L?1?i ? 10ⁱ> ?_{(j=i+1 to [L/2 – 1])}((10^L?1?j ? 10^j) · 9) + 10^L??L/2?

Let L_D be the number of digits of D in decimal notation. Then, when L > 2L_D and f(L, d) > 0, it can be seen that f(L, d) > D.
Therefore, it is enough to consider the values between L_D and 2L_D as the value of L.
For a fixed value of L, consider enumerating the sequences { d₀, d₁, …, d_?L/2??1 } such that f(L, d) = D (and finding the count of N that satisfy the given formula), by performing Depth First Search starting from d₀.
When the values up to d_i?1 are already decided, it can be seen that there are at most two candidates of the value of d_i that have to be considered: the maximum value such that (10ⁱ ? 10^L?1?i )d_i ? dif , and the minimum value such that (10ⁱ ? 10^L?1?i)d_i> dif . (Intuitively, if the “halfway” value of f(L, d) during the search gets too far from D, it is not possible to “get back”, and thus it should “stay close” to D.)
Therefore, for a fixed value of L, find the count of N that satisfy the given formula in O(2^?L/2?) time.

Below is the implementation of the above approach :

C++

// Cpp program for the
// above approach
#include <bits/stdc++.h>
 
using namespace std;
 
// Maximum digits in N
int MAXL = 17;
int N;
vector<int> v;
 
// Function to find count
// of possible values
// of N such that N + D = reverse(N)
int count(int D, int l, int t, int x[])
{
 
    // Base Case
    if (t == N) {
 
        // If D is not equal to 0
        if (D != 0)
            return 0;
 
        // Stores count of possible values
        // of N such that N + D = reverse(N)
        long ans = 1;
 
        for (int i = 0; i < N; i++) {
 
            // Update ans
            ans *= (i == 0 ? 9 : 10) - abs(x[i]);
        }
 
        // If l is even
        if (l % 2 == 0) {
 
            // Update ans
            ans *= 10;
        }
 
        return ans;
    }
 
    // Stores count of possible values
    // of N such that N + D = reverse(N)
    long ans = 0;
 
    // Iterate over the range [-9, 9]
    for (int m = -9; m <= 9; m++) {
 
        if (-v[t] < D + v[t] * m && D +
                      v[t] * m < v[t]) {
 
            x[t] = m;
 
            // Update ans
            ans += count(D + v[t] * m, l,
                                 t + 1, x);
        }
    }
 
    return ans;
}
 
// Utility function to find count of N
// such that N + D = reverse(N)
int findN(int D)
{
 
    // If d is a multiple of 9,
    // no such value N found
    if (D % 9 != 0)
        return 0;
 
    // Divide D by 9 check reverse
    // of number and its sum
    D /= 9;
 
    // B[i]: Stores power of (10, i)
    vector<int> B(MAXL);
    B[0] = 1;
 
    // Calculate power(10, i)
    for (int i = 1; i < MAXL; i++) {
 
        // Update B[i]
        B[i] = B[i - 1] * 10;
    }
 
    // Stores count of N such
    // that N + D = reverse(N)
    int ans = 0;
 
    // Iterate over the range [1, MAXL]
    for (int i = 1; i <= MAXL; i++) {
 
        N = (i + 1) / 2;
        v.clear();
        v.resize(N);
        for (int j = 0; j < N; j++)
            for (int k = j; k < i - j; k++)
                v[j] += B[k];
 
        int arr[N];
        ans += count(D, i, 0, arr);
    }
 
    return ans;
}
 
// Driver Code
int main()
{
    int D = 63;
 
    // Function call
    cout << findN(D);
}

Java

// Java program of the above approach
import java.util.*;
 
public class Main {
 
    // Maximum digits in N
    static final int MAXL = 17;
    static int N;
    static long[] v;
 
    // Utility function to find count of N
    // such that N + D = reverse(N)
    static long findN(int D)
    {
 
        // If d is a multiple of 9,
        // no such value N found
        if (D % 9 != 0)
            return 0;
 
        // Divide D by 9 check reverse
        // of number and its sum
        D /= 9;
 
        // B[i]: Stores power of (10, i)
        long[] B = new long[MAXL];
        B[0] = 1;
 
        // Calculate power(10, i)
        for (int i = 1; i < MAXL; i++) {
 
            // Update B[i]
            B[i] = B[i - 1] * 10;
        }
 
        // Stores count of N such
        // that N + D = reverse(N)
        long ans = 0;
 
        // Iterate over the range [1, MAXL]
        for (int i = 1; i <= MAXL; i++) {
 
            N = (i + 1) / 2;
            v = new long[N];
            for (int j = 0; j < N; j++)
                for (int k = j; k < i - j; k++)
                    v[j] += B[k];
 
            // Update ans
            ans += count(D, i, 0, new int[N]);
        }
 
        return ans;
    }
 
    // Function to find count of possible values
    // of N such that N + D = reverse(N)
    static long count(long D, int l,
                      int t, int[] x)
    {
 
        // Base Case
        if (t == N) {
 
            // If D is not equal to 0
            if (D != 0)
                return 0;
 
            // Stores count of possible values
            // of N such that N + D = reverse(N)
            long ans = 1;
 
            for (int i = 0; i < N; i++) {
 
                // Update ans
                ans *= (i == 0 ? 9 : 10)
                       - Math.abs(x[i]);
            }
 
            // If l is even
            if (l % 2 == 0) {
 
                // Update ans
                ans *= 10;
            }
 
            return ans;
        }
 
        // Stores count of possible values
        // of N such that N + D = reverse(N)
        long ans = 0;
 
        // Iterate over the range [-9, 9]
        for (int m = -9; m <= 9; m++) {
 
            if (-v[t] < D + v[t] * m
                && D + v[t] * m < v[t]) {
 
                x[t] = m;
 
                // Update ans
                ans += count(D + v[t] * m,
                             l, t + 1, x);
            }
        }
 
        return ans;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int D = 63;
 
        // Function call
        System.out.println(findN(D));
 
        sc.close();
    }
}

Python3

# Python program of the above approach
 
# Maximum digits in N
MAXL = 17;
N = 0;
v = 0;
 
# Utility function to find count of N
# such that N + D = reverse(N)
def findN(D):
    global N;
    global v;
     
    # If d is a multiple of 9,
    # no such value N found
    if (D % 9 != 0):
        return 0;
 
    # Divide D by 9 check reverse
    # of number and its sum
    D //= 9;
 
    # B[i]: Stores power of (10, i)
    B = [0]*MAXL;
    B[0] = 1;
 
    # Calculate power(10, i)
    for i in range(1, MAXL):
       
        # Update B[i]
        B[i] = B[i - 1] * 10;
 
    # Stores count of N such
    # that N + D = reverse(N)
    ans = 0;
 
    # Iterate over the range [1, MAXL]
    for i in range(1, MAXL + 1):
        N = (i + 1) // 2;
        v = [0]*N;
        for j in range(N):
            for k in range(j, i - j):
                v[j] += B[k];
 
        # Update ans
        temp = [0]*N;
        ans += count(D, i, 0, temp);
        return ans;
 
# Function to find count of possible values
# of N such that N + D = reverse(N)
def count(D, l, t, x):
    global N;
    global v;
     
    # Base Case
    if (t == N):
 
        # If D is not equal to 0
        if (D != 0):
            return 0;
 
        # Stores count of possible values
        # of N such that N + D = reverse(N)
        ans = 1;
        for i in range(N):
           
            # Update ans
            ans *= (9 if i == 0 else 10) - abs(x[i]);
 
        # If l is even
        if (l % 2 == 0):
           
            # Update ans
            ans *= 10;
        return ans;
 
    # Stores count of possible values
    # of N such that N + D = reverse(N)
    ans = 0;
 
    # Iterate over the range [-9, 9]
    for m in range(-9, 10):
        if (-v[t] < D + v[t] * m and D + v[t] * m < v[t]):
            x[t] = m;
 
            # Update ans
            ans += count(D + v[t] * m, l, t + 1, x);
    return ans;
 
# Driver Code
if __name__ == '__main__':
    D = 63;
 
    # Function call
    print(findN(D));
 
    # This code is contributed by 29AjayKumar

C#

// C# program for the above approach
using System;
class GFG
{
   
    // Maximum digits in N
    static int MAXL = 17;
    static int N;
    static long[] v;
 
    // Utility function to find count of N
    // such that N + D = reverse(N)
    static long findN(int D)
    {
 
        // If d is a multiple of 9,
        // no such value N found
        if (D % 9 != 0)
            return 0;
 
        // Divide D by 9 check reverse
        // of number and its sum
        D /= 9;
 
        // B[i]: Stores power of (10, i)
        long[] B = new long[MAXL];
        B[0] = 1;
 
        // Calculate power(10, i)
        for (int i = 1; i < MAXL; i++)
        {
 
            // Update B[i]
            B[i] = B[i - 1] * 10;
        }
 
        // Stores count of N such
        // that N + D = reverse(N)
        long ans = 0;
 
        // Iterate over the range [1, MAXL]
        for (int i = 1; i <= MAXL; i++)
        {
            N = (i + 1) / 2;
            v = new long[N];
            for (int j = 0; j < N; j++)
                for (int k = j; k < i - j; k++)
                    v[j] += B[k];
 
            // Update ans
            ans += count(D, i, 0, new int[N]);
        }
        return ans;
    }
 
    // Function to find count of possible values
    // of N such that N + D = reverse(N)
    static long count(long D, int l,
                      int t, int[] x)
    {
 
        // Base Case
        if (t == N)
        {
 
            // If D is not equal to 0
            if (D != 0)
                return 0;
 
            // Stores count of possible values
            // of N such that N + D = reverse(N)
            long ans = 1;
            for (int i = 0; i < N; i++)
            {
 
                // Update ans
                ans *= (i == 0 ? 9 : 10)
                       - Math.Abs(x[i]);
            }
 
            // If l is even
            if (l % 2 == 0)
            {
 
                // Update ans
                ans *= 10;
            }
            return ans;
        }
 
        // Stores count of possible values
        // of N such that N + D = reverse(N)
        long anss = 0;
 
        // Iterate over the range [-9, 9]
        for (int m = -9; m <= 9; m++)
        {
            if (-v[t] < D + v[t] * m
                && D + v[t] * m < v[t])
            {
                x[t] = m;
 
                // Update ans
                anss += count(D + v[t] * m,
                             l, t + 1, x);
            }
        }
        return anss;
    }
  
  // Driver code
  public static void Main(String[] args)
  {
        int D = 63;
 
        // Function call
        Console.WriteLine(findN(D));
  }
}
 
// This code is contributed by code_hunt.

Javascript

<script>
// javascript program of the above approach
 
    // Maximum digits in N
    let MAXL = 17;
    let N;
    let v = []
  
    // Utility function to find count of N
    // such that N + D = reverse(N)
    function findN(D)
    {
  
        // If d is a multiple of 9,
        // no such value N found
        if (D % 9 != 0)
            return 0;
  
        // Divide D by 9 check reverse
        // of number and its sum
        D /= 9;
  
        // B[i]: Stores power of (10, i)
        let B = new Array(MAXL).fill(0); 
         
        B[0] = 1;
  
        // Calculate power(10, i)
        for (let i = 1; i < MAXL; i++) {
  
            // Update B[i]
            B[i] = B[i - 1] * 10;
        }
  
        // Stores count of N such
        // that N + D = reverse(N)
        let ans = 0;
  
        // Iterate over the range [1, MAXL]
        for (let i = 1; i <= MAXL; i++) {
  
            N = Math.floor((i + 1) / 2);
            v = new Array(N).fill(0);
            for (let j = 0; j < N; j++)
                for (let k = j; k < i - j; k++)
                    v[j] += B[k];
  
            // Update ans
            ans += count(D, i, 0, new Array(N));
        }
  
        return ans;
    }
  
    // Function to find count of possible values
    // of N such that N + D = reverse(N)
    function count(D, l, t, x)
    {
  
        // Base Case
        if (t == N) {
  
            // If D is not equal to 0
            if (D != 0)
                return 0;
  
            // Stores count of possible values
            // of N such that N + D = reverse(N)
            let ans = 1;
  
            for (let i = 0; i < N; i++) {
  
                // Update ans
                ans *= (i == 0 ? 9 : 10)
                       - Math.abs(x[i]);
            }
  
            // If l is even
            if (l % 2 == 0) {
  
                // Update ans
                ans *= 10;
            }
  
            return ans;
        }
  
        // Stores count of possible values
        // of N such that N + D = reverse(N)
        let ans = 0;
  
        // Iterate over the range [-9, 9]
        for (let m = -9; m <= 9; m++)
        {
  
            if (-v[t] < D + v[t] * m
                && D + v[t] * m < v[t])
            {
  
                x[t] = m;
  
                // Update ans
                ans += count(D + v[t] * m,
                             l, t + 1, x);
            }
        }
  
        return ans;
    }
  
    // Driver Code
        let D = 63;
  
        // Function call
        document.write(findN(D));
  
 // This code is contributed by target_2.
</script>