Programming-Idioms.org

puts 'Hello World'

10.times do
  puts "Hello"
end

10.times { puts 'Hello' }

puts "Hello\n" * 10

def finish( name )
  puts "My job here is done. Goodbye #{name}"
end

def square(x)
  x*x
end

def square(x) = x*x

Point = Struct.new(:x, :y)

items.each{|x| do_something( x )}

items.each do |x|
  do_something( x )
end

items.each_with_index do |x, i| 
  puts "Item #{i} = #{x}"
end

items.each_index{|i| puts "Item %d = %s" % [i, items[i]]}

x = {one: 1, two: 2}

Node = Struct.new(:left, :right, :value)
parent = Node.new(Node.new, Node.new)

y = x.shuffle

x.sample

list.include? x

mymap.each {|k, x| puts "Key= #{k}  Value=#{x}"}

rand(a...b)

rand(a..b)

def dfs(f, bt)
  dfs(f, bt.left) if bt.left
  f.(bt)
  dfs(f, bt.right) if bt.right
end

Node = Struct.new(:children)
parent = Node.new([])
parent.children << Node.new([])

def dfs(f, node)
  f.(node)
  node.children.each do |child|
    dfs(f, child)
  end
end

x.reverse!

def search(m, x)
  m.each_with_index do |row, i|
    row.each_with_index do |value, j|
      return i, j if value == x
    end
  end
  nil
end

a, b = b, a

i = s.to_i

s = "%.2f" % x

s = "ネコ"

queue = Queue.new
thread = Thread.new do
  puts queue.pop
end
queue << "Alan"
thread.join

x = Array.new(m) { Array.new(n) }

x = Array.new(m) { Array.new(n) { Array.new(p) } }

items.sort_by(&:p)

items.delete_at(i) 

threads = 1000.times.map do |i|
  Thread.new { f(i) }
end
threads.join

f = Hash.new { |hash, i| hash[i] = i * hash[i -1] }
f[0] = 1

fac = Hash.new {|h, i| h[i] = i * h[i-1] }.tap {|h| h[0] = 1 }

def exp(x, n)
  x ** n
end

def exp(x, n)
  return 1 if n == 0
  return x if n == 1
  return exp(x*x, n/2) if n.even?
  x * exp(x*x, (n-1)/2)
end

x = Atomic.new(0)
x.update { |x| f(x) }

x = Set.new

def compose(f, g)
  -> x { g.(f.(x)) }
end

def compose(f, g)
  -> x { g.(f.(x)) }
end

def compose(f, g)
  f >> g
end

adder = -> a, b { a + b }
add_two = adder.curry.(2)
add_two.(5) # => 7

t = s[i..j-1] 

ok = s.include?(word)

Vertex = Struct.new(:x, :y, :z)
Graph = Struct.new(:vertex, :neighbours)

v = Vertex.new(1, 2, 3)
neighbours = [ Vertex.new(2, 3, 4), Vertex.new(4, 5, 6) ]
graph = Graph.new(v, neighbours)

t = s.reverse

a.each do |v|
  catch :matched do
    b.each do |u|
      throw :matched if v == u
    end
    puts v
  end  
end

negative_value = catch :negative do
  matrix.each do |row|
    row.each do |value|
      throw :negative, value if value < 0
    end
  end
end

puts negative_value

s.insert(i, x)

sleep 5

t = s[0, 5]

t = s.slice(0, 5)

t = s.slice(0...5)

t = s[-5..-1]

t = s[-5..]

s = "Spanning
string
works"

s = <<EOS
This is a
multi-line string.
We call it a "heredoc"
EOS

chunks = s.split

loop do
  # endless joy
end

m.include?(k)

m.key?(k)

m.has_key?(k)

m.value?(v)

y = x.join(", ")

s = x.sum

s = x.reduce(:+)

s = i.to_s

threads = 1000.times.map do |i|
  Thread.new { f(i) }
end
threads.join

y = x.select(&:p)

lines = File.read(f)

warn "#{x} is negative"
$stderr.puts "%d is negative" % x

x = ARGV.first

d = Time.now

i = x.index(y)

x2 = x.gsub(y, z)

x = 3 ** 247

s = "%.1f%%" % (100 * x)

z = x ** n

def binom(n,k)
  (1+n-k..n).inject(:*)/(1..k).inject(:*)
end

x = 0

r = Random.new(s)

Random.new

printf("%s\n", ARGV.join(' '))

puts ARGV.join(' ')

def fact(klass, str)
  klass.new(str) if klass.is_a?(Parent)
end

x = a.gcd(b)

