Comment puis-je déterminer la longueur d'un Fixnum en Ruby?

Dans le script que je suis en train d'écrire, je veux trouver la longueur d'un Fixnum en Ruby. Je pourrais faire <num>.to_s.length, mais est-il possible de directement trouver la longueur d'un Fixnum sans la convertir en une Chaîne de caractères?

Quelle est la durée d'un Fixnum"? Dans quelle représentation?
Combien de chiffres sont en elle.

OriginalL'auteur Orcris | 2012-12-22

24
```
puts Math.log10(1234).to_i + 1 # => 4
```
Vous pourriez ajouter à Fixnum comme ceci:
```
class Fixnum
  def num_digits
    Math.log10(self).to_i + 1
  end
end

puts 1234.num_digits # => 4
```
Chaque fois que j'ai le profil quelque chose, je reçois une surprise. En IRM 1.9.3, n.to_s.length est plus rapide pour tout entier représenté par un Fixnum. Un beaucoup le plus rapide: Sur ma boîte, n.to_s.length prend quelque part entre un tiers et la moitié du temps du logarithme de la méthode, en fonction de la longueur de la nombre. Si le nombre doit être représentée d'une Bignum, alors le logarithme de la méthode commence à gagner. Les deux méthodes sont très rapides, même si, à environ .6 millisecondes (pour le logarithme de la méthode), et entre 0,2 et 0,3 millisecondes (pour la méthode de chaîne).
Sonne comme Math.log10 doit avoir plutôt inefficace, la mise en œuvre. J'ai juste essayé une méthode simple, qui marche sur une table de toutes les puissances de 10 qui s'inscrivent dans 32/64 bits, et un >= comparaison pour chacun, c'était un contact plus rapide que Math.log10, mais encore plus lente que to_s. Il pourrait être fait plus rapidement en "déroulant" une recherche binaire de la même table, tout comme le déroulement d'une boucle (le tableau ne serait pas nécessaire, pas plus, le même nombre pourraient être codées en dur dans une série de conditions).
Watch out. Cela génère une erreur non des nombres positifs.
oui, j'ai remarqué. L'appel de .abs a entraîné un avertissement (lors de l'exécution avec ruby -w) que je n'ai pas compris ni pris en charge. J'ai pensé à une erreur était toujours mieux qu'un mauvais résultat de la to_s.size idée.
Avertissement: Ceci permet de diviser par 0.

OriginalL'auteur steenslag
9

Ruby 2.4 a une Entier#chiffres méthode qui retourne un Tableau contenant les chiffres.
```
num = 123456
num.digits
# => [6, 5, 4, 3, 2, 1] 
num.digits.count
# => 6 
```
EDIT:

De gérer les nombres négatifs (merci @MatzFan), l'utilisation de la valeur absolue. Entier#abs
```
-123456.abs.digits
# => [6, 5, 4, 3, 2, 1]
```
..si c'est un Entier positif, sinon Math::DomainError. Tellement plus Ruby si
vérifier mes repères pourquoi vous devriez pas utiliser .digits à grande échelle de cas d'utilisation

OriginalL'auteur Santhosh
4

Bien que le haut-voté boucle est gentil, il n'est pas très Rubis et sera lente pour un grand nombre, l' .to_s est une fonction intégrée et donc sera beaucoup plus rapide. PRESQUE universellement fonctions intégrées sera beaucoup plus rapide que construit des boucles ou des itérateurs.

OriginalL'auteur holzru

Note pour Ruby 2.4+

J'ai couru quelques repères sur les différentes solutions, et Math.log10(x).to_i + 1 est en fait beaucoup plus vite que x.to_s.length. Le commentaire de @Wayne Conrad est pas à jour. Le nouvelle solution avec chiffres.count n'est pas au top, loin derrière, surtout avec un plus grand nombre:

with_10_digits = 2_040_240_420

print Benchmark.measure { 1_000_000.times { Math.log10(with_10_digits).to_i + 1 } }
# => 0.100000   0.000000   0.100000 (  0.109846)
print Benchmark.measure { 1_000_000.times { with_10_digits.to_s.length } }
# => 0.360000   0.000000   0.360000 (  0.362604)
print Benchmark.measure { 1_000_000.times { with_10_digits.digits.count } }
# => 0.690000   0.020000   0.710000 (  0.717554)

with_42_digits = 750_325_442_042_020_572_057_420_745_037_450_237_570_322

print Benchmark.measure { 1_000_000.times { Math.log10(with_42_digits).to_i + 1 } }
# => 0.140000   0.000000   0.140000 (  0.142757)
print Benchmark.measure { 1_000_000.times { with_42_digits.to_s.length } }
# => 1.180000   0.000000   1.180000 (  1.186603)
print Benchmark.measure { 1_000_000.times { with_42_digits.digits.count } }
# => 8.480000   0.040000   8.520000 (  8.577174)

OriginalL'auteur davegson

D'une autre manière:

def ndigits(n)
  n=n.abs
  (1..1.0/0).each { |i| return i if (n /= 10).zero? }
end

ndigits(1234) # => 4
ndigits(0)    # => 1
ndigits(-123) # => 3

OriginalL'auteur Cary Swoveland

Si vous ne voulez pas utiliser les regex, vous pouvez utiliser cette méthode:

def self.is_number(string_to_test)
is_number = false
# use to_f to handle float value and to_i for int
string_to_compare = string_to_test.to_i.to_s
string_to_compare_handle_end = string_to_test.to_i

# string has to be the same
if(string_to_compare == string_to_test)
  is_number = true
end
# length for fixnum in ruby
size = Math.log10(string_to_compare_handle_end).to_i + 1
# size has to be the same
if(size != string_to_test.length)
  is_number = false
end
is_number
end

OriginalL'auteur CHABANON Julien

Vous devez vous connecter pour publier un commentaire.