Conteo de números mínimos que tienen K como el último dígito requerido para obtener la suma N

Posted on by Rudeus Greyrat

Dado un entero positivo N y un dígito K , la tarea es encontrar la cuenta mínima de números que terminen con el dígito K tal que la suma de esos números sea N . Si no existe tal número cuya suma sea K , imprima «-1» .

Ejemplos:

Entrada: N = 42, K = 3
Salida: 4
Explicación:
El número dado N(= 43) se puede expresar como 3 + 3 + 13 + 23, por lo que todos los números terminan con el dígito K(= 3). Por lo tanto, el conteo partió los números 4.

Entrada: N = 17, K = 3
Salida: -1

Enfoque: El problema dado se puede resolver mediante la observación de que si un número se puede expresar como la suma de números que terminan con el dígito K , entonces el resultado será el máximo de 10. Siga los pasos a continuación para resolver el problema:

  • Si el dígito K es par y el entero N es impar, imprima “ -1″ ya que no es posible obtener una suma impar con un número par.
  • Para el número K , encuentre el número más pequeño que termine con el dígito i en el rango [0, 9] . Si no es posible, establezca el valor como INT_MAX .
  • Además, para cada número K encuentre los pasos mínimos requeridos para crear un número que termine con el dígito i en el rango [0, 9] .
  • Ahora, si el número más pequeño que termina con el dígito i es mayor que N con el dígito unitario i , imprima «-1» ya que no es posible hacer la suma de números como N.
  • De lo contrario, la respuesta serán pasos mínimos para crear un número que termine con el dígito i , que es el mismo que el dígito unitario de N porque el dígito restante se puede obtener insertando esos dígitos en cualquiera de los números que contribuyen a la respuesta.

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

C++

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
int minCount(int N, int K)
{
    // Stores the smallest number that
    // ends with digit i (0, 9)
    int SmallestNumber[10];
 
    // Stores the minimum number of
    // steps to create a number ending
    // with digit i
    int MinimumSteps[10];
 
    // Initialize elements as infinity
    for (int i = 0; i <= 9; i++) {
        SmallestNumber[i] = INT_MAX;
        MinimumSteps[i] = INT_MAX;
    }
 
    for (int i = 1; i <= 10; i++) {
 
        int num = K * i;
 
        // Minimum number
        // ending with digit i
        SmallestNumber[num % 10]
            = min(
                SmallestNumber[num % 10],
                num);
 
        // Minimum steps to create a
        // number ending with digit i
        MinimumSteps[num % 10]
            = min(
                MinimumSteps[num % 10], i);
    }
 
    // If N < SmallestNumber then,
    // return -1
    if (N < SmallestNumber[N % 10]) {
        return -1;
    }
 
    // Otherwise, return answer
    else {
        return MinimumSteps[N % 10];
    }
}
 
// Driver Code
int main()
{
    int N = 42, K = 7;
    cout << minCount(N, K);
 
    return 0;
}

Java

// Java program for above approach
import java.util.*;
 
class GFG{
 
static int minCount(int N, int K)
{
     
    // Stores the smallest number that
    // ends with digit i (0, 9)
    int SmallestNumber[] = new int[10];
 
    // Stores the minimum number of
    // steps to create a number ending
    // with digit i
    int MinimumSteps[] = new int[10];
 
    // Initialize elements as infinity
    for(int i = 0; i <= 9; i++)
    {
        SmallestNumber[i] = Integer.MAX_VALUE;
        MinimumSteps[i] = Integer.MAX_VALUE;
    }
 
    for(int i = 1; i <= 10; i++)
    {
        int num = K * i;
         
        // Minimum number
        // ending with digit i
        SmallestNumber[num % 10] = Math.min(
            SmallestNumber[num % 10], num);
 
        // Minimum steps to create a
        // number ending with digit i
        MinimumSteps[num % 10] = Math.min(
            MinimumSteps[num % 10], i);
    }
 
    // If N < SmallestNumber then,
    // return -1
    if (N < SmallestNumber[N % 10])
    {
        return -1;
    }
 
    // Otherwise, return answer
    else
    {
        return MinimumSteps[N % 10];
    }
}
 
// Driver Code
public static void main(String[] args)
{
    int N = 42, K = 7;
   
    System.out.println(minCount(N, K));
}
}
 
