නූල් ලීට්කෝඩ් විසඳුමක ප්‍රතිලෝම ස්වර


දුෂ්කරතා මට්ටම පහසු
නිතර අසනු ලැබේ ඇමේසන් ෆේස්බුක් ගූගල්
String පොයින්ටර් දෙකක්

ගැටළු ප්රකාශය

මෙම ගැටලුවේදී අ පේළියකි ලබා දී ඇති අතර අපට ආපසු හැරවිය යුත්තේ මෙම නූලෙහි ස්වර පමණි.

උදාහරණයක්

"hello"
"holle"

පැහැදිලි කිරීම:
ආපසු හැරවීමට පෙර: “hello"
ආපසු හැරවීමෙන් පසු: “holle"

"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

නූල් ලීට්කෝඩ් විසඳුමක ප්‍රතිලෝම ස්වර සඳහා සංකීර්ණ විශ්ලේෂණය

කාල සංකීර්ණත්වය

මත): අපි නූල් හරහා ගමන් කළේ දෙවරක් පමණි. තොගයේ තල්ලුව සහ පොප් ක්‍රියාකාරිත්වය නියත කාලයක් ගත වන අතර ස්වර කට්ටලයට ඇත්තේ මූලද්‍රව්‍ය 10 ක් පමණි (එනම් අක්ෂරයක් සොයා ගැනීමට නියත කාලයක් ගතවනු ඇත), එබැවින් කාල සංකීර්ණතාව O (N) වේ.

අභ්‍යවකාශ සංකීර්ණතාව 

මත): නරකම සිරස් අතට ආදාන නූලෙහි සියලුම අක්ෂර තිබිය හැක. එබැවින් අවකාශයේ සංකීර්ණතාව O (N) වේ.

ප්‍රවේශය 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

නූල් ලීට්කෝඩ් විසඳුමක ප්‍රතිලෝම ස්වර සඳහා සංකීර්ණ විශ්ලේෂණය

කාල සංකීර්ණත්වය

මත): නූලෙහි සෑම අක්ෂරයක්ම එක් වරක් පමණක් නැරඹිය හැක, එබැවින් කාල සංකීර්ණතාව O (N) වේ.

අභ්‍යවකාශ සංකීර්ණතාව 

ඕ (1): මූලද්‍රව්‍ය 10 ක් (එනම් නියත අවකාශය) ඇති ස්වර කට්ටලයක් හැර අමතර ඉඩක් භාවිතා නොවේ. එබැවින් අවකාශයේ සංකීර්ණතාව O (1) වේ.