Question

The lesson asked you to create a new PythonAnywhere file with the following code:

decimalNum = int(input("Please enter a decimal number: "))
binaryList = []
while decimalNum > 0:
decimalNum = decimalNum / 2
remainder = decimalNum % 2
binaryList.append(remainder)
print(binaryList)

What is the result of running this code and entering 24 as your number?

(1 point)
Responses

[0, 0, 0, 1, 1]
[0, 0, 0, 1, 1]

A huge list of decimal values.
A huge list of decimal values.

24
24

0011 0000
0011 0000
Question 2
The lesson then has you change the code to look like this.

decimalNum = int(input("Please enter a decimal number: "))
binaryList = []
while decimalNum > 0:
remainder = decimalNum % 2
decimalNum = decimalNum // 2
binaryList.append(remainder)
print(binaryList)

What is printed to the console now when running the code and entering 24?

(1 point)
Responses

A huge list of decimal values.
A huge list of decimal values.

[0, 0, 0, 1, 1]
[0, 0, 0, 1, 1]

0001 1000
0001 1000

24
24
Question 3
Using the lesson and the code from the last two questions, what is the binary byte that represents 24?(1 point)
Responses

0000 0011
0000 0011

0001 1000
0001 1000

1100 0000
1100 0000

0010 0010
0010 0010

Answer 1

Let's break down the questions one by one:

### Question 1
You are given the following code snippet:
```python
decimalNum = int(input("Please enter a decimal number: "))
binaryList = []
while decimalNum > 0:
decimalNum = decimalNum / 2
remainder = decimalNum % 2
binaryList.append(remainder)
print(binaryList)
```
If you enter `24`, let's analyze what happens:

1. `decimalNum` starts as `24`.
2. In the first loop iteration:
- `decimalNum` becomes `12.0` (after division)
- `remainder` is `0.0` (since `12 % 2 = 0`)
- `binaryList` becomes `[0.0]`.
3. In the second iteration:
- `decimalNum` becomes `6.0`.
- `remainder` is `0.0`.
- `binaryList` becomes `[0.0, 0.0]`.
4. In the third iteration:
- `decimalNum` becomes `3.0`.
- `remainder` is `1.0`.
- `binaryList` becomes `[0.0, 0.0, 1.0]`.
5. In the fourth iteration:
- `decimalNum` becomes `1.5`.
- `remainder` is `0.5`.
- `binaryList` becomes `[0.0, 0.0, 1.0, 0.5]`.
6. In the fifth iteration:
- `decimalNum` becomes `0.75`.
- `remainder` is `0.25`.
- `binaryList` becomes `[0.0, 0.0, 1.0, 0.5, 0.25]`.

The loop stops when `decimalNum` is no longer greater than `0`.
So, `binaryList` ends up being `[0.0, 0.0, 1.0, 0.5, 0.25]` (which is not expected).

**Correct Output for Q1:** A huge list of decimal values.

### Question 2
Now the modified code:
```python
decimalNum = int(input("Please enter a decimal number: "))
binaryList = []
while decimalNum > 0:
remainder = decimalNum % 2
decimalNum = decimalNum // 2
binaryList.append(remainder)
print(binaryList)
```
Running the code with `24` gives us:

1. `decimalNum` starts as `24`.
2. In the iterations:
- Remainder when `24 % 2` is `0`. `decimalNum` is `12`.
- Remainder when `12 % 2` is `0`. `decimalNum` is `6`.
- Remainder when `6 % 2` is `0`. `decimalNum` is `3`.
- Remainder when `3 % 2` is `1`. `decimalNum` is `1`.
- Remainder when `1 % 2` is `1`. `decimalNum` becomes `0`.

Finally, the `binaryList` is `[0, 0, 0, 1, 1]`.

**Correct Output for Q2:** [0, 0, 0, 1, 1]

### Question 3
The binary representation of 24 (from the `binaryList`) is then reversed (since the least significant bit comes first in the list) to yield `0001 1000`.

**Correct Output for Q3:** 0001 1000

So the answers to the questions are:
1. A huge list of decimal values.
2. [0, 0, 0, 1, 1]
3. 0001 1000