ਤਬਦੀਲੀ ਤੋਂ ਬਾਅਦ ਸਭ ਤੋਂ ਛੋਟਾ ਪਲੈਂਡਰੋਮ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਸੌਖੀ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਅਡੋਬ ਆਰਸੀਸੀਅਮ ਫਲਿੱਪਕਾਰਟ GE ਹੈਲਥਕੇਅਰ ZScaler
ਪਾਲਿੰਦਰੋਮ ਸਤਰ

ਸਮੱਸਿਆ ਦਾ ਬਿਆਨ

“ਰਿਪਲੇਸਮੈਂਟ ਦੇ ਬਾਅਦ ਸਭ ਤੋਂ ਛੋਟਾ ਪਲੈਂਡਰੋਮ” ਸਮੱਸਿਆ ਵਿੱਚ ਅਸੀਂ ਇਨਪੁਟ ਦਿੱਤਾ ਹੈ ਸਤਰ ਛੋਟੇ ਅੱਖਰ ਅਤੇ ਅੱਖਰ (.) ਰੱਖਦਾ ਹੈ. ਸਾਨੂੰ ਸਾਰੇ ਬਿੰਦੀਆਂ ਨੂੰ ਕੁਝ ਵਰਣਮਾਲਾ ਦੇ ਅੱਖਰ ਨਾਲ ਇਸ replaceੰਗ ਨਾਲ ਬਦਲਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਕਿ ਨਤੀਜਾ ਵਾਲੀ ਸਤਰ ਇੱਕ ਪਲੀਸਰੋਮ ਬਣ ਜਾਵੇ. The ਪੈਲੀਡਰੋਮ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਸ਼ਬਦਕੋਸ਼ ਸਭ ਤੋਂ ਛੋਟਾ.

ਇੰਪੁੱਟ ਫਾਰਮੈਟ

ਪਹਿਲੀ ਅਤੇ ਸਿਰਫ ਇੱਕ ਲਾਈਨ ਜਿਸ ਵਿੱਚ ਇੰਪੁੱਟ ਸਤਰਾਂ ਹਨ.

ਆਉਟਪੁੱਟ ਫਾਰਮੈਟ

ਛੋਟੀ ਜਿਹੀ ਲੀਕੋਸੋਗ੍ਰਾਫਿਕ ਸਤਰ ਨੂੰ ਛਾਪੋ ਜੋ ਇਕ ਪਾਲੀਂਡਰੋਮ ਹੈ. ਜੇ ਅਜਿਹੀ ਕੋਈ ਸਤਰ ਨਹੀਂ ਬਣਦੀ ਤਾਂ ਪ੍ਰਿੰਟ ਕਰੋ "ਨਹੀਂ ਹੋ ਸਕਦਾ".

ਰੁਕਾਵਟਾਂ

  • 1 <= | s | <= 10 ^ 6
  • s [i] ਛੋਟੇ ਅੱਖਰ ਅੱਖਰ ਜਾਂ ਬਿੰਦੀ ਹੈ. "

ਉਦਾਹਰਨ

a..b.a
aabbaa

ਸਪਸ਼ਟੀਕਰਨ: ਇਸ ਸਤਰ ਲਈ, ਸਭ ਤੋਂ ਛੋਟਾ ਪਾਲੀਂਡਰੋਮ ਹੈ “ਆੱਬਾ”. ਇੱਥੇ ਅਸੀਂ s [i] ਅਤੇ s [n-1-i] ਨੂੰ 'a' ਨਾਲ ਬਦਲਦੇ ਹਾਂ ਜੇ ਦੋਵੇਂ ਚਰਣ ਬਿੰਦੀ (.) ਹਨ. ਜੇ ਉਨ੍ਹਾਂ ਵਿਚੋਂ ਇਕ ਡਾਟ ਅੱਖਰ ਹੈ ਤਾਂ ਉਸ ਨੂੰ ਇਕ ਹੋਰ ਗ਼ੈਰ-ਡੌਟ ਅੱਖਰ ਨਾਲ ਬਦਲੋ.

a..b.c
Not possible

ਸਪਸ਼ਟੀਕਰਨ: ਇਸ ਸਤਰ ਵਿੱਚ, ਅਸੀਂ ਆਸਾਨੀ ਨਾਲ ਵੇਖ ਸਕਦੇ ਹਾਂ ਕਿ ਪਹਿਲਾਂ ਅਤੇ ਆਖਰੀ ਚਰਣ ਇਕੋ ਜਿਹੇ ਨਹੀਂ ਹਨ, ਇਸ ਲਈ ਅਸੀਂ ਇਸ ਸਤਰ ਨੂੰ ਪਾਲੀਂਡਰੋਮ ਸਤਰ ਨਹੀਂ ਬਣਾ ਸਕਦੇ. ਇਸ ਲਈ, ਅਸੀਂ ਉੱਤਰ ਨੂੰ ਇਸੇ ਤਰਾਂ ਪ੍ਰਿੰਟ ਕਰਾਂਗੇ "ਨਹੀਂ ਹੋ ਸਕਦਾ".

ਤਬਦੀਲੀ ਤੋਂ ਬਾਅਦ ਛੋਟੇ ਪੈਲਿੰਡਰੋਮ ਲਈ ਐਲਗੋਰਿਦਮ

