Encuentra el número de números enteros positivos menores o iguales a N que tienen un número impar de dígitos

Dado un número entero N donde 1 ≤ N ≤ 10 ⁵ , la tarea es encontrar el número de números enteros positivos menores o iguales a N que tienen un número impar de dígitos sin ceros a la izquierda.
Ejemplos: 
 

Entrada: N = 11 
Salida: 9 
1, 2, 3, …, 8 y 9 son los números ≤ 11 
con número impar de dígitos.
Entrada: N = 893 
Salida: 803 
 

Enfoque ingenuo: Recorra de 1 a N y para cada número verifique si contiene dígitos impares o no.
Enfoque eficiente: Para los valores: 
 

• Cuando N < 10 , el recuento de números válidos será N.
• Cuando N / 10 < 10 entonces 9 .
• Cuando N / 100 < 10 entonces 9 + N – 99 .
• Cuando N / 1000 < 10 entonces 9 + 900 .
• Cuando N/10000 < 10 entonces 909 + N – 9999 .
• De lo contrario 90909 .

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 number of
// positive integers less than or equal
// to N that have odd number of digits
int odd_digits(int n)
{
    if (n < 10)
        return n;
    else if (n / 10 < 10)
        return 9;
    else if (n / 100 < 10)
        return 9 + n - 99;
    else if (n / 1000 < 10)
        return 9 + 900;
    else if (n / 10000 < 10)
        return 909 + n - 9999;
    else
        return 90909;
}
 
// Driver code
int main()
{
    int n = 893;
 
    cout << odd_digits(n);
 
    return 0;
}

// Java implementation of the approach
class GFG
{
 
// Function to return the number of
// positive integers less than or equal
// to N that have odd number of digits
static int odd_digits(int n)
{
    if (n < 10)
        return n;
    else if (n / 10 < 10)
        return 9;
    else if (n / 100 < 10)
        return 9 + n - 99;
    else if (n / 1000 < 10)
        return 9 + 900;
    else if (n / 10000 < 10)
        return 909 + n - 9999;
    else
        return 90909;
}
 
// Driver code
public static void main(String []args)
{
    int n = 893;
 
    System.out.println(odd_digits(n));
}
}
 
// This code is contributed by 29AjayKumar

# Python3 implementation of the approach
 
# Function to return the number of
# positive integers less than or equal
# to N that have odd number of digits
def odd_digits(n) :
 
    if (n < 10) :
        return n;
    elif (n / 10 < 10) :
        return 9;
    elif (n / 100 < 10) :
        return 9 + n - 99;
    elif (n / 1000 < 10) :
        return 9 + 900;
    elif (n / 10000 < 10) :
        return 909 + n - 9999;
    else :
        return 90909;
 
# Driver code
if __name__ == "__main__" :
 
    n = 893;
 
    print(odd_digits(n));
 
# This code is contributed by AnkitRai01

// C# implementation of the approach
using System;
                     
class GFG
{
 
// Function to return the number of
// positive integers less than or equal
// to N that have odd number of digits
static int odd_digits(int n)
{
    if (n < 10)
        return n;
    else if (n / 10 < 10)
        return 9;
    else if (n / 100 < 10)
        return 9 + n - 99;
    else if (n / 1000 < 10)
        return 9 + 900;
    else if (n / 10000 < 10)
        return 909 + n - 9999;
    else
        return 90909;
}
 
// Driver code
public static void Main(String []args)
{
    int n = 893;
 
    Console.WriteLine(odd_digits(n));
}
}
 
// This code is contributed by 29AjayKumar

<script>
// Java script implementation of the approach
 
 
// Function to return the number of
// positive integers less than or equal
// to N that have odd number of digits
function odd_digits( n)
{
    if (n < 10)
        return n;
    else if (n / 10 < 10)
        return 9;
    else if (n / 100 < 10)
        return 9 + n - 99;
    else if (n / 1000 < 10)
        return 9 + 900;
    else if (n / 10000 < 10)
        return 909 + n - 9999;
    else
        return 90909;
}
 
// Driver code
let n = 893;
 
    document.write(odd_digits(n));
 
 
// This code is contributed by sravan kumar Gottumukkala
</script>

803