మూడు వరుస ఆడ్స్ లీట్‌కోడ్ పరిష్కారం


కఠినత స్థాయి సులువు
తరచుగా అడుగుతుంది డిజి
అర్రే

సమస్యల నివేదిక

”మూడు వరుస ఆడ్స్” సమస్యలో మాకు ఇవ్వబడింది అమరిక మరియు శ్రేణిలో వరుసగా మూడు బేసి సంఖ్యలు ఉన్నాయా లేదా అని మనం తనిఖీ చేయాలి. అది ఉన్నట్లయితే మనం నిజం తిరిగి రావాలి, లేకపోతే మనం తప్పుడు తిరిగి ఇస్తాము.

ఉదాహరణ

arr = [2,6,4,1]
false

వివరణ :

వరుసగా మూడు అసమానతలు లేవు. అందువల్ల తప్పుడు తిరిగి.

arr = [1,2,34,3,4,5,7,23,12]
true

వివరణ:

మేము వరుసగా మూడు మూలకాల విభాగాలను తనిఖీ చేస్తే ఇచ్చిన శ్రేణిలో. ఇది క్రింది విధంగా ఉంటుంది:

మూడు వరుస ఆడ్స్ లీట్‌కోడ్ పరిష్కారం

[5, 7, 23] వరుసగా మూడు అసమానతలు. అందువల్ల నిజం తిరిగి.

అప్రోచ్

ఇది ఒక సాధారణ సమస్య, ఇది ఇచ్చిన శ్రేణి యొక్క ఒకే ట్రావెర్సల్ ఉపయోగించి పరిష్కరించబడుతుంది. ట్రావెర్సల్ సమయంలో మేము వరుసగా మూడు అంశాలను తనిఖీ చేయాలి. మేము మూడు సంఖ్యలను బేసిగా కనుగొన్నాము, మేము నిజం అవుతాము.

దీని కోసం మనం ఒక ఫర్ లూప్‌ను ఉపయోగించవచ్చు మరియు ప్రతి సమూహం యొక్క మూడవ మూలకం (వరుసగా 3 అంశాలు) ఇండెక్స్ = 2 నుండి ఇండెక్స్ = ఎన్ -1 వరకు మళ్ళించవచ్చు. అప్పుడు ప్రస్తుత వరుస విభాగాన్ని arr [i-2], arr [i-1] మరియు arr [i] మూలకాలు సూచిస్తాయి.
మేము ముందు నుండి మూడవ మూలకం నుండి మళ్ళించడం ప్రారంభిస్తాము. శ్రేణి యొక్క పరిమాణం మూడు కంటే తక్కువగా ఉంటే, అప్పుడు మేము తప్పుడు తిరిగి ఇస్తాము.

అల్గారిథం

  1. వేరియబుల్ i ని సృష్టించండి మరియు ఇండెక్స్ 2 తో ప్రారంభించండి.
  2. ఒక రన్ లూప్ కోసం నేను చివరి మూలకం వరకు, (n-1) వ సూచిక.
  3. సూచికలు i, (i-1) మరియు (i-2) వద్ద మూలకం బేసి లేదా కాదా అని తనిఖీ చేయండి.
  4. ముగ్గురూ బేసి అయితే, నిజం తిరిగి. లేకపోతే ట్రావెర్సల్ కొనసాగించండి.
  5. అన్ని సూచికలను దాటిన తరువాత, తప్పుడు తిరిగి ఇవ్వండి.

అమలు

మూడు వరుస ఆడ్స్ లీట్‌కోడ్ సొల్యూషన్ కోసం సి ++ ప్రోగ్రామ్

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

bool threeConsecutiveOdds(vector<int>& arr) 
{
    int n=arr.size();

    for(int i = 2; i < n; i++) 
    {
        if(arr[i] % 2 == 1 && arr[i-1] % 2 == 1 && arr[i-2] % 2 == 1 )
        return true;
    }

    return false;

}

int main() 
{
    vector<int> arr={1,2,34,3,4,5,7,23,12};
    
    if(threeConsecutiveOdds(arr) )
        cout<<"true"<<endl;
    else
        cout<<"no"<<endl;

  return 0; 
}
true

వరుసగా మూడు ఆడ్స్ లీట్‌కోడ్ సొల్యూషన్ కోసం జావా ప్రోగ్రామ్

import java.lang.*;

class Rextester
{  
    public static boolean threeConsecutiveOdds(int[] arr) {

        int n=arr.length;

        for(int i = 2; i < n; i++) 
        {
            if(arr[i] % 2 == 1 && arr[i-1] % 2 == 1 && arr[i-2] % 2 == 1 )
            return true;
        }

        return false;

    }
    
    public static void main(String args[])
    {
       int[] arr={1,2,34,3,4,5,7,23,12};
    
       System.out.println(threeConsecutiveOdds(arr));
   
    }
}
true

మూడు వరుస ఆడ్స్ లీట్‌కోడ్ పరిష్కారం కోసం సంక్లిష్టత విశ్లేషణ

సమయం సంక్లిష్టత

పై) : ఇక్కడ N అనేది ఇచ్చిన శ్రేణి యొక్క పరిమాణం. మేము ప్రతి సూచికకు ఒకసారి మాత్రమే ప్రయాణిస్తున్నప్పుడు, సమయ సంక్లిష్టత O (N) గా ఉంటుంది.

అంతరిక్ష సంక్లిష్టత 

ఓ (1): మేము అదనపు మెమరీని ఉపయోగించడం లేదు. అందువల్ల స్థల సంక్లిష్టత స్థిరంగా ఉంటుంది.