averiguar si a es una potencia de b

Question

Actualmente estoy usando singpath.com a practicar en mi pitón, pero se enfrentan a un problema con un problema:

un número, una, es una potencia de b si es divisible por by a/b es un poder de b. Escribe una función llamada is_power que toma los parámetros a y b y devuelve True si a es una potencia de b.

def is_power(a,b): 
    c = a/b 
    if (((a%b) == 0) and ((c%b) == 0)): 
     return True 
    else: 
     return False 

Above es mi solución pero el sistema me pide que generalice mi solución. ¿Alguien puede decirme qué pasa con mi solución?

Answer 1

No diría que lo generalice. Diría que lo corrija, ya que es incorrecto. Usando su solución is_power (12,2) devuelve True como lo hace is_power (18,3).

Creo que la razón por la que el sistema dice que es generalizar es que probablemente funcione correctamente para algunos de sus casos de prueba, pero no para otros. Es probable que los casos de prueba para los que está funcionando coincidan con aquellos para los que funcionaría si estuvieran codificados de una determinada manera (solo comprobando potencias de 2, por ejemplo).

Answer 2

Usted solo está revisando las primeras dos potencias: a divide b y a/b divide b. Podría ser que a = b ** 3 o b ** 4 (o b ** n en general), por lo que la solución real deberá incluir la recursión o un ciclo.

Answer 3

Estás mirando si a/b es divisible por b (en la expresión (c%b) == 0), en lugar de si a/b es una potencia de b. Sugerencia: ¿Qué función llamaría para ver si algo es una potencia de b?

Answer 4

Para comprender la recursión, primero necesita comprender la recursión.

def is_power(a, b): 
    if a < b: # 3 is never a power of 10, right? 
     return False # prevent recursion 
    if a == b: # a is always a**1, right? 
     return True # prevent recursion 
    else: 
     return is_power(a/b, b) # recursion! 

Tenga en cuenta que para los enteros a/b le dará errores de redondeo. Asegúrate de pasar flotadores.

Answer 5

No creo que tenga la implementación correcta. Con base en el problema, la función is_power debería ser algo como esto:

def is_power(a,b): 
    if a%b == 0 and is_power(float(a)/float(b), b): 
     return True 
    else: 
     return False 

Answer 6

La razón por lo cual su código original no funciona es la siguiente: Usted acaba de comprobar (c%b) == 0) aka (a/b) is divisible by b, que es mucho más débil que la parte a/b is a power of b de la definición.

Cuando desee resolver un problema como este, siempre debe comenzar con casos triviales. En este caso, hay dos casos: is_power(x,x) y is_power(1,x) - en ambos la respuesta es True, porque x**1==x y x**0==1.

Una vez que tenga estos casos cubiertos solo necesita escribir el resto de la definición. Escriba el código para (a is divisible by b) and (a/b is a power of b) y póngalo todo junto.

La función final se verá así:

def is_power(a,b): 
    if <trivial case 1> or <trivial case 2>: 
     return True 
    # its a recursive definition so you have to use `is_power` here 
    return <a is divisible by b> and <a/b is a power of b> 

La única pregunta que queda es cómo responder <a/b is a power of b>. La forma más fácil de hacerlo es usar la función is_power en sí misma; esto se denomina recursividad.

Answer 7

Puede usar el registro.

import math 

def is_power(a, b): 
    return math.log(a, b) % 1 == 0 

Answer 8

def is_power(a,b): 
    if a == b: 
     return True 
    if a % b == 0 and is_power(a/b,b): 
     return True 
    return False 

La condición final que es a == b es crucial aquí que se detiene cuando ambos números son iguales. Si esto no está incluido, la función podría mostrar False incluso para números legítimos al dividir a/b en la siguiente iteración, que da 1 donde 1% b = 1 que a su vez devuelve False en lugar de True.

Answer 9

que está respondiendo a la primera restricción, pero no a la segunda,
comprobar para ver que (a/b)%b == 0 que es un caso especial de "(a/b) is a power of b". para ello el error de generalización (trato de pensar en generalizar ese caso específico

Lo que escriba no es una solución a is power of por ejemplo, podrá indicar 12 como una potencia de 2 desde:.

• 12%2 = 0,
• (12/2)%2 = 0

Pero eso es claramente erróneo.

Como han dicho otros, piense en la recursión (o la solución de bucle menos preferible).

Answer 10

Yo mismo estaba trabajando en esta pregunta, y esto es lo que se me ocurrió.

Para escribir esto como una función recursiva, necesita la parte recursiva y la parte trivial. Para la parte recursiva, un número es el poder de otro número si:

((a%b)==0) and (is_power(a/b, b) # a is evenly divisible by b and a/b is also a power of b. 

para el caso trivial, b es una potencia de a si a=b.

Sin embargo, no hemos terminado. Debido a que estamos dividiendo por b, debemos hacer una excepción cuando b es zero.

Y la otra excepción es cuando b = 1. Dado que cuando b=1, a/b es a, terminaremos con recursión infinita.

lo tanto, poner todo junto:

def is_power(a,b): 
    # trivial case 
    if (a==b): return True 

    # Exception Handling 
    if (b==0) or (b==1): return False # unless a==b==0 or a==b==1, which are handled by the trivial case above 

    # recursive case 
    return ((a%b)==0) and (is_power(a/b,b)) 

Answer 11

Este ejemplo debería solucionar su problema:

def is_power(a,b): 
if a == 1: 
    return True 
elif a%b == 0 and is_power(a/b, b) == True: 
    return True 
else: 
    return False 

Answer 12

Aquí está mi solución.

def is_power(a,b): 
if a == 1: # base case for recursion 
    return True 
elif b == 0 or a%b !=0 or a<b: # exception cases. 
    return False 
return is_power(a//b,b) # recursion 

I probado con varios casos (16,2), (6,2), (1,2), (0,0), (0,1) y funciona bien.

Answer 13

Una solución mucho más simple es:

def is_power(a, b): 
    while a % b == 0: 
     a //= b 
    return a == 1 

recursividad realmente no es necesario para este problema. Además, la recusión puede causar un error de límite de recursión si a = b ** 1001.