元素具有相等模K的最长子数组

给定一个整数K和一个整数元素的数组arr ，任务是打印最长子数组的长度，以使该子数组的每个元素在除以K时产生相同的余数。

例子：

Input: arr[] = {2, 1, 5, 8, 1}, K = 3
Output: 2
{2, 1, 5, 8, 1} gives remainders {2, 1, 2, 2, 1} on division with 3
Hence, longest sub-array length is 2.

Input: arr[] = {1, 100, 2, 9, 4, 32, 6, 3}, K = 2
Output: 3

简单方法：

• 从左到右遍历数组，并将每个元素的模与K一起存储在第二个数组中。
• 现在，任务减少了，以找到具有相同元素的最长子数组。

下面是上述方法的实现：

C++

// C++ implementation of above approach
#include 
using namespace std;
  
// function to find longest sub-array
// whose elements gives same remainder
// when divided with K
int LongestSubarray(int arr[], int n, int k)
{
    // second array contains modulo
    // results of each element with K
    int arr2[n];
    for (int i = 0; i < n; i++)
        arr2[i] = arr[i] % k;
  
    int current_length, max_length = 0;
    int j;
  
    // loop for finding longest sub-array
    // with equal elements
    for (int i = 0; i < n;) {
        current_length = 1;
        for (j = i + 1; j < n; j++) {
            if (arr2[j] == arr2[i])
                current_length++;
            else
                break;
        }
        max_length = max(max_length, current_length);
        i = j;
    }
    return max_length;
}
  
