Ruby Programming Test: Newbie, Medium, Hard and Extra Hard

Written by James BrittTechnically reviewed by Jim Freeze · Reviewed 14 September 2026

Choose the version of this Ruby programming test that fits where you are today: Newbie, Medium, Hard or Extra Hard. There are ten questions at each level. Work through them in practice mode for feedback as you go, or try an exam attempt before opening the answer key. A coding challenge follows for each level.

You can stay with one level or attempt all 40 questions together. Flag the ones you want to revisit. After submitting, use the result to pick a few concepts to practise, then retry the questions you missed or left unanswered.

How to use this Ruby programming test

Set aside around 8–15 minutes for ten questions, with more time for the longer Hard and Extra Hard snippets. None of the levels has a countdown. If you have only just started Ruby, choose Newbie and take your time reading each line. You do not need Rails knowledge.

Make a prediction before running any code. Then choose an answer. In practice mode, Check answer reveals the explanation and locks that choice for this attempt. Exam mode lets you revise your choices until you submit. Flagging a question simply marks it for your attention; it does not change its score.

Scoring is straightforward: one point for a correct answer and zero for an incorrect or unanswered one. A level is scored out of ten, while the mixed test is out of 40. The coding challenges have their own checks and stay outside that percentage. The browser saves your current quiz attempt when local storage is available; Reset this attempt clears it.

Choose your Ruby programming test level

Newbie: ten questions on truthiness, arithmetic, interpolation, ranges, basic array operations, simple Hash lookups, return values and nil. Start here if you have read a few Ruby snippets but still find yourself guessing their output.

Medium: ten questions on shared references, transformations, fetch defaults, keyword arguments, blocks, instance state, iteration, ensure and input conversion. This level suits someone who can write a short method and wants to catch everyday mistakes.

Hard: ten questions on shared Hash defaults, shallow freezing, String keys, Proc and lambda argument handling, prepend, rescue scope, false-valued memoisation and accumulators. Trace the objects and method calls carefully; familiar-looking code can behave differently from your first guess.

Extra Hard: ten questions on closure capture, nonlocal returns, lazy enumeration, regular-expression anchors, keyword separation, constant lookup, refinements, module order, pattern matching and identity-based Hashes. This is intended for readers already comfortable with Ruby methods and collections.

These levels describe the difficulty of this question bank. They are not certifications or standard job grades. The quiz does not assess Rails, database design, concurrency, application security or your ability to maintain a production system.

puts(0 ? "runs" : "skips")

p [7 / 2, 7 / 2.0]

name = "Ada"
puts "Hello #{name}"
puts 'Hello #{name}'

p (1...4).to_a

p [1, 2, 3, 4].select { |n| n.odd? }

p [nil, false, 0, ""].compact

settings = { timeout: 5 }
p settings["timeout"]

def double(number)
  number * 2
  "done"
end
p double(4)

user = nil
p user&.upcase

colors = [:red, :blue]
p colors[5]

# frozen_string_literal: false
a = "ruby"
b = a
b.upcase!
puts a

numbers = [1, 2, 3]
doubled = numbers.map { |n| n * 2 }
p numbers
p doubled

limits = { max: nil }
p [limits.fetch(:max, 10), limits.fetch(:missing, 10)]

def label(name, prefix: "Hi")
  "#{prefix}, #{name}"
end
puts label("Ada", prefix: "Hello")

def with_value
  yield 2
end
p with_value { |n| n * 3 }

class Counter
  attr_reader :value
  def initialize
    @value = 0
  end
  def increment
    @value += 1
  end
end
a = Counter.new
b = Counter.new
a.increment
p [a.value, b.value]

result = [1, 2].each { |n| n * 10 }
p result

settings = {}
begin
  settings.fetch(:token)
rescue KeyError
  puts "missing token"
end

def answer
  7
ensure
  puts "cleanup"
end
p answer

lenient = "12cats".to_i
begin
  strict = Integer("12cats", 10)
rescue ArgumentError
  strict = :invalid
end
p [lenient, strict]

groups = Hash.new([])
groups[:a] << 1
p [groups[:b], groups.keys]

