തുടർച്ചയായ മൂന്ന് ആഡ്സ് ലീറ്റ്കോഡ് പരിഹാരം


വൈഷമ്യ നില എളുപ്പമായ
പതിവായി ചോദിക്കുന്നു ഡിജി
അറേ

പ്രശ്നം പ്രസ്താവന

“തുടർച്ചയായ മൂന്ന് ആഡ്സ്” പ്രശ്‌നത്തിൽ ഞങ്ങൾക്ക് ഒരു നൽകിയിട്ടുണ്ട് ശ്രേണി അറേയിൽ തുടർച്ചയായി മൂന്ന് വിചിത്ര സംഖ്യകൾ ഉണ്ടോ ഇല്ലയോ എന്ന് പരിശോധിക്കേണ്ടതുണ്ട്. അത് നിലവിലുണ്ടെങ്കിൽ ഞങ്ങൾ സത്യത്തിലേക്ക് മടങ്ങണം, അല്ലെങ്കിൽ ഞങ്ങൾ തെറ്റായി മടങ്ങും.

ഉദാഹരണം

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

വിശദീകരണം:

തുടർച്ചയായി മൂന്ന് പ്രതിബന്ധങ്ങളൊന്നുമില്ല. അതിനാൽ തെറ്റായി മടങ്ങുക.

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

വിശദീകരണം:

തുടർച്ചയായ മൂന്ന് ഘടക സെഗ്‌മെന്റുകളും പരിശോധിച്ചാൽ നൽകിയ അറേയിൽ. അത് ഇപ്രകാരമായിരിക്കും:

തുടർച്ചയായ മൂന്ന് ആഡ്സ് ലീറ്റ്കോഡ് പരിഹാരം

[5, 7, 23] തുടർച്ചയായി മൂന്ന് വിചിത്രമാണ്. അതിനാൽ സത്യത്തിലേക്ക് മടങ്ങുക.

സമീപനം

തന്നിരിക്കുന്ന അറേയുടെ ഒരൊറ്റ ട്രാവെർസൽ ഉപയോഗിച്ച് പരിഹരിക്കാവുന്ന ലളിതമായ ഒരു പ്രശ്നമാണിത്. ട്രാവെർസൽ സമയത്ത് ഞങ്ങൾ തുടർച്ചയായ മൂന്ന് ഘടകങ്ങളും പരിശോധിക്കേണ്ടതുണ്ട്. മൂന്ന് അക്കങ്ങളും വിചിത്രമാണെന്ന് ഞങ്ങൾ കണ്ടെത്തിയ പോയിന്റ്, ഞങ്ങൾ ശരിയാണ്.

ഇതിനായി നമുക്ക് ഒരു ഫോർ ലൂപ്പ് ഉപയോഗിക്കാം, ഒപ്പം ഓരോ ഗ്രൂപ്പിലെയും മൂന്നാമത്തെ ഘടകത്തിനായി (തുടർച്ചയായ 3 ഘടകങ്ങൾ) സൂചിക = 2 മുതൽ സൂചിക = n-1 വരെ ആവർത്തിക്കാം. നിലവിലെ തുടർച്ചയായ സെഗ്‌മെന്റിനെ arr [i-2], arr [i-1], arr [i] എന്നീ ഘടകങ്ങൾ പ്രതിനിധീകരിക്കും.
മുന്നിൽ നിന്ന് മൂന്നാമത്തെ ഘടകത്തിൽ നിന്ന് ഞങ്ങൾ ആവർത്തനം ആരംഭിക്കും. അറേയുടെ വലുപ്പം മൂന്നിൽ കുറവാണെങ്കിൽ ഞങ്ങൾ തെറ്റായി മടങ്ങുന്നു.

അൽഗോരിതം

  1. ഒരു വേരിയബിൾ i സൃഷ്ടിച്ച് സൂചിക 2 ഉപയോഗിച്ച് സമാരംഭിക്കുക.
  2. ഒരു പ്രവർത്തിപ്പിക്കുക ലൂപ്പിനായി അവസാന ഘടകം വരെ, (n-1) th സൂചിക.
  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

തുടർച്ചയായ മൂന്ന് ആഡ്സ് ലീറ്റ്കോഡ് പരിഹാരത്തിനുള്ള സങ്കീർണ്ണത വിശകലനം

സമയ സങ്കീർണ്ണത

O (N): ഇവിടെ N എന്നത് തന്നിരിക്കുന്ന അറേയുടെ വലുപ്പമാണ്. ഓരോ സൂചികയിലും ഞങ്ങൾ ഒരു തവണ മാത്രമേ സഞ്ചരിക്കുന്നതിനാൽ, സമയ സങ്കീർണ്ണത O (N) ആയിരിക്കും.

ബഹിരാകാശ സങ്കീർണ്ണത 

O (1): ഞങ്ങൾ അധിക മെമ്മറിയൊന്നും ഉപയോഗിക്കുന്നില്ല. അതിനാൽ സ്ഥല സങ്കീർണ്ണത സ്ഥിരമായിരിക്കും.