The Odin Project Ruby Syllabus

What is the difference between break and next inside a Ruby loop?

break exits the loop entirely; next skips the rest of the current iteration and jumps to the next one. Example: next if i.odd? skips odd numbers but keeps looping.

How do the #times, #upto, and #downto methods work in Ruby?

5.times { |i| ... } iterates with i from 0 to 4; 1.upto(5) counts 1,2,3,4,5; 5.downto(1) counts 5,4,3,2,1. They are the idiomatic replacements for C-style for loops when the number of iterations is known.

What is a Ruby array, and how do you access its first and last elements?

An ordered, integer-indexed collection that can hold mixed types. Access the first element with arr[0] or arr.first, and the last with arr[-1] or arr.last (negative indices count from the end).

What do push, pop, shift, and unshift do to a Ruby array?

push (or <<) adds to the end; pop removes and returns the last element; unshift adds to the front; shift removes and returns the first element. push/pop treat the array like a stack; shift/unshift work on the front like a queue.

In a Ruby hash, what is the difference between hash[:key] and hash.fetch(:key)?

hash[:key] returns nil if the key is absent, which can hide bugs; hash.fetch(:key) raises a KeyError, and hash.fetch(:key, default) returns the given default instead. fetch makes missing keys explicit.

What is the difference between the ranges (1..5) and (1...5) in Ruby?

Two dots are inclusive: (1..5) covers 1,2,3,4,5. Three dots exclude the end value: (1...5) covers 1,2,3,4. Both can be converted to arrays with to_a and used in case statements and iteration.

What does a Ruby method return if there is no explicit return statement?

The value of the last evaluated expression — this is called implicit return, and it is the idiomatic Ruby style. An explicit return keyword is used mainly to exit a method early.

What do the ? and ! suffixes conventionally mean on Ruby method names?

A ? suffix marks a predicate method that returns true or false (e.g., even?, empty?). A ! suffix marks a bang method that mutates its caller in place (e.g., upcase! changes the original string, while upcase returns a new one) or is otherwise the 'dangerous' version.

How do default parameters work in Ruby methods?

A parameter can be given a default value in the definition, e.g., def greet(name = "stranger"). If the caller omits the argument, the default is used; if provided, the argument overrides it. Parameters with defaults should come after required ones.

What does binding.pry do when debugging Ruby code?

It pauses program execution at that line and opens an interactive REPL (from the pry-byebug gem) where you can inspect and change variables in the current scope, then continue stepping through with commands like next, step, and continue.

When reading a Ruby stack trace, which line matters most and what does it tell you?

The first (top) line — it shows the file, line number, and method where the error was actually raised, plus the error type and message (e.g., NoMethodError: undefined method 'upcase' for nil). Lines below trace the chain of calls that led there.

What are the three main ways to debug a Ruby program covered by The Odin Project?

1) Read the stack trace to locate and understand the raised exception; 2) sprinkle puts/p statements to inspect values at runtime (p shows nil and types clearly); 3) use a debugger like pry-byebug to pause execution and step through code interactively.

What is the key difference between #each and #map in Ruby?

Both iterate over a collection, but #each returns the original collection unchanged (used for side effects like printing), while #map (alias #collect) returns a new array containing the block's return value for each element (used for transformation).

What do the enumerable methods #select and #reject do?

#select (alias #filter) returns a new collection containing only the elements for which the block returns true; #reject does the opposite, returning elements for which the block returns false. Neither mutates the original (their ! versions do).

How does #reduce (alias #inject) work in Ruby, and how would you sum an array with it?

It folds a collection into a single value using an accumulator: [1,2,3].reduce { |sum, n| sum + n } returns 6, computing $\sum_{i} a_{i}$. An optional argument sets the accumulator's initial value, e.g., reduce(10).

What do the enumerable predicates #include?, #any?, #all?, and #none? return?

#include?(x) — true if the collection contains x; #any? — true if the block is true for at least one element; #all? — true if the block is true for every element; #none? — true if the block is true for no elements. All return booleans.

How do #each_with_index and #each_with_object differ in Ruby?

