# 1’s and 2’s complement of a Binary Number

Given a Binary Number as a string, print its 1’s and 2’s complements.

**1’s complement **of a binary number is another binary number obtained by toggling all bits in it, i.e., transforming the 0 bit to 1 and the 1 bit to 0.

**Examples:**

1's complement of "0111" is "1000" 1's complement of "1100" is "0011"

**2’s complement **of a binary number is 1 added to the 1’s complement of the binary number.

Examples:

2's complement of "0111" is "1001" 2's complement of "1100" is "0100"

For one’s complement, we simply need to flip all bits.

For 2’s complement, we first find one’s complement. We traverse the one’s complement starting from LSB (least significant bit), and look for 0. We flip all 1’s (change to 0) until we find a 0. Finally, we flip the found 0. For example, 2’s complement of “01000” is “11000” (Note that we first find one’s complement of 01000 as 10111). If there are all 1’s (in one’s complement), we add an extra 1 in the string. For example, 2’s complement of “000” is “1000” (1’s complement of “000” is “111”).

Below is the implementation.

## C++

`// C++ program to print 1's and 2's complement of ` `// a binary number ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Returns '0' for '1' and '1' for '0' ` `char` `flip(` `char` `c) {` `return` `(c == ` `'0'` `)? ` `'1'` `: ` `'0'` `;} ` ` ` `// Print 1's and 2's complement of binary number ` `// represented by "bin" ` `void` `printOneAndTwosComplement(string bin) ` `{ ` ` ` `int` `n = bin.length(); ` ` ` `int` `i; ` ` ` ` ` `string ones, twos; ` ` ` `ones = twos = ` `""` `; ` ` ` ` ` `// for ones complement flip every bit ` ` ` `for` `(i = 0; i < n; i++) ` ` ` `ones += flip(bin[i]); ` ` ` ` ` `// for two's complement go from right to left in ` ` ` `// ones complement and if we get 1 make, we make ` ` ` `// them 0 and keep going left when we get first ` ` ` `// 0, make that 1 and go out of loop ` ` ` `twos = ones; ` ` ` `for` `(i = n - 1; i >= 0; i--) ` ` ` `{ ` ` ` `if` `(ones[i] == ` `'1'` `) ` ` ` `twos[i] = ` `'0'` `; ` ` ` `else` ` ` `{ ` ` ` `twos[i] = ` `'1'` `; ` ` ` `break` `; ` ` ` `} ` ` ` `} ` ` ` ` ` `// If No break : all are 1 as in 111 or 11111; ` ` ` `// in such case, add extra 1 at beginning ` ` ` `if` `(i == -1) ` ` ` `twos = ` `'1'` `+ twos; ` ` ` ` ` ` ` `cout << ` `"1's complement: "` `<< ones << endl; ` ` ` `cout << ` `"2's complement: "` `<< twos << endl; ` `} ` ` ` `// Driver program ` `int` `main() ` `{ ` ` ` `string bin = ` `"1100"` `; ` ` ` `printOneAndTwosComplement(bin); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java program to print 1's and 2's complement of ` `// a binary number ` ` ` `class` `GFG ` `{ ` ` ` ` ` `// Returns '0' for '1' and '1' for '0' ` ` ` `static` `char` `flip(` `char` `c) ` ` ` `{ ` ` ` `return` `(c == ` `'0'` `) ? ` `'1'` `: ` `'0'` `; ` ` ` `} ` ` ` ` ` `// Print 1's and 2's complement of binary number ` ` ` `// represented by "bin" ` ` ` `static` `void` `printOneAndTwosComplement(String bin) ` ` ` `{ ` ` ` `int` `n = bin.length(); ` ` ` `int` `i; ` ` ` ` ` `String ones = ` `""` `, twos = ` `""` `; ` ` ` `ones = twos = ` `""` `; ` ` ` ` ` `// for ones complement flip every bit ` ` ` `for` `(i = ` `0` `; i < n; i++) ` ` ` `{ ` ` ` `ones += flip(bin.charAt(i)); ` ` ` `} ` ` ` ` ` `// for two's complement go from right to left in ` ` ` `// ones complement and if we get 1 make, we make ` ` ` `// them 0 and keep going left when we get first ` ` ` `// 0, make that 1 and go out of loop ` ` ` `twos = ones; ` ` ` `for` `(i = n - ` `1` `; i >= ` `0` `; i--) ` ` ` `{ ` ` ` `if` `(ones.charAt(i) == ` `'1'` `) ` ` ` `{ ` ` ` `twos = twos.substring(` `0` `, i) + ` `'0'` `+ twos.substring(i + ` `1` `); ` ` ` `} ` ` ` `else` ` ` `{ ` ` ` `twos = twos.substring(` `0` `, i) + ` `'1'` `+ twos.substring(i + ` `1` `); ` ` ` `break` `; ` ` ` `} ` ` ` `} ` ` ` ` ` `// If No break : all are 1 as in 111 or 11111; ` ` ` `// in such case, add extra 1 at beginning ` ` ` `if` `(i == -` `1` `) ` ` ` `{ ` ` ` `twos = ` `'1'` `+ twos; ` ` ` `} ` ` ` ` ` `System.out.println(` `"1's complement: "` `+ ones);; ` ` ` `System.out.println(` `"2's complement: "` `+ twos); ` ` ` `} ` ` ` ` ` `// Driver code ` ` ` `public` `static` `void` `main(String[] args) ` ` ` `{ ` ` ` `String bin = ` `"1100"` `; ` ` ` `printOneAndTwosComplement(bin); ` ` ` `} ` `} ` ` ` `// This code contributed by Rajput-Ji ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program to print 1's and 2's ` `# complement of a binary number ` ` ` `# Returns '0' for '1' and '1' for '0' ` `def` `flip(c): ` ` ` `return` `'1'` `if` `(c ` `=` `=` `'0'` `) ` `else` `'0'` ` ` `# Print 1's and 2's complement of ` `# binary number represented by "bin" ` `def` `printOneAndTwosComplement(` `bin` `): ` ` ` ` ` `n ` `=` `len` `(` `bin` `) ` ` ` `ones ` `=` `"" ` ` ` `twos ` `=` `"" ` ` ` ` ` `# for ones complement flip every bit ` ` ` `for` `i ` `in` `range` `(n): ` ` ` `ones ` `+` `=` `flip(` `bin` `[i]) ` ` ` ` ` `# for two's complement go from right ` ` ` `# to left in ones complement and if ` ` ` `# we get 1 make, we make them 0 and ` ` ` `# keep going left when we get first ` ` ` `# 0, make that 1 and go out of loop ` ` ` `ones ` `=` `list` `(ones.strip("")) ` ` ` `twos ` `=` `list` `(ones) ` ` ` `for` `i ` `in` `range` `(n ` `-` `1` `, ` `-` `1` `, ` `-` `1` `): ` ` ` ` ` `if` `(ones[i] ` `=` `=` `'1'` `): ` ` ` `twos[i] ` `=` `'0'` ` ` `else` `: ` ` ` `twos[i] ` `=` `'1'` ` ` `break` ` ` ` ` `i ` `-` `=` `1` ` ` `# If No break : all are 1 as in 111 or 11111 ` ` ` `# in such case, add extra 1 at beginning ` ` ` `if` `(i ` `=` `=` `-` `1` `): ` ` ` `twos.insert(` `0` `, ` `'1'` `) ` ` ` ` ` `print` `(` `"1's complement: "` `, ` `*` `ones, sep ` `=` `"") ` ` ` `print` `(` `"2's complement: "` `, ` `*` `twos, sep ` `=` `"") ` ` ` `# Driver Code ` `if` `__name__ ` `=` `=` `'__main__'` `: ` ` ` `bin` `=` `"1100"` ` ` `printOneAndTwosComplement(` `bin` `.strip("")) ` ` ` `# This code is contributed ` `# by SHUBHAMSINGH10 ` |

