Generador de Números Nambiar

M. Nambiar ha ideado un mecanismo para procesar cualquier número dado y generar así un nuevo número resultante. Él llama a este mecanismo como el «Generador de números de Nambiar» y el número resultante se conoce como el «Número de Nambiar».
Mecanismo: en el número dado, comenzando con el primer dígito, sigue sumando todos los dígitos subsiguientes hasta que el estado (par o impar) de la suma de los dígitos sea opuesto al estado (par o impar) del primer dígito. Continúe de esta forma el dígito subsiguiente hasta llegar al último dígito del número. Concatenando las sumas se genera así el Número de Nambiar.
Ejemplos: 
 

Entrada: N = 9880127431 
Salida: 26971 
 

primer dígito Siguientes dígitos consecutivos válidos Número resultante
9 880127431 98801 27431 26
98801 2 7431 98801 27 431 269
9880127 4 31 9880127 43 1 2697
988012743 1 988012743 1 26971

Entrada: N = 9866364552 
Salida: 32157 
 

Enfoque: para el primer dígito no utilizado de la izquierda, compruebe si es par o impar. Si el dígito es par, encuentre la suma de los dígitos consecutivos a partir del dígito actual que es impar (suma par si el primer dígito era impar). Concatene esta suma con el número resultante y repita todo el proceso comenzando desde el primer dígito no utilizado de la izquierda.
A continuación se muestra la implementación del enfoque anterior: 
 

C++

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the Nambiar
// number of the given number
string numbiarNumber(string str, int i)
{
    // If there is no digit to choose
    if (i > str.length())
        return "";
 
    // Choose the first digit
    int firstDigit = str[i] - '0';
 
    // Chosen digit's parity
    int digitParity = firstDigit % 2;
 
    // To store the sum of the consecutive
    // digits starting from the chosen digit
    int sumDigits = 0;
 
    // While there are digits to choose
    while (i < str.length())
    {
        // Update the sum
        sumDigits += (str[i] - '0');
        int sumParity = sumDigits % 2;
 
        // If the parity differs
        if (digitParity != sumParity)
            break;
        i++;
    }
 
    // Return the current sum concatenated with the
    // Numbiar number for the rest of the string
    return (to_string(sumDigits) +
            numbiarNumber(str, i + 1));
}
 
// Driver code
int main()
{
    string str = "9880127431";
    cout << numbiarNumber(str, 0) << endl;
    return 0;
}
 
// This code is contributed by
// sanjeev2552

Java

// Java implementation of the approach
class GFG {
 
    // Function to return the Nambiar
    // number of the given number
    static String nambiarNumber(String str, int i)
    {
 
        // If there is no digit to choose
        if (i >= str.length())
            return "";
 
        // Choose the first digit
        int firstDigit = (str.charAt(i) - '0');
 
        // Chosen digit's parity
        int digitParity = firstDigit % 2;
 
        // To store the sum of the consecutive
        // digits starting from the chosen digit
        int sumDigits = 0;
 
        // While there are digits to choose
        while (i < str.length()) {
 
            // Update the sum
            sumDigits += (str.charAt(i) - '0');
            int sumParity = sumDigits % 2;
 
            // If the parity differs
            if (digitParity != sumParity) {
                break;
            }
            i++;
        }
 
        // Return the current sum concatenated with the
        // Numbiar number for the rest of the string
        return ("" + sumDigits + nambiarNumber(str, i + 1));
    }
 
    // Driver code
    public static void main(String[] args)
    {
        String str = "9880127431";
        System.out.println(nambiarNumber(str, 0));
    }
}

Python3

# Java implementation of the approach
 
# Function to return the Nambiar
# number of the given number
def nambiarNumber(Str,i):
 
    # If there is no digit to choose
    if (i >= len(Str)):
        return ""
 
    # Choose the first digit
    firstDigit =ord(Str[i])-ord('0')
 
    # Chosen digit's parity
    digitParity = firstDigit % 2
 
    # To store the sum of the consecutive
    # digits starting from the chosen digit
    sumDigits = 0
 
    # While there are digits to choose
    while (i < len(Str)):
 
        # Update the sum
        sumDigits += (ord(Str[i]) - ord('0'))
        sumParity = sumDigits % 2
 
        # If the parity differs
        if (digitParity != sumParity):
            break
        i += 1
 
    # Return the current sum concatenated with the
    # Numbiar number for the rest of the String
    return ("" + str(sumDigits) +
                 nambiarNumber(Str, i + 1))
 
# Driver code
Str = "9880127431"
print(nambiarNumber(Str, 0))
 
# This code is contributed by Mohit Kumar

C#

// C# implementation of the approach.
using System;
using System.Collections.Generic;
     
class GFG
{
 
    // Function to return the Nambiar
    // number of the given number
    static String nambiarNumber(String str, int i)
    {
 
        // If there is no digit to choose
        if (i >= str.Length)
            return "";
 
        // Choose the first digit
        int firstDigit = (str[i] - '0');
 
        // Chosen digit's parity
        int digitParity = firstDigit % 2;
 
        // To store the sum of the consecutive
        // digits starting from the chosen digit
        int sumDigits = 0;
 
        // While there are digits to choose
        while (i < str.Length)
        {
 
            // Update the sum
            sumDigits += (str[i] - '0');
            int sumParity = sumDigits % 2;
 
            // If the parity differs
            if (digitParity != sumParity)
            {
                break;
            }
            i++;
        }
 
        // Return the current sum concatenated with the
        // Numbiar number for the rest of the string
        return ("" + sumDigits + nambiarNumber(str, i + 1));
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        String str = "9880127431";
        Console.WriteLine(nambiarNumber(str, 0));
    }
}
 
// This code is contributed by Rajput-Ji

Javascript

<script>
// Javascript implementation of the approach
 
// Function to return the Nambiar
    // number of the given number
function nambiarNumber(str,i)
{
    // If there is no digit to choose
        if (i >= str.length)
            return "";
   
        // Choose the first digit
        let firstDigit = (str[i].charCodeAt(0) - '0'.charCodeAt(0));
   
        // Chosen digit's parity
        let digitParity = firstDigit % 2;
   
        // To store the sum of the consecutive
        // digits starting from the chosen digit
        let sumDigits = 0;
   
        // While there are digits to choose
        while (i < str.length) {
   
            // Update the sum
            sumDigits += (str[i].charCodeAt(0) - '0'.charCodeAt(0));
            let sumParity = sumDigits % 2;
   
            // If the parity differs
            if (digitParity != sumParity) {
                break;
            }
            i++;
        }
   
        // Return the current sum concatenated with the
        // Numbiar number for the rest of the string
        return ("" + sumDigits + nambiarNumber(str, i + 1));
}
 
// Driver code
let str = "9880127431";
document.write(nambiarNumber(str, 0));
 
 
 
 
 
// This code is contributed by unknown2108
</script>
Producción: 

26971

 

Complejidad de tiempo: O(n) donde n es la longitud de la string

Espacio auxiliar: O(n) donde n es la longitud de la string

Publicación traducida automáticamente

Artículo escrito por RithishJakkireddy y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *