Skip to content
Related Articles

Related Articles

Consecutive steps to roof top

View Discussion
Improve Article
Save Article
  • Difficulty Level : Basic
  • Last Updated : 01 Aug, 2022

Given heights of consecutive buildings, find the maximum number of consecutive steps one can put forward such that he gain a increase in altitude while going from roof of one building to next adjacent one. 

Examples : 

Input : arr[] = {1, 2, 2, 3, 2}
Output : 1
Explanation :
Maximum consecutive steps from 1 to 2 OR  2 to 3.

Input : arr[] = {1, 2, 3, 4}
Output : 3

This problem is basically a variation of Longest increasing subarray

Approach:

initialize count = 0
initialize maximum = 0
    if arr[i]>a[i-1]
then count increment
    else
maximum = max(maximum, count)

at the end maximum=max(maximum, count)

Implementation:

C++




// CPP code to find maximum
// number of consecutive steps.
#include <bits/stdc++.h>
using namespace std;
 
// Function to count consecutive steps
int find_consecutive_steps(int arr[], int len)
{
    int count = 0;
    int maximum = 0;
 
    for (int index = 1; index < len; index++) {
         
        // count the number of consecutive
        // increasing height building
        if (arr[index] > arr[index - 1])
            count++;
        else
        {
            maximum = max(maximum, count);
            count = 0;
        }
    }
     
    return max(maximum, count);   
}
 
// Driver code
int main()
{
    int arr[] = { 1, 2, 3, 4 };
    int len = sizeof(arr) / sizeof(arr[0]);
 
    cout << find_consecutive_steps(arr, len);
}

Java




// Java code to find maximum
// number of consecutive steps.
import java.io.*;
 
class GFG {
     
    // Function to count consecutive steps
    static int find_consecutive_steps(int arr[],
                                        int len)
    {
        int count = 0;
        int maximum = 0;
     
        for (int index = 1; index < len; index++) {
             
            // count the number of consecutive
            // increasing height building
            if (arr[index] > arr[index - 1])
                count++;
            else
            {
                maximum = Math.max(maximum, count);
                count = 0;
            }
        }
         
        return Math.max(maximum, count);
    }
     
    // Driver code
    public static void main (String[] args) {
         
        int arr[] = { 1, 2, 3, 4 };
        int len = arr.length;
      
        System.out.println(find_consecutive_steps(arr,
                                                len));
    }
}
 
// This code is contributed by Gitanjali.

Python3




# Python3 code to find maximum
# number of consecutive steps
import math
 
# Function to count consecutive steps
def find_consecutive_steps(arr, len):
 
    count = 0; maximum = 0
 
    for index in range(1, len):
         
        # count the number of consecutive
        # increasing height building
        if (arr[index] > arr[index - 1]):
            count += 1
             
        else:
            maximum = max(maximum, count)
            count = 0
     
    return max(maximum, count)
 
# Driver code
arr = [ 1, 2, 3, 4 ]
len = len(arr)
print(find_consecutive_steps(arr, len))
 
 
# This code is contributed by Gitanjali.

C#




// C# code to find maximum
// number of consecutive steps.
using System;
 
class GFG {
     
    // Function to count consecutive steps
    static int find_consecutive_steps(int []arr,
                                        int len)
    {
        int count = 0;
        int maximum = 0;
     
        for (int index = 1; index < len; index++) {
             
            // count the number of consecutive
            // increasing height building
            if (arr[index] > arr[index - 1])
                count++;
            else
            {
                maximum = Math.Max(maximum, count);
                count = 0;
            }
        }
         
        return Math.Max(maximum, count);
    }
     
    // Driver code
    public static void Main () {
         
        int []arr = { 1, 2, 3, 4 };
        int len = arr.Length;
     
        Console.WriteLine(find_consecutive_steps(arr,
                                                len));
    }
}
 
// This code is contributed by vt_m.

PHP




<?php
// PHP code to find maximum
// number of consecutive steps.
 
 
// Function to count
// consecutive steps
function find_consecutive_steps($arr,
                                $len)
{
    $count = 0;
    $maximum = 0;
 
    for ($index = 1; $index < $len;
                          $index++)
    {
         
        // count the number of consecutive
        // increasing height building
        if ($arr[$index] > $arr[$index - 1])
            $count++;
        else
        {
            $maximum = max($maximum, $count);
            $count = 0;
        }
    }
     
    return max($maximum, $count);
}
 
// Driver code
$arr = array( 1, 2, 3, 4 );
$len = count($arr);
 
echo find_consecutive_steps($arr, $len);
 
// This code is contributed by vt_m.
?>

Javascript




<script>
 
// JavaScript Program to find maximum
// number of consecutive steps.
 
 
 // Function to count consecutive steps
    function find_consecutive_steps(arr, len)
    {
        let count = 0;
        let maximum = 0;
       
        for (let index = 1; index < len; index++) {
               
            // count the number of consecutive
            // increasing height building
            if (arr[index] > arr[index - 1])
                count++;
            else
            {
                maximum = Math.max(maximum, count);
                count = 0;
            }
        }
           
        return Math.max(maximum, count);
    }
      
// Driver code
    let arr = [ 1, 2, 3, 4 ];
        let len = arr.length;    
       document.write(find_consecutive_steps(arr,len));
 
// This code is contributed by sanjoy_62.
</script>

Output

3

Time Complexity: O(n)
Auxiliary Space: O(1)

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!