Máxima potencia de salto necesaria para llegar al final de la cuerda

Dada una string que consta de 1 y 0, la tarea es encontrar la potencia máxima de salto necesaria para llegar al final de la string. A la vez puede saltar de un 1 al siguiente 1 o de un 0 al siguiente 0 . 
Nota: El poder de salto se define como la distancia entre dos 1 consecutivos o dos 0 consecutivos.
Ejemplos: 
 

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

Acercarse: 

• Compruebe si el último carácter de la string dada es 1 o 0.
• Si el último carácter es 1, busque el primer 1 en la string y continúe saltando al siguiente 1 para llegar al último de la string. Actualiza los saltos máximos.
• De manera similar, si el último carácter es 0, busque el primer 0 en la string y continúe saltando al siguiente 0 para llegar al último de la string. Actualiza los saltos máximos.
• Devuelve el número máximo de saltos realizados para llegar al final.

// 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 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 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# 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 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
?>

<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>

2

Complejidad de tiempo : O(n) donde n es la longitud de la string