Calculate Root Mean Kth power of all array elements

Given an array arr[] and an integer K, the task is to calculate the Kth root of the arithmetic mean of the Kth powers of all array elements.

Examples:

Input: arr[] = {1, 2, 3, 4, 5}, K = 2
Output: 3.31662
Explanation:
Sum of all Kth powers of array elements = 1 + 4 + 9 + 16 + 25 = 55
The value of root mean Kth power of array elements = √(55 / 5) = √11 = 3.31662

Input: arr[] = {10, 4, 6, 8}, K = 3
Output: 7.34847

Approach: The root mean of Kth powers of the array elements is given by the equation: 



\sqrt[k]{\frac{arr_{1}^{k} + arr_{2}^{k} + arr_{2}^{k} + ..... arr_{n}^{k}}{n}}

Therefore, the idea is to calculate the Kth power of each array element. Then, find the arithmetic mean of those elements. Finally, compute the Kth root of the calculated mean.

Below is the implementation of the above approach: 

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the Nth root
double nthRoot(int A, int N)
{
    // Intially guessing random
    // numberbetween 0 and 9
    double xPre = rand() % 10;
 
    // Smaller eps for more accuracy
    double eps = 1e-3;
 
    // Initialize difference between
    // the two roots by INT_MAX
    double delX = INT_MAX;
 
    // xK denotes current value of x
    double xK;
 
    // Iterate until desired
    // accuracy is reached
    while (delX > eps) {
 
        // Find the current value
        // from previous value by
        // newton's method
        xK = ((N - 1.0) * xPre
              + (double)A / pow(xPre, N - 1))
             / (double)N;
 
        delX = abs(xK - xPre);
        xPre = xK;
    }
 
    return xK;
}
 
// Function to calculate the Root
// Mean kth power of array elements
float RMNValue(int arr[], int n, int k)
{
    int Nth = 0;
 
    float mean = 0.0, root = 0.0;
 
    // Calculate sum of kth power
    for (int i = 0; i < n; i++) {
        Nth += pow(arr[i], k);
    }
 
    // Calculate Mean
    mean = (Nth / (float)(n));
 
    // Calculate kth Root of mean
    root = nthRoot(mean, k);
 
    return root;
}
 
// Driver Code
int main()
{
    int arr[] = { 10, 4, 6, 8 };
    int N = sizeof(arr) / sizeof(arr[0]);
    int K = 3;
 
    // Function Call
    cout << RMNValue(arr, N, K);
 
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for
// the above approach
class GFG{
 
// Function to find the
  // Nth root
static double nthRoot(int A,
                      int N)
{
  // Intially guessing random
  // numberbetween 0 and 9
  double xPre = (Math.random() * 10) % 10;
 
  // Smaller eps for more accuracy
  double eps = 1e-3;
 
  // Initialize difference between
  // the two roots by Integer.MAX_VALUE
  double delX = Integer.MAX_VALUE;
 
  // xK denotes current value of x
  double xK = 0;
 
  // Iterate until desired
  // accuracy is reached
  while (delX > eps)
  {
    // Find the current value
    // from previous value by
    // newton's method
    xK = ((N - 1.0) * xPre +
          (double)A /
          Math.pow(xPre, N - 1)) /
          (double)N;
 
    delX = Math.abs(xK - xPre);
    xPre = xK;
  }
 
  return xK;
}
 
// Function to calculate the Root
// Mean kth power of array elements
static float RMNValue(int arr[],
                      int n, int k)
{
  int Nth = 0;
  float mean = 0, root = 0;
 
  // Calculate sum of kth power
  for (int i = 0; i < n; i++)
  {
    Nth += Math.pow(arr[i], k);
  }
 
  // Calculate Mean
  mean = (Nth / (float)(n));
 
  // Calculate kth Root of mean
  root = (float) nthRoot((int)mean, k);
 
  return root;
}
 
// Driver Code
public static void main(String[] args)
{
  int arr[] = {10, 4, 6, 8};
  int N = arr.length;
  int K = 3;
 
  // Function Call
  System.out.print(RMNValue(arr, N, K));
 
}
}
 
// This code is contributed by Rajput-Ji

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for
# the above approach
import sys
import random
 
# Function to find
# the Nth root
def nthRoot(A, N):
 
    # Intially guessing random
    # numberbetween 0 and 9
    xPre = random.random() % 10
 
    # Smaller eps for
    # more accuracy
    eps = 1e-3
 
    # Initialize difference between
    # the two roots by INT_MAX
    delX = sys.maxsize
 
    # xK denotes current
    # value of x
    xK = 0
 
    # Iterate until desired
    # accuracy is reached
    while (delX > eps):
 
        # Find the current value
        # from previous value by
        # newton's method
        xK = (((N - 1.0) * xPre +
                A / pow(xPre, N - 1)) / N)
        delX = abs(xK - xPre)
        xPre = xK
    
    return xK
 
# Function to calculate the Root
# Mean kth power of array elements
def RMNValue(arr, n, k):
 
    Nth = 0
    mean = 0.0
    root = 0.0
 
    # Calculate sum of kth power
    for i in range (n):
        Nth += pow(arr[i], k)
 
    # Calculate Mean
    mean = (Nth // (n))
 
    # Calculate kth Root of mean
    root = nthRoot(mean, k)
 
    return root
 
# Driver Code
if __name__ == "__main__":
 
    arr = [10, 4, 6, 8 ]
    N = len(arr)
    K = 3
 
    # Function Call
    print ( RMNValue(arr, N, K))
 
# This code is contributed by Chitranayal

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach 
using System;
 
class GFG{
  
// Function to find the
// Nth root
static double nthRoot(int A, int N)
{
     
    // Instantiate random number generator
    Random rand = new Random();
         
    // Intially guessing random
    // numberbetween 0 and 9
    double xPre = (rand.Next() * 10) % 10;
     
    // Smaller eps for more accuracy
    double eps = 1e-3;
     
    // Initialize difference between
    // the two roots by Integer.MAX_VALUE
    double delX = Int32.MaxValue;
     
    // xK denotes current value of x
    double xK = 0;
     
    // Iterate until desired
    // accuracy is reached
    while (delX > eps)
    {
         
        // Find the current value
        // from previous value by
        // newton's method
        xK = ((N - 1.0) * xPre +
              (double)A /
              Math.Pow(xPre, N - 1)) /
              (double)N;
         
        delX = Math.Abs(xK - xPre);
        xPre = xK;
    }
    return xK;
}
  
// Function to calculate the Root
// Mean kth power of array elements
static float RMNValue(int[] arr, int n,
                                 int k)
{
    int Nth = 0;
    float mean = 0, root = 0;
     
    // Calculate sum of kth power
    for(int i = 0; i < n; i++)
    {
        Nth += (int)Math.Pow(arr[i], k);
    }
     
    // Calculate Mean
    mean = (Nth / (float)(n));
     
    // Calculate kth Root of mean
    root = (float)nthRoot((int)mean, k);
     
    return root;
}
  
// Driver Code
public static void Main()
{
    int[] arr = { 10, 4, 6, 8 };
    int N = arr.Length;
    int K = 3;
     
    // Function call
    Console.Write(RMNValue(arr, N, K));
}
}
 
// This code is contributed by code_hunt

chevron_right


Output: 

7.65172







 

Time Complexity: O(N*log(sum)), where the sum is the sum of the square of all the given numbers in the array. 
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.