Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Maximum distance between adjacent 1s in given Binary String

  • Difficulty Level : Basic
  • Last Updated : 11 Apr, 2022

Given a binary string S containing N characters, the task is to find the maximum distance between two adjacent 1’s. 

Examples:

Input: S = “1010010”
Output: 3
Explanation: There are 2 sets of adjacent 1’s in the given index on the indices {0, 2} and {2, 5}. 
The one with the maximum distance among them is {2, 5} with a distance of 3 units.

Input: S = “100000”
Output: -1
Explanation: No set of adjacent 1’s exist in the given string.

 

Approach: The given problem is an implementation-based problem. The idea is to store all the indices of 1’s in increasing order in a vector. Hence it can be observed that the required answer will be the maximum of the difference of consecutive integers in the index vector.

Below is the implementation of the above approach:

C++14




// C++ program of the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the maximum
// distance between two adjacent
// 1's in a given binary string
int maxDist(string S)
{
    // Stores the required answer
    int maxLen = INT_MIN;
 
    // Vector to store indices
    vector<int> indices;
 
    // Loop to traverse string
    for (int i = 0; i < S.length(); i++) {
        if (S[i] == '1')
            indices.push_back(i);
    }
 
    // Loop to reverse the
    // index vector
    for (int i = 1; i < indices.size(); i++)
 
        // Update maximum distance
        maxLen = max(maxLen, indices[i] -
                     indices[i - 1]);
 
    // Return Answer
    return maxLen == INT_MIN ? -1 : maxLen;
}
 
// Driver Code
int main()
{
    string S = "1010010";
    cout << maxDist(S);
    return 0;
}
Java



// Java program of the above approach
import java.io.*;
import java.util.*;
 
class GFG
{
 
  // Function to find the maximum
  // distance between two adjacent
  // 1's in a given binary String
  public static int maxDist(String S)
  {
     
    // Stores the required answer
    int maxLen = Integer.MIN_VALUE;
 
    // Vector to store indices
    Vector<Integer> indices = new Vector<Integer>();
 
    // Loop to traverse String
    for (int i = 0; i < S.length(); i++) {
      if (S.charAt(i) == '1')
        indices.add(i);
    }
 
    // Loop to reverse the
    // index vector
    for (int i = 1; i < indices.size(); i++)
 
      // Update maximum distance
      maxLen = Math.max(maxLen, indices.get(i) -
                        indices.get(i - 1));
 
    // Return Answer
    return maxLen == Integer.MIN_VALUE ? -1 : maxLen;
  }
 
  // Driver Code
  public static void main (String[] args)
  {
    String S = "1010010";
    System.out.println(maxDist(S));
  }
}
 
// This code is contributed by subhamsingh10.
Python3



# Python code for the above approach
 
# Function to find the maximum
# distance between two adjacent
# 1's in a given binary string
def maxDist(S):
 
    # Stores the required answer
    maxLen = 10 ** -9
 
    # Vector to store indices
    indices = []
 
    # Loop to traverse string
    for i in range(len(S)):
        if S[i] == "1":
            indices.append(i)
 
    # Loop to reverse the
    # index vector
    for i in range(1, len(indices)):
 
        # Update maximum distance
        maxLen = max(maxLen, indices[i] - indices[i - 1])
 
    # Return Answer
    return -1 if (maxLen == 10 ** -9) else maxLen
 
# Driver Code
S = "1010010"
print(maxDist(S))
 
# This code is contributed by gfgking
C#



// C# program for above approach
using System;
using System.Collections.Generic;
 
public class GFG
{
 
  // Function to find the maximum
  // distance between two adjacent
  // 1's in a given binary string
  static int maxDist(string S)
  {
 
    // Stores the required answer
    int maxLen = Int32.MinValue;
 
    // Vector to store indices
    List<int> indices = new List<int>();
 
    // Loop to traverse string
    for (int i = 0; i < S.Length; i++) {
      if (S[i] == '1')
        indices.Add(i);
    }
 
    // Loop to reverse the
    // index vector
    for (int i = 1; i < indices.Count; i++)
 
      // Update maximum distance
      maxLen = Math.Max(maxLen, indices[i] -
                        indices[i - 1]);
 
    // Return Answer
    if(maxLen == Int32.MinValue)
      return  -1;
    else
      return maxLen;
  }
 
