એક શબ્દમાળા લીટકોડ સોલ્યુશનના સ્વર વિરુદ્ધ


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે એમેઝોન ફેસબુક Google
શબ્દમાળા બે પોઇંટર્સ

સમસ્યા નિવેદન

આ સમસ્યામાં એ શબ્દમાળા આપવામાં આવે છે અને આપણે ફક્ત આ શબ્દમાળાના સ્વરો ઉલટાવીએ છીએ.

ઉદાહરણ

"hello"
"holle"

સમજૂતી:
ઉલટાવતાં પહેલાં: “એચello"
versલટું પછી: "એચolle"

"leetcode"
"leotcede"

સમજૂતી:
એક શબ્દમાળા લીટકોડ સોલ્યુશનના સ્વર વિરુદ્ધ

અભિગમ 1 (ઉપયોગ કરીને સ્ટેક)

આપણે ઇનપુટ શબ્દમાળામાં હાજર સ્વરોને ઉલટાવી જ જોઈએ. તેથી આપણે બધા સ્વરને સ્ટેકથી ડાબેથી જમણે તે જ ક્રમમાં સ્ટોર કરી શકીએ છીએ. પછી ફરીથી આપણે શબ્દમાળાને વટાવી શકીએ છીએ અને દરેક સ્વર પાત્ર માટે ડાબેથી જમણે આપણે તેને સ્ટેકના સૌથી ઉપરના મૂલ્યથી બદલીશું.

અલ્ગોરિધમ

  • સમૂહમાં બધા સ્વર અક્ષરો સંગ્રહિત કરો.
  • સ્ટેક બનાવો અને ઇનપુટ સ્ટ્રિંગમાં હાજર બધા સ્વર અક્ષરો ડાબેથી જમણે દબાણ કરો.
  • હવે ફરીથી દરેક પાત્ર માટે શબ્દમાળા પસાર કરો. જો વર્તમાન પાત્ર સ્વર હોય, તો તેને સ્ટેકના ટોચનાં પાત્ર (ઇનપુટ શબ્દમાળાના જમણે સ્વર પાત્ર) સાથે બદલો અને તેને સ્ટેકમાંથી દૂર કરો.
  • રૂપાંતરિત શબ્દમાળા પાછા.

સ્ટ્રિંગ લીટકોડ સોલ્યુશનના રિવર્સ સ્વર માટે અમલીકરણ

સી ++ પ્રોગ્રામ

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

string reverseVowels(string s) {

    set<char> vowels={'a','e','i','o','u','A','E','I','O','U'};
    stack<char> stack;
    for(char c:s)
    {
        if(vowels.count(c)) stack.push(c);
    }

    for(char& c:s)
    {
        if(vowels.count(c)) 
        {
            c=stack.top();
            stack.pop();
        }
    }

    return s;
}

int main() 
{
    string s="leetcode";
    cout<< reverseVowels(s)<<endl;
   
   return 0; 
}
leotcede

જાવા પ્રોગ્રામ

import java.util.*;

class Rextester
{ 
    public static String reverseVowels(String s) {

        char[] arr= s.toCharArray();

        Set<Character> vowels=new HashSet<Character>();
        vowels.add('a');
        vowels.add('e');
        vowels.add('i');
        vowels.add('o');
        vowels.add('u');
        vowels.add('A');
        vowels.add('E');
        vowels.add('I');
        vowels.add('O');
        vowels.add('U');

        Stack<Character> stack=new Stack<Character>();

        for(char c:arr)
        {
            if(vowels.contains(c)) stack.push(c);
        }

        for(int i=0;i<arr.length;i++)
        {
            if(vowels.contains(arr[i])) 
            {
                arr[i]=stack.pop();
            }
        }

        return new String(arr);
    }
    
    public static void main(String args[])
    {
        String s="leetcode";
        System.out.println(reverseVowels(s));
        
    }
}
leotcede

સ્ટ્રિંગ લીટકોડ સોલ્યુશનના વિપરીત સ્વરો માટે જટિલતા વિશ્લેષણ

સમય જટિલતા

ઓ (એન): અમે શબ્દમાળાને ફક્ત બે જ વાર પસાર કરી. સ્ટેક પર દબાણ અને પ popપ constantપરેશનમાં સતત સમય લે છે અને સ્વરના સમૂહમાં ફક્ત 10 તત્વો છે (એટલે ​​કે તે પાત્ર શોધવા માટે સતત સમય લેશે), તેથી સમય જટિલતા ઓ (એન) છે.