x = a.lcm(b)

s = x.to_s(2)

x = 3i - 2
x *= 1i

begin
  # code
end while c

y = x.to_f

y = x.to_i

y = (x + 1/2r).floor

s.scan(t).size

r = /htt+p/

c = i.digits(2).count(1)

def addingWillOverflow(x,y)
  false
end

def multiplyWillOverflow(x,y)
  false
end

exit

buf = (' ' * 1_000_000).bytes

raise ArgumentError, "invalid value #{x}."

class Foo

  def initialize
    @x = rand(10)
  end

  def x
    @x
  end

end

x = JSON.parse(File.read('data.json'))

x = {:hello => "goodbye"}

File.open("data.json", "w") do |f|
  f.puts(x.to_json)
end

def control
    yield
end

puts x.class

x = File.size(path)

b = s.start_with?(prefix)

b = s.end_with?(suffix)

d = DateTime.strptime(ts, '%s')

d = Date.today
x = d.to_s

items.sort!{|a,b| a-b }

items.sort!(&c)

u = URI("http://example.com/index.html")
s = Net::HTTP.get_response(u).body

u = URI('http://example.com/large_file')

Net::HTTP.start(u.host, u.port) do |http|
  request = Net::HTTP::Get.new(u)
  http.request(request) do |response|
    open('result.txt', 'w') do |file|
      response.read_body do |chunk|
        file.write(chunk)
      end
    end
  end
end

response = URI.open(u).read
File.write("result.txt", response)

class Person
  include XML::Mapping
  attr_accessor :name, :surname, :age, :children

  text_node :from, "@from"
  text_node :name, "Name"
  text_node :surname, "Surname"

  def initialize(name, surname, ..)
    # ...
  end
end

x = Person.new(..)
x.save_to_xml.write($stdout,2) # nicely prints
x.save_to_file('data.xml')

s = __FILE__

s = $0

dir = Dir.pwd

dir = __dir__

puts x if defined?(x)

n = ObjectSpace.memsize_of(t)

blank = s.nil? or s.strip.empty?

`x a b`

my_map.sort.each{|k,x| puts "#{k}: #{x}"}

mymap.sort_by{|k,x| x}.each{|k,x| puts "#{k}: #{x}"}

b = x == y

b = d1 < d2

s2 = s1.gsub(w, "")

n = x.length

y = x.to_set

x.uniq!

n = $stdin.gets.to_i

require 'socket'

p = 4913
u1 = UDPSocket.new
u1.bind("127.0.0.1", p)
u1.send "message-to-self", 0, "127.0.0.1", p

b = u1.recvfrom(1024).first

class Colors
  include Ruby::Enum

  define :SPADES, "spades"
  define :HEARTS, "hearts"
  define :DIAMONDS, "diamonds"
  define :CLUBS, "clubs"
end

raise unless isConsistent

def binary_search(a, el)
  a.bsearch_index{|x| x == el} || -1
end

t1 = Time.now
foo
p (Time.now - t1)*1000000

def foo
  string, boolean  = "bar", false
  [string, boolean]
end

def foo
  eval File.read "foobody.txt"
end

class Tree
  attr_accessor :value, :children

  def initialize(value)
    @value = value
    @children = []
  end

  def traverse_breadth_first(f)
    queue = []
    queue.unshift(self)
    while !(queue.empty?)
      node = queue.pop
      method(f).call(node.value)
      node.children.each { |child| queue.unshift(child) }
    end
  end
end

case
  when c1
    f1
  when c2
    f2
  when c3
    f3
end

def clock 
  t = Time.now
  yield
  Time.now - t
end

d = clock{ f }