# frozen_string_literal: false
items = ["a"]
items.freeze
items.first << "b"
p items

# frozen_string_literal: false
key = "a"
lookup = { key => 1 }
key.upcase!
p [lookup["a"], lookup["A"]]

add = ->(a, b) { a + b }
begin
  add.call(1)
rescue ArgumentError
  puts "wrong argument count"
end

pair = proc { |a, b| [a, b] }
p pair.call(1)

module Tagged
  def name
    "tag:" + super
  end
end
class Report
  prepend Tagged
  def name
    "report"
  end
end
puts Report.new.name

begin
  begin
    raise NotImplementedError
  rescue StandardError
    puts "inner"
  end
rescue NotImplementedError
  puts "outer"
end

class Probe
  attr_reader :calls
  def initialize
    @calls = 0
  end
  def ready?
    @ready ||= begin
      @calls += 1
      false
    end
  end
end
probe = Probe.new
2.times { probe.ready? }
p probe.calls

def value
  return 1
ensure
  return 2
end
p value

result = [1, 2, 3].each_with_object(0) do |number, total|
  total += number
end
p result

tasks = []
i = 0
while i < 3
  tasks << -> { i }
  i += 1
end
p tasks.map(&:call)

def build_handler
  proc { return :done }
end
handler = build_handler
begin
  p handler.call
rescue LocalJumpError
  puts "no active method"
end

seen = 0
values = (1..).lazy.map do |number|
  seen += 1
  number * 2
end.take(3).force
p [values, seen]

text = "12\n"
p [/\A[0-9]+\z/.match?(text), /^[0-9]+$/.match?(text)]

def quantity(limit:)
  limit
end
options = { limit: 3 }
begin
  p quantity(options)
rescue ArgumentError
  puts "use keyword expansion"
end

module Outer
  LABEL = "outer"
end
class Parent
  LABEL = "parent"
end
class Outer::Child < Parent
  def label
    LABEL
  end
end
puts Outer::Child.new.label

class Greeter
  def greeting
    "hello"
  end
end
module Loud
  refine Greeter do
    def greeting
      "HELLO"
    end
  end
end
def earlier(object)
  object.greeting
end
using Loud
greeter = Greeter.new
p [greeter.greeting, earlier(greeter)]

module First
  def chain
    ["first"] + super
  end
end
module Second
  def chain
    ["second"] + super
  end
end
class Base
  def chain
    ["base"]
  end
end
class Child < Base
  include First
  include Second
end
p Child.new.chain

record = { id: 7, extra: true }
case record
in { id: Integer => id, **nil }
  puts "exact keys"
in { id: Integer => id }
  puts "contains #{id}"
end

# frozen_string_literal: false
a = "ruby"
b = "ruby"
lookup = {}.compare_by_identity
lookup[a] = 1
lookup[b] = 2
p [lookup.size, lookup[a], lookup["ruby"]]

How to read your Ruby programming test results

A result is most useful when it tells you what to do next. Look through the missed answers and find one you can explain now. If the explanation still feels mysterious, copy its snippet into a small Ruby file and trace it one line at a time. The topic breakdown helps you spot where several mistakes have a common cause.

For this question bank, use 80–100% as a sign that most tested ideas are familiar, 50–79% as a prompt for focused practice and below 50% as a reason to revisit the foundations of that level. These are informal study bands. Compare Newbie attempts with Newbie and Extra Hard attempts with Extra Hard: the material is different, and a small topic score is only a limited sample.

Retrying missed and unanswered questions starts a fresh practice attempt with a smaller set. A higher score can show that an explanation helped, but you have also seen those questions before. Return to the full level later if you want a more useful comparison with your first attempt.

Turn a missed answer into a useful experiment

Choose a small example you misunderstood and change one thing. Swap map for each, replace a String key with a Symbol key, or remove the default from fetch. Write down your prediction before you run it. Comparing that prediction with the output gives you a specific mistake to investigate.

For additional exercises, work through our practical Ruby code examples. If transformations and blocks need more attention, the Ruby functional programming guide connects those ideas in longer examples.

