तीन लगातार अनियमित लीटकोड समाधान


कठिनाई तह सजिलो
बारम्बार सोधिन्छ Dji
एरे

समस्या वक्तव्य

"तीन लगातार अनियमित" समस्यामा हामीलाई एक दिइएको छ array र हामीले जाँच गर्नुपर्नेछ कि एरेमा लगातार तीन बिजोर नम्बरहरू छन् वा छैन। यदि यो अवस्थित छ भने हामीले साँचो फिर्ता गर्नुपर्नेछ अन्यथा हामी गलत फिर्ता हुनेछौं।

उदाहरणका

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

स्पष्टीकरण:

त्यहाँ कुनै तीनवटा लगातार समस्याहरू छैनन्। यसैले गलत फर्काउनुहोस्।

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

व्याख्या:

दिइएको एर्रेमा यदि हामी सबै तीन लगातार तत्व क्षेत्रहरूको लागि जाँच गर्छौं। यो निम्नानुसार हुनेछ:

तीन लगातार अनियमित लीटकोड समाधान

[,,,, २]] तीन लगातार विचित्रहरू हुन्। त्यसैले साँचो फिर्ता।

दृष्टिकोण

यो एक साधारण समस्या हो जुन दिइएको एरे को एकल traversal प्रयोग गरेर समाधान गर्न सकिन्छ। ट्रभर्सलको बेला हामीले सबै तीन लगातार तत्वहरूको लागि जाँच गर्नुपर्नेछ। पोइन्ट हामीले सबै तीन नम्बरहरू बिजोरको लागी पत्ता लगायौं, हामी सहि फर्कन्छौं।

यसको लागि हामी लूपको लागि प्रयोग गर्न सक्दछौं र हामी प्रत्येक समूहको तेस्रो तत्व (consec लगातार तत्वहरू) अनुक्रमणिका २ २ देखि अनुक्रमणिका = एन -१ मा पुनरावृत्ति गर्न सक्दछौं। त्यसो भए हालको लगातार भागमा एर्रे [i-3], एरर [i-2] र एर [i] प्रतिनिधित्व गर्दछ।
हामी अगाडि तेस्रो तत्व बाट पुनरावृत्ति शुरू गर्नेछौं। यदि एर्रेको साइज तीन भन्दा कम छ भने हामी गलत फिर्ता गर्छौं।

अल्गोरिदम

  1. भ्यारीएबल i सिर्जना गर्नुहोस् र अनुक्रमणिका २ को साथ आरम्भ गर्नुहोस्।
  2. चलाउनुहोस् लूप को लागी i को लागि अन्तिम तत्व सम्म, (n-1) th अनुक्रमणिका।
  3. सूचकहरु i, (i-1) र (i-2) अनौठो छ वा छैन भनेर जाँच गर्नुहोस्।
  4. यदि सबै तीन अनौठो हो, सहीमा फर्कनुहोस्। अन्यथा traversal जारी राख्नुहोस्।
  5. सबै सूचकांकहरूको अन्त्य पछि, गलतमा फर्कनुहोस्।

कार्यान्वयन

C ++ कार्यक्रम तीन लगातार अनियमित लीटकोड समाधानको लागि

#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

जटिलता विश्लेषण तीन लगातार अनियमित लीडकोड समाधानको लागि

समय जटिलता

O (N): जहाँ एन दिइएको एरेको आकार हो। जस्तो कि हामी प्रत्येक सूचकांकको लागि मात्र एक पटक ट्रेस गर्दैछौं, समय जटिलता ओ (एन) हुनेछ।

ठाउँ जटिलता 

O (१): हामी कुनै अतिरिक्त मेमोरी प्रयोग गरिरहेका छैनौं। त्यसकारण अन्तरिक्ष जटिलता स्थिर हुनेछ।