1. ਡੌਟ ਅੱਖਰਾਂ ਨੂੰ ਨਜ਼ਰ ਅੰਦਾਜ਼ ਕਰਨ ਵਾਲੇ ਗੈਰ-ਡੌਟ ਅੱਖਰਾਂ ਦੀ ਜੋੜੀ ਦੀ ਜਾਂਚ ਕਰੋ.

  •  ਜੇ ਖੱਬੇ ਅਤੇ ਸੱਜੇ ਦੋਵੇਂ ਗੈਰ-ਬਿੰਦੀਆਂ ਹਨ ਅਤੇ ਇਕਸਾਰ ਨਹੀਂ ਹਨ ਤਾਂ ਗਲਤ ਨੂੰ ਵਾਪਸ ਕਰੋ.
  • ਨਹੀਂ ਤਾਂ, ਅੱਧ ਤੱਕ ਟ੍ਰਾੱਸਰ.
  • ਸੱਚ ਵਾਪਸ ਕਰੋ, ਜੇ ਇਹ ਅੰਤ 'ਤੇ ਪਹੁੰਚ ਜਾਂਦਾ ਹੈ.

2. ਜੇ ਦੋਵੇਂ 'ਆਈ' ਅਤੇ 'ਨੀ -1' ਸਥਿਤੀ ਬਿੰਦੂਆਂ ਹਨ ਤਾਂ ਉਨ੍ਹਾਂ ਨੂੰ 'ਏ' ਨਾਲ ਤਬਦੀਲ ਕਰੋ.

3. ਨਹੀਂ ਤਾਂ, ਜੇ ਉਨ੍ਹਾਂ ਵਿਚੋਂ ਇਕ ਡਾਟ ਅੱਖਰ ਹੈ ਤਾਂ ਉਸ ਨੂੰ ਇਕ ਹੋਰ ਗ਼ੈਰ-ਡੌਟ ਅੱਖਰ ਨਾਲ ਬਦਲੋ.

4. ਫਾਈਨਲ ਸਤਰ ਵਾਪਸ ਕਰੋ.

ਲਾਗੂ

ਰਿਪਲੇਸਮੈਂਟ ਦੇ ਬਾਅਦ ਛੋਟੇ ਪਲੈਂਡਰੋਮ ਲਈ ਸੀ ++ ਪ੍ਰੋਗਰਾਮ

#include<bits/stdc++.h>
using namespace std;
int main()
{
   string s;
   cin>>s;
   int n=s.length();
   int flag=0;
   for(int i=0;i<n/2;i++)
   {
       if(s[i]!='.' && s[n-1-i]!='.' && s[i]!=s[n-1-i])
       {
           flag=1;
           break;
       }
   }
   if(flag==1)
   {
       cout<<"Not possible"<<endl;
   }
   else
   {
       for(int i=0;i<n;i++)
       {
           if(s[i]=='.')
           {
               if(s[n-1-i]=='.')
               {
                   s[i]='a';
                   s[n-1-i]='a';
               }
               else
               {
                   s[i]=s[n-1-i];
               }
           }
       }
       cout<<s<<endl;
   }
   return 0;
}

ਰਿਪਲੇਸਮੈਂਟ ਦੇ ਬਾਅਦ ਛੋਟੇ ਪਾਲੀਡਰੋਮ ਲਈ ਜਾਵਾ ਪ੍ਰੋਗਰਾਮ

import java.util.Scanner;

class sum {
    
    public static void main(String[] args) 
    {
        Scanner sr= new Scanner(System.in);
        String s = sr.next();
        int n = s.length();
        char a[] = s.toCharArray();
        int flag=0;
        for(int i=0;i<n/2;i++)
        {
            if(a[i]!='.' && a[n-1-i]!='.' && a[i]!=a[n-1-i])
            {
                flag=1;
                break;
            }
        }
        if(flag==1)
        {
            System.out.println("Not possible");
        }
        else
        {
            for(int i=0;i<n;i++)
            {
                if(a[i]=='.')
                {
                    if(a[n-1-i]=='.')
                    {
                        a[i]='a';
                        a[n-1-i]='a';
                    }
                    else
                    {
                        a[i]=a[n-1-i];
                    }
                }
            }
            for(int i=0;i<n;i++)
            {
                System.out.print(a[i]);
            }
            System.out.println();
        }
    } 
}
a..b.a
aabbaa

ਤਬਦੀਲੀ ਤੋਂ ਬਾਅਦ ਛੋਟੇ ਪੈਲੈਂਡਰੋਮ ਲਈ ਗੁੰਝਲਦਾਰਤਾ ਵਿਸ਼ਲੇਸ਼ਣ

ਟਾਈਮ ਜਟਿਲਤਾ

ਹੇ (n) ਜਿੱਥੇ ਕਿ n ਦਿੱਤੀ ਗਈ ਸਤਰ ਦਾ ਅਕਾਰ ਹੈ “S”. ਇੱਥੇ ਅਸੀਂ ਸਿਰਫ ਦਿੱਤੀ ਗਈ ਸਤਰ ਨੂੰ ਪਾਰ ਕਰਦੇ ਹਾਂ ਅਤੇ ਕੁਝ ਲਾਭਦਾਇਕ ਕਾਰਜ ਕਰਦੇ ਹਾਂ.

ਸਪੇਸ ਦੀ ਜਟਿਲਤਾ

ਓ (1) ਕਿਉਂਕਿ ਅਸੀਂ ਇਥੇ ਕੋਈ ਵਧੇਰੇ ਥਾਂ ਨਹੀਂ ਵਰਤਦੇ. ਜੋ ਸਾਨੂੰ ਨਿਰੰਤਰ ਸਪੇਸ ਗੁੰਝਲਦਾਰਤਾ ਵੱਲ ਲੈ ਜਾਂਦਾ ਹੈ.