Comment trouver la valeur de l'exposant dans Ruby?

Question

Tenir compte de l'équation ci-dessous:

2 ** n = A

Supposons A = 64.

Quelle est la manière la plus simple de trouver la valeur de n?

J'utilise actuellement selon deux approches

A= 64; n = 1; n+=1 while (A >> n) > 0; n-1 

A= 64; n = 0; n+=1 until (A == (2 ** n));n 

Y at-il une meilleure approche?

Autre façon d'exprimer le même problème:

2 = racine nième A Si je connais la valeur de A, comment puis-je déterminer la valeur de n?

Answer 1

Aucune des réponses ci-dessus est mieux que votre première approche:

A= 64; n = 1; n+=1 while (A >> n) > 0; n-1 

Évaluer Math.log(x) prend beaucoup plus de temps que de faire une douzaine de bits, et vous donnera également une réponse comme 5.99999999999980235 pour donner un sens à.

Voir this SO question pour de meilleures idées.

Answer 2

log n = ln n/ln 2

donc

log_2_64 = Math.log(64)/Math.log(2) 

Answer 3

Essayez ceci:

def exp_value(n) 
    Math.log(n)/Math.log(2) 
end 

Answer 4

Si vous vous intéressez à problems mentioned by mobrule. Que dis-tu de ça? C'est la même chose que votre propre méthode, mais utilisez la fonction intégrée pour communiquer l'idée de façon explicite.

def exp_value a 
     (1..a).to_a.detect {|n| 2**n >=a} 
    end 

    exp_value 64 
    => 6 

Answer 5

La réponse proposée est bonne, mais vous devez compter jusqu'à votre logarithme et il y a un peu plus de manière efficace, si vous savez que le logarithme a une limite supérieure, à savoir si vous savez que vous ne traitez avec des nombres supérieurs à 1 < < liés.

def faster_log2(n) 
    l = 0; bound = 64 
    while bound > 0 
    if 1 <<bound> n 
     n >>= bound; l += bound 
    end 
    bound >>= 1 
    end 
    l 
end 

Si vous ne disposez pas d'une limite supérieure, mais vous voulez continuer à utiliser cet algorithme, vous pouvez également calculer une limite avant d'exécuter l'algorithme, mais si les performances ne sont pas un problème, alors je collerait avec la solution plus courte.

def bound(n) 
    bound = 1; 
    bound >>= 1 while 1 << bound < n 
end