મેક્સ કsecન્સ્યુટ્યુઅલ ઓન્સ લીટકોડ સોલ્યુશન


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે એમેઝોન
અરે

સમસ્યા નિવેદન

મેક્સ કsecન્સ્યુટ્યુઅલ ઓન્સ સમસ્યામાં દ્વિસંગી એરે આપવામાં આવે છે. આપેલ એરેમાં આપણે વધુમાં વધુ સતત સંખ્યામાં હાજર રહેવાનું છે.
ઇનપુટ એરેમાં ફક્ત 0 અને 1 શામેલ હશે.

ઉદાહરણ

[1,1,0,1,1,1]
3

સમજૂતી:
પ્રથમ બે અંકો અથવા છેલ્લા ત્રણ અંકો સતત 1s છે.
સળંગ 1s ની મહત્તમ સંખ્યા 3 છે.

[0,1,0]
1

સમજૂતી:
સળંગ 1s ની મહત્તમ સંખ્યા 1 છે.

અભિગમ

આ સમસ્યા હલ કરવા માટે આપણે એરેમાં સૂચકાંકો દ્વારા બેમાં ફરી શકીએ છીએ લૂપ જ્યારે નેસ્ટ નીચેના અલ્ગોરિધમનો દ્વારા:

1. એક ચલ મહત્તમ બનાવો જે ટ્રversવર્સિંગ દરમિયાન અપડેટ કરેલા મહત્તમ સતત 1 સે સ્ટોર કરશે.
2. પ્રથમ અનુક્રમણિકા સાથે ચલ i બનાવો અને પ્રારંભ કરો.
I. હવે i <એરે સાઈઝ સુધી લૂપ ચલાવો.
The. લૂપની અંદર આપણે તપાસ કરીશું કે વર્તમાન અનુક્રમણિકા પર હું નંબર 4 છે કે નહીં. જો તે 1 ની બરાબર ન હોય તો ખાલી અનુક્રમણિકામાં વધારો. બાકી જો તે 1 ની બરાબર હોય, તો પછી ગણતરી ચલ બનાવીને નેસ્ટેડ જ્યારે ચલાવો અને 1 સાથે પ્રારંભ કરો. પછી લૂપ વખતે એ નેસ્ટેડમાં સતત 0s માટે એરેને વટાવી દો. એટલે કે ટ્ર traવર્સ એરે જ્યારે નંબરો [i] બરાબર 1 ની સાથે સાથે, નીચેની આકૃતિમાં બતાવ્યા પ્રમાણે વર્તમાન સળંગ 1 ની ગણતરીને વધારીને રાખો:

મહત્તમ સતત લોકો
5. એરેના 0 અથવા સમાપન પછી, વર્તમાન સળંગ 1 સે કાઉન્ટને ગણતરી ચલમાં સંગ્રહિત સાથે તેના જૂના મૂલ્યની તુલના કરીને મહત્તમ ચલને અપડેટ કરો.
6. જ્યારે લૂપ પૂર્ણ થાય ત્યારે મહત્તમ મૂલ્ય.

અમલીકરણ

સી ++ પ્રોગ્રામ મેક્સ કsecન્સ્યુટ્યુડ વન્સ લીટકોડ સોલ્યુશન માટે

#include <bits/stdc++.h>
using namespace std;

int findMaxConsecutiveOnes(vector<int>& nums) {

    int maximum=0;
    int i=0;

    while(i<nums.size())
    {
        int conOnes=0;
        while(i< nums.size() && nums[i]==1)
        {
            conOnes++;
            i++;
        }

        maximum=max(maximum,conOnes);
        i++;
    }

    return maximum; 
}

int main() 
{
    vector<int> nums={1,1,0,1,1,1};
    cout<<findMaxConsecutiveOnes(nums)<<endl;

  return 0; 
}
3

મેક્સ ક Maxન્સ્યુટ્યુડ વન્સ લીટકોડ સોલ્યુશન માટે જાવા પ્રોગ્રામ

import java.lang.*;

class MaxOnes
{  
    public static int findMaxConsecutiveOnes(int[] nums) 
    {
        int maximum=0;
        int i=0;

        while(i<nums.length)
        {
        int conOnes=0;
        while(i< nums.length && nums[i]==1)
        {
        conOnes++;
        i++;
        }

        maximum=Math.max(maximum,conOnes);

        i++;
        }

        return maximum; 

    }
    
    public static void main(String args[])
    {
        int nums[]={1,1,0,1,1,1};

        System.out.println(findMaxConsecutiveOnes(nums));
        
    }
}
3

જટિલતા વિશ્લેષણ મેક્સ કsecન્સ્યુટ્યુડ વન્સ લીટકોડ સોલ્યુશન

સમય જટિલતા

ઓ (એન): અમે અનુક્રમણિકાની શરૂઆતથી અંતિમ અનુક્રમણિકા સુધીના એરેને પાછળ ફેરવી રહ્યા છીએ અને દરેક અનુક્રમણિકાની મુલાકાત માત્ર એક જ વાર કરી છે. તેથી સમય જટિલતા રેખીય ઓ (એન) હશે.

અવકાશ જટિલતા 

ઓ (1): અમે કોઈ વધારાની જગ્યાનો ઉપયોગ કરી રહ્યાં નથી, તેથી વપરાયેલી જગ્યા સતત છે.