ok = s.match?( /#{word}/i )

items = [a, b, c]

i = items.index(x)
items.delete_at(i) unless i.nil?

items.delete(x)

b = s.count("^0-9").zero?

file = Tempfile.new('foo') 

td = Dir.mktmpdir

m.delete(k)

[items1, items2].each{|ar| ar.each{|item| p item }}

items1.chain(items2).each{|item| puts item}

s = x.to_s(16)

items1.zip(items2){|pair| puts pair}

b = File.exist?(fp)

logger = Logger.new('logfile.log') # or STDOUT or STDERR
logger.info(msg)

f = s.to_f

t = s.gsub(/[^[:ascii:]]/, "")

t = s.gsub(/[[:^ascii:]]/, "")

STDIN.read.split.map(&:to_i)

p.chomp!("/")

p = p.chomp("/")

p.chomp!("/")

s = ?c

t = s + i.to_s

t = "#{s}#{i}"

rgbs = c1[1..-1].scan(/../), c2[1..-1].scan(/../)
c = "#%02X%02X%02X" % rgbs.transpose.map{|h1, h2| (h1.hex + h2.hex)/2 }

File.delete(filepath)

s = "%03d" % i

Planet = 'Earth'

y = x.sample(k)

case 1.size
  when 8 then f64
  when 4 then f32
end

elements.map { |el| el * c }

bat if ARGV.include?("b")
fox if ARGV.include?("f")

list.each_slice(2){|slice| p slice}

cmd = case  RbConfig::CONFIG['host_os']
  when  /mswin|mingw|cygwin/ then "start "
  when  /darwin/ then "open "
  when  /linux|bsd/ then "xdg-open "
  else raise "No OS detected"
end
    
b = system cmd + s

x = items.last

x = items[-1]

ab = a + b

t = s.sub(/\A#{p}/, "")

t = s.delete_prefix(p)

t = s.sub(/#{w}\z/, "")

t = s.delete_suffix(w)

n = s.length

n = s.size

n = mymap.size

s << x

m[k] = v

'1000'.gsub(/\B(?=(...)*\b)/, ',')

1000.to_s(:delimited)

'1000'.reverse.scan(/.{1,3}/).join(',').reverse

Net::HTTP.post(u, content)

s = a.unpack("H*")

s = a.pack("c*").unpack("H*").first

a = [s].pack("H*").unpack("C*")

L = Dir.glob(File.join("**", "*.{jpg,jpeg,png}"), base: D)

Point = Struct.new(:x, :y)

Rect  = Struct.new(:x1, :y1, :x2, :y2) do
  def contains?(point)
    point.x.between?(x1,x2) && point.y.between?(y1,y2)
  end
end

b = Rect.new(0,0,2,5).contains?(Point.new(0,0))

Point = Struct.new(:x, :y)

Rect  = Struct.new(:x1, :y1, :x2, :y2) do
  def center  
    Point.new((x1+x2)/2.0, (y1+y2)/2.0)
  end
end

c = Rect.new(0,0,2,5).center

x = Dir.children(d)

eval s="print 'eval s=';p s"

http = Net::HTTP.new(u)
response = http.send_request('PUT', path, body)

t = (Date.today + 1).to_s

t = 1.day.since.to_s

t = Date.tomorrow.to_s

Thread.new do
  sleep 30
  f(42)
end

exit

a.disjoint?(b)

c = a * b

y = x.each_with_object([]){|e, ar| ar << t(e) if p(e)}

y = x.filter_map{|e| t(e) if p(e)}

f if a.any?{|v| v > x }

a = BigDecimal('1234567890.12345678901')

a = [[1,2], [3,4], [5,6]]
b = a.transpose

b  = a.map{|ar| ar.rotate(n) }

def foo(ar)
  puts "Array size: #{ar.size}, #{ar.max.size}."
  ar.each.with_index(1).sum do |a, i|
    a.each.with_index(1).sum do |el, j|
      el*i*j
    end
  end
end

puts foo(array)

# @param a [Array<Integer>]
# 
# @return [Array<Integer>]
# 
def foo(a)
  a.fill(42)
end

foo(arry.select(&:odd?))

# For older versions of ruby:
# foo(arry.select { |x| x.odd? })

lines = open(path).readlines

exit x

F.truncate(F.pos)

h = hypot(x, y)

data = Vector[5.0, 4.0, 3.0, 2.0, 1.0]
n = data.norm

s = data.sum{|i| i**2}

s = data.sum{ _1**2 }

m  = data.sum / data.length.to_f
sd = Math.sqrt data.sum { |n| (m-n)**2 } / data.length.to_f 

puts Math::frexp(a)

foo = ENV["FOO"]

method(str).call if ["foo", "bar", "baz", "barfl"].include?(str)

a = Array.new(n)

a = a.zip(b,c,d).map{|i,j,k,l| e*(i+j*k+Math::cos(l)) }

T = Struct.new(:s, :n)
v = T.new("Hello, world", [1, 4, 9, 16, 25])
v = nil

puts version = RUBY_VERSION

FileUtils.mkpath( path )

b = Dir.exist?( path )

strings = ['ᾲ στο διάολο', 'ὰι στο διάολο', 'Ὰͅ ΣΤΟ ΔΙΆΟΛΟ', 'ᾺΙ ΣΤΟ ΔΙΆΟΛΟ']

strings.combination(2){|a,b| puts "#{a} equals #{b}: #{a.casecmp?(b)}" }

s = s.ljust(m, c)

s.rjust(m, c)

s = s.center(m, c)

c = a & b

t = s.squeeze(" ")

t = [2.5, "hello", -1]

t = s.delete("^0-9")

i = items.index(x) || -1

items = ['foo', 'bar', 'baz', 'qux']
puts items.any?("baz") ? "found it" : "never found it"

items.unshift(x)

items.prepend(x)

def f( x=nil )
  puts x ? "present" : "not present"
end

items.pop

y = x.dup

FileUtils.copy(src, dst)

Timeout::timeout(5) { p }

b = s.force_encoding("UTF-8").valid_encoding?  

s = Base64.strict_encode64(data)

data = Base64.strict_decode64(s)

q = Rational(a, b)

c = a ^ b

c = a.zip(b).map{|aa, bb| aa ^ bb}

x = s.match(/\b\d{3}\b/).to_s

a, b = a.zip(b).sort.transpose

x.each { |e| f(e) }

puts a

puts a.join(", ")

puts a * ", "

puts m

puts x

c = items.uniq.count

x.select!(&:p)

d = (s ? -1 : 1) * Math::ldexp(m, e)

a, b, c = 42, 'hello', 5.0

x = m.values.sample

i = s.to_i(2)

x = condition ? "a" : "b"

x = if condition
      "a"
    else
      "b"
    end

puts caller

x.map!{|el| el == "foo" ? "bar" : el}

puts x

5.downto(0){|n| puts n }

items.each_with_index.reverse_each{|x, i| puts "#{i} #{x}" }

b = a.map(&:to_i)

parts = s.split( Regexp.union(",", "-", "_") )

items = []

d = Time.now
x = d.strftime("%H:%M:%S")

t = n.digits(2).index(1)

def log2d(n) =  n.bit_length - 1

def log2u(n) = 2 ** log2d(n) == n ? log2d(n) : log2d(n) + 1

(1..12).each{|n| puts "#{n}  #{log2d(n)}  #{log2u(n)}" }

def foo(ar)
  puts "#{ar.size} #{ar.first.size}"
end

a = [[1,2,3], [4,5,6]]
foo(a)

p = i.digits(2).count(1)[0]

s = v * n

def foo(x)
  puts x.class == String ? x : "Nothing"
end

foo("Hello, world")
foo(42)

Vector = Struct.new(:x, :y, :z) do
  def * (other)
    Vector.new(
      y*other.z - z*other.y,
      z*other.x - x*other.z,
      x*other.y - y*other.x)
  end
end

def tst(x)
  if x.class == Foo then puts "Same type."
    elsif x.is_a?(Foo) then puts "Extends type." 
    else puts "Not related."
  end
end

(1..100).each do |i|
  d3 = i % 3 == 0
  d5 = i % 5 == 0

  if d3 && d5
    puts "FizzBuzz"
  elsif d3
    puts "Fizz"
  elsif d5
    puts "Buzz"
  else
    puts "#{i}"
  end
end

b = Dir.empty?(p)

t = s.gsub(/[[:space:]]/, "")

t = s.gsub(/\s/, "")

a = s.scan(/[01]{8}/).map{|slice| slice.to_i(2).to_s(16).rjust(2, "0")}

x.add(e)

x << e

x.delete(e)

line = gets

lines = readlines

m.select{|k,v| p(v) }

Point = Struct.new(:x, :y)
m = {Point.new(42, 5) => "Hello"}

Foo = Struct.new(:x, :y)
m = {Foo.new(42, 5) => "Hello"}

parts = s.split(sep)

a = Array.new(n, 0)

a = [0] * n

a = Float::NAN

s.each_char.with_index{|c, i| puts "Char #{i} is #{c}" }

n = s.bytesize

b = x.include? e

s = a + b

items[i..j] = items[i..j].sort_by{|el| c(el) }

items.slice!(i...j)

puts "Hello World and 你好" 

s = []
s.push(x)
y = s.pop

puts a.join(", ")

x2 = x.gsub(/#{y}(?!.*#{y})/, z )

data.sort_by!(&:downcase)

y = x.dup

# This is a comment

def fib(n) = n < 2 ? n : fib(n-1) + fib(n-2)

s = "Our sun has #{x} planets."

data = s.bytes

puts a ** b, a ** n

def xor_string(str, key)
  ords = key.chars.map(&:ord).cycle
  str.chars.zip(ords).inject(""){|res, (c,o)| res << (c.ord ^ o) }
end

s = n.to_s(b)

y = Marshal.load(Marshal.dump(x))

a = SecureRandom.random_bytes(a.length)

y = Marshal.load(Marshal.dump(x))