Use the official Ruby Array reference to check indexing, map, select and compact. The official Ruby Hash reference explains key lookup and fetch. Both links point to Ruby 3.4 documentation, making the reference version explicit.

Four Ruby coding challenges: one for each level

For the coding challenges, start with the contract: what input is allowed, what output is required and what must stay unchanged. Draft your method in the scratchpad, then copy it into a local Ruby file with the supplied checks. The scratchpad neither executes Ruby nor saves your work. A worked solution is there when you want to compare approaches.

Keep going after the supplied example works. An empty array, repeated value or malformed argument can expose an assumption you missed. Use the checks as a starting point, add a case of your own and explain which error that case would catch.

def unique_positive(numbers)
  # Return a new array.
end

input = [-2, 3, 0, 3, 5, -1]
raise "values" unless unique_positive(input) == [3, 5]
raise "empty" unless unique_positive([]) == []
raise "order" unless unique_positive([5, 2, 5, 1]) == [5, 2, 1]
raise "input changed" unless input == [-2, 3, 0, 3, 5, -1]
puts "Challenge 1 checks passed"

def unique_positive(numbers)
  numbers.select { |n| n.positive? }.uniq
end

def label_counts(labels)
  # Return a hash of normalised labels and counts.
end

input = [" Ruby ", "ruby", "", "SWIFT", "  "]
raise "counts" unless label_counts(input) == { "ruby" => 2, "swift" => 1 }
raise "empty" unless label_counts([]) == {}
raise "input changed" unless input.first == " Ruby "
raise "separate calls" unless label_counts(["Ruby"]) == { "ruby" => 1 }
puts "Challenge 2 checks passed"

def label_counts(labels)
  labels.each_with_object(Hash.new(0)) do |label, counts|
    key = label.strip.downcase
    counts[key] += 1 unless key.empty?
  end
end

def parse_quantity(value)
  # Return an integer from 1 to 20, or nil.
end

raise "lower bound" unless parse_quantity("1") == 1
raise "upper bound" unless parse_quantity("20") == 20
raise "leading zero" unless parse_quantity("01") == 1
["0", "21", " 2", "2 ", "2cats", "+2", "2\n", "001", "", nil, 2].each do |bad|
  raise "accepted #{bad.inspect}" unless parse_quantity(bad).nil?
end
puts "Challenge 3 checks passed"

def parse_quantity(value)
  return nil unless value.is_a?(String)
  return nil unless /\A[0-9]{1,2}\z/.match?(value)

  number = Integer(value, 10)
  (1..20).cover?(number) ? number : nil
end

def first_valid_ids(events, limit:)
  # Filter lazily and stop once the requested IDs are found.
end

seen = 0
source = [nil, { id: 2, active: true }, { id: 2, active: true },
          { id: 3, active: false }, { id: 4, active: true },
          { id: 9, active: true }].lazy.map { |event| seen += 1; event }
raise "IDs" unless first_valid_ids(source, limit: 2) == [2, 4]
raise "over-consumed" unless seen == 5
never = Enumerator.new { raise "must not consume" }
raise "zero" unless first_valid_ids(never, limit: 0) == []
raise "empty" unless first_valid_ids([], limit: 3) == []
raise "invalid event" unless first_valid_ids([{ id: "2", active: true },
  { id: 0, active: true }, { id: 3, active: 1 }], limit: 3) == []
begin
  first_valid_ids([], limit: -1)
  raise "negative limit accepted"
rescue ArgumentError
  # Expected.
end
puts "Challenge 4 checks passed"

def first_valid_ids(events, limit:)
  unless limit.is_a?(Integer) && limit >= 0
    raise ArgumentError, "limit must be a nonnegative Integer"
  end

  events.lazy.filter_map do |event|
    next unless event.is_a?(Hash) && event[:active] == true
    id = event[:id]
    id if id.is_a?(Integer) && id.positive?
  end.uniq.take(limit).force
end

Ruby programming test: common questions

About this Ruby programming test

All 40 question snippets and the four worked challenge solutions were executed with Ruby 3.2.3. The linked references use Ruby 3.4. The test concerns core Ruby; individual questions state assumptions where they matter.