Skip to content
Related Articles

Related Articles

Save Article
Improve Article
Save Article
Like Article

Maximum subarray sum in an array created after repeated concatenation

  • Difficulty Level : Medium
  • Last Updated : 12 Apr, 2021

Given an array and a number k, find the largest sum of contiguous array in the modified array which is formed by repeating the given array k times. 
Examples : 

Input  : arr[] = {-1, 10, 20}, k = 2
Output : 59
After concatenating array twice, we 
get {-1, 10, 20, -1, 10, 20} which has 
maximum subarray sum as 59.

Input  : arr[] = {-1, -2, -3}, k = 3
Output : -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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

A simple solution is to create an array of size n*k, then run Kadane’s algorithm. Time complexity would be O(nk) and auxiliary space would be O(n*k)
A better solution is to run a loop on same array and use modular arithmetic to move back beginning after end of array. 
 

C++




// C++ program to print largest contiguous
// array sum when array is created after
// concatenating a small array k times.
#include<bits/stdc++.h>
using namespace std;
 
// Returns sum of maximum sum subarray created
// after concatenating a[0..n-1] k times.
int maxSubArraySumRepeated(int a[], int n, int k)
{
    int max_so_far = INT_MIN, max_ending_here = 0;
 
    for (int i = 0; i < n*k; i++)
    {
        // This is where it differs from Kadane's
        // algorithm. We use modular arithmetic to
        // find next element.
        max_ending_here = max_ending_here + a[i%n];
 
        if (max_so_far < max_ending_here)
            max_so_far = max_ending_here;
 
        if (max_ending_here < 0)
            max_ending_here = 0;
    }
    return max_so_far;
}
 
/*Driver program to test maxSubArraySum*/
int main()
{
    int a[] = {10, 20, -30, -1};
    int n = sizeof(a)/sizeof(a[0]);
    int k = 3;
    cout << "Maximum contiguous sum is "
         << maxSubArraySumRepeated(a, n, k);
    return 0;
}

Java




// Java program to print largest contiguous
// array sum when array is created after
// concatenating a small array k times.
import java.io.*;
 
class GFG {
     
// Returns sum of maximum sum
// subarray created after
// concatenating a[0..n-1] k times.
static int maxSubArraySumRepeated(int a[],
                             int n, int k)
{
    int max_so_far = 0;
    int INT_MIN, max_ending_here=0;
 
    for (int i = 0; i < n*k; i++)
    {
        // This is where it differs from
        // Kadane's algorithm. We use modular
        //  arithmetic to find next element.
        max_ending_here = max_ending_here +
                                    a[i % n];
 
        if (max_so_far < max_ending_here)
            max_so_far = max_ending_here;
 
        if (max_ending_here < 0)
            max_ending_here = 0;
    }
    return max_so_far;
}
 
// Driver program to test maxSubArraySum
public static void main (String[] args) {
     
    int a[] = {10, 20, -30, -1};
    int n = a.length;
    int k = 3;
     
    System.out.println("Maximum contiguous sum is "
                   + maxSubArraySumRepeated(a, n, k));
}
 
}
     
// This code is contributed by vt_m

Python3




# Python program to print
# largest contiguous
# array sum when array
# is created after
# concatenating a small
# array k times.
 
# Returns sum of maximum
# sum subarray created
# after concatenating
# a[0..n-1] k times.
def maxSubArraySumRepeated(a, n, k):
 
    max_so_far = -2147483648
    max_ending_here = 0
  
    for i in range(n*k):
     
        # This is where it
        # differs from Kadane's
        # algorithm. We use
        #  modular arithmetic to
        # find next element.
        max_ending_here = max_ending_here + a[i%n]
  
        if (max_so_far < max_ending_here):
            max_so_far = max_ending_here
  
        if (max_ending_here < 0):
            max_ending_here = 0
     
    return max_so_far
  
# Driver program
# to test maxSubArraySum
 
a = [10, 20, -30, -1]
n = len(a)
k = 3
 
print("Maximum contiguous sum is ",
    maxSubArraySumRepeated(a, n, k))
 
# This code is contributed
# by Anant Agarwal.

C#




// C# program to print largest contiguous
// array sum when array is created after
// concatenating a small array k times.
using System;
 
class GFG {
     
// Returns sum of maximum sum
// subarray created after
// concatenating a[0..n-1] k times.
static int maxSubArraySumRepeated(int []a,
                                  int n,
                                  int k)
{
    int max_so_far = 0;
    int max_ending_here=0;
 
    for (int i = 0; i < n * k; i++)
    {
        // This is where it differs from
        // Kadane's algorithm. We use modular
        // arithmetic to find next element.
        max_ending_here = max_ending_here +
                                  a[i % n];
 
        if (max_so_far < max_ending_here)
            max_so_far = max_ending_here;
 
        if (max_ending_here < 0)
            max_ending_here = 0;
    }
    return max_so_far;
}
 
// Driver Code
public static void Main ()
{
     
    int []a = {10, 20, -30, -1};
    int n = a.Length;
    int k = 3;
     
    Console.Write("Maximum contiguous sum is "
                  + maxSubArraySumRepeated(a, n, k));
}
}
     
// This code is contributed by nitin mittal.

PHP




<?php
// PHP program to print largest contiguous
// array sum when array is created after
// concatenating a small array k times.
 
// Returns sum of maximum
// sum subarray created
// after concatenating
// a[0..n-1] k times.
function maxSubArraySumRepeated($a, $n, $k)
{
    $INT_MIN=0;
    $max_so_far = $INT_MIN; $max_ending_here = 0;
 
    for ($i = 0; $i < $n*$k; $i++)
    {
         
        // This is where it differs
        // from Kadane's algorithm.
        // We use modular arithmetic
        // to find next element.
        $max_ending_here = $max_ending_here +
                                  $a[$i % $n];
 
        if ($max_so_far < $max_ending_here)
            $max_so_far = $max_ending_here;
 
        if ($max_ending_here < 0)
            $max_ending_here = 0;
    }
    return $max_so_far;
}
 
    // Driver Code
    $a = array(10, 20, -30, -1);
    $n = sizeof($a);
    $k = 3;
    echo "Maximum contiguous sum is "
          , maxSubArraySumRepeated($a, $n, $k);
 
// This code is contributed by nitin mittal.
?>

Javascript




<script>
 
// JavaScript program to print largest contiguous
// array sum when array is created after
// concatenating a small array k times.
 
// Returns sum of maximum sum
// subarray created after
// concatenating a[0..n-1] k times.
function maxSubArraySumRepeated(a, n, k)
{
    let max_so_far = 0;
    let INT_MIN, max_ending_here=0;
   
    for (let i = 0; i < n*k; i++)
    {
        // This is where it differs from
        // Kadane's algorithm. We use modular
        //  arithmetic to find next element.
        max_ending_here = max_ending_here +
                                    a[i % n];
   
        if (max_so_far < max_ending_here)
            max_so_far = max_ending_here;
   
        if (max_ending_here < 0)
            max_ending_here = 0;
    }
    return max_so_far;
}
 
 
// Driver code
 
    let a = [10, 20, -30, -1];
    let n = a.length;
    let k = 3;
       
    document.write("Maximum contiguous sum is "
                   + maxSubArraySumRepeated(a, n, k));
 
// This code is contributed by sanjoy_62.
</script>

Output : 

Maximum contiguous sum is 30

Can we use the repeating property of array to get a better solution ?
 




My Personal Notes arrow_drop_up
Recommended Articles
Page :