Cuente todos los números posibles de N dígitos que satisfagan la condición dada

Dado un número entero N , la tarea es contar todos los números de N dígitos posibles tales que A + reverso(A) = 10 ^N – 1 donde A es un número de N dígitos y reverso(A) es el reverso de A. A no debería haber cualquier 0 inicial.
Ejemplos: 
 

Entrada: N = 2 
Salida: 9 
Todos los números de 2 dígitos posibles son 90, 81, 72, 63, 54, 45, 36, 27 y 18.
Entrada: N = 4 
Salida: 90 
 

Enfoque: primero tenemos que concluir que si N es impar, entonces no hay ningún número que satisfaga la condición dada, demostrémoslo para N = 3 , 
 

, 
tal  y  . 
lo cual es imposible ya que es un número de coma flotante. 
 

Ahora encuentre la respuesta para cuando N es par . Por ejemplo, N=4, 
 

y  ahora si x + y = 9 entonces el número de pares que satisfacen esta condición son 10. 
(0, 9), (1, 8), (2, 7), (3, 6), (4, 5), (5, 4), (6, 3), (7, 2), (8, 1), (9, 0) 
Ahora, el 1.° y el N. ^° dígito no pueden tener el par (0, 9) porque no debería ser cualquier 0 inicial en A, pero para todos los pares N/2-1 restantes puede haber 10 pares. 
Entonces, la respuesta es  , como N es grande, imprimiremos 9 seguido de N/2-1 número de 0. 
 

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

// C++ implementation of above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the count of required numbers
string getCount(int N)
{
 
    // If N is odd then return 0
    if (N % 2 == 1)
        return 0;
 
    string result = "9";
 
    for (int i = 1; i <= N / 2 - 1; i++)
        result += "0";
 
    return result;
}
 
// Driver Code
int main()
{
 
    int N = 4;
    cout << getCount(N);
 
    return 0;
}

// Java implementation of above approach
class GFG
{
    // Function to return the count of required numbers
    static String getCount(int N)
    {
     
        // If N is odd then return 0
        if (N % 2 == 1)
            return "0";
     
        String result = "9";
        for (int i = 1; i <= N / 2 - 1; i++)
            result += "0";
        return result;
    }
     
    // Driver Code
    public static void main(String []args)
    {
     
        int N = 4;
        System.out.println(getCount(N));
    }
}
 
// This code is contributed by ihritik

# Python3 implementation of above approach
 
# Function to return the count of required numbers
def getCount(N):
 
    # If N is odd then return 0
    if (N % 2 == 1):
        return "0"
 
    result = "9"
 
    for i in range (1, N // 2 ):
        result = result + "0"
 
    return result
 
# Driver Code
N = 4
print(getCount(N))
 
# This code is contributed by ihritik

// C# implementation of above approach
using System;
 
class GFG
{
    // Function to return the count of required numbers
    static string getCount(int N)
    {
     
        // If N is odd then return 0
        if (N % 2 == 1)
            return "0";
        string result = "9";
        for (int i = 1; i <= N / 2 - 1; i++)
            result += "0";
        return result;
    }
     
    // Driver Code
    public static void Main()
    {
     
        int N = 4;
        Console.WriteLine(getCount(N));
    }
}
 
// This code is contributed by ihritik

<?php
// PHP implementation of above approach
 
// Function to return the count of
// required numbers
function getCount($N)
{
 
    // If N is odd then return 0
    if ($N % 2 == 1)
        return 0;
 
    $result = "9";
 
    for ($i = 1; $i <= $N / 2 - 1; $i++)
        $result .= "0";
 
    return $result;
}
 
// Driver Code
$N = 4;
echo getCount($N);
 
// This code is contributed by Ryuga
?>

<script>
 
// Javascript implementation of the approach
 
    // Function to return the count of required numbers
    function getCount(N)
    {
     
        // If N is odd then return 0
        if (N % 2 == 1)
            return "0";
     
        let result = "9";
        for (let i = 1; i <= N / 2 - 1; i++)
            result += "0";
        return result;
    }
     
 
// Driver code
 
    let N = 4;
    document.write(getCount(N));
     
</script>

90

Complejidad de tiempo: O(N)

Espacio Auxiliar: O(1)