Dados dos números N y K , donde K representa el término inicial de la sucesión. La tarea es encontrar el término N de una secuencia formada por la suma del término actual con el producto del dígito más grande y el más pequeño del término actual, es decir,
A N+1 = A N + max(dígitos de A N ) * min(dígitos de A N )
Ejemplos:
Entrada: K = 1, N = 5
Salida: 50
Explicación:
A 1 = 1
A 2 = A 1 + minDigit( A 1 ) * maxDigit( A 1 ) = 1 + min(1) * max(1) = 1 + 1*1 = 2
A 3 = A 2 + minDigit( A 2 ) * maxDigit( A 2 ) = 2 + min(2) * max(2) = 2 + 2*2 = 6
A 4 = A 3 + minDigit( A 3 ) * maxDigit( A 3 ) = 6 + min(6) * max(6) = 6 + 6*6 = 42
A 5 = A 4 + minDigit( A 4) * maxDigit( A 4 ) = 42 + min(4, 2) * max(4, 2) = 42 + 2*4 = 50
Entrada: K = 487, N = 2
Salida: 519
Explicación:
A 1 = 487
A 2 = A 1 + minDigit( A 1 ) * maxDigit( a 1 ) = 487 + min(4, 8, 7) * max(4, 8, 7) = 487 + 4*8 = 519
Planteamiento:
Tratemos de ver algunas observaciones,
Cuando K = 1, la secuencia se convierte en: 1, 2, 6, 42, 50, 50, 50, … Cuando K
= 2, la secuencia se convierte en: 2, 6, 42, 50, 50, 50, …
.
.
Cuando K = 5, la secuencia se convierte en: 5, 30, 30, 30, 30, 30, …
.
.
De manera similar, cuando K = 10, la secuencia se convierte en: 10, 10, 10, 10, 10, 10, …
De los ejemplos anteriores, se puede observar que la secuencia finalmente deja de aumentar después de que un número entero tiene al menos un dígito se convierte en 0. Si cualquier dígito se convierte en 0, entonces el dígito mínimo sería siempre 0 y después de eso, todos los números enteros en la secuencia permanece igual.
Entonces, el enfoque es encontrar los términos de la secuencia hasta que se encuentre cualquier 0 en los dígitos del término actual.
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;
// Function to find integer
int find(int K, int N)
{
// because 1st integer is K itself
N--;
while (N--) {
int curr_term = K;
// Initialize min_d and max_d
int min_d = 9;
int max_d = 0;
while (curr_term > 0) {
int r = curr_term % 10;
// updating min_d and max_d
min_d = min(min_d, r);
max_d = max(max_d, r);
curr_term = curr_term / 10;
}
// break if min digit is 0
if (min_d == 0) {
break;
}
K = K + min_d * max_d;
}
return K;
}
// Driver code
int main()
{
int K = 487;
int N = 2;
cout << find(K, N) << endl;
return 0;
}
Java
// Java program for the above approach.
import java.util.*;
class GFG{
// Function to find integer
static int find(int K, int N)
{
// Because 1st integer is K itself
N--;
while (N-- != 0)
{
int curr_term = K;
// Initialize min_d and max_d
int min_d = 9;
int max_d = 0;
while (curr_term > 0)
{
int r = curr_term % 10;
// Updating min_d and max_d
min_d = Math.min(min_d, r);
max_d = Math.max(max_d, r);
curr_term = curr_term / 10;
}
// Break if min digit is 0
if (min_d == 0)
{
break;
}
K = K + min_d * max_d;
}
return K;
}
// Driver code
public static void main(String[] args)
{
int K = 487;
int N = 2;
System.out.print(find(K, N) + "\n");
}
}
// This code is contributed by 29AjayKumar
Python3
# Python3 program for the above approach. # Function to find integer def find(K, N): # Because 1st integer is K itself N = N - 1 for i in range(0, N): curr_term = K # Initialize min_d and max_d min_d = 9 max_d = 0 while curr_term > 0: r = int(curr_term % 10) # Updating min_d and max_d min_d = min(min_d, r) max_d = max(max_d, r) curr_term = int(curr_term / 10) # Break if min digit is 0 if min_d == 0: break K = K + min_d * max_d return K # Driver code K = 487 N = 2 print(find(K, N)) # This code is contributed by ishayadav181
C#
// C# program for the above approach.
using System;
class GFG{
// Function to find integer
static int find(int K, int N)
{
// Because 1st integer is K itself
N--;
while (N-- != 0)
{
int curr_term = K;
// Initialize min_d and max_d
int min_d = 9;
int max_d = 0;
while (curr_term > 0)
{
int r = curr_term % 10;
// Updating min_d and max_d
min_d = Math.Min(min_d, r);
max_d = Math.Max(max_d, r);
curr_term = (int)(curr_term / 10);
}
// Break if min digit is 0
if (min_d == 0)
{
break;
}
K = K + min_d * max_d;
}
return K;
}
// Driver code
public static void Main()
{
int K = 487;
int N = 2;
Console.Write(find(K, N));
}
}
// This code is contributed by Code_Mech
Javascript
<script>
// JavaScript program for the above approach.
// Function to find integer
function find(K, N)
{
// because 1st integer is K itself
N--;
while (N--) {
let curr_term = K;
// Initialize min_d and max_d
let min_d = 9;
let max_d = 0;
while (curr_term > 0) {
let r = curr_term % 10;
// updating min_d and max_d
min_d = Math.min(min_d, r);
max_d = Math.max(max_d, r);
curr_term = Math.floor(curr_term / 10);
}
// break if min digit is 0
if (min_d == 0) {
break;
}
K = K + min_d * max_d;
}
return K;
}
// Driver code
let K = 487;
let N = 2;
document.write(find(K, N) + "<br>");
// This code is contributed by Surbhi Tyagi.
</script>
519
Complejidad de tiempo: O(N * log 10 K), donde N y K son los números enteros dados.
Espacio auxiliar: O(1), no se requiere espacio adicional, por lo que es una constante.
Publicación traducida automáticamente
Artículo escrito por chitrasingla2001 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA