ആവർത്തന പലിൻഡ്രോം പരിശോധന


വൈഷമ്യ നില എളുപ്പമായ
പതിവായി ചോദിക്കുന്നു കാപ്ജെമിനിയും ഫാക്റ്റ്സെറ്റ് ഇൻഫോസിസ് MAQ o9 പരിഹാരങ്ങൾ ഒറാക്കിൾ സമചതുരം
പലിന്ദ്രോമുകൾ സ്ട്രിംഗ്

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

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

കുറിപ്പ്: ഒരേ പ്രശ്‌നത്തിന്റെ ചെറിയ സംഭവങ്ങൾക്കുള്ള പരിഹാരങ്ങളെ ആശ്രയിച്ചിരിക്കുന്ന ഒരു പ്രശ്‌നം പരിഹരിക്കുന്നതിനുള്ള ഒരു രീതിയാണ് ആവർത്തനം.

ഇൻപുട്ട് ഫോർമാറ്റ്

“S” എന്ന സ്ട്രിംഗ് അടങ്ങിയിരിക്കുന്ന ആദ്യത്തേതും ഒരേയൊരു വരിയും.

Put ട്ട്‌പുട്ട് ഫോർമാറ്റ്

തന്നിരിക്കുന്ന സ്‌ട്രിംഗ് ഒരു പലിൻഡ്രോം ആണെങ്കിൽ “അതെ” അച്ചടിക്കുക, അല്ലെങ്കിൽ “ഇല്ല” എന്ന് പ്രിന്റുചെയ്യുക.

നിയന്ത്രണങ്ങൾ

  • 1 <= | s | <= 10 ^ 6
  • s [i] ഒരു ചെറിയ അക്ഷരമാല ആയിരിക്കണം

ഉദാഹരണം

racecar
Yes

വിശദീകരണം: ഇവിടെ നമ്മൾ “റേസ്‌കാർ” ഇടത്തുനിന്ന് വലത്തോട്ടോ വലത്തോട്ടോ ഇടത്തോട്ടോ വായിച്ചാൽ അർത്ഥം അതേപടി നിലനിൽക്കും. അതിനാൽ ഞങ്ങളുടെ സ്ട്രിംഗ് ഒരു പലിൻഡ്രോം ആണ്.

racing
No

വിശദീകരണം: ഇവിടെ “റേസിംഗ്” ഇടത്തുനിന്ന് വലത്തോട്ടോ വലത്തോട്ടോ ഇടത്തോട്ടോ വായിച്ചാൽ അർത്ഥം മാറി. അതിനാൽ, ഈ സാഹചര്യത്തിൽ ഞങ്ങളുടെ സ്ട്രിംഗ് ഒരു പലിൻഡ്രോം അല്ല.

ആവർത്തന പലിൻഡ്രോം പരിശോധനയ്ക്കുള്ള അൽഗോരിതം

1. പ്രധാന ബോഡിയിൽ നിന്ന് “palindrome_check” ഫംഗ്ഷനെ വിളിക്കുക.

2. സ്‌ട്രിംഗിന്റെ ദൈർഘ്യം 1 ആണെങ്കിൽ, ശരി നൽകുക.

3. അല്ലെങ്കിൽ, ആദ്യത്തെയും അവസാനത്തെയും പ്രതീകങ്ങൾ താരതമ്യം ചെയ്ത് പരിശോധിക്കുക.

4. രണ്ട് ചാർ‌ട്ടറുകളും തുല്യമാണെങ്കിൽ‌, ശേഷിക്കുന്ന സബ്‌ സ്ട്രിംഗിലേക്ക് ആവർത്തനം പ്രയോഗിക്കുക.

5. അല്ലെങ്കിൽ മടക്കം തെറ്റാണ്;

നടപ്പിലാക്കൽ

ആവർത്തന പലിൻഡ്രോം പരിശോധനയ്ക്കുള്ള സി ++ പ്രോഗ്രാം

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

int palindrome_check(string s, int start, int end)
{
    if(end-start==1 || start==end)
    {
        return 1;
    }
    else
    {
        if(s[start]==s[end])
        {
            return palindrome_check(s,start+1,end-1); 
        }
        else
        {
            return 0;
        }
    }
}

int main()
{
   string s;
   cin>>s;
   int n=s.length();
   if(palindrome_check(s, 0, n-1))
   {
       cout<<"Yes"<<endl;
   }
   else
   {
       cout<<"No"<<endl;
   }
   return 0;
}

ആവർത്തന പലിൻഡ്രോം പരിശോധനയ്ക്കുള്ള ജാവ പ്രോഗ്രാം

import java.util.Scanner;

class sum
{ 
        public static int palindrome_check(char [] s, int start, int end)
        {
            if(start==end || (end-start==1))
            {
                return 1;
            }
            else
            {
                if(s[start]==s[end])
                {
                    return palindrome_check(s,start+1,end-1);
                }
                else
                {
                    return 0;
                }
            }
        }
  public static void main(String[] args) 
  { 
    Scanner sr = new Scanner(System.in); 
                String s = sr.next();
                char a[] = s.toCharArray();
    int n = s.length();
                if(palindrome_check(a,0,n-1)==1)
                {
                    System.out.println("Yes");
                }
                else
                {
                    System.out.println("No");
                }
  } 
} 
abcdcba
Yes

ആവർത്തന പലിൻഡ്രോം പരിശോധനയ്ക്കുള്ള സങ്കീർണ്ണത വിശകലനം

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

O (n) എവിടെ n സ്ട്രിംഗിന്റെ വലുപ്പമാണ്. ഇവിടെ ഞങ്ങൾ സ്‌ട്രിംഗിന്റെ ആരംഭവും അവസാനവും പരിശോധിക്കുകയും ആരംഭത്തിന്റെയും അവസാനത്തിന്റെയും മൂല്യങ്ങൾ അപ്‌ഡേറ്റുചെയ്യുകയും ആ സ്ഥാനത്ത് ചാർ സമാനമാണെങ്കിൽ 0 നൽകുകയും ചെയ്യുക.

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

O (1) കാരണം ഞങ്ങൾ ഇവിടെ ഒരു സഹായ ഇടവും സൃഷ്ടിക്കുന്നില്ല. ഇവിടെ ഞങ്ങൾ ഒരു ഫംഗ്ഷൻ നിർവചിക്കുകയും വ്യവസ്ഥകളുടെ അടിസ്ഥാനത്തിൽ ഉത്തരം നൽകുകയും ചെയ്യുന്നു.