我发现的一本书的问题。
编写一个程序，要求用户输入一个整数并打印两个 整数，根和pwr，使得0 <0。 pwr＆lt; 6和root ** pwr相等 到输入的整数用户。如果不存在这样的对，则打印出来 不可能找到这样一对。
integer = 3 #there will be raw_input but I use it as an example
root = 0
for pwr in range(1,6):
if root**pwr != integer:
pwr += 1
print pwr
else:
print root, pwr
if pwr > 5:
pwr = 1
root += 1
我还没有完成程序，因为我无法正确循环。问题是我收到输出2,3,4,5,6然后循环终止。但是，我确实在你看到的最后一个if语句代码块中使用了pwr变量的重启。但是，无论如何它都会停止执行。这有什么问题？
答案 0 :(得分：4)
正如其他人所说，这是John Guttag的计算和使用Python编程的第3.1节（关于详尽列举）的手指练习，这是大规模开放在线课程的教科书MITx: 6.00.1x Introduction to Computer Science and Programming Using Python。教科书和课程使用 Python 2.7 。
我还没有足够高的声誉来评论其他答案，所以请允许我在我的回答中说明，当我发布这个时，所有以前发布的答案都不正确或不完整< / strong>，据我所见。其他答案中的一个常见错误是它们不考虑所有整数。正确的程序应解决所有整数的问题，包括正整数和负整数以及零（zero is also an integer）。
在Guttag的书中进行此练习之前，我们已经介绍了while循环，但没有介绍for循环和range函数，这两个函数都在下一节。以下是我的回答，仅使用本练习前本书中介绍的概念：
num = int(raw_input("Enter an integer: "))
pwr = 1
root = 0
found = False
if num < 0:
neg = True
else:
neg = False
while pwr < 6:
while abs(root**pwr) <= abs(num):
if root**pwr == num:
print(str(root) + "**" + str(pwr) + " = " + str(num))
found = True
if abs(root) > abs(num):
root = 0
elif neg:
root -= 1
else:
root +=1
pwr += 1
root = 0
if not found:
print("No pair of integers, 'root' and 'pwr', exists such that 0 < pwr < 6 and root**pwr = " + str(num))
我已经使用整数0,1，-1,2，-2,8，-8和其他一些整数测试了这段代码，它似乎可行。
答案 1 :(得分：2)
另一种选择，“简单数学”。
integer = 3
for power in range(1,6):
a = (integer ** (1.0/power))
if math.ceil(a) == a:
print a, power
>> 3.0 1
答案 2 :(得分：2)
通常，修改循环内部循环的内容并不是一个好主意。当您使用pwr来迭代range(1,6)时，没有理由使用root ** pwr == integer。
您的代码尝试做的是测试pwr的连续值root和pwr的固定值，直到root达到6.然后您希望它将一个添加到for root in range(0,integer):
for pwr in range(1,6):
if root ** pwr == integer:
print root, pwr
并重复。这最自然地表达为两个嵌套for循环：
pwr无论如何，这是一种相当昂贵的方式，所以我建议在这里查看其他一些解决方案。但是，你应该记住这一点，因为它是如何使用for循环的一个很好的例子。
要回答关于循环终止原因的问题，你必须考虑python如何处理迭代器。当for循环中的代码块终止时，python将next()设置为迭代器next()方法返回的值（这完全符合您的想法）。当迭代器中没有剩余值时，StopIteration将引发pwr异常，Python将退出循环。关键是Python不会通过每次迭代添加1来修改range(1,6)的值，它会覆盖该值。因此，循环将正好运行5次，因为for i in range(0,9):
print i
i += 5
print i
为了澄清，请运行以下代码：
{{1}}
答案 3 :(得分：1)
正如其他人所提到的，这是来自John Guttag的计算简介和使用Python的程序的手指练习。
虽然上面的一些反应可能有用（说实话，我还没有测试过），但更简单的方法会产生所需的结果并适应负整数，例如：
x = int(input("Enter an integer: "))
root = 0
while root < abs(x):
root += 1
for pwr in range(1,6):
if root ** pwr == abs(x):
if x < 0:
print(-root, "to the power of", pwr, "=", x)
else:
print(root, "to the power of", pwr, "=", x)
答案 4 :(得分：1)
x = int(input('Enter an integer:'))
pwr = [1,2,3,4,5]
mypairs = []
for p in pwr:
root = 0
while root**p < abs(x):
print('Value of decrementing function abs(x) - root**p is',\
abs(x)-root**p)
root = root + 1
if root**p == abs(x) and p%2 !=0:
print('For the power %s there exists such a pair, shown in final list.'%p)
if root**p != abs(x):
print('For the power %s there does not exist any such pairs.'%p)
else:
if x < 0:
if p%2 == 0 :
print('For the power %s there does not exist any such pairs'%p)
else:
root = -root
mypairs.append([root,p])
else:
mypairs.append([root,p])
print(mypairs)
x = int(input('Enter an integer:'))
pwr = [1,2,3,4,5]
mypairs = []
for p in pwr:
root = 0
while root**p < abs(x):
root = root + 1
if root**p != abs(x):
print('For the power %s there does not exist any such pairs.'%p)
else:
if x < 0:
if p%2 == 0 :
print('For the power %s there does not exist any such pairs'%p)
else:
root = -root
mypairs.append([root,p])
else:
mypairs.append([root,p])
print(mypairs)
答案 5 :(得分：1)
我有一个逻辑错误，在试图找出它可能是什么时，我浪费了很多时间，我认为这可能是一个常见的错误。我忘了重置外循环中<?php echo do_shortcode('[wcp-carousel id="37122" order="DESC" orderby="date" count="10"]');?>
的值。
以下是当前版本：
pwr我希望这有助于节省一些时间。
答案 6 :(得分：1)
integer ** 1总是满足条件。
替代方案（假设您实际需要1 < pwr < 6）：
检查某个基数a和数字n：ceil(a ** log_a(n)) == n。如果是这样 - 那么a ** log_a(n)就是你的回答。
对范围内所有可能的a重复。
（在这里log_a(n)是基数为a的对数，可以计算为log(n)/log(a)）
答案 7 :(得分：0)
我认为这个问题已经得到回答，但是希望它可以扩展到当前的工作状态。任何反馈表示赞赏！
我目前正在MIT OpenCourseWare上进行此工作。我想提出一种解决方案，该解决方案将打印给定整数的所有可能的root / pwr组合，同时将详尽的猜测限制在最小数量。这是我的答案：
intNum = int(input("Please enter an integer: "));
neg = False;
if intNum < 0:
neg = True;
root = 0;
pwr = 2;
print("The integer is: ", intNum);
# Will always have at least one root/pwr such that intNum=root and pwr = 1
print ("rootFOUND: ", intNum, " pwrFOUND : ", 1);
while 0 < pwr < 6:
while root**pwr <= abs(intNum):
# print ("root: ", root, " pwr: ", pwr);
if root**pwr == abs(intNum):
if neg and pwr%2 != 0:
print ("rootFOUND: ", -root, " pwrFOUND : ", pwr);
elif not neg:
print ("rootFOUND: ", root, " pwrFOUND : ", pwr);
root += 1;
pwr += 1;
root = 0;
我要考虑的边界是：
思考过程：
通过将初始根值设置为零并在root ** pwr小于输入的整数时递增，可以实现正整数。
通过首先完成负整数，始终检查整数是否为负数。其次，随着根的增加，将根** pwr与整数的绝对值进行比较。最后需要说明的事实是，如果指数是奇数，则负整数只能通过指数语句找到。这是通过检查整数是否为负数和指数是否为奇数来实现的。
零整数检查是通过将初始根设置为零并在中断内部while循环时始终将根重置为零来实现的。
以下是一些输出：
Please enter an integer: -4096
The integer is: -4096
rootFOUND: -4096 pwrFOUND : 1
rootFOUND: -16 pwrFOUND : 3
Please enter an integer: 4096
The integer is: 4096
rootFOUND: 4096 pwrFOUND : 1
rootFOUND: 64 pwrFOUND : 2
rootFOUND: 16 pwrFOUND : 3
rootFOUND: 8 pwrFOUND : 4
Please enter an integer: 0
The integer is: 0
rootFOUND: 0 pwrFOUND : 1
rootFOUND: 0 pwrFOUND : 2
rootFOUND: 0 pwrFOUND : 3
rootFOUND: 0 pwrFOUND : 4
rootFOUND: 0 pwrFOUND : 5
答案 8 :(得分：0)
integer = int(input('Enter an integer: '))
root = 0
ans=0
isTrue=False
while (root < integer):
for pwr in range(1,6):
ans=root**pwr
if ans==integer:
print(root, 'to the power', pwr, '=', ans)
isTrue= True
root = root+1
if isTrue != True:
print('No such pair of integers exists')
答案 9 :(得分：0)
x = int(input("Enter an Integer :"))
root = 1
pwr = 0
while root**pwr != abs(x) and x != 0 :
if pwr == 6 :
pwr = 0
root = root + 1
else :
pwr = pwr + 1
if x > 0 :
print(root,"**",pwr,"==",x)
elif x < 0 :
if pwr%2 == 0 :
print ("no solution")
else :
print(-1*root,"**",pwr,"==",x)
else :
print("no solution")
大家好，我认为将有很多解决问题的方法。目前，我也只是从这本书中学习phyton。
因为这是使用“ while”的迭代部分的问题，所以我认为解决方案也应该使用“ while”。
答案 10 :(得分：0)
以下是最新的答案（2020年6月），该书使用了 Python 3.7.6 ，这是John Guttag撰写的《使用Python计算和编程入门第二版》 。
巨无霸写道
正如其他人所指出的，这是第3.1节（在 详尽的枚举） 使用John Guttag编写的Python，这是大量使用的教材 开放在线课程MITx：6.00.1x计算机科学与技术概论 使用Python进行编程。教科书和课程使用Python 2.7。 ...其他答案的一个常见错误是他们不考虑 所有整数。正确的程序应该可以解决所有问题 整数，包括正整数和负整数以及零 （零也是整数）。
在Guttag的书中进行此练习之前，我们已经介绍了 while循环，但没有for循环，也没有range函数， 在下一节中介绍。
手指练习：编写一个程序，要求用户输入整数
并输出两个整数，即root和pwr，这样0 该解决方案适用于所有整数，使用的是 Python 3 ，并且略短（关于到目前为止在参考书的第二版中获得的知识），并通过为每项功效打印一个答案（甚至在没有这样的对的情况下 ）（根据我的理解）。 它将返回类似的结果x = int(input('Enter an integer to analyze '))
root = 0
pwr = 1
while pwr < 6:
while root**pwr < abs(x):
root += 1
if abs(root**pwr) != abs(x):
print('no root at the power', pwr, 'for', x)
else:
if x < 0:
root = -root
if pwr%2 != 0:
print (root, "**", pwr, '=', x)
else:
print('no root at the power', pwr, 'for', x)
else:
print (root, "**", pwr, '=', x)
root = 0
pwr += 1
Enter an integer to analyze -8
-8 ** 1 = -8
no root at the power 2 for -8
-2 ** 3 = -8
no root at the power 4 for -8
no root at the power 5 for -8
答案 11 :(得分：0)
#instead of asking for input, i input random so you could test faster
#and greater range of integers
input = randint(-10000,10000)
root = 0
power = 1
while root <= abs(input):
if root**power == abs(input):
break
# if power is within bounds, increment, else reset it to 1 and increment
# root to loop through
if power < 6:
power = power + 1
else:
power = 1
root = root + 1
if root**power != abs(input):
print("There are no perfect integers")
else:
if input < 0:
root = -root
print("Root:",root,"; Power:",power)
答案 12 :(得分：0)
这是我通过使用两个while循环而得到的
x = int(input('Enter an integer'))
root = 0
pwr = 0
while(root**pwr < abs(x)):
while(root**pwr < abs(x) and pwr < 6):
pwr += 1
#print('root',root, ' power', pwr, 'result', root**pwr)
if(root**pwr == abs(x)):
if(x<=0):
print('root', -root, 'power', pwr)
else:
print('root', root, 'power', pwr)
break
if(root**pwr == abs(x)):
break
else:
root+=1
pwr = 0
if(root**pwr!=x):
print('no result found')
答案 13 :(得分：0)
这是John Guttag撰写的“使用Python进行计算和编程简介”第3章的手指练习，内容如下：
编写一个程序，要求用户输入一个整数并打印两个整数，root和pwr，这样0＆lt; pwr＆lt; 6和root ** pwr等于用户输入的整数。如果不存在这样的对，它应该打印一条消息。
鉴于作者指出可能没有对存在，我假设pwr的条件应该是1 <1。 pwr＆lt; 6否则总会有一个解（整数** 1）。我的答案仅使用了本书中介绍的概念：
num = int(raw_input('Enter a positive integer: '))
pwr = 2
root = 1
ans = ''
while pwr < 6:
while root**pwr <= num:
if root**pwr == num:
print 'the root is ',root,
print 'the power is ', pwr
ans = True
root += 1
pwr += 1
root = 1
if ans != True:
print'No such pair of integers exist'
答案 14 :(得分：0)
我相信这可能是一个更优雅的解决方案，因为它根据Guttag文本提供了所有可能的根，并且初始化最少，并且仅使用 while循环。请试一试。我相信它适用于所有用例。
我使用根等于整数来打破循环，以便可以在每次迭代时重置功率。这样可以防止while循环过载。 （根==整数与幂等于1的情况相同）
integer = int(input("Enter an integer please: "))
root = 0
pwr = 0
while root**pwr < abs(integer):
root = root + 1
while pwr < 6:
pwr = pwr + 1
if root**pwr == integer:
print("Root:", root, ", Power:", pwr)
if root == integer:
break
pwr = 0
整数输出= 343：
根：7，功率：3
根：343，功率：1
答案 15 :(得分：0)
这是我想出的。如上一篇文章中所述，pwr的范围应该是2-6，因为pwr总是存在一个整数的答案，并且练习表明存在不存在该对的整数。
x = int(input('Enter an integer: '))
root = 0
pwr = 2
while pwr > 1 and pwr < 7:
while root**pwr < x:
root = root + 1
if root**pwr == x:
print(str(root) + '**' + str(pwr), '==', str(x))
break
else:
root = 1
pwr = pwr + 1
else:
print('no such pair exists')
答案 16 :(得分：0)
这是我的答案：
usr = int(raw_input("Enter an integer > "))
paired = False
for pwr in range(1,6):
root = 0
while (usr - root**pwr > 0):
root += 1
if usr == root**pwr:
paired = True
print "root is " + str(root) + " and ",
print "power is " + str(pwr)
break
if paired == False:
print "No pair"
答案 17 :(得分：0)
number = int(raw_input("Enter a number: "))
pwr = 1
root = 2
while root < number:
pwr = 1
while pwr < 6:
if root*pwr == number:
print'Numbers are', (root, pwr)
pwr += 1
root += 1
print('No such numbers')
答案 18 :(得分：0)
我很喜欢Pragu的解决方案但我认为有点改进了。如果找到解决方案的话，我就会停止它，例如在Pragu的解决方案中，你将找到最低值，16将返回2 ^ 3和4 ^ 2这些都是真正的答案。我自己已经把非零零件放进去并用它来解决它，但实际上，正如Pragu那样雄辩地说，我们还没有在书中找到它。这就是我所做的。
# -*- coding: utf-8 -*-
"""
Created on Sat Jan 13 12:03:09 2018
@author: chief
"""
import random #this imports the random function
mysteryNumber = int(input('Please enter a non-zero positive integer: ')) #give me input Seymour!
if mysteryNumber <= 0: #did they give me a non-zero positive integer?
print("that wasn't a non-zero positive integer doofenshmirtz!! I'll fix that for you") #Carl would understand
if mysteryNumber < 0: #make it a positive integer
mysteryNumber = -mysteryNumber
if mysteryNumber == 0: #make it a non zero integer by generating random number
mysteryNumber = random.randint(1,100)
print ('Your number is', mysteryNumber)
root=0 #set the variables or clear the pallet if you will
pwr=1
check=0
while(root**pwr<abs(mysteryNumber)): #first while loop
while(pwr<6) and check == 0: # this and logical stops it at the earliest answer otherwise 16 will give you two answers as will 81
if root**pwr == abs(mysteryNumber): #if then loop checks did you find the answer, if yes then next 2 lines are active, if no then to the else line
check=1
print('The root =',root,'or -'+ str(root),'and Power =',pwr, 'will yield', mysteryNumber)
pwr+=1 #else line, adds 1 to the pwr and moves back to the while statement of while<6
root+=1 #While pwr <6 is done so we go onto the next root
pwr=1 #<--------------Resetting pwr to 1 inside the outer loop
if check!=1: #the first while is done now, if we found an answer this argument returns false and the line below doesn't get executed
print('No rational combination of root and power exists for', mysteryNumber)
答案 19 :(得分：0)
首先，如果我们输入一个整数，例如1024，那么我们有1024 ^ 1 = 1024.所以总会有问题的解决方案：
n = int(input('Enter an integer: '))
pwr = 1
root = 1
found = False
while root <= n:
if root**pwr == n:
print('root =',root, 'pwr =', pwr)
found = True
pwr = pwr + 1
if pwr == 6:
pwr = 1
root = root + 1
if not found:
print('No such pair exist.')
答案 20 :(得分：0)
这是基于archery1234提交的答案。感谢archery1234，我对此很陌生，如果没有这个帮助我就无法开始。我喜欢提供的答案，因为它只使用了本书中解释的概念，因此我觉得它与Guttag博士可能希望我们学习的内容很接近（而在while循环中循环）。以下代码满足0＆lt; pwr＆lt; 6并不总是只是以作为根输入的整数终止，而pwr = 1。
integer = abs(int(raw_input("Enter an integer: ")))
pwr = 1
root = 2
ans = ' '
if abs(integer) == 1:
print "No such pair of integers exists"
else:
while root < abs(integer):
while root**pwr <= integer:
if root**pwr == integer:
print "The root is ",root,";"
print "The power is ",pwr,"."
ans = True
pwr += 1
root += 1
pwr = 1
if ans != True:
print "No such pair of integers exist"
答案 21 :(得分：0)
我正在自学python，我的解决方案正在跟随。
num = int(input('Please enter integer: '))
list= []
list1=[]
for root in range (0,num):
for pwr in range (1,6):
if root**pwr == num:
list.append([root,pwr])
else:
list1.append(0)
if list ==[]:
print ('No root exist')
else:
print (list)
我创建了列表以保存其中的所有根和pwrs。
答案 22 :(得分：0)
尝试这样做而不重新考虑手指练习的规格，只使用到目前为止介绍的书 - 这适用于正整数和负整数，并且据我所知，它将列出所有可能的对，包括root = number，pwr = 1。其中一个关键似乎是在正确的位置使用abs，并确保在用户整数为负数时将root设置为负数。希望这有助于像所有其他有思想的贡献一样帮助我。
num = int(raw_input('Enter an integer: '))
pwr = 1
root = 1
ans = ''
while pwr < 6:
while root**pwr <= abs(num):
if root**pwr == abs(num):
if num<0:
root=-root
print 'the root is ',root, 'the power is ', pwr
ans = True
root= abs(root)+1
pwr += 1
root = 1
if ans != True:
print'No such pair of integers exist'
答案 23 :(得分：0)
我正在解决这个问题，我的回答有效：
number = int(raw_input("Enter a number: "))
i = 1
pwr = 1
test = 0
while i <= number/2:
while pwr < 6:
if i ** pwr == number:
print i
test = 1
pwr = pwr + 1
i = i + 1
pwr = 1
if test == 0:
print 'No such pair of integers exist.'
答案 24 :(得分：0)
我已经设法用你在第1章中获得的知识解决了这个问题，直到Gattug的书中的3.1。这次手指练习花了我两个星期的时间。我也刚刚开始编码。
这是我的解决方案：
num = int(raw_input('Enter an integer: '))
root = num
power = 1
if root**power == abs(num):
print ' First pair of integers which equal the integer:', num, 'is root = ', root, 'power = ', power
root -= 1
while root**power != abs(num) and root > 0:
while power < 6 and root**power != abs(num):
if not(root**power == abs(num)):
power +=1
if not(root**power == abs(num)):
power +=1
if power >= 6 and root**power != abs(num):
power = 1
root -= 1
if root**power == abs(num):
print 'Second pair of integers which equal the integer:', num, 'is root = ', root, 'power = ', power
elif root**power != abs(num) and root == 0:
print ' there is no other pair of integers that equal', num
我已经完成了它，这是教你编写代码的最佳书籍