Recuento de todos los números de N dígitos tales que num + Rev(num) = 10^N – 1

Dado un número entero N , la tarea es encontrar el conteo de todos los números de N dígitos tal que num + Rev(num) = 10 ^N – 1
Ejemplos: 

Entrada: N = 2 
Salida: 9 
Todos los números posibles son 
18 + 81 = 99 
27 + 72 = 99 
36 + 45 = 99 
45 + 54 = 99 
54 + 45 = 99 
63 + 54 = 99 
72 + 27 = 99 
81 + 18 = 99 
90 + 09 = 99

Entrada: N = 4 
Salida: 90 

Enfoque Hay 2 casos: 
si n es impar , la respuesta será 0. 

Sea n = 3 , entonces num = d1d2d3 y rev(num) = d3d2d1 
num + rev(num) debe ser 999 ya que n = 3. 
Por lo tanto, las siguientes ecuaciones deben cumplirse 
d1 + d3 = 9 … (1) 
d2 + d2 = 9 … (2) 
d3 + d1 = 9 … (3) 
Considerando la ecuación 2: 
d2 + d2 = 9 
2 * d2 = 9 
d2 = 4.5 lo cual no es posible porque el dígito de un número siempre debe ser un número entero. 
Por lo tanto, si n es impar, la respuesta será 0. 
 

Si n es par , la respuesta será 9 * 10 ^{(N / 2 – 1)} . 
 

Sea n = 4 , luego num = d1d2d3d4 y rev(num) = d4d3d2d1 
Entonces las siguientes ecuaciones deben cumplirse 
d1 + d4 = 9 … (1) 
d2 + d3 = 9 … (2) 
d3 + d2 = 9 … (3) 
d4 + d1 = 9 … (4)
Considerando la ecuación 1: d1 + d4 = 9 . Puede ser cierto de 9 maneras: 
(1 + 8), (2 + 7), (3 + 6), (4 + 5), (5 + 4), (6 + 3), (7 + 2), (8 + 1) y (9 + 0) 
De manera similar, otras ecuaciones también tendrán 9 soluciones + 1 solución más ya que los dígitos restantes no son el primer y último dígito del número y podemos tomar la suma de la forma (0 + 9) . 
Y dado que la mitad de las ecuaciones son iguales 
, por lo tanto, si n es par, la respuesta será9 * 10 ^{(N/2 – 1)} . 
 

A continuación se muestra la implementación del enfoque anterior.

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the
// count of such numbers
int countNumbers(int n)
{
 
    // If n is odd
    if (n % 2 == 1)
        return 0;
 
    return (9 * pow(10, n / 2 - 1));
}
 
// Driver code
int main()
{
    int n = 2;
    cout << countNumbers(n);
 
    return 0;
}

// Java implementation of the approach
class GFG {
 
    // Function to return the
    // count of such numbers
    static int countNumbers(int n)
    {
 
        // If n is odd
        if (n % 2 == 1)
            return 0;
 
        return (9 * (int)Math.pow(10, n / 2 - 1));
    }
 
    // Driver code
    public static void main(String args[])
    {
        int n = 2;
        System.out.print(countNumbers(n));
    }
}

# Python3 implementation of the approach
 
# Function to return the
# count of such numbers
def countNumbers(n):
 
    # If n is odd
    if n % 2 == 1:
        return 0
 
    return (9 * pow(10, n // 2 - 1))
 
# Driver code
if __name__ == "__main__":
 
    n = 2
    print(countNumbers(n))
 
# This code is contributed
# by Rituraj Jain

// C# implementation of the approach
using System;
class GFG {
 
    // Function to return the
    // count of such numbers
    static int countNumbers(int n)
    {
 
        // If n is odd
        if (n % 2 == 1)
            return 0;
 
        return (9 * (int)Math.Pow(10, n / 2 - 1));
    }
 
    // Driver code
    public static void Main()
    {
        int n = 2;
        Console.WriteLine(countNumbers(n));
    }
}

<?php
// PHP implementation of the approach
 
// Function to return the
// count of such numbers
function countNumbers($n)
{
 
    // If n is odd
    if ($n % 2 == 1)
        return 0;
 
    return (9 * (int)pow(10, $n / 2 - 1));
}
 
// Driver code
$n = 2;
echo(countNumbers($n));
 
// This code is contributed by Code_Mech

<script>
 
 
// Javascript implementation of the approach
 
// Function to return the
// count of such numbers
function countNumbers(n)
{
 
    // If n is odd
    if (n % 2 == 1)
        return 0;
 
    return (9 * Math.pow(10, parseInt(n / 2) - 1));
}
 
// Driver code
var n = 2;
document.write(countNumbers(n));
 
 
</script>

9

Tiempo Complejidad: O(1)
Espacio Auxiliar: O(1)