અવકાશ જટિલતા 

ઓ (એન): સૌથી ખરાબ સ્ટેકમાં ઇનપુટ શબ્દમાળાના બધા અક્ષરો હોઈ શકે છે. તેથી જગ્યા જટિલતા ઓ (એન) છે.

અભિગમ 2 (બે પોઇન્ટનો ઉપયોગ કરીને એક પાસ)

અમે પણ નીચેના ગાણિતીક નિયમો દ્વારા બે પોઇન્ટરનો ઉપયોગ કરીને એક પાસમાં સ્વર ઉલટાવી શકીએ:

  • બે ચલો બનાવો શરૂઆત અને અંત અનુક્રમે ડાબેથી અને જમણે સ્વર તરફ ધ્યાન દોરવા માટે.
  • તરીકે પ્રારંભ શરૂઆત= 0 અને અંત= લંબાઈ (શબ્દમાળા) -1.
  • હવે જ્યારે લૂપ ચલાવો શરૂઆત.
  • આ લૂપની અંદર આ બે પોઇન્ટરને ખસેડવા માટે બે લૂપ્સ ચલાવો અને અનુક્રમે ડાબેથી જમણે અને જમણેથી ડાબે ડાબી બાજુથી જેથી તેઓ આગલા સ્વર તરફ નિર્દેશ કરે.
  • પ્રારંભ અને અંત દ્વારા નિર્દેશિત બે સ્વર અક્ષરોનું એકબીજામાં વિનિમય કરો.
  • વધારો શરૂઆત અને ઘટાડો અંત 1 દ્વારા.
  • જ્યારે નવી શબ્દમાળા પાછા ફરો શરૂઆત વધારે બને છે અંત

સ્ટ્રિંગ લીટકોડ સોલ્યુશનના રિવર્સ સ્વર માટે અમલીકરણ

સી ++ પ્રોગ્રામ

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

string reverseVowels(string s) {

    set<char> vowels={'a','e','i','o','u','A','E','I','O','U'};

    int start=0,end=s.length()-1;
    while(start<end)
    {
        while(start<end && !vowels.count(s[start])) start++;

        while(start<end && !vowels.count(s[end])) end--;

        char temp=s[start];
        s[start]=s[end];
        s[end]=temp;

        start++;
        end--;
    }

    return s;
}

int main() 
{
    string s="leetcode";
    cout<< reverseVowels(s)<<endl;
   
   return 0; 
}
leotcede

જાવા પ્રોગ્રામ

import java.util.*;

class Rextester
{ 
    public static String reverseVowels(String s) {

       char[] arr= s.toCharArray();
        
        Set<Character> vowels=new HashSet<Character>();
        vowels.add('a');
        vowels.add('e');
        vowels.add('i');
        vowels.add('o');
        vowels.add('u');
        vowels.add('A');
        vowels.add('E');
        vowels.add('I');
        vowels.add('O');
        vowels.add('U');
        
       int start=0,end=arr.length-1;
        while(start<end)
        {
            while(start<end && !vowels.contains(arr[start])) start++;
            
            while(start<end && !vowels.contains(arr[end])) end--;
            
            char temp=arr[start];
            arr[start]=arr[end];
            arr[end]=temp;
            
            start++;
            end--;
        }
        
        return new String(arr);
    }
    
    public static void main(String args[])
    {
        String s="leetcode";
        System.out.println(reverseVowels(s));
        
    }
}
leotcede

સ્ટ્રિંગ લીટકોડ સોલ્યુશનના વિપરીત સ્વરો માટે જટિલતા વિશ્લેષણ

સમય જટિલતા

ઓ (એન): શબ્દમાળાના દરેક પાત્રની મુલાકાત માત્ર એક જ વાર થાય છે, તેથી સમય જટિલતા ઓ (એન) છે.

અવકાશ જટિલતા 

ઓ (1): સ્વરના સમૂહ સિવાય કોઈ વધારાની જગ્યાનો ઉપયોગ કરવામાં આવતો નથી જેમાં ફક્ત 10 તત્વો હોય છે (એટલે ​​કે સતત જગ્યા). તેથી જગ્યા જટિલતા ઓ (1) છે.