问题求助
# Q1---
## Learning objective
* Experience that the same problem can be solved by iteration and recursion
* Practice using recursion to solve a problem
---
## Instructions
We revisit the problem set 2 Q2 for which we convert an integer from the decimal representation to its 32-bit binary representation.
1. In (src/binary.py), define:
* A function `to_32_bit_binary()` to take an `int` (in the decimal representation, >= 0 and <= 4294967295) as the argument and return the corresponding 32-bit binary representation (`str` with length 32)
* Another function `to_decimal()` to take a 32-bit binary representation (`str` with length 32) as the argument and returns the corresponding decimal representation (`int`)
For both functions, you _must_ use recursion. No `for` loops or `while` loops are allowed.
**Note**
* Unlike problem set Q2 which requires the program to ask users for input and printout the results, here you are required to define the function `to_32_bit_binary()` that takes an `int` as an _argument_ and _returns_ a _str_
* You should not use `input()` or `print()` in your answer
* If you are not sure how to write a function definition that takes "arguments" and "returns" some value, please have a look at the problem set 3 solution when it is available
* Remember to include an _abstract_ function docstring inside the function definition
2. Ensure your function works as intended by calling the functions with different arguments (like the ones in the `Examples` section). Please note down at least 3 function calls that you have tried for each function, their expected return values, and the actual return values. You should consider different cases, for example, when the value is very big, very small, etc.
* For `to_32_bit_binary()`:
* Function calls that you have tried: _________________
* Expected return values: _________________
* Actual return values: _________________
* For `to_decimal()`:
* Function calls that you have tried: _________________
* Expected return values: _________________
* Actual return values: _________________
**Note**
* When submitting the `binary.py`, it should only contain the function definitions of `to_32_bit_binary()` and `to_decimal()`
* Please remove any function calls you tried from the `binary.py` file before you submit your work
---
## Function argument assumptions
Assume the argument provided is always valid, i.e.:
* For `to_32_bit_binary()`, the argument provided is always an `int` with values in the range
* For `to_decimal()`, the argument provided is always a string that only contains `'0'` or `'1'` with length 32
---
## Example
Example function calls on the required function `to_32_bit_binary()`:
```
>>> to_32_bit_binary(0)
'00000000000000000000000000000000'
>>> to_32_bit_binary(123)
'00000000000000000000000001111011'
>>> to_32_bit_binary(4294967295)
'11111111111111111111111111111111'
```
Example function calls on the required function `to_decimal()`:
```
>>> to_decimal('00000000000000000000000000000000')
0
>>> to_decimal('00000000000000000000000001111011')
123
>>> to_decimal('11111111111111111111111111111111')
4294967295
```
---
## Note
* Unlike problem set 2, you can use `list`, slicing, indexing, and anything else we have seen so far in the course
* This question is a modified version of a question from the 2020/21 ST101 summative problem set It seems like you are seeking help with a programming problem related to recursion. Unfortunately, I cannot directly execute or evaluate code. However, I can provide guidance and suggestions to help you solve the problem.
The task you described requires implementing two functions: to_32_bit_binary() and to_decimal(). Both functions should use recursion to convert between decimal and binary representations. Here's an outline of how you can approach this problem:
1. Implement the to_32_bit_binary() function:
· Base case: If the input number is 0, return a string of 32 zeros.
· Recursive case: Divide the input number by 2 and recursively call to_32_bit_binary() on the quotient. Append the remainder (0 or 1) to the result obtained from the recursive call. Make sure the resulting binary string has a length of 32 by padding zeros if necessary.
2. Implement the to_decimal() function:
· Base case: If the input binary string is empty, return 0.
· Recursive case: Take the most significant bit (leftmost) of the binary string and convert it to an integer. Multiply it by 2 raised to the power of the current position (0-based indexing). Recursively call to_decimal() on the remaining binary string (without the most significant bit) and add the result to the calculated value.
Remember to test your functions with various inputs to ensure they work correctly. For example, you can try converting small numbers, large numbers, and edge cases to validate their behavior.
If you encounter specific issues while implementing the solution, feel free to ask for further assistance.
请注意，本回答来自GPT-4
如果问题已经解决，请设置最佳答案 首先，我们需要定义一个函数 to_32_bit_binary() ，该函数将一个十进制表示的整数作为参数，并返回相应的32位二进制表示（长度为32的字符串）。我们需要使用递归来实现这个函数。
def to_32_bit_binary(num):
if num == 0:
return '0' * 32
elif num == 1:
return '0' * 31 + '1'
else:
return to_32_bit_binary(num // 2) + str(num % 2)
这个函数的思路是，当 num 为0时，返回一个长度为32的全0字符串；当 num 为1时，返回一个长度为31的全0字符串加上一个1；对于其他情况，我们可以将 num 除以2并向下取整，然后将结果递归地转换为32位二进制表示，并将 num 对2取余数作为最后一位。
接下来，我们需要定义另一个函数 to_decimal() ，该函数将一个长度为32的二进制表示（由字符串表示）作为参数，并返回相应的十进制表示（整数）。
def to_decimal(binary):
if binary == '0' * 32:
return 0
else:
return 2 * to_decimal(binary[:-1]) + int(binary[-1])
这个函数的思路是，当 binary 全为0时，返回0；对于其他情况，我们可以将 binary 去掉最后一位，并将结果递归地转换为十进制表示，然后将结果乘以2并加上 binary 的最后一位。
我们可以通过调用这两个函数并传入不同的参数来验证它们的正确性。
# 对于 to_32_bit_binary() 函数的测试
print(to_32_bit_binary(0))# 预期结果：'00000000000000000000000000000000'
print(to_32_bit_binary(123))# 预期结果：'00000000000000000000000001111011'
print(to_32_bit_binary(4294967295))# 预期结果：'11111111111111111111111111111111'
# 对于 to_decimal() 函数的测试
print(to_decimal('00000000000000000000000000000000'))# 预期结果：0
print(to_decimal('00000000000000000000000001111011'))# 预期结果：123
print(to_decimal('11111111111111111111111111111111'))# 预期结果：4294967295
以上代码中的测试结果应该与预期结果相符。
页:
[1]