Related Articles
Longest subarray such that adjacent elements have at least one common digit | Set 1
• Difficulty Level : Easy
• Last Updated : 11 May, 2021

Given an array of N integers, write a program that prints the length of the longest subarray such that adjacent elements of the subarray have at least one digit in common.

Examples:

```Input : 12 23 45 43 36 97
Output : 3
Explanation: The subarray is 45 43 36 which has
4 common in 45, 43 and 3 common in 43, 36.

Input : 11 22 33 44 54 56 63
Output : 4
Explanation: Subarray is 44, 54, 56, 63 ```

A normal approach will be to check for all the subarrays possible. But the time complexity will be O(n2).
An efficient approach will be to create a hash[n] array which marks the occurrence of digits in the i-th index number. We iterate for every element and check if adjacent elements have a digit common in between. If they have a common digit, we keep the count of the length. If the adjacent elements do not have a digit in common, we initialize the count to zero and start counting again for a subarray. Print the maximum count which is obtained while iteration. We use a hash array to minimize the time complexity as the number can be of range 10^18 which will take 18 iterations in the worst case.
Given below is the illustration of the above approach:

## C++

 `// CPP program to print the length of the``// longest subarray such that adjacent elements``// of the subarray have at least one digit in``// common.``#include ``using` `namespace` `std;` `// function to print the longest subarray``// such that adjacent elements have at least``// one digit in common``int` `longestSubarray(``int` `a[], ``int` `n)``{``    ``// remembers the occurrence of digits in``    ``// i-th index number``    ``int` `hash[n];``    ``memset``(hash, 0, ``sizeof``(hash));` `    ``// marks the presence of digit in i-th``    ``// index number``    ``for` `(``int` `i = 0; i < n; i++) {``        ``int` `num = a[i];``        ``while` `(num) {``            ``// marks the digit``            ``hash[i][num % 10] = 1;``            ``num /= 10;``        ``}``    ``}` `    ``// counts the longest Subarray``    ``int` `longest = INT_MIN;``    ``// counts the subarray``    ``int` `count = 0;` `    ``// check for all adjacent elements``    ``for` `(``int` `i = 0; i < n - 1; i++) {``        ``int` `j;``        ``for` `(j = 0; j < 10; j++) {` `            ``// if adjacent elements have digit j``            ``// in them count and break as we have``            ``// got at-least one digit``            ``if` `(hash[i][j] and hash[i + 1][j]) {``                ``count++;``                ``break``;``            ``}``        ``}``        ``// if no digits are common``        ``if` `(j == 10) {``            ``longest = max(longest, count + 1);``            ``count = 0;``        ``}``    ``}` `    ``longest = max(longest, count + 1);` `    ``// returns the length of the longest subarray``    ``return` `longest;``}``// Driver Code``int` `main()``{``    ``int` `a[] = { 11, 22, 33, 44, 54, 56, 63 };` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a);``    ``// function call``    ``cout << longestSubarray(a, n);``    ``return` `0;``}`

