பைனரி சரத்தை மாற்று x மற்றும் y நிகழ்வுகளாக மறுசீரமைக்கவும்


சிரமம் நிலை நடுத்தர
அடிக்கடி கேட்கப்படுகிறது அகோலைட் சிஸ்கோ Citrix உயர்வு ஐபிஎம் தகவல் எட்ஜ் இடுகைகள் Roblox டெஸ்லா
சரம்

சிக்கல் அறிக்கை

உங்களுக்கு பைனரி வழங்கப்பட்டதாக வைத்துக்கொள்வோம் சரம், மற்றும் x மற்றும் y ஆகிய இரண்டு எண்கள். சரம் 0 வி மற்றும் 1 வி மட்டுமே கொண்டுள்ளது. “ஒரு பைனரி சரத்தை மாற்று x மற்றும் y நிகழ்வுகளாக மறுசீரமைக்கவும்” என்ற சிக்கல் 0 ஐ x முறை comes 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 முறையும், வெளியீட்டு சரம் “y” முறைகளில் 1 விவையும் தொடர்ச்சியாக மீண்டும் செய்ய வேண்டும். ஒரு சரம் எஞ்சியிருந்தால், மீதமுள்ள சரத்தை இந்த வெளியீட்டு சரத்துடன் இணைக்கவும். இதற்காக, பூஜ்ஜியங்கள் மற்றும் ஒன்றிற்கான எண் மற்றும் தடங்களை வைத்திருக்க ஜீரோகவுண்ட் மற்றும் ஒன்ஸ்கவுண்ட் இரண்டிற்கும் ஒரு எளிய கவுண்டரைத் தவிர வேறு எதையும் நாங்கள் பயன்படுத்தப் போவதில்லை.

ஒவ்வொரு எழுத்தையும் சரம் கடந்து செல்லப் போகிறோம். ஒவ்வொரு கடிதமும் ஒரு சரம் வடிவில் 0 அல்லது 1 ஆக இருக்கும். கொடுக்கப்பட்ட சரத்தில் எத்தனை பூஜ்ஜியங்கள் உள்ளன, எத்தனை உள்ளன? பூஜ்ஜியங்களின் எண்ணிக்கை பூஜ்ஜிய எண்ணிக்கையில் சேமிக்கப்படும் மற்றும் அவற்றின் எண்ணிக்கை ஒன்ஸ்கவுண்டில் சேமிக்கப்படும். இந்த இரண்டு மாறிகள் பூஜ்ஜியங்களின் எண்ணிக்கையையும், நாம் செயல்பாடுகளைச் செய்த பிறகும் வைத்திருக்கும்.

ஒரு சரத்தில் மொத்த பூஜ்ஜியங்கள் மற்றும் எண்ணிக்கையின் எண்ணிக்கையைப் பெற்ற பிறகு. பூஜ்ஜிய கணக்கு அல்லது ஒன்ஸ்கவுண்ட் 0 இருக்கும் வரை வளையம் தொடரும் என்ற நிபந்தனையுடன் ஒரு சுழற்சியைத் தொடங்குவோம். அந்த வளையத்தில், நாம் ஒரு பூஜ்ஜிய கணக்கிற்கும் தனித்தனியாகவும் கணக்கிடுவோம், ஒரு நிபந்தனையுடன் x வரை வளையம் செல்லும் மதிப்பு ஒரு சுழற்சியில் அடையப்படுகிறது. இந்த நேரத்தில் நாம் '0' ஐ அச்சிடுவோம், மேலும் ஜீரோகவுண்டின் மதிப்பைக் குறைத்து அதை x முறை அச்சிடுவோம். அதன் பிறகு மற்றொரு வளையம் செயல்படுத்தப்படும், இது '1' y முறை அச்சிடும். பின்னர் எண்ணின் மதிப்பைக் குறைத்துக்கொண்டே இருங்கள். இந்த மீதமுள்ள சரம் பாதிக்கப்படாது, நாங்கள் விரும்பிய வெளியீட்டைப் பெறுவோம்.

குறியீடு

ஒரு பைனரி சரத்தை மாற்று 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

பைனரி சரத்தை மாற்று 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) எங்கே “N” இது சரத்தின் நீளம். இங்கே நாம் சரத்தின் நீளத்திற்கு சமமான சுழற்சியை இயக்கினோம். ஒரு குறிப்பிட்ட முறையில் சரத்தை மறுசீரமைக்க வேண்டிய அவசியம் எங்களுக்கு இருந்தது. நேரியல் நேர சிக்கலில் இயங்கக்கூடிய அனைத்து எழுத்துக்களையும் நாங்கள் அச்சிட வேண்டியிருந்தது.

விண்வெளி சிக்கலானது

ஓ (1), ஏனெனில் நாங்கள் புதிய சரத்தை சேமிக்கவில்லை. புதிய சரத்தின் கூறுகளை வெறுமனே அச்சிடுகிறோம். எனவே இந்த செயல்பாடு எங்களுக்கு எந்த இடத்தையும் செலவழிக்காது. எனவே வழிமுறையின் இட சிக்கலானது நிலையானது. முழு நிரலுக்கும் உள்ளீட்டை சேமிக்க O (N) இடம் தேவைப்படுகிறது.