મહત્તમ સંખ્યા ફુગ્ગાઓનો લેટકોડ સોલ્યુશન  


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે ટેસ્લા વેઇફેર
ગાણિતીક નિયમો કોડિંગ હેશિંગ મુલાકાત ઇન્ટરવ્યુની તૈયારી લેટકોડ LeetCodeSolutions શબ્દમાળા

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

આ સમસ્યામાં, અમને અક્ષરોની સ્ટ્રિંગ આપવામાં આવે છે જેમાં લોઅર-કેસ અંગ્રેજી અક્ષરો હોય છે. આપણે શબ્દના કેટલા દાખલા શોધવાની જરૂર છે “બલૂન"આપણે આપેલ શબ્દમાળાનાં પાત્રોનો ઉપયોગ કરી શકીએ છીએ.

ઉદાહરણ

String = "banooll"
1

સમજૂતી:

મહત્તમ સંખ્યા ફુગ્ગાઓનો લેટકોડ સોલ્યુશનપિન

String = baqwweeeertylln

સમજૂતી: શબ્દમાળામાં 'ઓ' ન હોવાથી, આપણે “બલૂન” નો એક પણ દાખલો બનાવી શકીએ નહીં. તેથી, આપણે 0 છાપીશું.

અભિગમ  

તે સ્પષ્ટ છે કે આપણે શબ્દમાળામાં અક્ષરોની આવર્તન જાણવાની જરૂર છે જે શબ્દ "બલૂન" બનાવે છે. તે છે, અક્ષરો 'બ', 'એ', 'લ', 'ઓ' અને 'એન' ની ફ્રીક્વન્સીઝ સાચવવાનું આપણા માટે ફક્ત મહત્વપૂર્ણ છે, કારણ કે તે શબ્દમાળા “બલૂન” બનાવે છે. તે પછી, અમે શક્ય શબ્દના ઉદાહરણોની સંખ્યા નક્કી કરવા માટે ન્યૂનતમ ગણતરીવાળા પત્ર શોધી શકીએ. આ તેનું લાક્ષણિક ઉદાહરણ છે હેશીંગ તેમની આવર્તન સાથેના અક્ષરો. નોંધ લો કે આપણે ધ્યાનમાં લેવાની જરૂર છે કે 'l' અને 'o' અક્ષરોની માત્ર અડધા આવર્તનનો ઉપયોગ એક જ શબ્દ બનાવવા માટે કરી શકાય છે. આ કેસમાં સામાન્ય બનાવવા માટે, અમે અગાઉથી આ બંને અક્ષરોની આવર્તનની અડધી.

અલ્ગોરિધમ

  1. 5 પૂર્ણાંકો પ્રારંભ કરો: બી, એ, એલ, ઓ, અને n જેમ કે સંબંધિત ફ્રીક્વન્સીઝ સ્ટોર કરવા
  2. દરેક પાત્ર માટે 'chrશબ્દમાળા માં:
    • જો 'chr'ઉપર જણાવેલ કોઈપણ પાત્રો છે, તેની આવર્તન વધારવી
  3. ભાગલા l અને o 2 દ્વારા
  4. વચ્ચે લઘુત્તમ પરત બી, એ, એલ, ઓ, અને n
  5. પરિણામ છાપો
આ પણ જુઓ
લાઇસેંસ કી ફોર્મેટિંગ લીટકોડ સોલ્યુશન

મહત્તમ સંખ્યાના ફુગ્ગાઓનો લેટકોડ સોલ્યુશનનો અમલ

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

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

int maxNumberOfBalloons(string text)
{
    int b = 0 , a = 0 , l = 0 , o = 0 , n = 0;
    for(char &chr : text)
    {
        switch(chr)
        {
            case 'b' : b++;
                break;
            case 'a' : a++;
                break;
            case 'l' : l++;
                break;
            case 'o' : o++;
                break;
            case 'n' : n++;
                break;
        }
    }

    l /= 2;
    o /= 2;
    return min({b , a , l , o , n});
}

int main()
{
    string text = "blloona";
    cout << maxNumberOfBalloons(text) << '\n';
    return 0;
}

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

import java.lang.*;

class max_balloons
{
    public static void main(String args[])
    {
        String text = "blloona";
        System.out.println(maxNumberOfBalloons(text));
    }

    static int maxNumberOfBalloons(String text)
    {
        int b = 0 , a = 0 , l = 0 ,  o = 0 , n = 0;
        char chr;
        for(int i = 0 ; i < text.length() ; i++)
        {
            chr = text.charAt(i);
            switch(chr)
            {
                case 'b' : b++;
                case 'a' : a++;
                case 'l' : l++;
                case 'o' : o++;
                case 'n' : n++;
                default: ;
            }
        }

        l /= 2;
        o /= 2;

        return Math.min(b , Math.min(a , Math.min(l, Math.min(o , n))));
    }
}
1

મહત્તમ સંખ્યાના ફુગ્ગાઓનો લેટકોડ સોલ્યુશનનું જટિલતા વિશ્લેષણ

સમય જટિલતા

ઓ (એન) આપણે અમુક અક્ષરોની આવર્તન સંગ્રહવા માટે એકવાર શબ્દમાળાને વટાવીએ છીએ. અહીં, N એરેનું = કદ.

અવકાશ જટિલતા 

ઓ (1) કારણ કે આપણે ઇનપુટને ધ્યાનમાં લીધા વિના સતત મેમરી સ્પેસનો ઉપયોગ કરીએ છીએ. અમે ફક્ત તેમના ફ્રીક્વન્સીની ગણતરી માટે કેટલાક ચલો સંગ્રહિત કરીએ છીએ.