Farthest position that can be reached in a binary string in K jumps by jumping on alternate digits

• Last Updated : 12 Oct, 2022

Given a binary string S of length N and an integer K, the task is to calculate the farthest position that can be reached starting from the first position in exactly K jumps.
A jump can be made from index i to j only if:

• i != j
• If the character at one of them is ‘0’ and another is ‘1’.

Examples:

Input: S = “100101”, K = 2
Output: 6
Explanation: Following steps can be taken: 1 -> 5 -> 6, Therefore 6th index can be reached in exactly 2 jumps

Input: S = “10111”, K = 1
Output: 2
Explanation: Following steps can be taken: 1 -> 2, Therefore 2nd index can be reached in exactly 2 jumps

Approach: The main observation of the problem is that the continuous patterns of 0s and 1s can be replaced with single 0 or single 1 because one cannot jump between similar characters. After replacing these continuous patterns of 0s and 1s, Now, one can simply check if the new pattern says str formed is less than equal to K then it is not possible to reach some point with K moves, otherwise, the position is simply the first position from the right in the actual pattern which contains the character str[K].

Follow the steps below to solve the problem:

• Iterate from start to end of the given string i = 0 to i = N-1 and generate new string str after replacing all continuous subpatterns of 0s with single 0 and of 1s with single 1.
• Now, check if the length of the newly formed string is less than equal to K then print -1
• Else if the length of the newly formed string is greater than K, then simply print the 1-based position of the character str[K] from the right.

Below is the implementation of the above approach:

