# 14/14 error

``````def flip_bit(number,n):
return bin(result)
``````

what is wrong with the code?

Here is the correct function:

``````def flip_bit(number,n):
return bin(result)``````
8 Likes
``````== Right Shift 5 >> 4 ==================
0b00000101 (5)
0b00000000 (5 >> 4 )
0
== Left Shift 5 << 1 ==================
0b00000101 (5)
0b00001010 (5 << 1 )
10
== Bitwise AND 8 & 5==================
AND | 0 1
----+-----
0  | 0 0
1  | 0 1
0b00000101 (5)
0b00001000 (8)
0b00000000
== Bitwise OR 9 | 4 ==================
OR | 0 1
----+-----
0 | 0 1
1 | 1 1
0b00001001 (9)
0b00000100 (4)
0b00001101
13
``````

#==
== Bitwise XOR 12 ^ 42 ==================
XOR | 0 1
----±—
0 | 0 1
1 | 1 0
0b00001100 (12)
0b00101010 (42)
0b00100110
38
== Bitwise NOT ~88==================
NOT | 0 1
----±----
| 1 0
0b01011000
-0b1011001
-89
====================

#==

``````== flip_bit(6,2) ==
0b00000110 (6)
0b00011000 ( 6 << 2 ) (24)
============

0b00000110 (6)
== mask = number << n // 0b00000110 << 2
0b00011000 ( 6 << 2 ) (24)
0b00000010 (2)
== mask ^ n // 0b00011000 ^ 0b00000010
XOR | 0 1
----+----
0 | 0 1
1 | 1 0
0b00011000 (24)
0b00000010 (2)
0b00011010  //Result 26
== END flip_bit
``````

#==

``````== flip_bit(7,2) ==
0b00000111 (7)
0b00011100 ( 7 << 2 ) (28)
============

0b00000111 (7)
== mask = number << n // 0b00000111 << 2
0b00011100 ( 7 << 2 ) (28)
0b00000010 (2)
== mask ^ n // 0b00011100 ^ 0b00000010
XOR | 0 1
----+----
0 | 0 1
1 | 1 0
0b00011100 (28)
0b00000010 (2)
0b00011110  //Result 30
== END flip_bit``````
1 Like
``````print "== Right Shift 5 >> 4 =================="
print format(5, '#010b') +" ("+str(5) +")"
print format(5 >> 4, '#010b') +" ("+str(5) +" >> 4 )"
print 5 >> 4  # Right Shift
print "== Left Shift 5 << 1 =================="
print format(5, '#010b') +" ("+str(5) +")"
print format(5 << 1, '#010b') +" ("+str(5) +" << 1 )"
print 5 << 1  # Left Shift
``````

