&&_versus_and.rb

"blue"

a_man_a_plan_a_canal_panama!.rb

def longest_palindrome(string)
  max = string.length
  palindrome = ""
    0.upto(max) do |n|
      n.upto(max) do |m|
        chunk = string[n..m]
        palindrome = chunk if chunk == chunk.reverse && chunk.size > palindrome.size
      end
    end
  palindrome
end

alternate_array_notation.rb

%w

an_unconventional_join.rb

$,='_'

architecting_a_solution.rb

class Architect < Struct.new(:name, :works); end;

array_item_removal.rb

& [:b, :q]

array_to_hash.rb

{}.tap { |hash| each { |n| hash[yield(n)] = n }}

baby_got_stacks.rb

def initialize(arg)
  @stack = arg
end

def pop(*n)
  r = @stack.pop(*n)
  r.is_a?(Array) ? r.reverse : r
end

def push(arg)
  @stack.push(*arg) && true
end

def to_a
  @stack
end

blackjack.rb

def twenty_one?(*args)
  args.inject(:+) == 21
end

brackets_and_searches.rb

/e/]

caution_case.rb

false

class_test.rb

bar

constant_rule.rb

::CONST

counting_elements_in_array.rb

{}.tap do |result|
  array.each { |e| result[e] ? result[e] += 1 : result[e] = 1 }
end

default_encoding.rb

Encoding.find("US-ASCII")

defined?_or_not?.rb

true

defusing_a_bomb

class NilClass
  def length
    false
  end
  
  def reverse
    false
  end
end

each_with_object.rb

([]) { |n, arr| arr << n.reverse if n && n.length.even? }

fixing_bad_code_the_wrong_way.rb

if m == :name
  nam
elsif m == :race=
  @race = args.first
elsif m == :race
  @race.capitalize
elsif m == :age
  agE

fizzbuzz.rb

result = "" 
result << "Fizz" if x % 3 == 0
result << "Buzz" if x % 5 == 0
result

generating_random_numbers.rb

(100..500)

getters_and_setters.rb

attr_accessor

hello?_yes_this_is_dog.rb

[/^\d{10}$/, /^\d{3}-\d{4}$/, /^\(\d{3}\) \d{3}-\d{4}$/, /^\d{3}-\d{3}-\d{4}$/].any? { |expr| expr =~ num }

hello_world.rb

upcase

home_on_the_range.rb

(11..94)

implement_a_hash_with_indifferent_access.rb

def self.[](*args)
  new(*args)
end

def initialize(*args)
  @memory = Hash[Hash[*args].map { |k, v| [k.to_sym, v] }]
end

def [](key)
  @memory[key.to_sym]
end

def []=(key, value)
  @memory[key.to_sym] = value
end

implement_array#interleave.rb

(self + args.flatten).sort {|a,b| a.to_i <=> b.to_i}

including_modules.rb

b

injected_and_rejected.rb

inject(0) do |mem, x|
  mem += x if x > 50
  mem
end

introduction_to_regular_expressions.rb

\w+@\w+\.\w+

join_url_params.rb

"#{link}?" << url_parameters.to_a.map do |pair|
  pair.join('=')
end.join('&')

map.rb

|x| x**2

maximum.rb

arr.max

method_acting.rb

__method__

nil_values.rb

false

no_limit.rb

split(/,/, -2)

or_equal.rb

"rubeque"

pack_template_utf8.rb

"U*"

phanaeng_curry.rb

curry(2)[2]

picking_lottery_numbers.rb

sample(5)

pigs_fly_wait_no_they_do_not.rb

ensure return false

quelle_heure_est-il?.rb

parsed = []

if date =~ (regexp = /(\d{2})-(\d{2})-(\d{4})/)
  n = date.scan(regexp).flatten
  parsed = [n[2], n[0], n[1]]
end

if date =~ (regexp = /(\w+) (\d{2}), (\d{4})/)
  n = date.scan(regexp).flatten
  parsed = [n[2], n[0][0..2], n[1]]
end

if date =~ (regexp = /(\d{4})-(\d{2})-(\d{2})/)
  n = date.scan(regexp).flatten
  parsed = [n[0], n[1], n[2]]
end

if date =~ (regexp = /(\d{1,})\/(\d{2})\/(\d{4})/)
  n = date.scan(regexp).flatten
  parsed = [n[2], n[0], n[1]]
end

Time.new(*parsed).strftime("%b %d, %Y")

queue_continuum.rb

def initialize(args)
  @queue = args
end

def pop(n = 1)
  result = @queue.shift(n)
  return result[0] if result.size == 1
  result
end

def push(args)
  @queue.push(args).flatten! && true
end

def to_a
  @queue
end

random_boolean.rb

[true, false].sample

redefining_splat.rb

class String
  def to_a
    [self.upcase]
  end

  def to_ary
    [self.downcase]
  end
end

related_keys_of_hash.rb

select { |k, v| args.any? { |arg| arg == v }}.keys

reverse.rb

'chunky bacon'

reverse_each_word.rb

sentence.split(/ /).map(&:reverse).join(' ')

select_map.rb

->(n) {n.to_i % 2 == 1}

separating_numbers_with_commas.rb

"#{n}".reverse.gsub(/(\d{3})/, '\0,').gsub(/,$/, '').reverse

set_Intersection.rb

&

simple_string_substitution.rb

gsub pattern, replace.gsub(/\\\d/, '\\\\\\0')

something_does_not_add_up.rb

100).round(

subtracting_out_the_sugar.rb

+

temperature_robot.rb

(18..21)

ternary_operator.rb

.nil? ? "Not Irish" : "Irish"

the_curious_case_of_the_missing_method.rb

compact

the_curious_case_of_the_missing_method_part_2.rb

find

the_curious_case_of_the_missing_method_part_3.rb

zip

the_curious_case_of_the_missing_method_part_4.rb

ancestors

the_curious_case_of_the_missing_method_part_5.rb

assoc

the_gray_area.rb

class BasicObject
  def ==(n)
    true
  end
end

the_lambda_lambda_lambda_fraternity.rb

even_check = lambda { |a, b=0| true if (a.even? && b.even?) }

the_limits_of_probability.rb

13

the_little_hash_key_that_could.rb

hash.key(hash.values.min)

the_truth.rb

true

there_is_no_way_this_works.rb

true

there_is_no_way_this_works_version_2.rb

"HelloWorld"

unidentified_x_object.rb

<=>

what_is_your_area_of_expertise.rb

(self.lower_right.x - self.upper_left.x) * (self.lower_right.y - self.upper_left.y)

your_favorite_and_mine_fibonacci!.rb

return 0 if n == 0
return 1 if n == 1
fibo_finder(n-1) + fibo_finder(n-2)