Dada una array circular arr[] que consta de N enteros positivos, la tarea es modificar la array reemplazando cada elemento de la array con la potencia más cercana de su elemento de array anterior o siguiente.
Ejemplos:
Entrada: arr[] = {2, 3, 4, 1, 2}
Salida: {2, 4, 3, 1, 2}
Explicación:
Para arr[0](= 2): Los elementos de array anterior y siguiente son 2 y 3 respectivamente. Por lo tanto, la potencia más cercana es 2 1 .
Para arr[1](= 3): Los elementos anterior y siguiente son 2 y 4 respectivamente. Por lo tanto, la potencia más cercana es 4 1 .
Para arr[2](= 4): Los elementos anterior y siguiente son 3 y 1 respectivamente. Por lo tanto, la potencia más cercana es 3 1 .
Para arr[3](= 1): Los elementos anterior y siguiente son 4 y 2. Por lo tanto, la potencia más cercana es 4 0 .
Para arr[4](= 2): Los elementos anterior y siguiente son 1 y 2. Por lo tanto, la potencia de 1 más cercana es 2 1.Entrada: arr[] = {21, 3, 54, 78, 9}
Salida: {27, 1, 78, 81, 1}
Enfoque: la idea es atravesar la array y reemplazar cada elemento de la array con la potencia más cercana de su elemento anterior o del siguiente elemento de la array.
Siga los pasos a continuación para resolver este problema:
- Recorra la array arr[] y realice los siguientes pasos:
- Encuentre el valor de K para el cual X K será el más cercano a Y.
- Para calcular K , tome el valor mínimo de log x (Y).
- Por lo tanto, K y K + 1 serán los dos números enteros para los cuales la potencia más cercana es la más cercana.
- Calcule Y K e Y (K + 1) y verifique cuál está más cerca de X y actualice el elemento de array arr[i] con el valor más cercano.
- Después de completar los pasos anteriores, imprima la array arr[] como 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 y which is nearest to x
int nearestPow(int x, int y)
{
// Base Case
if (y == 1)
return 1;
// Stores the logarithmic
// value of x with base y
int k = log10(x) / log10(y);
if (abs(pow(y, k) - x) <
abs(pow(y, (k + 1)) - x))
return pow(y, k);
return pow(y, (k + 1));
}
// Function to replace each array
// element by the nearest power of
// its previous or next element
void replacebyNearestPower(vector<int> arr)
{
// Stores the previous
// and next element
int prev = arr[arr.size() - 1];
int lastNext = arr[0];
int next = 0;
// Traverse the array
for(int i = 0; i < arr.size(); i++)
{
int temp = arr[i];
if (i == arr.size() - 1)
next = lastNext;
else
next = arr[(i + 1) % arr.size()];
// Calculate nearest power for
// previous and next elements
int prevPow = nearestPow(arr[i], prev);
int nextPow = nearestPow(arr[i], next);
// Replacing the array values
if (abs(arr[i] - prevPow) <
abs(arr[i] - nextPow))
arr[i] = prevPow;
else
arr[i] = nextPow;
prev = temp;
}
// Print the updated array
for(int i = 0; i < arr.size(); i++)
cout << arr[i] << " ";
}
// Driver Code
int main()
{
// Given array
vector<int> arr{ 2, 3, 4, 1, 2 };
replacebyNearestPower(arr);
}
// This code is contributed by ipg2016107
Java
// Java program for the above approach
class GFG{
// Function to calculate the power
// of y which is nearest to x
static int nearestPow(int x, int y)
{
// Base Case
if (y == 1)
return 1;
// Stores the logarithmic
// value of x with base y
int k = (int)(Math.log10(x) /
Math.log10(y));
if (Math.abs(Math.pow(y, k) - x) <
Math.abs(Math.pow(y, (k + 1)) - x))
return (int)(Math.pow(y, k));
return (int)(Math.pow(y, (k + 1)));
}
// Function to replace each array
// element by the nearest power of
// its previous or next element
static void replacebyNearestPower(int[] arr)
{
// Stores the previous
// and next element
int prev = arr[arr.length - 1];
int lastNext = arr[0];
int next = 0;
// Traverse the array
for(int i = 0; i < arr.length; i++)
{
int temp = arr[i];
if (i == arr.length - 1)
next = lastNext;
else
next = arr[(i + 1) % arr.length];
// Calculate nearest power for
// previous and next elements
int prevPow = nearestPow(arr[i], prev);
int nextPow = nearestPow(arr[i], next);
// Replacing the array values
if (Math.abs(arr[i] - prevPow) <
Math.abs(arr[i] - nextPow))
arr[i] = prevPow;
else
arr[i] = nextPow;
prev = temp;
}
// Print the updated array
for(int i = 0; i < arr.length; i++)
System.out.print(arr[i] + " ");
}
// Driver Code
public static void main(String args[])
{
// Given array
int[] arr = { 2, 3, 4, 1, 2 };
replacebyNearestPower(arr);
}
}
// This code is contributed by abhinavjain194
Python3
# Python3 program for the above approach import math # Function to calculate the power # of y which is nearest to x def nearestPow(x, y): # Base Case if y == 1: return 1 # Stores the logarithmic # value of x with base y k = int(math.log(x, y)) if abs(y**k - x) < abs(y**(k + 1) - x): return y**k return y**(k + 1) # Function to replace each array # element by the nearest power of # its previous or next element def replacebyNearestPower(arr): # Stores the previous # and next element prev = arr[-1] lastNext = arr[0] # Traverse the array for i in range(len(arr)): temp = arr[i] if i == len(arr)-1: next = lastNext else: next = arr[(i + 1) % len(arr)] # Calculate nearest power for # previous and next elements prevPow = nearestPow(arr[i], prev) nextPow = nearestPow(arr[i], next) # Replacing the array values if abs(arr[i]-prevPow) < abs(arr[i]-nextPow): arr[i] = prevPow else: arr[i] = nextPow prev = temp # Print the updated array print(arr) # Driver Code # Given array arr = [2, 3, 4, 1, 2] replacebyNearestPower(arr)
C#
// C# program for the above approach
using System;
class GFG{
// Function to calculate the power
// of y which is nearest to x
static int nearestPow(int x, int y)
{
// Base Case
if (y == 1)
return 1;
// Stores the logarithmic
// value of x with base y
int k = (int)(Math.Log(x, y));
if (Math.Abs(Math.Pow(y, k) - x) <
Math.Abs(Math.Pow(y, (k + 1)) - x))
return (int)(Math.Pow(y, k));
return (int)(Math.Pow(y, (k + 1)));
}
// Function to replace each array
// element by the nearest power of
// its previous or next element
static void replacebyNearestPower(int[] arr)
{
// Stores the previous
// and next element
int prev = arr[arr.Length - 1];
int lastNext = arr[0];
int next = 0;
// Traverse the array
for(int i = 0; i < arr.Length; i++)
{
int temp = arr[i];
if (i == arr.Length - 1)
next = lastNext;
else
next = arr[(i + 1) % arr.Length];
// Calculate nearest power for
// previous and next elements
int prevPow = nearestPow(arr[i], prev);
int nextPow = nearestPow(arr[i], next);
// Replacing the array values
if (Math.Abs(arr[i] - prevPow) <
Math.Abs(arr[i] - nextPow))
arr[i] = prevPow;
else
arr[i] = nextPow;
prev = temp;
}
// Print the updated array
for(int i = 0; i < arr.Length; i++)
Console.Write(arr[i] + " ");
}
// Driver Code
public static void Main()
{
// Given array
int[] arr = { 2, 3, 4, 1, 2 };
replacebyNearestPower(arr);
}
}
// This code is contributed by ukasp
Javascript
<script>
// JavaScript program for the above approach
// Function to calculate the power
// of y which is nearest to x
function nearestPow(x, y) {
// Base Case
if (y == 1)
return 1
// Stores the logarithmic
// value of x with base y
var k = Math.floor(Math.log(x) / Math.log(y))
if (Math.abs(Math.pow(y,k) - x) <
Math.abs(Math.pow(y,(k + 1)) - x))
return Math.pow(y,k)
return Math.pow(y,(k + 1))
}
// Function to replace each array
// element by the nearest power of
// its previous or next element
function replacebyNearestPower(arr) {
// Stores the previous
// and next element
var prev = arr[arr.length -1]
var lastNext = arr[0]
// Traverse the array
for (var i = 0; i < arr.length; i++){
var temp = arr[i]
if (i == arr.length -1)
var next = lastNext
else
var next = arr[(i + 1) % arr.length]
// Calculate nearest power for
// previous and next elements
var prevPow = nearestPow(arr[i], prev)
var nextPow = nearestPow(arr[i], next)
// Replacing the array values
if (Math.abs(arr[i]-prevPow) <
Math.abs(arr[i]-nextPow))
arr[i] = prevPow
else
arr[i] = nextPow
prev = temp
}
// Print the updated array
document.write(arr)
}
// Driver Code
// Given array
var arr = [2, 3, 4, 1, 2]
replacebyNearestPower(arr)
// This code is contributed by AnkThon
</script>
Producción:
[2, 4, 3, 1, 2]
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