ප්‍රතිලෝම බිටු  


දුෂ්කරතා මට්ටම පහසු
නිතර අසනු ලැබේ Apple ජංගම දුරකථන ගූගල් Samsung ජංගම දුරකථන
බිට් බිට් හැසිරවීම බිටු

ලබා දී ඇති බිටු 32 ක ප්‍රතිලෝම බිටු අත්සන් නොකළ පූර්ණ සංඛ්‍යාවක්.

උදාහරණයක්  

ආදාන

43261596 (00000010100101000001111010011100)

ප්රතිදාන

964176192 (00111001011110000010100101000000)

32-බිට් අත්සන් නොකළ පූර්ණ සංඛ්‍යාවක් යනු අක්ෂර 32 කින් සමන්විත වන අතර එය සෑම අක්ෂරයක්ම '0' හෝ '1' විය හැකිය.

ඇල්ගොරිතම  

  1. මම 0 සිට 15 දක්වා පරාසයක
    • ආරම්භයේ සිට අවසානය දක්වා ith බිට් එක සමාන නොවේ නම් එය පෙරළන්න.
  2. ද්විමය වශයෙන් අංකය මුද්‍රණය කරන්න.

පැහැදිලි කිරීම  

  1. අපි බිටු මාරු කරන්නේ ඒවා වෙනස් වූ විට පමණි. මන්ද ඒවා බිටු එක සමාන වන විට මාරු කිරීම අපගේ අවසාන පිළිතුර වෙනස් නොකරන බැවිනි.
  2. වෙනස් බිටු දෙකක් මාරු කිරීම සඳහා, අපි XOR භාවිතා කරමින් පුද්ගලයාගේ බිටු පෙරළන්නෙමු ක්රියාකරු.

ප්‍රතිලෝම බිටුපින්

ක්රියාත්මක කිරීම  

ප්‍රතිලෝම බිටු සඳහා C ++ වැඩසටහන

#include <bits/stdc++.h>
using namespace std;
void Reverse(uint32_t n)
{
    for (int i = 0; i < 16; i++)
    {
        bool temp = (n & (1 << i));
        bool temp1 = (n & (1 << (31 - i)));
        if (temp1 != temp)
        {
            n ^= (1 << i);
            n ^= (1 << (31 - i));
        }
    }
    for (int i = 31; i >= 0; i--)
    {
        bool temp = (n & (1 << i));
        cout << temp;
    }
    cout << endl;
}
int main()
{
    uint32_t n;
    cin >> n;
    Reverse(n);
    return 0;
}
43261596
00111001011110000010100101000000

ප්‍රතිලෝම බිටු සඳහා ජාවා වැඩසටහන

import java.util.*;

public class Main
{
    public static void Reverse(int n)
    {
        for (int i = 0; i < 16; i++)
        {
            int temp = (n & (1 << i));
            temp = temp==0? 0: 1;
            int temp1 = (n & (1 << (31 - i)));
            temp1 = temp1==0? 0: 1;
            if (temp1 != temp)
            {
                n ^= (1 << i);
                n ^= (1 << (31 - i));
            }
        }
        for (int i = 31; i >= 0; i--)
        {
            int temp = (n & (1 << i));
            temp = temp==0? 0: 1;
            System.out.print(temp);
        }
    }
  public static void main(String[] args) {
    Scanner sc = new Scanner( System.in ) ;
    int n=sc.nextInt();
    Reverse(n);
  }
}


3456785
10001000111111010010110000000000

ප්‍රතිලෝම බිටු සඳහා සංකීර්ණතා විශ්ලේෂණය  

කාල සංකීර්ණත්වය

අපි ගමන් කරන්නේ බිටු 16 ක් මත පමණි කාල සංකීර්ණත්වය O (16) යනු මූලික වශයෙන් O (1) වේ.

මෙයද බලන්න
නූල් ප්‍රතිසංවිධානය කරන්න

අවකාශයේ සංකීර්ණතාව

එය O (1) ද වන බැවින් අප ගත්තේ අතිරේක බූල් වර්ගයේ විචල්‍ය 2 ක් පමණි.

ප්‍රතිලෝම බිටු වල විචලනය  

  • මෙම ප්‍රශ්නයේදී, ලබා නොදුන් පූර්ණ සංඛ්‍යාවේ බිටු ආපසු හරවන්නැයි අපෙන් ඉල්ලා සිටියද, ලබා දී ඇති අත්සන් නොකළ පූර්ණ සංඛ්‍යාවේ අනුපූරකය සොයා ගන්නා විට එම ප්‍රශ්නයම වෙනස් කළ හැකිය.

දැන්, දී ඇති සංඛ්‍යාවක අනුපූරකය කුමක්ද?

A number obtained by toggling the state of each binary character in the given binary representation of integer is known as the complement of that number.

එබැවින් එය සිදු කිරීම සඳහා අපට දී ඇති ද්විමය නූලෙහි සියලු 0 න් 1 ට සහ 1 න් 0 ට වෙනස් කළ හැකිය.

උදාහරණයක්

දී ඇති අංකය 20 නම්, එහි ද්විමය නිරූපණය 10100 වේ

එබැවින් එහි අනුපූරකය 01011 වේ.

ක්රියාත්මක කිරීම

#include<bits/stdc++.h>
using namespace std;
int main(){
    int n = 20;
    string ans;
    while(n){
        if(n%2==0){
            ans = '1'+ans;
        }
        else{
            ans = '0'+ans;
        }
        n/=2;
    }
    cout<<"Complement of the given number is: "<<ans;
}
Complement of the given number is: 01011
  • ද්විමය නූල් දෙකක් එකතු කිරීම වැනි පූර්ණ සංඛ්‍යා වල ද්විමය නිරූපණය මත බොහෝ ප්‍රශ්න සැකසිය හැකිය. එවැනි ප්‍රශ්න විසඳීම සඳහා ද්විමය එකතු කිරීමේ නීති ගැන දැනගත යුතුය.

එකතු කිරීම සඳහා නීති:

පින්

මෙම වගුව සත්‍ය වගුව ලෙස හැඳින්වේ. එකතු කිරීම, අඩු කිරීම යනාදිය වැනි ද්විමය බිට්වේස් මෙහෙයුම්වල ප්‍රතිදානය සොයා ගැනීමට එය භාවිතා කරයි.

  • බිට්වේස් මෙහෙයුම් හා ද්විමය නිරූපණයන් සම්බන්ධ වඩාත් සංකීර්ණ ගැටළු තරඟකාරී වැඩසටහන්කරණයේදී බහුලව අසනු ලබන බිට් හැසිරවීම යටතේ පවතී.

බිට් හැසිරවීමේ මූලික කරුණු වන්නේ විවිධ දත්ත ව්‍යුහයන් ද්විමය ස්වරූපයෙන් නිරූපණය වන ආකාරයයි.

මෙයද බලන්න
N සහ එහි ද්විත්ව පවතින ලීට්කෝඩ් විසඳුම තිබේදැයි පරීක්ෂා කරන්න

ආශ්රිත