## Java

 `// Java program to print the length of the``// longest subarray such that adjacent elements``// of the subarray have at least one digit in``// common.` `class` `GFG {` `// function to print the longest subarray``// such that adjacent elements have at least``// one digit in common``    ``static` `int` `longestSubarray(``int` `a[], ``int` `n) {``        ``// remembers the occurrence of digits in``        ``// i-th index number``        ``int` `hash[][] = ``new` `int``[n][``10``];` `        ``// marks the presence of digit in i-th``        ``// index number``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``int` `num = a[i];``            ``while` `(num != ``0``) {``                ``// marks the digit``                ``hash[i][num % ``10``] = ``1``;``                ``num /= ``10``;``            ``}``        ``}` `        ``// counts the longest Subarray``        ``int` `longest = Integer.MIN_VALUE;``        ``// counts the subarray``        ``int` `count = ``0``;` `        ``// check for all adjacent elements``        ``for` `(``int` `i = ``0``; i < n - ``1``; i++) {``            ``int` `j;``            ``for` `(j = ``0``; j < ``10``; j++) {` `                ``// if adjacent elements have digit j``                ``// in them count and break as we have``                ``// got at-least one digit``                ``if` `(hash[i][j] == ``1` `& hash[i + ``1``][j] == ``1``) {``                    ``count++;``                    ``break``;``                ``}``            ``}``            ``// if no digits are common``            ``if` `(j == ``10``) {``                ``longest = Math.max(longest, count + ``1``);``                ``count = ``0``;``            ``}``        ``}` `        ``longest = Math.max(longest, count + ``1``);` `        ``// returns the length of the longest subarray``        ``return` `longest;``    ``}``// Driver Code` `    ``public` `static` `void` `main(String[] args) {``        ``int` `a[] = {``11``, ``22``, ``33``, ``44``, ``54``, ``56``, ``63``};` `        ``int` `n = a.length;``        ``// function call``        ``System.out.println(longestSubarray(a, n));` `    ``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python 3 program to print the length of the``# longest subarray such that adjacent elements``# of the subarray have at least one digit in``# common.``import` `sys` `# function to print the longest subarray``# such that adjacent elements have at least``# one digit in common``def` `longestSubarray(a, n):``    ` `    ``# remembers the occurrence of digits``    ``# in i-th index number``    ``hash` `=` `[[``0` `for` `i ``in` `range``(``10``)]``               ``for` `j ``in` `range``(n)]` `    ``# marks the presence of digit in``    ``# i-th index number``    ``for` `i ``in` `range``(n):``        ``num ``=` `a[i]``        ``while` `(num):``            ` `            ``# marks the digit``            ``hash``[i][num ``%` `10``] ``=` `1``            ``num ``=` `int``(num ``/` `10``)``    ` `    ``# counts the longest Subarray``    ``longest ``=` `-``sys.maxsize``-``1``    ` `    ``# counts the subarray``    ``count ``=` `0` `    ``# check for all adjacent elements``    ``for` `i ``in` `range``(n ``-` `1``):``        ``for` `j ``in` `range``(``10``):``            ` `            ``# if adjacent elements have digit j``            ``# in them count and break as we have``            ``# got at-least one digit``            ``if` `(``hash``[i][j] ``and` `hash``[i ``+` `1``][j]):``                ``count ``+``=` `1``                ``break``        ` `        ``# if no digits are common``        ``if` `(j ``=``=` `10``):``            ``longest ``=` `max``(longest, count ``+` `1``)``            ``count ``=` `0``    ` `    ``longest ``=` `max``(longest, count ``+` `1``)` `    ``# returns the length of the longest``    ``# subarray``    ``return` `longest` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``a ``=` `[``11``, ``22``, ``33``, ``44``, ``54``, ``56``, ``63``]` `    ``n ``=` `len``(a)``    ` `    ``# function call``    ``print``(longestSubarray(a, n))``    ` `# This code is contributed by``# Sanjit_Prasad`

## C#

 `    ` `// C# program to print the length of the``// longest subarray such that adjacent elements``// of the subarray have at least one digit in``// common.``using` `System;``public` `class` `GFG {` `// function to print the longest subarray``// such that adjacent elements have at least``// one digit in common``    ``static` `int` `longestSubarray(``int` `[]a, ``int` `n) {``        ``// remembers the occurrence of digits in``        ``// i-th index number``        ``int` `[,]hash = ``new` `int``[n,10];` `        ``// marks the presence of digit in i-th``        ``// index number``        ``for` `(``int` `i = 0; i < n; i++) {``            ``int` `num = a[i];``            ``while` `(num != 0) {``                ``// marks the digit``                ``hash[i,num % 10] = 1;``                ``num /= 10;``            ``}``        ``}` `        ``// counts the longest Subarray``        ``int` `longest = ``int``.MinValue;``        ``// counts the subarray``        ``int` `count = 0;` `        ``// check for all adjacent elements``        ``for` `(``int` `i = 0; i < n - 1; i++) {``            ``int` `j;``            ``for` `(j = 0; j < 10; j++) {` `                ``// if adjacent elements have digit j``                ``// in them count and break as we have``                ``// got at-least one digit``                ``if` `(hash[i,j] == 1 & hash[i + 1,j] == 1) {``                    ``count++;``                    ``break``;``                ``}``            ``}``            ``// if no digits are common``            ``if` `(j == 10) {``                ``longest = Math.Max(longest, count + 1);``                ``count = 0;``            ``}``        ``}` `        ``longest = Math.Max(longest, count + 1);` `        ``// returns the length of the longest subarray``        ``return` `longest;``    ``}``// Driver Code` `    ``public` `static` `void` `Main() {``        ``int` `[]a = {11, 22, 33, 44, 54, 56, 63};` `        ``int` `n = a.Length;``        ``// function call``        ``Console.Write(longestSubarray(a, n));` `    ``}``}``// This code is contributed by Rajput-Ji//`

## PHP

 ``

## Javascript

 ``

Output:

`4`

Time Complexity: O(n*10)
Longest subarray such that adjacent elements have at least one common digit | Set – 2

Want to learn from the best curated videos and practice problems, check out the C++ Foundation Course for Basic to Advanced C++ and C++ STL Course for the language and STL.  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