*chevron_right*

*filter_none*

## C#

`// C# program to print 1's and 2's complement of ` `// a binary number ` `using` `System; ` ` ` `class` `GFG ` `{ ` ` ` ` ` `// Returns '0' for '1' and '1' for '0' ` ` ` `static` `char` `flip(` `char` `c) ` ` ` `{ ` ` ` `return` `(c == ` `'0'` `) ? ` `'1'` `: ` `'0'` `; ` ` ` `} ` ` ` ` ` `// Print 1's and 2's complement of binary number ` ` ` `// represented by "bin" ` ` ` `static` `void` `printOneAndTwosComplement(String bin) ` ` ` `{ ` ` ` `int` `n = bin.Length; ` ` ` `int` `i; ` ` ` ` ` `String ones = ` `""` `, twos = ` `""` `; ` ` ` `ones = twos = ` `""` `; ` ` ` ` ` `// for ones complement flip every bit ` ` ` `for` `(i = 0; i < n; i++) ` ` ` `{ ` ` ` `ones += flip(bin[i]); ` ` ` `} ` ` ` ` ` `// for two's complement go from right to left in ` ` ` `// ones complement and if we get 1 make, we make ` ` ` `// them 0 and keep going left when we get first ` ` ` `// 0, make that 1 and go out of loop ` ` ` `twos = ones; ` ` ` `for` `(i = n - 1; i >= 0; i--) ` ` ` `{ ` ` ` `if` `(ones[i] == ` `'1'` `) ` ` ` `{ ` ` ` `twos = twos.Substring(0, i) + ` `'0'` `+ ` ` ` `twos.Substring(i + 1,twos.Length-(i+1)); ` ` ` `} ` ` ` `else` ` ` `{ ` ` ` `twos = twos.Substring(0, i) + ` `'1'` `+ ` ` ` `twos.Substring(i + 1,twos.Length-(i+1)); ` ` ` `break` `; ` ` ` `} ` ` ` `} ` ` ` ` ` `// If No break : all are 1 as in 111 or 11111; ` ` ` `// in such case, add extra 1 at beginning ` ` ` `if` `(i == -1) ` ` ` `{ ` ` ` `twos = ` `'1'` `+ twos; ` ` ` `} ` ` ` ` ` `Console.WriteLine(` `"1's complement: "` `+ ones);; ` ` ` `Console.WriteLine(` `"2's complement: "` `+ twos); ` ` ` `} ` ` ` ` ` `// Driver code ` ` ` `public` `static` `void` `Main(String[] args) ` ` ` `{ ` ` ` `String bin = ` `"1100"` `; ` ` ` `printOneAndTwosComplement(bin); ` ` ` `} ` `} ` ` ` `// This code has been contributed by 29AjayKumar ` |