##=
print “== Bitwise AND 8 & 5==================”
print “AND | 0 1 "
print “----±----”
print " 0 | 0 0 "
print " 1 | 0 1 "
print format(5, ‘#010b’) +” ("+str(5) +")"
print format(8, ‘#010b’) +" ("+str(8) +")"
print format(8 & 5, ‘#010b’) # Bitwise AND
##=
print “== Bitwise OR 9 | 4 ==================”

``````print " OR | 0 1"
print "----+-----"
print "  0 | 0 1  "
print "  1 | 1 1  "
print format(9, '#010b') +" ("+str(9) +")"
print format(4, '#010b') +" ("+str(4) +")"
print format(9 | 4, '#010b')
print 9 | 4   # Bitwise OR
print "== Bitwise XOR  12 ^ 42 =================="
``````

##=

``````print "XOR | 0 1"
print "----+----"
print "  0 | 0 1"
print "  1 | 1 0"
print format(12, '#010b') +" ("+str(12) +")"
print format(42, '#010b') +" ("+str(42) +")"
print format(12^42, '#010b')
print 12 ^ 42 # Bitwise XOR
print "== Bitwise NOT ~88=================="
``````

##=

``````print "NOT | 0 1"
print "----+-----"
print "    | 1 0"
print format(88, '#010b')
print format(~88, '#010b')

print ~88     # Bitwise NOT
print "====================\n\n\n"
``````

##=

``````def flip_bit(number,n):
print "== flip_bit(" + str(number) +","+ str(n) + ") =="
print format(number, '#010b')+" ("+str(number)+")"
print format(number << n, '#010b')+\
" ( "+str(number)+" << "+str(n)+" ) ("+\
str(number << n)+")"
print "============\n"
print format(number, '#010b')+" ("+str(number)+")"
print "== mask = number << n // "+format(number, '#010b')+" << "+str(n)
print format(mask, '#010b') +" ( "+str(number)+" << "+str(n)+" )"+\
" ("+ str(number << n)+")"
print format(n, '#010b')+" ("+str(n)+")"
print "== mask ^ n // "+ format(mask, '#010b') + " ^ "+\
format(n, '#010b')
print "XOR | 0 1"
print "----+----"
print "  0 | 0 1"
print "  1 | 1 0"
print format(mask, '#010b') +" ("+ str(number << n)+")"
print format(n, '#010b') +" ("+ str(n)+")"
print format(result, '#010b') +"  //Result "+\
#    return bin(result)
``````

##=
flip_bit(6,2)
print “== END flip_bit \n\n\n”
flip_bit(7,2)
print “== END flip_bit \n\n\n”

1 Like

Thanks for the answer, but can you explain it? I wrote the following code, and I don’t understand why it isn’t correct. Why do you need to subtract 1 from `n`?

``````def flip_bit(number, n):
return bin(result)
``````

Thank you!

2 Likes

‘’’
Let’s say that I want
to turn on the 2th bit from the right of the integer a.

Instead of writing out the entire number,
we slide a bit over using the << operator.

We use 1
because we only need to slide the mask 1 place over
from the first bit to reach the 2nd bit.
‘’’

``````print "== your flip_bit function =="
def flip_bit(number, n):
mask = (0b1 << n)   #you move to the 3th bit
print format(number, '#0010b')
print format(result, '#010b')
print bin(result)
return bin(result)

flip_bit(10,2)
``````

``````def flip_bit(number,n):
mask = (0b1 << (n-1)) #he moves over to the 2nd bit
print format(number, '#010b')
print format(result, '#010b')
print bin(result)
return bin(result)

print "===================="
print "== his  flip_bit function =="
flip_bit(10,2)
``````

[output]

``````== your flip_bit function ==
0b00000100
0b00001010
0b00001110
0b1110
====================
== his  flip_bit function ==
0b00000010
0b00001010
0b00001000
0b1000``````
1 Like

I’m pretty sure I get sliding the bit, but I still don’t understand why you have to subtract 1 from n. Why is the default the 3th position if the argument is n?

1 Like

1 byte is 8 bit

``````  8765 4321 bit-count as number - - - - - -+
0000 0000                                |
7654 3210 bit-count as =shift= <<    (number-1)
``````

``````  8765 4321 bit-count as number - - - ( shift-count + 1)
0000 0000                                |
7654 3210 bit-count as =shift= << - - - -+``````
1 Like

Oh dear. I am actually more confused now 3 Likes

Hi,

In response to your question regarding the position to insert 0b1, think of it sort of as a list. 0b1 = 1 and you want to position it so that it has the same place value as n; that way you can flip with XOR.

But just because you want 0b1 to fall in position n, you can’t discount the fact 0b1 already has a place value of 1. Shifting by n would result in shifting n+1. That is why you subtract 1 (at least that is how I think about it).

3 Likes

So with 0b1, subtracting one shifts the original value over one slot to it’s starting slot… of 1? If this is what you mean, I understand. I really hope this is what you mean, LOL!

the reason for substracting 1 from n is to get the shift position.
take for instance: 0b0001
you want to shift left to bit 3 which should give us 0b0100
all we had to do was move the 1 left two times i.e (n-1) 3-1= 2

3 Likes