ריעריינדזש אַ ביינערי שטריקל ווי אָלטערנאַטיוו X און Y פֿאַלן


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

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

רעכן איר האָבן אַ ביינערי שטריקל, און צוויי נומערן x און y. די שטריקל באשטייט בלויז פֿון 0 ס און 1 ס. די פּראָבלעם "ריעריינדזש אַ ביינערי שטריקל ווי בייַטנ לויט דער ריי x און y פֿאַלן" בעט צו ריעריינדזש די שטריקל אַזוי אַז די 0 קומט רענטגענ מאָל ⇒ 1 קומט י מאל ⇒ ווידער 0 קומט רענטגענ מאָל times 1 קומט י מאָל און אַזוי אויף ביז 0 ס אָדער 1 ס זענען פאַרטיק. דערנאָך קאַנקאַטאַנייט די רוען טייל פון די שטריקל און דרוקן עס.

בייַשפּיל

str = “01101”,

x = 1

y = 1
01011

דערקלערונג

ערשטער 0 געדרוקט רענטגענ מאָל, דאַן 1 געדרוקט י מאָל, דאַן 0 רענטגענ מאָל דעמאָלט ווידער 1 י מאָל, אָבער איצט 0 איז לינקס אַזוי מיר קאַנקייט די רוען טייל פון די שטריקל וואָס איז 1.

ריעריינדזש אַ ביינערי שטריקל ווי אָלטערנאַטיוו X און Y פֿאַלן

 

אַלגערידאַם צו ריעריינדזש אַ ביינערי שטריקל ווי אָלטערנאַטיוו X און Y פֿאַלן

1. Count the total number of 0s and 1s.
2. Make a loop till the count of either of zeros or ones will be 0.
  1. Traverse in an individual loop for zeroCount, till the value x is reached and till the zeroCount will not be 0, print the 0, and decrease the value of zeroCount by 1.
  2. Traverse in an individual loop for onesCount, till the value y is reached and till the onesCount will not be 0, print the 1, and decrease the value of onesCount by 1.

דערקלערונג

א ביינערי שטריקל ווי אַ אַרייַנשרייַב מיר האָבן געגעבן. דער ביינערי שטריקל איז בלויז פֿון 0 ס און 1 ס ווי די נאָמען סאַגדזשעסץ. מיר אויך געבן צוויי וואַלועס x און y. אַזאַ אַז מיר האָבן צו איבערחזרן די 0 ס אין די רעזולטאַט שטריקל רענטגענ מאָל און 1 ס אין דער רעזולטאַט שטריקל "י" מאָל קאַנסעקיאַטיוולי. און אויב עס איז אַ שטריקל לינקס, קאַנקאַטאַנייט די רוען שטריקל מיט דעם רעזולטאַט שטריקל. צוליב דעם, מיר וועלן נוצן גאָרנישט אָבער אַ פּשוט טאָמבאַנק פֿאַר ביידע די נולקאָונט און אָנעסקאָונט צו האַלטן די נומער און טראַקס פֿאַר זעראָס און אָנעס.

מיר וועלן דורכגיין די שטריקל יעדער בריוו. יעדער בריוו וועט זיין 0 אָדער 1 אין דער פאָרעם פון אַ שטריקל. און מיר וועלן ציילן ווי פילע זענען זעראָעס און ווי פילע זענען אָנעס אין די געגעבן שטריקל? די נומער פון זעראָעס וועט זיין סטאָרד אין די נולקאָונט און די נומער פון אָנעס וועט זיין סטאָרד אין אָנעסקאָונט. די צוויי וועריאַבאַלז וועט האַלטן די נומער פון זעראָעס און אָנעס אפילו נאָך מיר דורכפירן אַפּעריישאַנז.

נאָך באַקומען די ציילן פון די גאַנץ נומער פון זעראָס און אָנעס אין אַ שטריקל. מיר וועלן אָנהייבן אַ שלייף מיט אַ צושטאַנד אַז די שלייף וועט פאָרזעצן ביז די נולקאָונט אָדער אָנעסקאָונט וועט זיין 0. אין דעם שלייף, מיר וועלן גיין דורך אַ נולקאָונט און אָנעסקאָונט ינדיווידזשואַלי, מיט אַ צושטאַנד אַז די שלייף וועט פאָרזעצן ביז די x ווערט איז ריטשט אין אַ שלייף. אין דעם צייט מיר דרוקן די '0' און וועט פאַרמינערן די ווערט פון zeroCount און דרוקן עס קס מאָל. און נאָך דעם, אן אנדער שלייף וועט זיין עקסאַקיוטאַד וואָס וועט דרוקן '1' י מאָל. דערנאָך רידוסינג די ווערט פון אָנעסקאָונט. מיט דעם מנוחה פון די שטריקל, עס וועט נישט זיין אַפעקטאַד און מיר וועלן באַקומען די געבעטן רעזולטאַט.

קאָדעקס

C ++ קאָד צו ריעריינדזש אַ ביינערי שטריקל ווי בייַטנ לויט דער ריי X און Y פֿאַלן

#include<iostream>

using namespace std;

void arrangeZeroesAndOnes(string str, int x, int y)
{
    int zeroCount = 0;
    int onesCount = 0;
    int len = str.length();

    for (int i = 0; i < len; i++)
    {
        if (str[i] == '0')
            zeroCount++;
        else
            onesCount++;
    }
    while (zeroCount > 0 || onesCount > 0)
    {
        for (int j = 0; j < x && zeroCount > 0; j++)
        {
            if (zeroCount > 0)
            {
                cout << "0";
                zeroCount--;
            }
        }
        for (int j = 0; j < y && onesCount > 0; j++)
        {
            if (onesCount > 0)
            {
                cout << "1";
                onesCount--;
            }
        }
    }
}
int main()
{
    string str = "01101";
    int x = 1;
    int y = 1;
    arrangeZeroesAndOnes(str, x, y);
    return 0;
}
01011

Java קאָד צו ריעריינדזש אַ ביינערי שטריקל ווי אָלטערנאַטיוו רענטגענ און י פֿאַלן

class arrangeBinaryString
{
    static void arrangeZeroesAndOnes(String str, int x, int y)
    {
        int zeroCount = 0;
        int onesCount = 0;
        int len = str.length();

        for (int i = 0; i < len; i++)
        {
            if (str.charAt(i) == '0')
                zeroCount++;
            else
                onesCount++;
        }

        while (zeroCount > 0 || onesCount > 0)
        {
            for (int j = 0; j < x && zeroCount > 0; j++)
            {
                if (zeroCount > 0)
                {
                    System.out.print ("0");
                    zeroCount--;
                }
            }
            for (int j = 0; j < y && onesCount > 0; j++)
            {
                if (onesCount > 0)
                {
                    System.out.print("1");
                    onesCount--;
                }
            }
        }
        System.out.println();
    }
    public static void main (String[] args)
    {
        String str = "01101";
        int x = 1;
        int y = 1;
        arrangeZeroesAndOnes(str, x, y);

    }
}
01011

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

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

אָ (N) ווו “N” איז די לענג פון די שטריקל. דאָ מיר לויפן די שלייף גלייַך צו די לענג פון די שטריקל. מיר זייַנען פארלאנגט צו ריעריינדזש די שטריקל אויף אַ באַזונדער שטייגער. מיר האָבן צו דרוקן אַלע די אותיות וואָס געמאכט עס לויפן אין לינעאַר צייט קאַמפּלעקסיטי.

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

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