Dada una array arr[] de tamaño N y un entero K , la tarea es reemplazar cada elemento de la array que consiste en K como un dígito, con su potencia más cercana de K .
Nota: si hay dos potencias más cercanas, tome la mayor.
Ejemplos:
Entrada: arr[] = {432, 953, 232, 333}, K = 3
Salida: {243, 729, 243, 243}
Explicación:
arr[0] = 3 5 = 243.
arr[1] = 3 6 = 729.
arr[2] = 3 5 = 243.
arr[3] = 3 5 = 243.Entrada: arr[] = {532, 124, 244, 485}, K = 4
Salida: {532, 64, 256, 256}
Enfoque: la idea es convertir cada elemento de la array en una string y luego buscar K en la string y, si lo encuentra, reemplazarlo con la potencia de K más cercana . Siga los pasos a continuación para resolver el problema:
- Declare una función para encontrar la potencia más cercana de K:
- Encuentre el valor de p para el cual X p será el más cercano al elemento.
- Para el cálculo de la p se toma el valor mínimo de log X (Elemento) .
- Por lo tanto, p y p+1 serán los dos números enteros para los que se puede obtener la potencia más cercana.
- Calcule X k y X (K + 1) y verifique cuál está más cerca del elemento y devuelva ese elemento.
- Atraviesa la array arr[] :
- Convierta cada elemento en una string.
- Recorra la string y verifique la presencia del dígito K y, si lo encuentra, reemplace el elemento de la array con la potencia de K más cercana y rompa desde ese punto.
- Imprime la array modificada.
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 calculate the
// power of base nearest to x
int nearestPow(int x, int base)
{
// Stores logX to the base K
int k = int(log(x) / log(base));
if (abs(pow(base, k) - x) < abs(pow(base, (k + 1)) - x))
return pow(base, k);
else
return pow(base, (k + 1));
}
// Function to replace array
// elements with nearest power of K
void replaceWithNearestPowerOfK(int arr[], int K, int n)
{
// Traverse the array
for (int i = 0; i < n; i++) {
// Convert integer into a string
string strEle = to_string(arr[i]);
for (int c = 0; c < strEle.length(); c++) {
// If K is found, then replace
// with the nearest power of K
if ((strEle-'0') == K) {
arr[i] = nearestPow(arr[i], K);
break;
}
}
}
// Print the array
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
}
// Driver Code
int main()
{
// Given array
int arr[] = { 432, 953, 232, 333 };
int n = sizeof(arr) / sizeof(arr[0]);
// Given value of K
int K = 3;
// Function call to replace array
// elements with nearest power of K
replaceWithNearestPowerOfK(arr, K, n);
}
// This code is contributed by ukasp.
Java
// Java program for the above approach
import java.io.*;
class GFG {
// Function to calculate the
// power of base nearest to x
static int nearestPow(int x, int base1)
{
// Stores logX to the base K
int k = (int)(Math.log(x) / Math.log(base1));
if (Math.abs(Math.pow(base1, k) - x) <
Math.abs(Math.pow(base1, (k + 1)) - x))
return (int)Math.pow(base1, k);
else
return (int)Math.pow(base1, (k + 1));
}
// Function to replace array
// elements with nearest power of K
static void replaceWithNearestPowerOfK(int []arr, int K,
int n)
{
// Traverse the array
for(int i = 0; i < n; i++)
{
// Convert integer into a string
int num = arr[i];
String strEle = String.valueOf(num);
for(int c = 0; c < strEle.length(); c++)
{
// If K is found, then replace
// with the nearest power of K
if ((strEle.charAt(c) - '0') == K)
{
arr[i] = nearestPow(arr[i], K);
break;
}
}
}
// Print the array
for(int i = 0; i < n; i++)
System.out.print(arr[i] + " ");
}
// Driver Code
public static void main (String[] args)
{
// Given array
int []arr = { 432, 953, 232, 333 };
int n = arr.length;
// Given value of K
int K = 3;
// Function call to replace array
// elements with nearest power of K
replaceWithNearestPowerOfK(arr, K, n);
}
}
// This code is contributed by avanitrachhadiya2155
Python3
# Python3 program # for the above approach import math # Function to calculate the # power of base nearest to x def nearestPow(x, base): # Stores logX to the base K k = int(math.log(x, base)) if abs(base**k - x) < abs(base**(k+1) - x): return base**k else: return base**(k+1) # Function to replace array # elements with nearest power of K def replaceWithNearestPowerOfK(arr, K): # Traverse the array for i in range(len(arr)): # Convert integer into a string strEle = str(arr[i]) for c in strEle: # If K is found, then replace # with the nearest power of K if int(c) == K: arr[i] = nearestPow(arr[i], K) break # Print the array print(arr) # Driver Code # Given array arr = [432, 953, 232, 333] # Given value of K K = 3 # Function call to replace array # elements with nearest power of K replaceWithNearestPowerOfK(arr, K)
C#
// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG{
// Function to calculate the
// power of base nearest to x
static int nearestPow(int x, int base1)
{
// Stores logX to the base K
int k = (int)(Math.Log(x) / Math.Log(base1));
if (Math.Abs(Math.Pow(base1, k) - x) < Math.Abs(Math.Pow(base1, (k + 1)) - x))
return (int)Math.Pow(base1, k);
else
return (int)Math.Pow(base1, (k + 1));
}
// Function to replace array
// elements with nearest power of K
static void replaceWithNearestPowerOfK(int []arr, int K, int n)
{
// Traverse the array
for (int i = 0; i < n; i++) {
// Convert integer into a string
int num = arr[i];
string strEle = num.ToString();
for (int c = 0; c < strEle.Length; c++) {
// If K is found, then replace
// with the nearest power of K
if ((strEle-'0') == K) {
arr[i] = nearestPow(arr[i], K);
break;
}
}
}
// Print the array
for (int i = 0; i < n; i++)
Console.Write(arr[i]+" ");
}
// Driver Code
public static void Main()
{
// Given array
int []arr = { 432, 953, 232, 333 };
int n = arr.Length;
// Given value of K
int K = 3;
// Function call to replace array
// elements with nearest power of K
replaceWithNearestPowerOfK(arr, K, n);
}
}
// This code is contributed by ipg2016107.
Javascript
<script>
// Javascript program for the
// above approach
// Function to calculate the
// power of base nearest to x
function nearestPow( x, base)
{
// Stores logX to the base K
let k =
Math.floor(Math.log(x) / Math.log(base));
if (Math.abs(Math.pow(base, k) - x) <
Math.abs(Math.pow(base, (k + 1)) - x))
return Math.pow(base, k);
else
return Math.pow(base, (k + 1));
}
// Function to replace array
// elements with nearest power of K
function replaceWithNearestPowerOfK( arr, K, n)
{
// Traverse the array
for (let i = 0; i < n; i++) {
// Convert integer into a string
let strEle = arr[i].toString();
for (let c = 0; c < strEle.length; c++)
{
// If K is found, then replace
// with the nearest power of K
if ((strEle - '0') == K) {
arr[i] = nearestPow(arr[i], K);
break;
}
}
}
// Print the array
for (let i = 0; i < n; i++)
document.write(arr[i] + " ")
}
// Driver Code
// Given array
let arr = [ 432, 953, 232, 333 ];
let n = arr.length;
// Given value of K
let K = 3;
// Function call to replace array
// elements with nearest power of K
replaceWithNearestPowerOfK(arr, K, n)
// This code is contributed by Hritik
</script>
Producción:
[243, 729, 243, 243]
Complejidad temporal: O(N)
Espacio auxiliar: O(1)
Publicación traducida automáticamente
Artículo escrito por rohitsingh07052 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA