Skip to content
Related Articles

Related Articles

Sum of the series Kn + ( K(n-1) * (K-1)1 ) + ( K(n-2) * (K-1)2 ) + ……. (K-1)n
  • Last Updated : 15 Nov, 2019

Given a value K and n, the task is to find the sum of the below series:

Kn + ( K(n-1) * (K-1)1 ) + ( K(n-2) * (K-1)2 ) + ……. (K-1)n

Examples:

Input:  n = 3, K = 3
Output: 65
Explanation:
(3*3*3) + (3*3*2) + (3*2*2) + (2*2*2)
= 27 + 18 + 12 + 8
= 65 


Input: n = 4, k = 2
Output: 31
Explanation:
(2*2*2*2) + (2*2*2*1)+ (2*2*1*1) + (2*1*1*1) + (1*1*1*1)
= 16 + 8 + 4 + 2 + 1
= 31

  1. Simple Approach: O(n2)
    1. Total number of term in series = n+1
    2. Calculate each term separately, and add them:

    Below is the implementation of the above approach:

    C++




    // C++ implementation of the approach
      
    #include <bits/stdc++.h>
    using namespace std;
      
    // Function to return sum
    int sum(int k, int n)
    {
      
        int sum = 0;
        for (int i = 0; i <= n; i++) {
            int p = 1;
      
            for (int j = 0; j < n - i; j++) {
                p = p * k;
            }
      
            for (int j = 0; j < i; j++) {
                p = p * (k - 1);
            }
      
            sum = sum + p;
        }
        return sum;
    }
      
    // Driver code
    int main()
    {
        int n = 3;
        int K = 3;
        cout << sum(K, n);
    }

    Java




    // Java implementation of the approach
    class GFG {
        // Function to return sum
        static int sum(int k, int n)
        {
      
            int sum = 0;
            for (int i = 0; i <= n; i++) {
                int p = 1;
      
                for (int j = 0; j < n - i; j++) {
                    p = p * k;
                }
      
                for (int j = 0; j < i; j++) {
                    p = p * (k - 1);
                }
      
                sum = sum + p;
            }
            return sum;
        }
      
        // Driver code
        public static void main(String[] args)
        {
            int n = 3;
            int K = 3;
            System.out.println(sum(K, n));
        }
    }
      
    // This code is contributed by Code_Mech

    Python3




    # Python3 implementation of the approach
      
    # Function to return sum
    def Sum(k, n):
      
        Summ = 0
        for i in range(n + 1):
            p = 1
      
            for j in range(n - i):
                p = p * k
      
            for j in range(i):
                p = p * (k - 1)
              
            Summ = Summ + p
          
        return Summ
      
    # Driver code
    n = 3
    K = 3
    print(Sum(K, n))
      
    # This code is contributed by mohit kumar

    C#




    // C# implementation of the approach
      
    using System;
      
    class GFG {
        // Function to return sum
        static int sum(int k, int n)
        {
      
            int sum = 0;
            for (int i = 0; i <= n; i++) {
                int p = 1;
      
                for (int j = 0; j < n - i; j++) {
                    p = p * k;
                }
      
                for (int j = 0; j < i; j++) {
                    p = p * (k - 1);
                }
      
                sum = sum + p;
            }
            return sum;
        }
      
        // Driver code
        public static void Main()
        {
            int n = 3;
            int K = 3;
            Console.WriteLine(sum(K, n));
        }
        // This code is contributed by Ryuga
    }

    PHP




    <?php
    // PHP implementation of the approach
      
    // Function to return sum
    function sum($k, $n)
    {
      
        $sum = 0;
        for ($i = 0; $i <= $n; $i++)
        {
            $p = 1;
      
            for ($j = 0; $j < $n - $i; $j++)
            {
                $p = $p * $k;
            }
      
            for ($j = 0; $j < $i; $j++) 
            {
                $p = $p * ($k - 1);
            }
      
            $sum = $sum + $p;
        }
        return $sum;
    }
      
    // Driver code
    $n = 3;
    $K = 3;
    echo sum($K, $n);
      
    // This code is contributed 
    // by Akanksha Rai
    ?>
    Output:



    65
    

    Time Complexity: O( n^2 )

  2. Second Approach: O(n)

    It is observed that, given series is Geometric Progression, with common ratio = (K – 1)/K
    So, above expression can be simplified as:

    Below is the implementation of the above approach:

    C++




    #include <bits/stdc++.h>
    using namespace std;
      
    // Function to return sum
    int sum(int k, int n)
    {
        int sum
            = pow(k, n + 1)
              - pow(k - 1, n + 1);
      
        return sum;
    }
      
    // Driver code
    int main()
    {
        int n = 3;
        int K = 3;
        cout << sum(K, n);
    }

    Java




    // Java implementation of above approach
    class GFG
    {
      
    // Function to return sum
    static int sum(int k, int n)
    {
        int sum = (int)(Math.pow(k, n + 1) - 
                        Math.pow(k - 1, n + 1));
      
        return sum;
    }
      
    // Driver code
    public static void main(String args[])
    {
        int n = 3;
        int K = 3;
        System.out.print(sum(K, n));
    }
    }
      
    // This code is contributed
    // by Akanksha Rai

    Python3




    # Function to return sum 
    def sum(k, n):
        sum = (pow(k, n + 1) - 
               pow(k - 1, n + 1)); 
      
        return sum
      
    # Driver code 
    n = 3
    K = 3
    print(sum(K, n)); 
      
    # This code is contributed by mits

    C#




    // C# implementation of above approach
    using System;
      
    class GFG
    {
      
    // Function to return sum
    static int sum(int k, int n)
    {
        int sum = (int)(Math.Pow(k, n + 1) - 
                        Math.Pow(k - 1, n + 1));
      
        return sum;
    }
      
    // Driver code
    public static void Main()
    {
        int n = 3;
        int K = 3;
        Console.Write(sum(K, n));
    }
    }
      
    // This code is contributed
    // by Akanksha Rai

    PHP




    <?php
      
    // Function to return sum
    function sum($k, $n)
    {
        $sum = pow($k, $n + 1) - 
               pow($k - 1, $n + 1);
      
        return $sum;
    }
      
    // Driver code
    $n = 3;
    $K = 3;
    echo sum($K, $n);
      
    // This code is contributed
    // by Akanksha Rai
    Output:
    65
    

    Time Complexity: O( n )

  3. Third Approach (Efficient): O(log n)

    Note: Time complexity can further be reduced to O(log(n)), by calculating power in log(n) complexity.

    Below is the implementation of the above approach:

    C++




    #include <bits/stdc++.h>
    using namespace std;
      
    // Recursive C program to compute modular power
    int exponent(int A, int B)
    {
        // Base cases
        if (A == 0)
            return 0;
        if (B == 0)
            return 1;
      
        // If B is even
        long y;
        if (B % 2 == 0) {
            y = exponent(A, B / 2);
            y = (y * y);
        }
      
        // If B is odd
        else {
            y = A;
            y = (y * exponent(A, B - 1));
        }
      
        return y;
    }
      
    // Function to return sum
    int sum(int k, int n)
    {
        int sum = exponent(k, n + 1)
                  - exponent(k - 1, n + 1);
      
        return sum;
    }
      
    // Driver code
    int main()
    {
        int n = 3;
        int K = 3;
        cout << sum(K, n);
    }

    Java




    import java.lang.Math;
      
    class GFG
    {
          
    // Recursive C program to compute modular power
    static int exponent(int A, int B)
    {
        // Base cases
        if (A == 0)
            return 0;
        if (B == 0)
            return 1;
      
        // If B is even
        int y;
        if (B % 2 == 0
        {
            y = exponent(A, B / 2);
            y = (y * y);
        }
      
        // If B is odd
        else 
        {
            y = A;
            y = (y * exponent(A, B - 1));
        }
      
        return y;
    }
      
    // Function to return sum
    static int sum(int k, int n)
    {
        int sum = exponent(k, n + 1)
                - exponent(k - 1, n + 1);
      
        return sum;
    }
      
    // Driver code
    public static void main(String[] args)
    {
        int n = 3;
        int K = 3;
        System.out.println(sum(K, n));
    }
    }
      
    // This code is contributed by Code_Mech.

    Python3




    # Recursive python3 program to compute modular power
      
    def exponent(A, B):
        # Base cases
        if (A == 0):
            return 0;
        if (B == 0):
            return 1;
      
        # If B is even
        if (B % 2 == 0):
            y = exponent(A, B / 2);
            y = (y * y);
      
        # If B is odd
        else:
            y = A;
            y = (y * exponent(A, B - 1));
      
        return y;
      
    # Function to return sum
    def sum(k, n):
        sum = exponent(k, n + 1) - exponent(k - 1, n + 1);
      
        return sum;
      
    # Driver code
    n = 3;
    K = 3;
    print(sum(K, n));
      
    # This code has been contributed by 29AjayKumar

    C#




    // C# program of above approach
    using System;
      
    class GFG
    {
          
    // Recursive C program to compute modular power
    static int exponent(int A, int B)
    {
        // Base cases
        if (A == 0)
            return 0;
        if (B == 0)
            return 1;
      
        // If B is even
        int y;
        if (B % 2 == 0) 
        {
            y = exponent(A, B / 2);
            y = (y * y);
        }
      
        // If B is odd
        else
        {
            y = A;
            y = (y * exponent(A, B - 1));
        }
      
        return y;
    }
      
    // Function to return sum
    static int sum(int k, int n)
    {
        int sum = exponent(k, n + 1)
                - exponent(k - 1, n + 1);
      
        return sum;
    }
      
    // Driver code
    public static void Main()
    {
        int n = 3;
        int K = 3;
        Console.WriteLine(sum(K, n));
    }
    }
      
    // This code is contributed by Code_Mech.

    PHP




    <?php
    // Recursive C program to compute modular power
      
    function exponent($A, $B)
    {
        // Base cases
        if ($A == 0)
            return 0;
        if ($B == 0)
            return 1;
      
        // If B is even
        if ($B % 2 == 0) 
        {
            $y = exponent($A, $B / 2);
            $y = ($y * $y);
        }
      
        // If B is odd
        else
        {
            $y = $A;
            $y = ($y * exponent($A, $B - 1));
        }
      
        return $y;
    }
      
    // Function to return sum
    function sum($k, $n)
    {
        $sum = exponent($k, $n + 1) - 
               exponent($k - 1, $n + 1);
      
        return $sum;
    }
      
    // Driver code
    $n = 3;
    $K = 3;
    echo sum($K, $n);
      
    // This code is contributed by Akanksha Rai
    ?>
    Output:
    65
    

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :