1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

def random_word(*args)
  options = args.last.is_a?(Hash) ? args.pop : {}
  options[:length] = 16 unless options[:length] # Default to a word length o
  options[:letters] = (0 .. 9).to_a unless options[:letters] # Default to nu
  chars = options[:letters].to_a

  val = ""
  options[:length].times do
    pos = rand(chars.size)
    val << chars[pos].to_s
  end
  val
end

# 500 random 16-letter words containing only numbers
500.times do
  puts random_word
end

# 500 random 20-letter words containing a-z
500.times do
  puts random_word(:length => 20, :letters => 'a' .. 'z')
end

1

500.times { puts((1..16).collect { '1234567890'.split('')[rand(10)] }.join) }

1
2
3
4
5

500.times { puts((1..16).inject('') { |a,n| a << '1234567890'[rand(10),1] }) }

# or

500.times { puts((1..16).map { '1234567890'[rand(10),1] }.join) }

1

500.times { puts((1..16).map { rand(10) }.to_s) }

1
2
3
4
5
6
7
8
9
10
11

def rand_word(*args)
  options = args.last.is_a?(Hash)? args.pop : {}
  options[:size] = 8 unless options[:size]
  options[:chars] = ("a".."z").to_a + ("A".."Z").to_a + (0..9).to_a unless options[:chars]
  chars = options[:chars].to_a
  size = options[:size].to_i
  (0...size).map{|n| chars[rand(chars.size)]}.join
end

500.times{puts rand_word(:size => 6, :chars => "a".."z")}
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class Array
  def rand_select_1
    self[rand*size]
  end

  def rand_select(size)
    Array.new(size) { rand_select_1 }
  end
end

def random_pronouncable_password(size = 4)
  c = %w(b c d f g h j k l m n p qu r s t v w x z ch cr fr nd ng nk nt ph pr rd sh sl sp st th tr)
  v = %w(a e i o u y)

  c.rand_select(size).zip(v.rand_select(size)).to_s
end

1

(1..500).map {rand(10 ** 16).to_s.rjust(16,'0')}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# when setting optional parameters, it's often a bit cleaner to use
# ||= instead of "unless options[:whatever]"

def rand_word(options = {})
  options[:size]  ||= 8
  options[:chars] ||= (0..9).to_a
  size              = options[:size]
  chars             = options[:chars]
  (0...size).map{|n| chars[rand(chars.size)]}.join
end

# even better (but untested)

def rand_word(options = {})
  size  = (options[:size]  ||= 8)
  chars = (options[:chars] ||= (0..9).to_a)
  (0...size).map{|n| chars[rand(chars.size)]}.join
end

1

ruby -e "puts (1..500).map {rand(10 ** 16).to_s.rjust(16,'0')}"