*chevron_right*

*filter_none*

**Output:**

1's complement: 0011 2's complement: 0100

Thanks to Utkarsh Trivedi for above solution.

As a side note, signed numbers generally use 2’s complement representation. Positive values are stored as it is and negative values are stored in their 2’s complement form. One extra bit is required to indicate whether number is positive or negative. For example char is 8 bits in C. If 2’s complement representation is used for char, then 127 is stored as it is, i.e., 01111111 where first 0 indicates positive. But -127 is stored as 10000001.

Related Post :

Efficient method for 2’s complement of a binary string

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

**References:**

http://qa.geeksforgeeks.org/6439/write-program-calculate-ones-and-twos-complement-of-number

http://geeksquiz.com/whats-difference-between-1s-complement-and-2s-complement/

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: **DSA Self Paced**. Become industry ready at a student-friendly price.

## Recommended Posts:

- Check if binary representation of a given number and its complement are anagram
- Efficient method for 2's complement of a binary string
- 9's complement of a decimal number
- Previous number same as 1's complement
- Complement of a number with any base b
- 10's Complement of a decimal number
- 8085 program to find 1’s and 2’s complement of 16-bit number
- 8085 program to find 1's and 2's complement of 8-bit number
- Interface 8255 with 8085 microprocessor for 1’s and 2’s complement of a number
- What’s difference between 1's Complement and 2's Complement?
- Subtraction of two numbers using 2's Complement
- Check if one of the numbers is one's complement of the other
- Find One's Complement of an Integer
- Why are negative numbers stored as 2's complement?
- Check if bits in range L to R of two numbers are complement of each other or not
- Find relative complement of two sorted arrays
- 8085 program to find 2's complement of the contents of Flag Register
- Count number of trailing zeros in Binary representation of a number using Bitset
- Number of ways to split a binary number such that every part is divisible by 2
- Check if the binary representation of a number has equal number of 0s and 1s in blocks