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


שוועריקייט לעוועל גרינג
אָפט געבעטן אין טעסלאַ ווייַפאַיר
האַשינג שטריקל

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

אין דעם פּראָבלעם, מיר געבן אַ שטריקל פון אותיות מיט קליין-ענגליש אותיות. מיר דאַרפֿן צו געפֿינען ווי פילע ינסטאַנסיז פון די וואָרט "באַלאָן"קענען מיר מאַכן ניצן די אותיות פון די געגעבן שטריקל.

בייַשפּיל

String = "banooll"
1

דערקלערונג:

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

String = baqwweeeertylln
0

דערקלערונג: ווי די שטריקל האט קיין 'אָ', מיר קענען נישט מאַכן אפילו אַ איין בייַשפּיל פון "באַלאָן". אַזוי, מיר דרוקן 0.

צוגאַנג

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

אַלגאָריטהם

  1. ערשט 5 ינטאַדזשערז: b, a, l, o, און n צו קראָם זייער ריספּעקטיוו פריקוואַנסיז ווי 0
  2. פֿאַר יעדער כאַראַקטערchrאין די שטריקל:
    • אויב 'chr'איז איינער פון די אויבן דערמאנטע אותיות, ינקרעאַמענט די אָפטקייַט
  3. צעטיילן l און o דורך קסנומקס
  4. ווייַזן די מינימום צווישן b, a, l, o, און n
  5. דרוק דעם רעזולטאַט

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

C ++ פּראָגראַם

#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;
}

Java פּראָגראַם

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) ווען מיר דורכפאָר די שטריקל אַמאָל צו קראָם אָפטקייַט פון עטלעכע אותיות. דאָ, N = גרייס פון דעם מענגע.

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

אָ (1) ווי מיר נוצן קעסיידערדיק זיקאָרן פּלאַץ ראַגאַרדלאַס פון די ינפּוט. מיר נאָר קראָם עטלעכע וועריאַבאַלז פֿאַר קאַונטינג זייער פריקוואַנסיז.