Par, ímpar, MDC, MMC e digits em Ruby

Dicas - 15/Jun/2020 - por Luis Arantes

Neste artigo serão abordados alguns métodos nativos da classe Integer do Ruby. São métodos que abstraem alguns cálculos aritméticos que costumamos fazer em nossos códigos no dia a dia. O Ruby já deixa alguns métodos prontos para que não tenhamos que nos preocupar com isso e possamos focar nas demais partes do código. Com isso, alguns trechos ficam mais enxutos e, consequentemente, o código como um todo fica mais legível e mais orientado para os problemas que queremos de fato solucionar.

O criador da linguagem, Yukihiro Matsumoto (ou Matz), disse em 2019 que "o Ruby é desenhado para humanos, não para máquinas" ("Ruby is designed for humans, not machines"). É com base nessa filosofia que a linguagem nos fornece métodos como os descritos a seguir.

even? e odd?

São métodos que permitem avaliar rapidamente se um número é par ("even") ou ímpar ("odd").

42.even?
# => true
101.even?
# => false

23.odd?
# => true
72.odd?
# => false

# num trecho onde escreveríamos assim
do_something if number % 2 == 0

# simplesmente podemos escrever assim
do_something if number.even?

# fica bem fácil de ler, não é? =)

gcd, lcm e gcdlcm

Os nomes dos métodos lcm e gcd são, respectivamente, abreviações para least common multiple e greatest common divisor, os famosos mínimo múltiplo comum e máximo divisor comum que aprendemos na época da escola. Basta chamar o método em um número inteiro e passar outro número como parâmetro.

Já o método gcdlcm faz os dois cálculos ao mesmo tempo, retornando um array contendo os resultados de gcd e lcm.

# maximo divisor comum (MDC)
72.gcd(40)
# => 8
1740.gcd(120)
# => 60

# minimo multiplo comum (MMC)
3.lcm(7)
# => 21
44.lcm(32)
# => 352

# MDC e MMC em conjunto
12.gcdlcm(20)
# => [4, 60]

É possível combinar o lcm e o gcd com o método inject/reduce e o syntatic sugar do Ruby para fazer estes cálculos com mais de dois números:

# MDC de quatro números
[40, 60, 80, 200].inject(:gcd)
# => 20

# MMC de cinco números
(2..6).reduce(:lcm)
# => 60

pred, next, succ

Estes métodos servem para retornar o número predecessor (pred) e número sucessor (succ ou next) ao número que invocá-los.

my_number = 10
# => 10
my_number.pred
# => 9
my_number.succ
# => 11
my_number.next # faz a mesma coisa que .succ
# => 11

digits

Este método "desmonta" o número e retorna um array contendo seus algarismos ordenados ao contrário e acompanhando os pesos da base numérica - a partir do dígito da unidade, seguindo para dezena, centena, etc. Utiliza a base decimal como padrão, mas pode ser informada outra base numérica como parâmetro.

É um método útil para momentos em que precisamos tratar um número por meio de suas casas decimais, ou para momentos de conversão para outras bases numéricas.

# base decimal é a padrão
4567.digits
=> [7, 6, 5, 4]

# utilizando a base binária
256.digits(2)
=> [0, 0, 0, 0, 0, 0, 0, 0, 1]
Foto de perfil do autor
Luis Arantes

Dev na Rebase

Desenvolvedor Ruby que gosta de falar sobre código, videogames e bandas de heavy metal obscuras