  // Driver code
  static public void Main ()
  {
 
    string S = "1010010";
    Console.WriteLine(maxDist(S));
  }
}
// This code is contributed by hrithikgarg03188
Javascript



  <script>
      // JavaScript code for the above approach
 
      // Function to find the maximum
      // distance between two adjacent
      // 1's in a given binary string
      function maxDist(S)
      {
       
          // Stores the required answer
          let maxLen = Number.MIN_VALUE;
 
          // Vector to store indices
          let indices = [];
 
          // Loop to traverse string
          for (let i = 0; i < S.length; i++) {
              if (S[i] == '1')
                  indices.push(i);
          }
 
          // Loop to reverse the
          // index vector
          for (let i = 1; i < indices.length; i++)
 
              // Update maximum distance
              maxLen = Math.max(maxLen, indices[i] -
                  indices[i - 1]);
 
          // Return Answer
          return maxLen == Number.MIN_VALUE ? -1 : maxLen;
      }
 
      // Driver Code
      let S = "1010010";
      document.write(maxDist(S));
 
// This code is contributed by Potta Lokesh
  </script>
Output
3
Time Complexity: O(N)
Auxiliary Space: O(N)   where N is the length of the Binary String.
 Space Efficient Approach: The above approach can also be implemented without using any extra space (vector). The only change is to achieve maximum distance by rigorous difference storing and updation everytime we found 1 in the binary string.
C++14



// C++ program of the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the maximum
// distance between two adjacent
// 1's in a given binary string
int maxDist(string S)
{
    // Stores the required answer
    int maxLen=0,i,start=0;
 
    // Loop to find first occurrence of '1' string
    for ( i = 0; i < S.length(); i++) {
        if (S[i] == '1')
        {
            start=i;
            break;
        }
    }
 
    // Loop to traverse remaining
    // indices of character '1'
    for (; i < S.length(); i++){
     
        // Update maximum distance
            if (S[i] == '1')
        {
            maxLen=max(maxLen,i-start);
            start=i;
        }
    }       
 
    // Return Answer
    return maxLen == 0 ? -1 : maxLen;
}
 
// Driver Code
int main()
{
    string S = "100000";
    cout << maxDist(S);
    return 0;
}
Java



// Java program of the above approach
 
import java.util.*;
 
class GFG{
 
// Function to find the maximum
// distance between two adjacent
// 1's in a given binary String
static int maxDist(String S)
{
    // Stores the required answer
    int maxLen=0,i,start=0;
 
    // Loop to find first occurrence of '1' String
    for ( i = 0; i < S.length(); i++) {
        if (S.charAt(i) == '1')
        {
            start=i;
            break;
        }
    }
 
    // Loop to traverse remaining
    // indices of character '1'
    for (; i < S.length(); i++){
     
        // Update maximum distance
            if (S.charAt(i) == '1')
        {
            maxLen=Math.max(maxLen,i-start);
            start=i;
        }
    }       
 
    // Return Answer
    return maxLen == 0 ? -1 : maxLen;
}
 
// Driver Code
public static void main(String[] args)
{
    String S = "100000";
    System.out.print(maxDist(S));
}
}
 
// This code contributed by Rajput-Ji
C#



// C# program of the above approach
using System;
public class GFG {
 
  // Function to find the maximum
  // distance between two adjacent
  // 1's in a given binary String
  static public int maxDist(String S)
  {
 
    // Stores the required answer
    int maxLen = 0, i, start = 0;
 
    // Loop to find first occurrence of '1' String
    for (i = 0; i < S.Length; i++) {
      if (S[i] == '1') {
        start = i;
        break;
      }
    }
 
    // Loop to traverse remaining
    // indices of character '1'
    for (; i < S.Length; i++) {
 
      // Update maximum distance
      if (S[i] == '1') {
        maxLen = Math.Max(maxLen, i - start);
        start = i;
      }
    }
 
    // Return Answer
    return maxLen == 0 ? -1 : maxLen;
  }
 
