# Solving Leetcode Interviews in Seconds with AI: K-Concatenation Maximum Sum


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1191" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> Given an integer array arr and an integer k, modify the array by repeating it k times. For example, if arr = [1, 2] and k = 3 then the modified array will be [1, 2, 1, 2, 1, 2]. Return the maximum sub-array sum in the modified array. Note that the length of the sub-array can be 0 and its sum in that case is 0. As the answer can be very large, return the answer modulo 109 + 7.   Example 1:  Input: arr = [1,2], k = 3 Output: 9  Example 2:  Input: arr = [1,-2,1], k = 5 Output: 2  Example 3:  Input: arr = [-1,-2], k = 7 Output: 0    Constraints:  1 <= arr.length <= 105 1 <= k <= 105 -104 <= arr[i] <= 104  

	# Explanation
	Here's a breakdown of the optimal solution for the maximum subarray sum after repeating an array `k` times:

*   **Kadane's Algorithm:** Employ Kadane's Algorithm to find the maximum subarray sum within a single repetition of the array. This handles cases where the maximum subarray lies entirely within one repetition.
*   **Handle Multiple Repetitions:**  Consider the possibility that the maximum subarray spans multiple repetitions. If the sum of the original array is positive, multiplying this sum by (k-2) will contribute to an increased sum. Extend Kadane's to find the maximum suffix sum in the initial array and the maximum prefix sum in the final array.
*   **Modulo Arithmetic:** Perform all calculations modulo 10<sup>9</sup> + 7 to prevent integer overflow.

*   **Time & Space Complexity:** O(N) time, where N is the length of the array, and O(1) space.

	
	# Code
	```python
	def k_concatenation_max_sum(arr, k):
    """
    Calculates the maximum subarray sum of the array concatenated k times, modulo 10^9 + 7.

    Args:
        arr: The input array of integers.
        k: The number of times to repeat the array.

    Returns:
        The maximum subarray sum modulo 10^9 + 7.
    """

    MOD = 10**9 + 7
    n = len(arr)

    # Calculate Kadane's algorithm for a single array
    max_so_far = 0
    current_max = 0
    for i in range(n):
        current_max = max(arr[i], current_max + arr[i])
        max_so_far = max(max_so_far, current_max)

    # Calculate the sum of the entire array
    arr_sum = sum(arr)

    # If k = 1, return the Kadane's result
    if k == 1:
        return max(0, max_so_far) % MOD

    # Calculate max prefix sum
    max_prefix_sum = 0
    current_prefix_sum = 0
    for i in range(n):
        current_prefix_sum += arr[i]
        max_prefix_sum = max(max_prefix_sum, current_prefix_sum)

    # Calculate max suffix sum
    max_suffix_sum = 0
    current_suffix_sum = 0
    for i in range(n - 1, -1, -1):
        current_suffix_sum += arr[i]
        max_suffix_sum = max(max_suffix_sum, current_suffix_sum)

    # Calculate the result
    if arr_sum > 0:
        result = (max_prefix_sum + max_suffix_sum + (k - 2) * arr_sum) % MOD
    else:
        result = (max_prefix_sum + max_suffix_sum) % MOD

    return max(0, max(max_so_far, result)) % MOD
	```