Skip to content
Related Articles
Check if all the 1’s in a binary string are equidistant or not
• Difficulty Level : Basic
• Last Updated : 22 Apr, 2021

Given a binary string str, the task is to check if all the 1’s in the string are equidistant or not. The term equidistant means that the distance between every two adjacent 1’s is same. Note that the string contains at least two 1’s.

Examples:

Input: str = “00111000”
Output: Yes
The distance between all the 1’s is same and is equal to 1.

Input: str = “0101001”
Output: No
The distance between the 1st and the 2nd 1’s is 2
and the distance between the 2nd and the 3rd 1’s is 3.

Approach: Store the position of all the 1’s in the string in a vector and then check if the difference between each two consecutive positions is same or not.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``#include ``using` `namespace` `std;` `// Function that returns true if all the 1's``// in the binary string s are equidistant``bool` `check(string s, ``int` `l)``{` `    ``// Initialize vector to store``    ``// the position of 1's``    ``vector<``int``> pos;` `    ``for` `(``int` `i = 0; i < l; i++) {` `        ``// Store the positions of 1's``        ``if` `(s[i] == ``'1'``)``            ``pos.push_back(i);``    ``}` `    ``// Size of the position vector``    ``int` `t = pos.size();``    ``for` `(``int` `i = 1; i < t; i++) {` `        ``// If condition isn't satisfied``        ``if` `((pos[i] - pos[i - 1]) != (pos - pos))``            ``return` `false``;``    ``}` `    ``return` `true``;``}` `// Drivers code``int` `main()``{``    ``string s = ``"100010001000"``;``    ``int` `l = s.length();``    ``if` `(check(s, l))``        ``cout << ``"Yes"``;``    ``else``        ``cout << ``"No"``;` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG``{` `// Function that returns true if all the 1's``// in the binary string s are equidistant``static` `boolean` `check(String s, ``int` `l)``{` `    ``// Initialize vector to store``    ``// the position of 1's``    ``Vector pos = ``new` `Vector();` `    ``for` `(``int` `i = ``0``; i < l; i++)``    ``{` `        ``// Store the positions of 1's``        ``if` `(s.charAt(i)== ``'1'``)``            ``pos.add(i);``    ``}` `    ``// Size of the position vector``    ``int` `t = pos.size();``    ``for` `(``int` `i = ``1``; i < t; i++)``    ``{` `        ``// If condition isn't satisfied``        ``if` `((pos.get(i) - pos.get(i-``1``)) != (pos.get(``1``) - pos.get(``0``)))``            ``return` `false``;``    ``}` `    ``return` `true``;``}` `// Drivers code``public` `static` `void` `main(String args[])``{``    ``String s = ``"100010001000"``;``    ``int` `l = s.length();``    ``if` `(check(s, l))``        ``System.out.print(``"Yes"``);``    ``else``        ``System.out.print(``"No"``);``}``}` `// This code is contributed by Arnab Kundu`

## Python3

 `# Python3 implementation of the approach` `# Function that returns true if all the 1's``# in the binary s are equidistant``def` `check(s, l):` `    ``# Initialize vector to store``    ``# the position of 1's``    ``pos ``=` `[]` `    ``for` `i ``in` `range``(l):` `        ``# Store the positions of 1's``        ``if` `(s[i] ``=``=` `'1'``):``            ``pos.append(i)` `    ``# Size of the position vector``    ``t ``=` `len``(pos)``    ``for` `i ``in` `range``(``1``, t):` `        ``# If condition isn't satisfied``        ``if` `((pos[i] ``-``             ``pos[i ``-` `1``]) !``=` `(pos[``1``] ``-``                             ``pos[``0``])):``            ``return` `False` `    ``return` `True` `# Driver code``s ``=` `"100010001000"``l ``=` `len``(s)``if` `(check(s, l)):``    ``print``(``"Yes"``)``else``:``    ``print``(``"No"``)` `# This code is contributed``# by mohit kumar`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `// Function that returns true if all the 1's``// in the binary string s are equidistant``static` `bool` `check(String s, ``int` `l)``{` `    ``// Initialize vector to store``    ``// the position of 1's``    ``List<``int``> pos = ``new` `List<``int``>();` `    ``for` `(``int` `i = 0; i < l; i++)``    ``{` `        ``// Store the positions of 1's``        ``if` `(s[i]== ``'1'``)``        ``{``            ` `            ``pos.Add(i);``        ``}``    ``}` `    ``// Size of the position vector``    ``int` `t = pos.Count;``    ``for` `(``int` `i = 1; i < t; i++)``    ``{` `        ``// If condition isn't satisfied``        ``if` `((pos[i] - pos[i - 1]) != (pos - pos))``            ``return` `false``;``    ``}` `    ``return` `true``;``}` `// Drivers code``public` `static` `void` `Main(String []args)``{``    ``String s = ``"100010001000"``;``    ``int` `l = s.Length;``    ``if` `(check(s, l))``        ``Console.WriteLine(``"Yes"``);``    ``else``        ``Console.WriteLine(``"No"``);``}``}` `/* This code contributed by PrinciRaj1992 */`

## Javascript

 ``
Output:
`Yes`

Time Complexity: O(N) where N is the length of the string.

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 industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up