ਬਾਈਨਰੀ ਲੀਟਕੋਡ ਘੋਲ ਸ਼ਾਮਲ ਕਰੋ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਸੌਖੀ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਐਮਾਜ਼ਾਨ ਫੇਸਬੁੱਕ Microsoft ਦੇ
ਗਣਿਤ ਸਤਰ

ਸਮੱਸਿਆ ਦਾ ਬਿਆਨ

ਦੋ ਬਾਈਨਰੀ ਦਿੱਤੀ ਗਈ ਸਤਰ a ਅਤੇ b, ਸਾਨੂੰ ਇਨ੍ਹਾਂ ਦੋਹਾਂ ਸਤਰਾਂ ਨੂੰ ਜੋੜਨਾ ਹੈ ਅਤੇ ਫਿਰ ਨਤੀਜੇ ਨੂੰ ਬਾਈਨਰੀ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਵਾਪਸ ਕਰਨਾ ਹੈ. ਬਾਈਨਰੀ ਸਤਰ ਉਹ ਸਤਰਾਂ ਹੁੰਦੀਆਂ ਹਨ ਜਿਹੜੀਆਂ ਸਿਰਫ 0 ਸਕਿੰਟ ਅਤੇ 1 ਸਕਿੰਟ ਹੁੰਦੀਆਂ ਹਨ.

ਉਦਾਹਰਨ

a = "11", b = "1"
"100"
a = "1010", b = "1011"
"10101"

ਪਹੁੰਚ

ਬਾਈਨਰੀ ਲੀਟਕੋਡ ਘੋਲ ਸ਼ਾਮਲ ਕਰੋ

ਦੋ ਬਾਈਨਰੀ ਸਤਰਾਂ ਨੂੰ ਜੋੜਨ ਲਈ ਸਾਨੂੰ ਥੋੜ੍ਹੀ-ਥੋੜੀ ਹੋਰ ਜੋੜਨਾ ਪਏਗਾ. ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਜਾਣਦੇ ਹਾਂ ਕਿ ਖੱਬੇ ਬਿੱਟਾਂ ਵੱਲ ਵਧਣ ਨੂੰ ਸੱਜੇ ਸਿਰੇ ਤੋਂ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ. ਇਸ ਲਈ ਸਾਨੂੰ ਪਹਿਲਾਂ ਦਿੱਤੀ ਗਈ ਸਤਰਾਂ ਨੂੰ ਉਲਟਾਉਣਾ ਪਏਗਾ ਅਤੇ ਫਿਰ ਅਸੀਂ ਇੰਡੈਕਸ 0 ਤੋਂ ਸ਼ੁਰੂ ਕਰਦਿਆਂ ਇਸ ਦੇ ਬਿੱਟ ਨੂੰ ਜੋੜ ਸਕਦੇ ਹਾਂ.
ਬਿੱਟ ਜੋੜਨ ਦੀ ਤਰਤੀਬ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਅਸੀਂ ਇੱਕ ਸਟਰਿੰਗ ਵੇਰੀਏਬਲ ਬਣਾ ਸਕਦੇ ਹਾਂ ਰੈਜ਼ੋਲੇਸ਼ਨ ਅਤੇ ਦੋ ਬਿੱਟਾਂ ਦਾ ਜੋੜ ਜੋੜੋ ਅਤੇ ਅੰਤ ਵਿੱਚ ਲੈ ਜਾਓ ਰੈਜ਼ੋਲੇਸ਼ਨ ਹਰੇਕ ਬਿੱਟ ਸਥਿਤੀ ਲਈ ਸਤਰ. ਅੰਤ ਵਿੱਚ ਸਾਨੂੰ ਵਾਪਸ ਕਰ ਦੇਵੇਗਾ ਰੈਜ਼ੋਲੇਸ਼ਨ ਆਉਟਪੁੱਟ ਲਈ ਸਤਰ.

ਐਲਗੋਰਿਥਮ

  • ਦਿੱਤੀਆਂ ਤਾਰਾਂ ਉਲਟਾਓ.
  • ਇੱਕ ਖਾਲੀ ਸਤਰ ਬਣਾਓ ਅਤੇ ਏ ਚੁੱਕੋ ਪਰਿਵਰਤਨਸ਼ੀਲ. ਅਰੰਭ ਕਰੋ ਚੁੱਕੋ 0 ਦੇ ਨਾਲ.
  • ਹੁਣ ਕੁਝ ਸਮੇਂ ਦੇ ਲੂਪ ਵਿਚ ਦਿੱਤੀ ਗਈ ਸਤਰ ਨੂੰ ਦੁਹਰਾਓ ਅਤੇ ਕੈਰੀ ਦੇ ਨਾਲ ਪਹਿਲੇ ਅਤੇ ਦੂਜੇ ਸਤਰ ਦੇ ਕੁਝ ਜੋੜ ਦਿਓ. ਹੁਣ ਵਾਧੂ ਮੁੱਲ ਦੇ ਅਨੁਸਾਰ ਨਤੀਜਾ ਬਿੱਟ ਨੂੰ ਮੁੜ ਸਤਰ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ ਅਤੇ ਅਪਡੇਟ ਵੀ ਕਰੋ ਚੁੱਕੋ ਅਗਲੇ ਬਿੱਟ ਲਈ.
  • ਅੰਤ ਵਿੱਚ ਸਾਡੇ ਕੋਲ ਆਉਟਪੁਟ ਸਟਰਿੰਗ ਹੈ ਪਰ ਇਹ ਰਿਵਰਸ ਆਰਡਰ ਵਿੱਚ ਹੈ ਕਿਉਂਕਿ ਅਸੀਂ ਆਪਣੀ ਸਹੂਲਤ ਲਈ ਉਲਟਾ ਇਨਪੁਟ ਸਤਰ ਉੱਤੇ ਹੋਰ ਪ੍ਰਦਰਸ਼ਨ ਕੀਤਾ ਹੈ. ਇਸ ਲਈ ਆਉਟਪੁੱਟ ਸਤਰ ਉਲਟਾਓ ਅਤੇ ਅੰਤ ਵਿੱਚ ਇਸਨੂੰ ਵਾਪਸ ਕਰੋ.

