బెలూన్ల లీట్‌కోడ్ పరిష్కారం యొక్క గరిష్ట సంఖ్య


కఠినత స్థాయి సులువు
తరచుగా అడుగుతుంది టెస్లా Wayfair
హ్యాషింగ్ స్ట్రింగ్

సమస్యల నివేదిక

ఈ సమస్యలో, మాకు చిన్న అక్షరాలతో కూడిన అక్షరాల స్ట్రింగ్ ఇవ్వబడుతుంది. పదం యొక్క ఎన్ని ఉదాహరణలను మనం కనుగొనాలి “బెలూన్”ఇచ్చిన స్ట్రింగ్ యొక్క అక్షరాలను ఉపయోగించి మనం చేయగలమా.

ఉదాహరణ

String = "banooll"
1

వివరణ:

బెలూన్ల లీట్‌కోడ్ పరిష్కారం యొక్క గరిష్ట సంఖ్య

String = baqwweeeertylln
0

వివరణ: స్ట్రింగ్‌కు 'ఓ' లేనందున, మనం “బెలూన్” యొక్క ఒక్క ఉదాహరణ కూడా చేయలేము. కాబట్టి, మేము 0 ప్రింట్ చేస్తాము.

అప్రోచ్

“బెలూన్” అనే పదాన్ని చేసే స్ట్రింగ్‌లోని అక్షరాల ఫ్రీక్వెన్సీని మనం తెలుసుకోవాల్సిన అవసరం ఉంది. అంటే, 'బి', 'ఎ', 'ఎల్', 'ఓ' మరియు 'ఎన్' అక్షరాల పౌన encies పున్యాలను “బెలూన్” స్ట్రింగ్‌గా ఉంచడం వల్ల వాటిని సేవ్ చేయడం మాత్రమే మాకు ముఖ్యం. అప్పుడు, పదం యొక్క ఉదాహరణల సంఖ్యను నిర్ణయించడానికి కనీస గణన ఉన్న అక్షరాన్ని మనం కనుగొనవచ్చు. దీనికి విలక్షణ ఉదాహరణ హాషింగ్ అక్షరాలు వాటి పౌన .పున్యాలు. 'L' మరియు 'o' అక్షరాల పౌన encies పున్యాలలో సగం మాత్రమే ఒకే పదాన్ని చేయడానికి ఉపయోగించవచ్చని మనం పరిగణించాల్సిన అవసరం ఉందని గమనించండి. ఈ కేసును సాధారణీకరించడానికి, మేము ఈ రెండు అక్షరాల సగం పౌన frequency పున్యాన్ని ముందే.

అల్గారిథం

  1. 5 పూర్ణాంకాలను ప్రారంభించండి: b, a, l, o, మరియు n వారి సంబంధిత పౌన encies పున్యాలను నిల్వ చేయడానికి 0
  2. ప్రతి పాత్రకు 'chr'స్ట్రింగ్‌లో:
    • ఉంటే 'chr'పైన పేర్కొన్న అక్షరాలలో ఏదైనా, దాని పౌన .పున్యాన్ని పెంచండి
  3. డివైడ్ l మరియు o 2 ద్వారా
  4. వాటిలో కనిష్టాన్ని తిరిగి ఇవ్వండి b, a, l, o, మరియు 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

బెలూన్ల లీట్‌కోడ్ సొల్యూషన్ యొక్క గరిష్ట సంఖ్య యొక్క సంక్లిష్టత విశ్లేషణ

సమయం సంక్లిష్టత

పై) కొన్ని అక్షరాల పౌన encies పున్యాలను నిల్వ చేయడానికి మేము ఒకసారి స్ట్రింగ్‌లో ప్రయాణిస్తున్నప్పుడు. ఇక్కడ, N = శ్రేణి యొక్క పరిమాణం.

అంతరిక్ష సంక్లిష్టత 

O (1) మేము ఇన్పుట్తో సంబంధం లేకుండా స్థిరమైన మెమరీ స్థలాన్ని ఉపయోగిస్తాము. వాటి పౌన .పున్యాలను లెక్కించడానికి మేము కొన్ని వేరియబుల్స్ నిల్వ చేస్తాము.