// This code is contributed by hritikrommie

Python3

# Python3 program for the above approach
import sys
 
def minCount(N, K):
   
    # Stores the smallest number that
    # ends with digit i (0, 9)
    SmallestNumber = [0 for i in range(10)]
 
    # Stores the minimum number of
    # steps to create a number ending
    # with digit i
    MinimumSteps = [0 for i in range(10)]
 
    # Initialize elements as infinity
    for i in range(10):
        SmallestNumber[i] = sys.maxsize;
        MinimumSteps[i] = sys.maxsize
 
    for i in range(1,11,1):
        num = K * i
 
        # Minimum number
        # ending with digit i
        SmallestNumber[num % 10] = min(SmallestNumber[num % 10],num)
 
        # Minimum steps to create a
        # number ending with digit i
        MinimumSteps[num % 10] = min(MinimumSteps[num % 10], i)
 
    # If N < SmallestNumber then,
    # return -1
    if (N < SmallestNumber[N % 10]):
        return -1
 
    # Otherwise, return answer
    else:
        return MinimumSteps[N % 10]
 
# Driver Code
if __name__ == '__main__':
    N = 42
    K = 7
    print(minCount(N, K))
     
    # This code is contributed by SURENDRA_GANGWAR.

C#

// C# program for the above approach
using System;
 
public class GFG{
     
    static int minCount(int N, int K)
    {
         
        // Stores the smallest number that
        // ends with digit i (0, 9)
        int[] SmallestNumber = new int[10];
     
        // Stores the minimum number of
        // steps to create a number ending
        // with digit i
        int[] MinimumSteps = new int[10];
     
        // Initialize elements as infinity
        for(int i = 0; i <= 9; i++)
        {
            SmallestNumber[i] = Int32.MaxValue;
            MinimumSteps[i] = Int32.MaxValue;
        }
     
        for(int i = 1; i <= 10; i++)
        {
            int num = K * i;
             
            // Minimum number
            // ending with digit i
            SmallestNumber[num % 10] = Math.Min(
                SmallestNumber[num % 10], num);
     
            // Minimum steps to create a
            // number ending with digit i
            MinimumSteps[num % 10] = Math.Min(
                MinimumSteps[num % 10], i);
        }
     
        // If N < SmallestNumber then,
        // return -1
        if (N < SmallestNumber[N % 10])
        {
            return -1;
        }
     
        // Otherwise, return answer
        else
        {
            return MinimumSteps[N % 10];
        }
    }
     
    // Driver Code
    static public void Main ()
    {
        int N = 42, K = 7;
       
        Console.Write(minCount(N, K));
    }
}
 
// This code is contributed by shubhamsingh10

Javascript

<script>
 
// JavaScript program for the above approach
 
function minCount(N, K)
{
    // Stores the smallest number that
    // ends with digit i (0, 9)
    let SmallestNumber = new Array(10);
 
    // Stores the minimum number of
    // steps to create a number ending
    // with digit i
    let MinimumSteps = new Array(10);
 
    // Initialize elements as infinity
    for (let i = 0; i <= 9; i++) {
        SmallestNumber[i] = Number.MAX_VALUE;
        MinimumSteps[i] = Number.MAX_VALUE;
    }
 
    for (let i = 1; i <= 10; i++) {
 
        let num = K * i;
 
        // Minimum number
        // ending with digit i
        SmallestNumber[num % 10]
            = Math.min(
                SmallestNumber[num % 10],
                num);
 
        // Minimum steps to create a
        // number ending with digit i
        MinimumSteps[num % 10]
            = Math.min(
                MinimumSteps[num % 10], i);
    }
 
    // If N < SmallestNumber then,
    // return -1
    if (N < SmallestNumber[N % 10]) {
        return -1;
    }
 
    // Otherwise, return answer
    else {
        return MinimumSteps[N % 10];
    }
}
 
// Driver Code
    let N = 42, K = 7;
    document.write(minCount(N, K));
 
</script>
Producción: 

6

 

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

Publicación traducida automáticamente

Artículo escrito por imsoumyadeep 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 *