Le carnet de Théo & Julien

Les bases

Retrouvez notre page dédiées aux bases du golfing en Ruby ici →

Les bases du golfing en Ruby

Récup l’input

Utiliser dd plutôt que gets peut permettre de gagner un espace quand il n’y a qu’un seul input

(équivalent à $stdin.read)

puts gets
# vs
puts`dd`

n=gets.to_i
#vs
n=eval`dd`

On peut aussi utiliser sed pour ne prendre que la deuxième ligne

puts`sed 1d`
# vs
gets
puts gets

On peut mapper toute l’entrée en même temps avec $<

a,b,c=$<.map &:to_i
# vs
n=gets.to_i
a=gets.to_i
b=gets.to_i

Utiliser l’étoile pour utiliser directement $<

a,b,c=*$<
#vs
a,b,c = $<.map{_1}

Faire un gets peut permettre de supprimer le premier élément de $<

gets
d=$<.map &:chars
# vs
d=$<.map(&:chars)[1..]

$_ stocke la dernière ligne lue, on peut donc ne pas l’assigner

n=gets.to_i
puts (1..10).map{n*_1}
# vs
gets
puts (1..10).map{$_.to_i*_1}

Comment print

Utiliser p pour print les entiers et les booléens

p 1
# vs
puts 1

Utiliser p * pour print des tableaux d’entiers ou de booléens

a=[1,2,3]
p *a
# vs
puts a

Utiliser $><< pour print les strings

$><<a
#vs
puts a
#!! attention à la priorité de l'opérateur ternaire
$><<(a?'a':'b')
# vs
puts a?'a':'b'

Les tableaux

Utiliser [*..] pour convertir les ranges en tableaux plutot que la méthode .to_a

d=[*1..10]
# vs
d=(1..10).to_a

.product permet de générer toutes les combinaisons possibles d’un tableau

d=[1,2,3]
d.product d
# => [[1, 1], [1, 2], [1, 3], [2, 1], [2, 2], [2, 3], [3, 1], [3, 2], [3, 3]]

Utiliser l’opérateur * plutôt que .join

a=[1,2,3]
p a*" "
# vs
puts a.join" "

.each_cons permet de générer tous les sous-tableaux de n éléments adjacents

d=[*1..10]
d.each_cons(3).to_a
# => [[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6], 
#     [5, 6, 7], [6, 7, 8], [7, 8, 9], [8, 9, 10]]

.each_slice permet de découper le tableau en sous-tableaux de taille n

d=[*1..10]
d.each_slice(3).to_a
# => [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]

Utiliser l’évaluation plutôt qu’un .reduce sur les opérations simple

d=[1,2,3,4]
p eval d*?*
# vs
p d.reduce :*

Utiliser (a...b) plutot que (a..b-1)

tally c’est bien des fois, et transpose

flat_map vs flatten puis map

String

Utiliser .split sans arguments

"Hello, world!".split # => ["Hello,", "world!"]
# vs
"Hello, world!".split(' ') => ["Hello,", "world!"]

.bytes permet de travailler directement sur les valeurs ascii

"abcdefghi".bytes
# vs
"abcdefghi".chars.map(&:ord)

Utiliser des regex est souvent plus court que des méthodes empiriques

"AbCdEfGhIjKlMnOpQrStUvWxYz".scan /A-Z/
# vs
"AbCdEfGhIjKlMnOpQrStUvWxYz".chars.select{_1 == _1.upcase}

%w() permet d’initialiser un tableau de plusieurs string

%w(one two three)
# vs
["one","two","three"]

.next permet d’incrémenter les caractères alphanumériques une string (surtout utile pour les heures)

"12:24".succ # => "12:25"

.tr permet de traduire une liste de caractère en une autre

"hello, world!".tr("lo","10") # => "he110, w0r1d"

.tr est plus court que .gsub pour supprimer les caractères

"hello, world!".tr("lo","") # => "he, wrd"

gets.ord-97 pour avoir la position de la lettre dans l’alphabet

Autres

Lorsque les valeurs possibles sont limitées, on peut souvent remplacer une égalité par une inégalité

a%10<1
#vs
a%10==0

.digits permet de générer le tableau des chiffres en base quelconque

13.digits # => [3,1]

57.digits 9 # => [3,6]

Certaines variables sont définie dans ruby, il est possible des les utiliser afin d’éviter de déclarer une nouvelle variable

n=gets.to_i
(1..n).map{$.*_1}
puts $. 
# => n!

Utiliser le spaceship operator <=> pour indexer un tableau

puts ["a égal b","a plus grand que b","a plus petit que b"][a<=>b]

De la même manière, on peut utiliser des formules en index de tableau plutot que des conditions

(a=_1.to_i)*[3,5][a%2]

(?1..?9) pour ne pas avoir à faire des to_s dans le range

Les captures de la dernière regex est stockée dans la variable $~ on peut accéder aux éléments $~[0] directement par $1 / $~[1] par $2, etc… jusqu’à $9

On peut utiliser l’implémentation des nombres négatifs et la priorité des opérateurs unaires pour gagner des caractères (plus d’info sur le complément à 2)

~-a == a-1
-~a == a+1

On peut assigner plusieurs variables en même temps en chaînant les assignations

a=b=c=d=0
# vs
a=0
b=0
c=0
d=0

On peut tester si une string inclut une substring avec l’opérateur []

string["substring"]  # renvoie "substring" ou nil

On peut se servir du même opérateur pour réaliser un sub

string["substring"]=''
#vs
string.sub("substring")

inputs = inputs.slice_when{_2-_1!=1}

inputs = inputs.chunk.with_index{_2-_1}

opérateur * qui split array

https://codegolf.stackexchange.com/questions/363/tips-for-golfing-in-ruby

permutation = combien de combinaison et ordres différents tu peux faire

combination = combien de combinaison différente tu peux faire

_1[/ */]

[a,b]* » « 

 »#{a} #{b} »

p 4440-dd.sum

c,s,n,*i=dd.split.map &:to_f puts »%s #{a=i.sum{(_1/s).ceil}} ».%a>c?:no: »yes »

l’opérateur % sur un range permet d’ajouter un step

*x,a=gets permet d’initialiser a à gets, x=[]

cycle

center