ਲਾਗੂ

ਸੀ ਬਾਈ + ਬਾਈਨਰੀ ਲੀਟਕੋਡ ਸਲਿ Sਸ਼ਨ ਲਈ ਪ੍ਰੋਗਰਾਮ

#include <bits/stdc++.h>
using namespace std;

string addBinary(string a, string b) 
{      
    int carry=0;
    string res="";

    reverse(a.begin(),a.end()); 
    reverse(b.begin(),b.end());

    int i=0,sum;
    while(i<a.size() || i<b.size())
    {
        sum= carry;

        if(i<a.size()) sum+= a[i]-'0';
        if(i<b.size()) sum+= b[i]-'0';

        if(sum==0) carry=0, res+='0';
        else if(sum==1)  carry=0, res+='1';
        else if(sum==2)carry=1, res+='0';
        else carry=1, res+='1';


        i++;
    }


    if(carry==1)  res+='1';

    reverse(res.begin(),res.end());
    return res;
        
}
int main()
{
  string a = "1010"; 
  string b = "1011";
  cout<<addBinary(a,b)<<endl;
}
10101

ਬਾਈਨਰੀ ਲੀਟਕੋਡ ਸਲੂਸ਼ਨ ਲਈ ਜਾਵਾ ਪ੍ਰੋਗਰਾਮ

import java.util.*;

class Rextester{
    
    public static String addBinary(String a, String b) 
    {      
        int carry=0;

        StringBuilder s1=new StringBuilder(a);
        StringBuilder s2=new StringBuilder(b);
        StringBuilder res=new StringBuilder();

        s1.reverse(); 
        s2.reverse();

        int i=0,sum;
        while(i<a.length() || i<b.length())
        {
            sum= carry;

            if(i<a.length()) sum+= s1.charAt(i)-'0';
            if(i<b.length()) sum+= s2.charAt(i)-'0';

            if(sum==0) 
            {
                 carry=0;
                 res.append('0');
            }
            if(sum==1) 
            {
                 carry=0;
                 res.append('1');
             }
            if(sum==2)
            {
                carry=1;
                res.append('0');
            }
           if(sum==3) 
            {
                carry=1;
                res.append('1');
            }

            i++;
        }
    
        if(carry==1)   res.append('1');

        res.reverse();
        return res.toString();
        
    }
    
  public static void main(String args[])
    {
        String a = "1010"; 
        String b = "1011";
        System.out.println(addBinary(a,b));
    }
}
10101

ਐਡ ਬਾਈਨਰੀ ਲੀਟਕੋਡ ਹੱਲ ਲਈ ਜਟਿਲਤਾ ਵਿਸ਼ਲੇਸ਼ਣ

ਟਾਈਮ ਜਟਿਲਤਾ

ਓ (ਅਧਿਕਤਮ (ਐਨ, ਐਮ)): ਜਿੱਥੇ ਐਨ ਅਤੇ ਐਮ ਇੰਪੁੱਟ ਸਤਰ ਦੀ ਲੰਬਾਈ ਹਨ. ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਇਕੋ ਲੂਪ ਵਿਚ ਦੋਵੇਂ ਸਤਰਾਂ ਨੂੰ ਰੇਖਾ ਰੂਪ ਵਿਚ ਲੰਘ ਰਹੇ ਹਾਂ, ਸਮੇਂ ਦੀ ਜਟਿਲਤਾ ਦੋਨਾਂ ਇਨਪੁਟ ਤਾਰਾਂ ਵਿਚੋਂ ਅਧਿਕਤਮ ਲੰਬਾਈ ਦੇ ਬਰਾਬਰ ਹੋਵੇਗੀ.

ਸਪੇਸ ਦੀ ਜਟਿਲਤਾ 

ਓ (ਅਧਿਕਤਮ (ਐਨ, ਐਮ)): ਨਤੀਜੇ ਦੇ ਬਾਅਦ ਇੱਕ ਸਤਰ ਵਿੱਚ ਨਤੀਜੇ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਸਾਨੂੰ ਸਤਰ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ ਜਿਸਦਾ ਆਕਾਰ ਇੰਪੁੱਟ ਸਤਰਾਂ ਦੀ ਲੰਬਾਈ ਦੇ ਵੱਧ ਤੋਂ ਵੱਧ ਹੁੰਦਾ ਹੈ.