# 8. A BIT of This OR That - Alternative Solution!

<Below this line, add a link to the exact exercise that you are stuck at.>
<In what way does your code behave incorrectly? Include ALL error messages.>

<What do you expect to happen instead?>

Nothing wrong with my code (that i know of), but the instructions sort of offers you the challenge of doing this operation outside of the built in bitwise function OR. I wanted to test what I had learned, so I spent the better part of an hour figuring out how to make this work. I would love to hear feedback on how I could have done this better.

Also, Hi All! This website is awesome!

EDIT:: so i apparently misunderstood the instructions when it said â€śtry to do this on your ownâ€ť. Lol, i had fun doing it anyways.

```python

#print bin(14 | 5) # commented out for the following code to be able to fail if i get it wrong

fourteen = â€ś1110â€ť
five = â€ś101â€ť

combined = [fourteen, five]

def bitwise_OR(fourteen, five):
one = â€ś1â€ť
together =
different_length = abs(len(five) - len(fourteen))
final = â€śâ€ť

``````if len(fourteen) > len(five):
for i in fourteen:
together.append("0")
five = ("0" * different_length) + five
elif len(five) > len(fourteen):
for i in five:
together.append("0")
fourteen = ("0" * different_length) + fourteen

for i, c in enumerate(five):
if c == one:
together[i] = c
for i, c in enumerate(fourteen):
if c == one:
together[i] = c
final = "0b" + final.join(together)
return final
``````

print bitwise_OR(fourteen, five)

``<do not remove the three backticks above>``
6 Likes

I interpreted those instructions to mean â€śDo it in your headâ€ť or â€śUse a pen and paper to figure it outâ€ť. The purpose being to get your head fully wrapped around the concept of bitwise operations.

1 Like

Hey! I am trying to understand this. Here is my interpretation:

For the given pair of numbers, you will (1) check to see which is larger in length; (2) for the larger number, you will create a list of â€ś0â€ť for each digit of the number. (3) then you will add â€ś0â€ť before the shorter number, as many times as the difference between the two lengths.
Next, (4) for every digit in both numbers, if a digit is to equal â€ś1â€ť, then change the equivalent digit in the created list to 1. (5) Lastly, convert the final list into binary by adding â€ś0bâ€ť followed by each number in the list.

Great stuff! Writing out each step helped me understand it too Let me know if I was off the mark at all.

Hey all! I think you can just build the final list as you compare the values of the two binary numbers rather than building the final list with 0â€™s first and then replacing them with 1â€™s as you do the comparison. Here is how I did it with a bit less of code and for any two binary numbers input by the user, but itâ€™s essentially the same.

``````def bitwise_or(num1, num2):
``````
``````    final_list = []
difference = abs(len(num1)-len(num2))
``````
``````    if len(num1) >= len(num2):
num2 = '0' * difference + num2
else:
num1 = '0' * difference + num1
``````
``````    num2_list = list(num2)
num1_list = list(num1)
``````
``````    for i in range(len(num1_list)):
if num1_list[i] == '1' or num2_list[i] == '1':
final_list.append('1')
else:
final_list.append('0')
``````
``````    print '0b' + ''.join(final_list)
``````
``bitwise_or(raw_input('Please enter the first binary # here: '), raw_input('Please enter the second binary # here: '))``
1 Like

Hi I am pretty new here! Been on codecademy less than 2 weeks, and this is my first post in a forum. Hoping to revive this old conversationâ€¦

My solution seems pretty similar in approach to the above. I just wondered how it compares.

Mine takes in num1 and num2 as strings with the prefix â€ś0bâ€ť.

Is it better to build the result as you go (like in the final_list of @kenfucius) than to have a working result whose digits you change as you compare the two inputs?

``````def thisorthat(num1, num2):
a = list(num1)[2:]
b = list(num2)[2:]

if len(b) <= len(a):
shorter = list(b)
longer = list(a)
else:
shorter = a
longer = b

s = len(shorter)
l = len(longer)

aorb = longer

for i in range(s):
if shorter[s-1-i] == "1":
aorb[l-1-i] = "1"
return "0b" + "".join(aorb)``````

My solution seems a little comlex to the above but similar
Hereâ€™s it:

``````
def bitor(a,b):
stra = str(a)[2:]
strb = str(b)[2:]
if len(stra) > len(strb):
strb = '0'*(len(stra)-len(strb))+strb
elif len(strb) > len(stra):
stra = '0'*(len(strb)-len(stra))+stra
aorb = ''
for i in range(len(stra)):
if stra[i] == '0' and strb[i] == '0':
aorb += '0'
else:
aorb += '1'
return bin(int(aorb,2))

a = bin(int(raw_input("First number:")))
b = bin(int(raw_input("Second number:")))
print bitor(a, b)
``````

this is my solution: itâ€™s probably not optimal, but it works. what do you think? Itâ€™s actually printing a binary, not just a string that looks like one. some of the solutions above are doing that. not sure if that counts or not.

``````def counting_bits(a,b):
a = '{:b}'.format(a)
b = '{:b}'.format(b)
a = a.zfill(len(b))
b = b.zfill(len(a))
ans = ['1' if a[i] != b[i] else '0' for i in range(len(a))]
ans = '0b' + ''.join(ans)
ans = int(ans, 2)
return bin(ans)
print counting_bits(0b1110,0b101)
``````

This is my alternative solution:

``````def bitwise_or(num1, num2):
str_bits = ""
while (num1 != 0 or num2 != 0):
value = 0x1 if (num1 & 0x1) == 0x1 or (num2 & 0x1) == 0x1 else 0x0
str_bits = str(value) + str_bits
num1 >>= 1
num2 >>= 1
return "0b" + str_bits

print bitwise_or(0b1110, 0b101)
``````