Número máximo en la pantalla de 7 segmentos usando N segmentos: Recursivo

Dado un número entero N , la tarea es encontrar el número más grande que se puede mostrar con la ayuda de N segmentos usando cualquier número de pantallas de 7 segmentos.
Ejemplos: 
 

Entrada: N = 4 
Salida: 11 
Explicación: 
El número más grande que se puede mostrar con la ayuda de 4 segmentos usando 2 pantallas de siete segmentos giradas es 11. 
 

Entrada: N = 7 
Salida: 711 
Explicación: 
El número más grande que se puede mostrar al encender siete segmentos es 711 con la ayuda de un conjunto de pantalla de 3 segmentos. 
 

Enfoque: 
La observación clave en la pantalla de siete segmentos es encender cualquier número del 0 al 9 para tomar cierta cantidad de segmentos, que se describe a continuación: 
 

Si se observa detenidamente el problema, entonces el número N puede ser de dos tipos, par o impar y cada uno de ellos debe resolverse por separado de la siguiente manera: 
 

• Para par: como en la imagen de arriba, hay 6 números que se pueden mostrar usando un número par de segmentos que es 
   

0 - 6
1 - 2
2 - 5
4 - 4
6 - 6
9 - 6

• Como se observa, el número 1 utiliza el conteo mínimo de segmentos para mostrar un dígito. Entonces, incluso el número de segmentos se puede mostrar utilizando 1 con 2 recuentos de segmentos en cada dígito. 
   
• Para impar: como en la imagen de arriba, hay 5 números que se pueden mostrar usando un número impar de segmentos que es 
   

3 - 5
5 - 5
7 - 3
8 - 7

• Como se observa, el número 7 utiliza el número mínimo de segmentos impares para mostrar un dígito. Luego, se puede mostrar un número impar de segmentos usando 7 con 3 conteos de segmentos en cada dígito. 
   

Algoritmo: 
 

• Si el número dado N es 0 o 1 , entonces no se puede mostrar ningún número con esta cantidad de bits.
• Si el número N dado es impar, entonces el dígito más significativo será 7 y el resto de los dígitos se pueden mostrar con la ayuda de los segmentos (N – 3) porque para mostrar 7 se necesitan 3 segmentos.
• Si el número N dado es par, entonces el dígito más significativo será 1 y el resto de los dígitos se pueden mostrar con la ayuda de los segmentos (N – 2) porque para mostrar 1, solo se necesitan 2 segmentos.
• El número N se procesa dígito a dígito recursivamente.

Explicación con Ejemplo: 
Dado el número N sea – 11 
 

Entonces, el número más grande será 71111 .
A continuación se muestra la implementación del enfoque anterior:
 

// C++ implementation to find the
// maximum number that can be
// using the N segments in
// N segments display
 
#include <iostream>
using namespace std;
 
// Function to find the maximum
// number that can be displayed
// using the N segments
void segments(int n)
{
    // Condition to check base case
    if (n == 1 || n == 0) {
        return;
    }
    // Condition to check if the
    // number is even
    if (n % 2 == 0) {
        cout << "1";
        segments(n - 2);
    }
     
    // Condition to check if the
    // number is odd
    else if (n % 2 == 1) {
 
        cout << "7";
        segments(n - 3);
    }
}
 
// Driver Code
int main()
{
    int n;
    n = 11;
    segments(n);
    return 0;
}

// Java implementation to find the
// maximum number that can be
// using the N segments in
// N segments display
class GFG {
     
    // Function to find the maximum
    // number that can be displayed
    // using the N segments
    static void segments(int n)
    {
        // Condition to check base case
        if (n == 1 || n == 0) {
            return;
        }
        // Condition to check if the
        // number is even
        if (n % 2 == 0) {
            System.out.print("1");
            segments(n - 2);
        }
         
        // Condition to check if the
        // number is odd
        else if (n % 2 == 1) {
     
            System.out.print("7");
            segments(n - 3);
        }
    }
     
    // Driver Code
    public static void main (String[] args)
    {
        int n;
        n = 11;
        segments(n);
    }
}
 
// This code is contributed by AnkitRai01

# Python3 implementation to find the
# maximum number that can be
# using the N segments in
# N segments display
 
# Function to find the maximum
# number that can be displayed
# using the N segments
def segments(n) :
 
    # Condition to check base case
    if (n == 1 or n == 0) :
        return;
     
    # Condition to check if the
    # number is even
    if (n % 2 == 0) :
        print("1",end="");
        segments(n - 2);
     
    # Condition to check if the
    # number is odd
    elif (n % 2 == 1) :
 
        print("7",end="");
        segments(n - 3);
 
# Driver Code
if __name__ == "__main__" :
 
    n = 11;
    segments(n);
 
# This code is contributed by AnkitRai01

// C# implementation to find the
// maximum number that can be
// using the N segments in
// N segments display
using System;
 
class GFG {
     
    // Function to find the maximum
    // number that can be displayed
    // using the N segments
    static void segments(int n)
    {
        // Condition to check base case
        if (n == 1 || n == 0) {
            return;
        }
        // Condition to check if the
        // number is even
        if (n % 2 == 0) {
            Console.Write("1");
            segments(n - 2);
        }
         
        // Condition to check if the
        // number is odd
        else if (n % 2 == 1) {
     
            Console.Write("7");
            segments(n - 3);
        }
    }
     
    // Driver Code
    public static void Main()
    {
        int n;
        n = 11;
        segments(n);
    }
}
 
// This code is contributed by AnkitRai01

<script>
    // Javascript implementation to find the
    // maximum number that can be
    // using the N segments in
    // N segments display
     
    // Function to find the maximum
    // number that can be displayed
    // using the N segments
    function segments(n)
    {
        // Condition to check base case
        if (n == 1 || n == 0) {
            return;
        }
        // Condition to check if the
        // number is even
        if (n % 2 == 0) {
            document.write("1");
            segments(n - 2);
        }
           
        // Condition to check if the
        // number is odd
        else if (n % 2 == 1) {
       
            document.write("7");
            segments(n - 3);
        }
    }
     
    let n;
    n = 11;
    segments(n);
 
// This code is contributed by divyesh072019.
</script>

71111

Análisis de rendimiento: 
 

• Complejidad de tiempo: como en el enfoque anterior, hay una llamada recursiva que toma tiempo O (N) en el peor de los casos, por lo tanto, la complejidad de tiempo será O (N) .
• Complejidad del espacio auxiliar: como en el enfoque anterior, teniendo en cuenta el espacio de pila utilizado en la llamada recursiva, la complejidad del espacio auxiliar será O (N)