Maximum power of jump required to reach the end of string

Given a string consisting of 1 and 0, the task is to find out the maximum power of jump required to reach the end of the string. At a time you can jump from one 1 to the next 1 or from one 0 to the next 0. 

Note: Power of jump is defined as the distance between two consecutive 1’s or two consecutive 0’s.

Examples:

Input: 10101
Output: 2
First, make a power jump of 1 to reach first 1, 
then a power jump of 2 to reach second 1
and then finally a power jump of 2 
to reach the end of the string
hence the maximum power of jump is 2.

Input: 11110
Output: 5
Since to reach the end of the string, we have to make
power jump of 5 to reach 0 and end of the string

Approach: 

• Check if the last character of a given string is 1 or 0.
• If the last character is 1 then search for the first 1 in the string and continue to jump to the next 1 to reach the last of the string. Update the maximum jumps.
• Similarly, if the last character is 0 then search for the first 0 in the string and continue to jump to the next 0 to reach the last of the string. Update the maximum jumps.
• Return the maximum number of jumps taken to reach the end.

Below is the implementation of the above approach:

C++

// C++ program to calculate power of jump
#include<bits/stdc++.h>
using namespace std;

// Function to calculate the maximum power of the jump
int powerOfJump(string s)
{
    // Initialize the count with 1
    int count = 1;
    int max_so_far = INT_MIN;

    // Find the character at last index
    char ch = s[s.length() - 1];

    // Start traversing the string
    for (int i = 0; i < s.length(); i++)
    {
        // Check if the current char is equal
        // to the last character
        if (s[i] == ch)
        {
            // max_so_far stores maximum value of
            // the power of the jump from starting
            // to ith position
            if (count > max_so_far) {
                max_so_far = count;

            }
            // Reset the count to 1
            count = 1;

        }
        // Else, increment the number of jumps/count
        else
        count++;

    }
    // Return the maximum number of jumps
    return max_so_far;

}

// Driver code
int main(){
    string st = "1010101";
    cout<<powerOfJump(st);

}
// This code is contributed by ash264

Java

// java program to calculate power of jump
import java.util.ArrayList;

public class string_sort {

    // Function to calculate the maximum power of the jump
    public static int powerOfJump(String s)
    {
        // Initialize the count with 1
        int count = 1;
        int max_so_far = Integer.MIN_VALUE;

        // Find the character at last index
        char ch = s.charAt(s.length() - 1);

        // Start traversing the string
        for (int i = 0; i < s.length(); i++) {

           // Check if the current char is equal
           // to the last character
            if (s.charAt(i) == ch) {

                // max_so_far stores maximum value of
                // the power of the jump from starting
                // to ith position
                if (count > max_so_far) {
                    max_so_far = count;
                }

                // Reset the count to 1
                count = 1;
            }

            // Else, increment the number of jumps/count
            else
                count++;
        }

        // Return the maximum number of jumps
        return max_so_far;
    }
    // Driver code
    public static void main(String[] args)
    {
        String st = "1010101";
        System.out.println(powerOfJump(st));
    }
}

Python3

# Python3 program to calculate
# power of jump

# Function to calculate the maximum
# power of the jump
def powerOfJump(s):

    # Initialize the count with 1
    count = 1
    max_so_far = 0

    # Find the character at last index
    ch = s[-1]

    # Start traversing the string
    for i in range(0, len(s)):

        # Check if the current char is
        # equal to the last character
        if s[i] == ch:

            # max_so_far stores maximum value of
            # the power of the jump from starting
            # to ith position
            if count > max_so_far:
                max_so_far = count

            # Reset the count to 1
            count = 1

        # Else, increment the number
        # of jumps/count
        else:
            count += 1

    # Return the maximum number of jumps
    return max_so_far

# Driver Code
if __name__ == "__main__":

    st = "1010101"
    print(powerOfJump(st))

# This code is contributed
# by Rituraj Jain

C#

// C# program to calculate
// power of jump
using System;

class GFG
{

// Function to calculate the
// maximum power of the jump
public static int powerOfJump(String s)
{
    // Initialize the count with 1
    int count = 1;
    int max_so_far = int.MinValue;

    // Find the character at last index
    char ch = s[s.Length - 1];

    // Start traversing the string
    for (int i = 0; i < s.Length; i++)
    {

    // Check if the current char is
    // equal to the last character
        if (s[i] == ch)
        {

            // max_so_far stores maximum value
            // of the power of the jump from
            // starting to ith position
            if (count > max_so_far)
            {
                max_so_far = count;
            }

            // Reset the count to 1
            count = 1;
        }

        // Else, increment the number
        // of jumps/count
        else
            count++;
    }

    // Return the maximum number of jumps
    return max_so_far;
}

// Driver code
public static void Main()
{
    String st = "1010101";
    Console.WriteLine(powerOfJump(st));
}
}

// This code is contributed
// by Akanksha Rai(Abby_akku)

PHP

<?php
// PHP program to calculate
// power of jump

// Function to calculate the
// maximum power of the jump
function powerOfJump($s)
{
    // Initialize the count with 1
    $count = 1;
    $max_so_far = PHP_INT_MIN;

    // Find the character at last index
    $ch = $s[strlen($s) - 1];

    // Start traversing the string
    for ($i = 0;
         $i < strlen($s); $i++)
    {
        // Check if the current char
        // is equal to the last character
        if ($s[$i] == $ch)
        {
            // max_so_far stores maximum value
            // of the power of the jump from
            // starting to ith position
            if ($count > $max_so_far)
            {
                $max_so_far = $count;
            }

            // Reset the count to 1
            $count = 1;

        }

        // Else, increment the number
        // of jumps/count
        else
        $count++;
    }

    // Return the maximum number
    // of jumps
    return $max_so_far;
}

// Driver code
$st = "1010101";
echo powerOfJump($st);

// This code is contributed by ajit
?>

Javascript

<script>

// Javascript program to calculate power of jump

    // Function to calculate the maximum power of the jump
     function powerOfJump( s) {
        // Initialize the count with 1
        let count = 1;
        let max_so_far = Number.MIN_VALUE;

        // Find the letacter at last index
        let ch = s[s.length - 1];

        // Start traversing the string
        for (let i = 0; i < s.length; i++) {

            // Check if the current let is equal
            // to the last letacter
            if (s[i] == ch) {

                // max_so_far stores maximum value of
                // the power of the jump from starting
                // to ith position
                if (count > max_so_far) {
                    max_so_far = count;
                }

                // Reset the count to 1
                count = 1;
            }

            // Else, increment the number of jumps/count
            else
                count++;
        }

        // Return the maximum number of jumps
        return max_so_far;
    }

    // Driver code

        let st = "1010101";
        document.write(powerOfJump(st));

// This code is contributed by shikhasingrajput

</script>

Output

2

Time Complexity: O(n) where n is the length of the string
Auxiliary Space: O(1), no extra space is required, so it is constant.