  // Driver Code
  public static void Main(String[] args) {
    String S = "100000";
    Console.Write(maxDist(S));
  }
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
// javascript program of the above approach   
// Function to find the maximum
    // distance between two adjacent
    // 1's in a given binary String
    function maxDist( S)
    {
     
        // Stores the required answer
        var maxLen = 0, i, start = 0;
 
        // Loop to find first occurrence of '1' String
        for (i = 0; i < S.length; i++) {
            if (S.charAt(i) == '1') {
                start = i;
                break;
            }
        }
 
        // Loop to traverse remaining
        // indices of character '1'
        for (; i < S.length; i++) {
 
            // Update maximum distance
            if (S.charAt(i) == '1') {
                maxLen = Math.max(maxLen, i - start);
                start = i;
            }
        }
 
        // Return Answer
        return maxLen == 0 ? -1 : maxLen;
    }
 
    // Driver Code
        var S = "100000";
        document.write(maxDist(S));
 
// This code is contributed by Rajput-Ji
</script>
Python3



# Python program of the above approach
 
 
 
 
 
# Function to find the maximum
# distance between two adjacent
# 1's in a given binary String
def maxDist(S):
    # Stores the required answer
    maxLen = 0;
    start = 0;
 
    # Loop to find first occurrence of '1' String
    for i in range(len(S)):
        if (S[i] == '1'):
            start = i;
            break;
         
     
 
    # Loop to traverse remaining
    # indices of character '1'
    for i in range(start,len(S)):
 
        # Update maximum distance
        if (S[i] == '1'):
            maxLen = max(maxLen, i - start);
            start = i;
         
     
 
    # Return Answer
    if(maxLen == 0):
        return -1;
    else:
        return maxLen;
 
 
# Driver Code
if __name__ == '__main__':
    S = "100000";
    print(maxDist(S));
 
 
# This code contributed by Rajput-Ji
Output
-1
Time Complexity: O(N)
Auxiliary Space: O(1)    where N is the length of the Binary String.

My Personal Notes
arrow_drop_up
Next

Reverse a string without affecting special characters
Recommended Articles
Page :
Minimize the maximum distance between adjacent points after adding K points anywhere in between
27, Sep 21
Minimum string such that every adjacent character of given string is still adjacent
12, May 20
Generate string with Hamming Distance as half of the hamming distance between strings A and B
30, Mar 20
Distance of chord from center when distance between center and another equal length chord is given
28, May 19
Maximum distance between two 1s in a Binary Array in a given range
06, Apr 20
Sum of the shortest distance between all 0s to 1 in given binary string
21, Sep 21
Minimal product subsequence where adjacent elements are separated by a maximum distance of K
12, Mar 19
Minimal distance such that for every customer there is at least one vendor at given distance
11, Jan 22
Maximise distance by rearranging all duplicates at same distance in given Array
16, Feb 22
Maximum distance between two 1's in Binary representation of N
10, Oct 19
Maximum distance between Peaks in given Linked List
26, Jan 22
Minimum distance between the maximum and minimum element of a given Array
16, Jul 20
Maximum distance between two even integers in a given array
02, Mar 22
Minimize swaps of adjacent characters to sort every possible rearrangement of given Binary String
03, Jan 21
Lexicographically smallest string whose hamming distance from given string is exactly K
17, Oct 17
Maximum adjacent index difference for a subsequence T present in given string S
25, Jan 22
Periodic Binary String With Minimum Period and a Given Binary String as Subsequence.
27, Apr 20
Minimize hamming distance in Binary String by setting only one K size substring bits
02, Jul 21
Queries to find distance between two nodes of a Binary tree - O(logn) method
05, Jun 18
Binary Array Range Queries to find the minimum distance between two Zeros
14, Apr 20
Replace '?' to convert given string to a binary string with maximum count of '0' and "10"
04, Jan 21
Longest substring with no pair of adjacent characters are adjacent English alphabets
10, Feb 21
Maximum distance between two occurrences of same element in array
13, Dec 16
Maximum distance between two points in coordinate plane using Rotating Caliper's Method
08, Jul 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
prophet1999
@prophet1999
Vote for difficulty
Current difficulty :
Basic





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!