据说简单的Python作业

Question

I have a CompSci problem (optional), don't worry, you are not doing my homework :) I am having a rather impossible time understanding this question, as this is all I have to go on. It is in regards to a rather elementary understanding of python.

I have to create a function that satisfies this requirement. I have no idea why there is a 6 in the problem or what it signifies.

"Returns a pair of integers 'root' and 'pwr' st 0 < pwr < 6 and root**pwr = user input. If no pairs of integers satisfy these conditions, the function will notify the user."

Like I said, it's optional, so rather than just get the answer I am hoping for an explanation. Thanks you guys!

Answer 1

You're looking for a value, given a specific root, and a power between 0 and 6 exclusive, that is equivalent to a user's input. An example of that would be an input of 4 == 2**2, hence you'd probably output (2, 2) .

There doesn't appear to be any bounds on root .

Answer 2

This is how I read it:

1. Create a function that accepts a number as an argument (I'm assuming an integer, but that's not clear)

2. find the nth root of that number, where n is one of 1,2,3,4 or 5. Return n and the root.

3. if you can't find a suitable root, display an error.

Answer 3

To get you started:

0 < pwr < 6

… is equivalent to:

(0 < pwr) and (pwr < 6)

This 0 < pwr < 6 notation is pretty common in mathematics, and in a few programming languages (including Python). See Chained notation at Wikipedia for details.

So, for each such power, try to find a root such that root**pwr is the user's input value.

There's a quick way to do this using math.log , but if you don't know what logarithms are, don't worry about that. Instead, you can just try every possible root . If any root is too big, then all larger root s will also be too big.

Except for one problem: What if user_input is negative? So, you'll need to find a way to count all positive and negative numbers, until you find one where the absolute value is too big.

So, a brief sketch in pseudocode:

def find_root_pwr(user_input):
    for every pwr such that 0 < pwr < 6:
        for every possible root:
            test_value = root**pwr
            if it's a match:
                return root, pwr
            elif abs(test_value) is too big:
                break # don't need to check larger roots
    else:
        # We tried all 5 powers, and no match
        raise ValueError('No answer for {}'.format(user_input))

And to test it:

user_input = int(input()) # raw_input if you're on Python 2.x
root, pwr = find_root_pwr(user_input)
print('{} ** {} = {}'.format(root, pwr, user_input))

See range and itertools.count for hints on how to write the loops. You should be able to fill in the details from here, or at least get far enough to have a more specific followup question.

Answer 4

Other answers provided the explanation for the problem description. Here's a possible solution for positive input:

def find_root_power(n, minpower, maxpower):
    for pwr in range(minpower, maxpower + 1):  # minpower <= pwr <= maxpower
        # find root such that root**pwr == n
        f = n ** (1. / pwr)  # float
        root = int(f + 0.5)  # int (per problem statement)
        if root**pwr == n:
           yield root, pwr # multiple solutions are possible

n = int(raw_input("Input a number:"))
for root, pwr in find_root_power(n, minpower=1, maxpower=5):
    print("root: %d pwr: %d" % (root, pwr))

For example, if the user input is 81 ; the output is :

root: 81 pwr: 1
root: 9 pwr: 2
root: 3 pwr: 4

Note: root=n , pwr=1 is always a solution if n is an integer. If user input is not an integer then the code raises ValueError (given the problem description; root**pwr may only be an integer so no solution exists for non-integer input).

Note: if root ** pwr == n then also (-root) ** pwr == n for even pwr . You could add:

  if root**pwr == n:
      yield root, pwr # multiple solutions are possible
      if pwr % 2 == 0: # even
          yield -root, pwr

to include negative root as a solution.