ਲਾਈਸੈਂਸ ਕੁੰਜੀ ਫਾਰਮੈਟਿੰਗ ਲੀਟਕੋਡ ਹੱਲ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਸੌਖੀ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਕੈਪੀਟਲ ਇਕ ਗੂਗਲ
ਸਤਰ ਸਟਰਿੰਗ ਬਿਲਡਰ

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

ਸਮੱਸਿਆ "ਲਾਈਸੈਂਸ ਕੀ ਫੌਰਮੈਟਿੰਗ" ਵਿੱਚ, ਇਨਪੁਟ ਵਿੱਚ ਏ ਸਤਰ ਅੱਖਰਾਂ ਦਾ, ਇੱਕ ਲਾਇਸੈਂਸ ਕੁੰਜੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ. ਸ਼ੁਰੂ ਵਿਚ, ਸਤਰ ਨੂੰ N + 1 ਸਮੂਹਾਂ (ਸ਼ਬਦ) ਵਿਚ N ਡੈਸ਼ ਦੁਆਰਾ ਵੱਖ ਕੀਤਾ ਗਿਆ ਹੈ. ਸਾਨੂੰ ਇੱਕ ਪੂਰਨ ਅੰਕ ਕੇ ਵੀ ਦਿੱਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਟੀਚਾ ਇਹ ਹੈ ਕਿ ਸਤਰ ਨੂੰ ਇਸ ਤਰਾਂ ਫਾਰਮੈਟ ਕਰਨਾ ਹੈ ਕਿ ਹਰੇਕ ਸਮੂਹ ਵਿੱਚ ਬਿਲਕੁਲ K ਅੱਖਰ ਹੋਣ, ਸਿਰਫ ਇੱਕ ਤੋਂ ਇਲਾਵਾ, ਜਿਸ ਨੂੰ ਕੇ ਨਾਲੋਂ ਘੱਟ ਅੱਖਰਾਂ ਦੀ ਆਗਿਆ ਹੈ. ਇਸ ਤੋਂ ਇਲਾਵਾ, ਸਮੂਹਾਂ ਨੂੰ ਵੱਖ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ '- '(ਡੈਸ਼) ਅਤੇ ਸਿਰਫ ਵੱਡੇ ਅੱਖਰ ਹਨ.

ਉਦਾਹਰਨ

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

ਪਹੁੰਚ

ਇਹ ਅਨੁਭਵੀ ਹੈ ਕਿ ਸਾਨੂੰ ਸਟਰਿੰਗ (ਇਨਪੁਟ) ਵਿਚ ਬੈਕਡਰੇਟ ਕਰਦੇ ਸਮੇਂ ਇਕ ਨਵੀਂ ਸਤਰ ਬਣਾਉਣਾ ਚਾਹੀਦਾ ਹੈ. ਇਹ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ ਅਸੀਂ ਜਾਣਦੇ ਹਾਂ ਕਿ ਪਹਿਲੇ ਸਮੂਹ ਨੂੰ ਛੱਡ ਕੇ, ਹੋਰ ਸਾਰੇ ਸਮੂਹਾਂ ਵਿੱਚ ਉਨ੍ਹਾਂ ਵਿੱਚ ਬਿਲਕੁਲ 'ਕੇ' ਅੱਖਰ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ. ਜੇ ਅਸੀਂ ਸਟਰਿੰਗ s ਵਿਚ ਦੁਹਰਾਉਂਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਏ ਵਿਰੋਧੀ ਜੋ ਕਿ ਸਮੂਹ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੇ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਗਿਣਤੀ ਰੱਖਦਾ ਹੈ. ਜੇ ਇਹ ਕਿਸੇ ਵੀ ਸਮੇਂ 'ਕੇ' ਦੇ ਬਰਾਬਰ ਹੋ ਜਾਂਦਾ ਹੈ, ਅਸੀਂ ਇਸਨੂੰ ਸਿਫ਼ਰ 'ਤੇ ਵਾਪਸ ਕਰ ਸਕਦੇ ਹਾਂ. ਇਸ weੰਗ ਨਾਲ ਅਸੀਂ ਨਵੀਂ ਸਤਰ ਵਿਚ ਤੱਤ ਜੋੜਦੇ ਰਹਿੰਦੇ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਵਾਪਸ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਅਸੀਂ ਇਸਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਉਲਟਾ ਦਿੰਦੇ ਹਾਂ.

ਲਾਇਸੈਂਸ ਕੁੰਜੀ ਫਾਰਮੈਟਿੰਗ ਲੀਟਕੋਡ ਹੱਲ਼ ਦੀ ਸਥਾਪਨਾ

ਸੀ ++ ਪ੍ਰੋਗਰਾਮ

#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), ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਨਿਰੰਤਰ ਮੈਮੋਰੀ ਸਪੇਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ.