લાઇસેંસ કી ફોર્મેટિંગ લીટકોડ સોલ્યુશન


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે કેપિટલ વન Google
શબ્દમાળા સ્ટ્રિંગબિલ્ડર

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

“લાઇસન્સ કી ફોર્મેટિંગ” સમસ્યામાં, ઇનપુટમાં એ શબ્દમાળા અક્ષરો, લાઇસન્સ કી રજૂ. શરૂઆતમાં, આ શબ્દમાળાને N + 1 જૂથો (શબ્દો) માં એન ડasશ દ્વારા અલગ પાડવામાં આવે છે. આપણને પૂર્ણાંક કે પણ આપવામાં આવે છે, અને ધ્યેય એ છે કે દરેક જૂથમાં બરાબર K અક્ષરો હોય તેવી શબ્દમાળાને ફોર્મેટ કરવાનું છે, કે જે કે કરતાં ઓછા અક્ષરોને માન્ય છે. વધુમાં, જૂથો '- દ્વારા અલગ થવું જોઈએ. '(આડંબર) અને તેમાં ફક્ત મોટા અક્ષરો છે.

ઉદાહરણ

S = "5F3Z-2e-9-w", K = 4
5F3Z-2E9W
S = "2-5g-3-J", K = 2
2-5G-3J

અભિગમ

તે સાહજિક છે કે સ્ટ્રિંગ્સ (ઇનપુટ) માં પછાત ફરી વળતી વખતે આપણે નવી સ્ટ્રિંગ બનાવવી જોઈએ. આ મહત્વપૂર્ણ છે કારણ કે આપણે જાણીએ છીએ કે પહેલા જૂથ સિવાય, અન્ય તમામ જૂથોમાં તેમનામાં બરાબર 'કે' અક્ષરો હોવા જોઈએ. જો આપણે સ્ટ્રીંગ s માં ફરી વળવું, તો આપણે a જાળવી શકીએ છીએ કાઉન્ટર જે જૂથમાં ઉમેરવામાં આવેલા અક્ષરોની સંખ્યાની ગણતરી રાખે છે. જો તે કોઈપણ ક્ષણે 'કે' ની બરાબર થઈ જાય, તો આપણે તેને ફરી શૂન્ય પર ફરીથી સેટ કરી શકીએ. આ રીતે અમે નવી સ્ટ્રિંગમાં તત્વો ઉમેરવાનું ચાલુ રાખીએ છીએ અને તેને પાછા આપતા પહેલા, અમે તેને orderર્ડર પાછો મેળવવા માટે ઉલટાવીએ છીએ.

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

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

#include <bits/stdc++.h>

using namespace std;

string licenseKeyFormatting(string s , int k) {
    string ans;
    int cnt = 0 , n = s.size();

    for(int i = n - 1 ; i >= 0 ; i--) {
        if(s[i] != '-') {
            if(cnt == k) {
                ans += '-';
                cnt = 0;
            }
            cnt++;
            if(s[i] >= 'a' && s[i] <= 'z') {
                s[i] += 'A' - 'a';
            }
            ans += s[i];
        }
    }

    reverse(ans.begin() , ans.end());
    return ans;
}

int main() {
    string s = "5F3Z-2e-9-w";
    int K = 4;
    cout << licenseKeyFormatting(s, K) << endl;
    return 0;
}

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

import java.lang.*;
import java.io.*;
import java.util.*;

class license_key {
    public static void main(String args[]) {
        String s = "5F3Z-2e-9-w";
        int K = 4;
        System.out.println(licenseKeyFormatting(s , K));
    }

    public static String licenseKeyFormatting(String s , int k) {
        StringBuilder ans = new StringBuilder();
        int cnt = 0 , n = s.length();

        char c;
        for(int i = n - 1 ; i >= 0 ; i--) {
            c = s.charAt(i);
            if(c != '-') {
                if(cnt == k) {
                    ans.append('-');
                    cnt = 0;
                }
                cnt++;
                if(c >= 'a' && c <= 'z') {
                    c += 'A' - 'a';
                }
                ans.append(c);
            }
        }
        return ans.reverse().toString();
    }
}
5F3Z-2E9W

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

સમય જટિલતા

ઓ (એન), એન = શબ્દમાળાની લંબાઈ. પ્રોગ્રામ રેખીય છે કારણ કે આપણે એક વાર શબ્દમાળાને ફરી વળવું.

અવકાશ જટિલતા 

ઓ (1), કેમ કે આપણે સતત મેમરી સ્પેસનો ઉપયોગ કરીએ છીએ.