#each_with_index yields each element along with its integer index (element, index). #each_with_object(obj) yields each element plus a memo object you build up (like a hash or array) and returns that object at the end — similar to reduce but the memo is passed, not returned, by the block.

In the Caesar Cipher, what is the formula for encrypting a letter, and what does it mean?

$E(x) = (x + n) \bmod 26$, where $x$ is the letter's position in the alphabet ($0$–$25$) and $n$ is the shift factor. Each letter is shifted $n$ positions forward, wrapping past 'z' back to 'a' thanks to the modulo.

In the Odin Project Caesar Cipher, how do you handle wrap-around and non-letter characters?

Wrap-around: apply modulo 26 to the shifted alphabet position (so 'z' with shift 1 becomes 'a'), handling uppercase and lowercase within their own ranges. Non-letter characters (spaces, punctuation) must pass through unchanged, and letter case must be preserved.

What is the goal of the Odin Project Sub Strings exercise, and what is the standard approach?

Write a method that takes a string and a dictionary array and returns a hash counting how many times each dictionary word appears as a substring, case-insensitively. Standard approach: downcase the input, then iterate the dictionary (e.g., with each_with_object or reduce), using String#scan or #include? to count matches — "below" matches both "below" and "low".

What is the rule and goal of the Odin Project Stock Picker exercise?

Given an array of daily stock prices, return the pair of indices [buy_day, sell_day] that maximizes profit $= p_{sell} - p_{buy}$, with the constraint that you must buy before you sell ($buy < sell$). The efficient solution scans once, tracking the minimum price so far and the best profit found.

Describe how the bubble sort algorithm works.

Repeatedly step through the array comparing adjacent pairs; if a pair is out of order, swap them. After each full pass the largest unsorted element 'bubbles up' to its final position at the end. Repeat passes until a complete pass makes no swaps, meaning the array is sorted.

What is the time complexity of bubble sort in the worst and best cases?

Worst and average case: $O(n^{2})$, because up to $n$ passes each do up to $n$ comparisons. Best case (already sorted, with the no-swap early exit optimization): $O(n)$, one pass with zero swaps. Space complexity is $O(1)$ since it sorts in place.

In a Ruby class, what is the initialize method and what are instance variables?

initialize is the constructor that runs automatically when you call ClassName.new(args). Instance variables start with @ (e.g., @name) and hold state unique to each object instance; they are accessible from any instance method of the class but not from outside without accessor methods.

What do attr_reader, attr_writer, and attr_accessor generate in a Ruby class?

They auto-generate methods for instance variables: attr_reader :name creates a getter (name), attr_writer :name creates a setter (name=), and attr_accessor :name creates both. They replace hand-written trivial getter/setter methods.

How do instance methods/variables differ from class methods/variables in Ruby?

Instance methods are called on objects and use @variables unique to each instance. Class methods are defined with self. (def self.method) and called on the class itself; class variables use @@ and are shared by the class and all its instances (and subclasses, which makes @@ risky).

How does inheritance work in Ruby, and what does super do?

A subclass inherits with <, e.g., class Dog < Animal, gaining all of Animal's methods. super inside an overriding method calls the parent's version of that same method — super passes the same arguments along, super() passes none.

What does marking methods private in a Ruby class accomplish?

Methods below the private keyword can only be called from within the object's other instance methods, not from outside (no explicit receiver). This enforces encapsulation: the public interface stays small while internal helper logic is hidden from users of the class.

What is the difference between require and require_relative when organizing a multi-file Ruby project?

require loads from Ruby's load path (installed gems and standard library), e.g., require 'json'. require_relative loads a file by its path relative to the current file, e.g., require_relative 'lib/board' — the standard way to split your own project into multiple files.

What is RuboCop and what do the commands rubocop and rubocop -a do?

RuboCop is Ruby's standard linter and formatter that enforces the community Ruby Style Guide through rules called 'cops'. Running rubocop reports offenses; rubocop -a (autocorrect) safely fixes many of them automatically. Project-specific rules are configured in a .rubocop.yml file.