C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the farthest point``void` `get(string s, ``int` `k)``{``    ``// Store the answer``    ``int` `ans = 0;` `    ``// Find the new string str``    ``string str = ``""``;``    ``str += s[0];` `    ``// Variables to count the zeroes and ones``    ``int` `cnt1 = 0, cnt0 = 0;``    ``int` `n = s.length();` `    ``// Boolean variable to keep track of the subpattern``    ``bool` `isOne;` `    ``if` `(s[0] == ``'0'``)``        ``isOne = ``false``;` `    ``// Iterate over the string and remove the``    ``// continuous patterns of 0s and 1s``    ``for` `(``int` `i = 1; i < n; i++) {``        ``if` `(s[i] == ``'0'` `&& isOne) {``            ``str += s[i];``            ``isOne = !isOne;``        ``}``        ``else` `if` `(s[i] == ``'1'` `&& !isOne) {``            ``str += s[i];``            ``isOne = !isOne;``        ``}``    ``}` `    ``// Count the number of zeroes and ones``    ``for` `(``int` `i = 0; i < n; i++) {``        ``if` `(str[i] == ``'0'``)``            ``cnt0++;``        ``else``            ``cnt1++;``    ``}` `    ``// Check if the K jumps are not possible``    ``if` `(str.length() <= k) {``        ``cout << -1 << endl;``        ``return``;``    ``}` `    ``// If K jumps are possible``    ``for` `(``int` `i = n - 1; i >= 0; i--) {``        ``if` `(s[i] == str[k]) {``            ``ans = i + 1;``            ``break``;``        ``}``    ``}``    ``cout << ans + 1 << endl;``}` `// Driver Code``int` `main()``{``    ``string s = ``"100101"``;``    ``int` `k = 2;``    ``get(s, k);``    ``return` `0;``}`

Java

 `// Java program for the above approach``import` `java.util.*;``public` `class` `GFG``{``// Function to find the farthest point``static` `void` `get(String s, ``int` `k)``{``    ``// Store the answer``    ``int` `ans = ``0``;` `    ``// Find the new string str``    ``String str = ``""``;``    ``str += s.charAt(``0``);` `    ``// Variables to count the zeroes and ones``    ``int` `cnt1 = ``0``, cnt0 = ``0``;``    ``int` `n = s.length();` `    ``// Boolean variable to keep track of the subpattern``    ``boolean` `isOne = ``false``;` `    ``if` `(s.charAt(``0``) == ``'0'``)``        ``isOne = ``false``;` `    ``// Iterate over the string and remove the``    ``// continuous patterns of 0s and 1s``    ``for` `(``int` `i = ``1``; i < n; i++) {``        ``if` `(s.charAt(i) == ``'0'` `&& isOne) {``            ``str += s.charAt(i);``            ``isOne = !isOne;``        ``}``        ``else` `if` `(s.charAt(i) == ``'1'` `&& !isOne) {``            ``str += s.charAt(i);``            ``isOne = !isOne;``        ``}``    ``}` `    ``// Count the number of zeroes and ones``    ``for` `(``int` `i = ``0``; i < str.length(); i++) {``        ``if` `(str.charAt(i) == ``'0'``)``            ``cnt0++;``        ``else``            ``cnt1++;``    ``}` `    ``// Check if the K jumps are not possible``    ``if` `(str.length() <= k) {``        ``System.out.print(-``1``);``        ``return``;``    ``}` `    ``// If K jumps are possible``    ``for` `(``int` `i = n - ``1``; i >= ``0``; i--) {``        ``if` `(s.charAt(i) == str.charAt(k)) {``            ``ans = i + ``1``;``            ``break``;``        ``}``    ``}``    ``System.out.print(ans + ``1``);``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ``String s = ``"100101"``;``    ``int` `k = ``2``;``    ``get(s, k);``}``}``// This code is contributed by Samim Hossain Mondal`

Python3

 `# Python3 program for the above approach` `# Function to find the farthest point``def` `get(s, k) :` `    ``# Store the answer``    ``ans ``=` `0``;` `    ``# Find the new string str``    ``string ``=` `"";``    ``string ``+``=` `s[``0``];` `    ``# Variables to count the zeroes and ones``    ``cnt1 ``=` `0``; cnt0 ``=` `0``;``    ``n ``=` `len``(s);` `    ``# Boolean variable to keep track of the subpattern``    ``isOne``=``False``;` `    ``if` `(s[``0``] ``=``=` `'0'``) :``        ``isOne ``=` `False``;` `    ``# Iterate over the string and remove the``    ``# continuous patterns of 0s and 1s``    ``for` `i ``in` `range``(``1``, n) :``        ``if` `(s[i] ``=``=` `'0'` `and` `isOne) :``            ``string ``+``=` `s[i];``            ``isOne ``=` `not` `isOne;``        ` `        ``elif` `(s[i] ``=``=` `'1'` `and` `(``not` `isOne)) :``            ``string ``+``=` `s[i];``            ``isOne ``=` `not` `isOne;` `    ``# Count the number of zeroes and ones``    ``for` `i ``in` `range``(``len``(string)) :``        ``if` `(string[i] ``=``=` `'0'``) :``            ``cnt0 ``+``=` `1``;``        ``else` `:``            ``cnt1 ``+``=` `1``;` `    ``# Check if the K jumps are not possible``    ``if` `(``len``(string) <``=` `k) :``        ``print``(``-``1``) ;``        ``return``;` `    ``# If K jumps are possible``    ``for` `i ``in` `range``(n ``-` `1``, ``-``1``, ``-``1``) :``        ` `        ``if` `(s[i] ``=``=` `string[k]) :``            ``ans ``=` `i ``+` `1``;``            ``break``;``    ``print``(ans ``+` `1``);`  `# Driver Code``if` `__name__ ``=``=`  `"__main__"` `:` `    ``s ``=` `"100101"``;``    ``k ``=` `2``;``    ``get(s, k);` `    ``# This code is contributed by AnkThon`

C#

 `// C# program for the above approach``using` `System;``class` `GFG``{``// Function to find the farthest point``static` `void` `get``(``string` `s, ``int` `k)``{``    ``// Store the answer``    ``int` `ans = 0;` `    ``// Find the new string str``    ``string` `str = ``""``;``    ``str += s[0];` `    ``// Variables to count the zeroes and ones``    ``int` `cnt1 = 0, cnt0 = 0;``    ``int` `n = s.Length;` `    ``// Bool variable to keep track of the subpattern``    ``bool` `isOne = ``false``;` `    ``if` `(s[0] == ``'0'``)``        ``isOne = ``false``;` `    ``// Iterate over the string and remove the``    ``// continuous patterns of 0s and 1s``    ``for` `(``int` `i = 1; i < n; i++) {``        ``if` `(s[i] == ``'0'` `&& isOne) {``            ``str += s[i];``            ``isOne = !isOne;``        ``}``        ``else` `if` `(s[i] == ``'1'` `&& !isOne) {``            ``str += s[i];``            ``isOne = !isOne;``        ``}``    ``}` `    ``// Count the number of zeroes and ones``    ``for` `(``int` `i = 0; i < str.Length; i++) {``        ``if` `(str[i] == ``'0'``)``            ``cnt0++;``        ``else``            ``cnt1++;``    ``}` `    ``// Check if the K jumps are not possible``    ``if` `(str.Length <= k) {``        ``Console.Write(-1);``        ``return``;``    ``}` `    ``// If K jumps are possible``    ``for` `(``int` `i = n - 1; i >= 0; i--) {``        ``if` `(s[i] == str[k]) {``            ``ans = i + 1;``            ``break``;``        ``}``    ``}``    ``Console.Write(ans + 1);``}` `// Driver Code``public` `static` `void` `Main()``{``    ``string` `s = ``"100101"``;``    ``int` `k = 2;``    ``get``(s, k);``}``}``// This code is contributed by Samim Hossain Mondal`

Javascript

 ``

Output

`6`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up