Qu'est-ce qu'un code Ruby court, simple, utile, cool, impressionnant ou geek?

Question

Pour des exemples,

@second = 2 
@foo = @first || @second || @third 
p @foo #=> 2 

et

p [1, 2, 3].map(&:to_s) #=> ["1", "2", "3"] 

Je suis impatient de lire un code intéressant! Merci :)

Answer 1

class Array 
    def to_hash; Hash[*map {|x| [x, yield(x)] }.flatten]; end 
end 

(Edit) Voici une version plus détaillée:

class Array 
    def to_hash 
    keys_and_values = self.map {|x| [x, yield(x)] } 
    # Now `keys_and_values` is an array of arrays reperesenting 
    # the hash. If the array this method was called on was, for 
    # example, `[1, 2, 3]`, and the block passed to this method 
    # was `{|x| x + 1 }`, `keys_and_values` would be: 
    # 
    #  [[1, 2], [2, 3], [3, 4]] 


    keys_and_values = keys_and_values.flatten 
    # now `keys_and_values` still contains all of the keys/values 
    # of the new hash, but without the inner arrays. Even numbered 
    # indexes will be keys, and odd indexes will be values. Example: 
    # 
    #  [1, 2, 2, 3, 3, 4] 


    Hash[*keys_and_values] 
    # This returns the keys/values translated to a hash. The docs 
    # for the `Hash.[]` method is here: 
    # 
    #  http://ruby-doc.org/core/classes/Hash.html#M002839 
    end 
end 

Answer 2

Une fonction qui vérifie si un nombre entier n est premier en utilisant regex!

def is_prime(n) 
    ("1" * n) !~ /^1?$|^(11+?)\1+$/ 
end 

Explication et source here.

Answer 3

utilisant enum.zip et bloc:

class Array 
    def to_hash(&b) 
    Hash[*self.zip([b.call]*self.size).flatten] 
    end 
end 
#[1,2,3].to_hash{'n'} >> {1=>'n',2=>'n',3=>'n'}