סאָרט אַ שטריקל לויט צו אן אנדער שטריקל  


שוועריקייט לעוועל גרינג
אָפט געבעטן אין אַקסענטורע אַקקאָליטע אַדאָובי אַמאַזאָן פרעעטשאַרגע InfoEdge מייקראָסאָפֿט סאַלעספאָרסע
סאָרטינג שטריקל

פּראָבלעם סטאַטעמענט  

צוויי ינפּוט סטרינגס, מוסטער און שטריקל מיר דאַרפֿן צו סאָרט די שטריקל לויט די סדר דיפיינד דורך די מוסטער. מוסטער שטריקל האט קיין דופּליקאַטן און עס האט אַלע אותיות פון די שטריקל.

ינפּוט פֿאָרמאַט  

דער ערשטער שורה כּולל אַ שטריקל וואָס מיר דאַרפֿן סאָרט.

רגע-שורה מיט אַ שטריקל t וואָס האט קיין דופּליקאַטן און עס האט אַלע אותיות פון די שטריקל s.

רעזולטאַט פֿאָרמאַט  

דרוקן די סאָרטעד שטריקל אויף די יקער פון שטריקל ה.

קאַנסטריינץ  

  • 1 <= | ס |, | ה | <= 10 ^ 6
  • s [i] און t [j] מוזן נאָר זיין קלענערער אותיות.

בייַשפּיל  

abcedabdceade
ebcda
eeebbccdddaaa

דערקלערונג: דאָ ערשטער מיר ציילן די אָפטקייַט פון יעדער טשאַר אין די שטריקל. אַזוי, דורך דעם אויבן ביישפּיל s = “abcedabdceade”, מיר קענען לייכט באַקומען אַז freq פון 'a' איז 3, freq פון 'b' איז 2, freq פון 'c' איז 2, freq פון d איז 3, און freq פון e איז 3. איצט מיר פאָרן דורך די שטריקל ה און קאָנטראָלירן די אָפטקייַט פון די טשאַר און דרוקן עס פילע מאָל און מאַך צו די ווייַטער טשאַר, עס סטרינגס ה ​​און ריפּיץ די זעלבע טריט ביז דעם סוף. אַזוי, לעסאָף מיר באַקומען די סאָרטעד שטריקל s = “eeebbccdddaaa”.

אַלגאָריטהם  

  1. קראָם די ציילן פון אותיות פון די אַרייַנשרייַב שטריקל אין די פריי [] מענגע.
  2. אַריבער די שטריקל t פֿון לינקס צו רעכטס, פֿאַר יעדער כאַראַקטער t [i], זען די ציילן.
  3. דרוק דעם טשאַר אַז פילע מאָל.
  4. טאָן דאָס ביז די סוף פון די מוסטער שטריקל.
זע אויך
לאָנגעסט סובסטרינג אָן ריפּיטינג אותיות

ימפּלאַמענטיישאַן פֿאַר סאָרט אַ שטריקל לויט צו אן אנדער שטריקל  

C ++ פּראָגראַם פֿאַר סאָרט אַ סטרינג לויט צו אן אנדער שטריקל

#include <bits/stdc++.h>
using namespace std;
 
void SortByPattern(string &s, string t)
{
    int freq[26] = {0};
    int n=s.length();
    int m=t.length();
    for(int i=0;i<n;i++)
    {
        freq[s[i]-'a']++;
    }
    int index = 0;
    for(int i=0;i<m;i++)
    {
        for(int j=0;j<freq[t[i]-'a'];j++)
        {
            s[index]=t[i];
            index++;
        }
    }
}

int main()
{
    string s,t;
    cin>>s>>t;
    SortByPattern(s,t);
    cout<<s<<endl;
    return 0;
}

Java פּראָגראַם פֿאַר סאָרט אַ שטריקל לויט אן אנדער שטריקל

import java.util.Arrays;
import java.util.Scanner;

class sum {
    
    static void SortByPattern(String s, String t)
    {
       int n = s.length();
       int m = t.length();
       char[] s1 = s.toCharArray();
       char[] t1 = t.toCharArray();
       int freq[] = new int[26];
       Arrays.fill(freq, 0);
       for(int i=0;i<n;i++)
       {
           freq[s1[i]-'a']++;
       }
       int index=0;
       for(int i=0;i<m;i++)
       {
           for(int j=0;j<freq[t1[i]-'a'];j++)
           {
               s1[index]=t1[i];
               index++;
           }
       }
       for(int i=0;i<n;i++)
       {
           System.out.print(s1[i]);
       }
    }
    public static void main(String[] args) 
    {
        Scanner sr= new Scanner(System.in);
        String s = sr.next();
        String t = sr.next();
        SortByPattern(s,t);
    } 
abcabcabc
bxyzca
bbbcccaaa

קאַמפּלעקסיטי אַנאַליסיס פֿאַר סאָרט אַ שטריקל לויט אן אנדער שטריקל  

צייט קאַמפּלעקסיטי

אָ (N) ווו N איז די גרייס פון די געגעבן מענגע s. דאָ מיר פאָרן שטריקל s וואָס פירן אונדז צו לינעאַר צייט קאַמפּלעקסיטי.

ספעיס קאַמפּלעקסיטי

אָ (1) ווייַל מיר טאָן ניט נוצן קיין הילף פּלאַץ.