// Driver code
int main()
{
    int arr[] = { 4, 9, 7, 18, 29, 11 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 11;
    cout << LongestSubarray(arr, n, k);
    return 0;
}

Java

//  Java implementation of above approach
import java .io.*;
  
class GFG
{
// function to find longest sub-array
// whose elements gives same remainder
// when divided with K
static int LongestSubarray(int[] arr, 
                        int n, int k)
{
    // second array contains modulo
    // results of each element with K
    int[] arr2 = new int[n];
    for (int i = 0; i < n; i++)
        arr2[i] = arr[i] % k;
  
    int current_length, max_length = 0;
    int j;
  
    // loop for finding longest 
    // sub-array with equal elements
    for (int i = 0; i < n;) 
    {
        current_length = 1;
        for (j = i + 1; j < n; j++) 
        {
            if (arr2[j] == arr2[i])
                current_length++;
            else
                break;
        }
        max_length = Math.max(max_length, 
                            current_length);
        i = j;
    }
    return max_length;
}
  
// Driver code
public static void main(String[] args)
{
    int[] arr = { 4, 9, 7, 18, 29, 11 };
    int n = arr.length;
    int k = 11;
    System.out.println(LongestSubarray(arr, n, k));
}
}
  
// This code is contributed 
// by shs

Python 3

# Python 3 implementation of above approach
  
# function to find longest sub-array
# whose elements gives same remainder
# when divided with K
def LongestSubarray(arr, n, k):
  
    # second array contains modulo
    # results of each element with K
    arr2 = [0] * n
    for i in range( n):
        arr2[i] = arr[i] % k
          
    max_length = 0
  
    # loop for finding longest sub-array
    # with equal elements
    i = 0
    while i < n :
        current_length = 1
        for j in range(i + 1, n):
            if (arr2[j] == arr2[i]):
                current_length += 1
            else:
                break
          
        max_length = max(max_length, 
                         current_length)
        i = j
        i += 1
  
    return max_length
  
# Driver code
if __name__ == "__main__":
    arr = [ 4, 9, 7, 18, 29, 11 ]
    n = len(arr)
    k = 11
    print(LongestSubarray(arr, n, k))
  
# This code is contributed 
# by ChitraNayal

C#

// C# implementation of above approach
using System;
  
class GFG
{
// function to find longest sub-array
// whose elements gives same remainder
// when divided with K
static int LongestSubarray(int[] arr, 
                           int n, int k)
{
    // second array contains modulo
    // results of each element with K
    int[] arr2 = new int[n];
    for (int i = 0; i < n; i++)
        arr2[i] = arr[i] % k;
  
    int current_length, max_length = 0;
    int j;
  
    // loop for finding longest 
    // sub-array with equal elements
    for (int i = 0; i < n;) 
    {
        current_length = 1;
        for (j = i + 1; j < n; j++) 
        {
            if (arr2[j] == arr2[i])
                current_length++;
            else
                break;
        }
        max_length = Math.Max(max_length,   
                              current_length);
        i = j;
    }
    return max_length;
}
  
// Driver code
public static void Main()
{
    int[] arr = { 4, 9, 7, 18, 29, 11 };
    int n = arr.Length;
    int k = 11;
    Console.Write(LongestSubarray(arr, n, k));
}
}
  
// This code is contributed 
// by Akanksha Rai

输出：

3

时间复杂度： O(n * n)
辅助空间： O(n)

一种有效的方法是跟踪单个遍历中的当前计数。每当我们找到模数不相同的元素时，就会将count重置为0。

C++

// C++ implementation of above approach
#include 
using namespace std;
  
// function to find longest sub-array
// whose elements gives same remainder
// when divided with K
int LongestSubarray(int arr[], int n, int k)
{
    int count = 1;
    int max_length = 1; 
    int prev_mod = arr[0] % k;
    
    // Iterate in the array 
    for (int i = 1; i < n; i++) { 
  
        int curr_mod = arr[i] % k;
    
        // check if array element 
        // greater then X or not 
        if (curr_mod == prev_mod) { 
            count++;
        } 
        else { 
    
            max_length = max(max_length, count);   
            count = 1; 
            prev_mod = curr_mod;
        } 
    } 
      
    return max_length; 
}
  
// Driver code
int main()
{
    int arr[] = { 4, 9, 7, 18, 29, 11 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 11;
    cout << LongestSubarray(arr, n, k);
    return 0;
}

Java

// Java implementation of above approach 
  
class GFG {
  
// function to find longest sub-array 
// whose elements gives same remainder 
// when divided with K 
    static public int LongestSubarray(int arr[], int n, int k) {
        int count = 1;
        int max_length = 1;
        int prev_mod = arr[0] % k;
  
        // Iterate in the array 
        for (int i = 1; i < n; i++) {
  
            int curr_mod = arr[i] % k;
  
            // check if array element 
            // greater then X or not 
            if (curr_mod == prev_mod) {
                count++;
            } else {
  
                max_length = Math.max(max_length, count);
                count = 1;
                prev_mod = curr_mod;
            }
        }
  
        return max_length;
    }
  
// Driver code 
    public static void main(String[] args) {
        int arr[] = {4, 9, 7, 18, 29, 11};
        int n = arr.length;
        int k = 11;
        System.out.print(LongestSubarray(arr, n, k));
    }
}
// This code is contributed by Rajput-Ji

Python3

# Python3 implementation of above approach
  
# function to find longest sub-array
# whose elements gives same remainder
#  when divided with K
  
def LongestSubarray(arr,n,k):
    count = 1
    max_lenght = 1
    prev_mod = arr[0]%k
  
    # Iterate in the array
    for i in range(1,n):
        curr_mod = arr[i]%k
  
       #  check if array element 
       # greater then X or not 
        if curr_mod==prev_mod:
            count+=1
        else:
            max_lenght = max(max_lenght,count)
            count=1
            prev_mod = curr_mod
  
  
    return max_lenght
  
# Driver code
arr = [4, 9, 7, 18, 29, 11]
n = len(arr)
k =11
print(LongestSubarray(arr,n,k))
  
  
  
# This code is contributed by Shrikant13

C＃

// C# implementation of above approach
using System;
  
class GFG
{
      
// function to find longest sub-array
// whose elements gives same remainder
// when divided with K
static int LongestSubarray(int []arr, int n, int k)
{
    int count = 1;
    int max_length = 1; 
    int prev_mod = arr[0] % k;
  
    // Iterate in the array 
    for (int i = 1; i < n; i++)
    { 
  
        int curr_mod = arr[i] % k;
  
        // check if array element 
        // greater then X or not 
        if (curr_mod == prev_mod)
        { 
            count++;
        } 
        else 
        { 
            max_length = Math.Max(max_length, count); 
            count = 1; 
            prev_mod = curr_mod;
        } 
    } 
    return max_length; 
}
  
// Driver code
public static void Main()
{
    int[] arr = { 4, 9, 7, 18, 29, 11 };
    int n = arr.Length;
    int k = 11;
    Console.Write(LongestSubarray(arr, n, k));
}
}
  
// This code is cntributed by Shivi_Aggarwal

输出：

3

时间复杂度： O(n)
辅助空间： O(1)