బైనరీ స్ట్రింగ్‌ను ప్రత్యామ్నాయ x మరియు y సంఘటనలుగా మార్చండి


కఠినత స్థాయి మీడియం
తరచుగా అడుగుతుంది అకోలైట్ సిస్కో సిట్రిక్స్ హైక్ IBM సమాచారం ఎడ్జ్ Pinterest Roblox టెస్లా
స్ట్రింగ్

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

మీకు బైనరీ ఇవ్వబడిందని అనుకుందాం స్ట్రింగ్, మరియు x మరియు y అనే రెండు సంఖ్యలు. స్ట్రింగ్ 0 సె మరియు 1 సె మాత్రమే కలిగి ఉంటుంది. “బైనరీ స్ట్రింగ్‌ను ప్రత్యామ్నాయ x మరియు y సంఘటనలుగా మార్చండి” అనే సమస్య స్ట్రింగ్‌ను క్రమాన్ని మార్చమని అడుగుతుంది, అంటే 0 వస్తుంది x సార్లు ⇒ 1 వస్తుంది y సార్లు ⇒ మళ్ళీ 0 వస్తుంది x సార్లు ⇒ 1 y సార్లు వస్తుంది మరియు 0 సె లేదా 1 సె వరకు పూర్తయ్యాయి. అప్పుడు స్ట్రింగ్ యొక్క మిగిలిన భాగాన్ని కలిపి ప్రింట్ చేయండి.

ఉదాహరణ

str = “01101”,

x = 1

y = 1
01011

వివరణ

మొదట 0 ముద్రించిన x సార్లు, తరువాత 1 ముద్రించిన y సార్లు, తరువాత 0 x సార్లు తరువాత మళ్ళీ 1 y సార్లు, కానీ ఇప్పుడు 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 సెలను x సార్లు మరియు 1 సె అవుట్‌పుట్ స్ట్రింగ్‌లో “y” సార్లు వరుసగా పునరావృతం చేయాలి. మరియు స్ట్రింగ్ మిగిలి ఉంటే మిగిలిన స్ట్రింగ్‌ను ఈ అవుట్పుట్ స్ట్రింగ్‌తో కలపండి. దీని కోసం, సున్నా మరియు వాటి రెండింటికీ సంఖ్య మరియు ట్రాక్‌లను ఉంచడానికి మేము జీరోకౌంట్ మరియు వన్‌కౌంట్ రెండింటికీ సాధారణ కౌంటర్ తప్ప మరేమీ ఉపయోగించబోము.

మేము ప్రతి అక్షరానికి స్ట్రింగ్ దాటబోతున్నాం. ప్రతి అక్షరం స్ట్రింగ్ రూపంలో 0 లేదా 1 గా ఉంటుంది. మరియు ఇచ్చిన స్ట్రింగ్‌లో సున్నాలు ఎన్ని ఉన్నాయి మరియు ఎన్ని ఉన్నాయి? సున్నాల సంఖ్య జీరోకౌంట్‌లో నిల్వ చేయబడుతుంది మరియు వాటి సంఖ్య వన్‌కౌంట్‌లో నిల్వ చేయబడుతుంది. మేము ఆపరేషన్లు చేసిన తర్వాత కూడా ఈ రెండు వేరియబుల్స్ సున్నాలు మరియు వాటి సంఖ్యను కలిగి ఉంటాయి.

స్ట్రింగ్‌లోని మొత్తం సున్నాలు మరియు వాటి సంఖ్యను పొందిన తరువాత. సున్నాకౌంట్ లేదా వన్‌కౌంట్ 0 అయ్యే వరకు లూప్ కొనసాగుతుందనే షరతుతో మేము లూప్‌ను ప్రారంభిస్తాము. ఆ లూప్‌లో, మేము సున్నాకౌంట్ మరియు ఒక్కొక్కటి ఒక్కొక్కటిగా ప్రయాణిస్తాము, లూప్ x వరకు కొనసాగుతుంది అనే షరతుతో విలువ లూప్‌లో చేరింది. ఈ సమయంలో మేము '0' ను ప్రింట్ చేస్తాము మరియు జీరోకౌంట్ విలువను తగ్గిస్తుంది మరియు దానిని x సార్లు ప్రింట్ చేస్తాము. మరియు ఆ తరువాత మరొక లూప్ అమలు అవుతుంది, ఇది '1' y సార్లు ముద్రించబడుతుంది. అప్పుడు వాటిని లెక్కించడం కొనసాగించండి. ఈ మిగిలిన స్ట్రింగ్‌తో ప్రభావితం ఉండదు మరియు మనకు కావలసిన అవుట్పుట్ లభిస్తుంది.

కోడ్

బైనరీ స్ట్రింగ్‌ను ప్రత్యామ్నాయ x మరియు y సంఘటనలుగా క్రమాన్ని మార్చడానికి C ++ కోడ్

#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

బైనరీ స్ట్రింగ్‌ను ప్రత్యామ్నాయ x మరియు y సంఘటనలుగా క్రమాన్ని మార్చడానికి జావా కోడ్

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” స్ట్రింగ్ యొక్క పొడవు. ఇక్కడ మేము స్ట్రింగ్ యొక్క పొడవుకు సమానమైన లూప్‌ను నడిపాము. మేము స్ట్రింగ్‌ను ఒక నిర్దిష్ట పద్ధతిలో క్రమాన్ని మార్చాల్సిన అవసరం ఉంది. మేము అన్ని అక్షరాలను ప్రింట్ చేయవలసి వచ్చింది, ఇది సరళ సమయ సంక్లిష్టతతో నడుస్తుంది.

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

ఓ (1), ఎందుకంటే మేము క్రొత్త స్ట్రింగ్‌ను నిల్వ చేయడం లేదు. మేము క్రొత్త స్ట్రింగ్ యొక్క అంశాలను ప్రింట్ చేస్తున్నాము. కాబట్టి ఈ ఆపరేషన్ మాకు ఎటువంటి స్థలాన్ని ఖర్చు చేయదు. అందువల్ల అల్గోరిథం కోసం స్థలం సంక్లిష్టత స్థిరంగా ఉంటుంది. మొత్తం ప్రోగ్రామ్‌కు ఇన్‌పుట్ నిల్వ చేయడానికి O (N) స్థలం అవసరం.