Ruby Range

In Ruby, a range represents an interval - a set of values with a start and an end. Ranges can be constructed using either two dots ".." (inclusive range) or three dots "..." (exclusive range).

Here is how you create ranges:

# Inclusive range: includes the end value.
inclusive_range = 1..10
puts inclusive_range.to_a  # Outputs: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Exclusive range: excludes the end value.
exclusive_range = 1...10
puts exclusive_range.to_a  # Outputs: [1, 2, 3, 4, 5, 6, 7, 8, 9]

Ranges are commonly used in case statements, for loops, to create arrays, and more.

Case Statements:

age = 15

case age
when 0..12
  puts "Child"
when 13..19
  puts "Teen"
else
  puts "Adult"
end
# Outputs: "Teen"

For Loops:

for i in 1..5
  puts i
end
# Outputs: 1 2 3 4 5

Creating Arrays:

array = (1..5).to_a
puts array  # Outputs: [1, 2, 3, 4, 5]

Ranges can also be used with characters:

letters_range = 'a'..'z'
puts letters_range.to_a
# Outputs: ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]

A few useful methods you can use with ranges include include? to check if a value exists within the range, and min and max to get the smallest and largest values in the range respectively.

range = 1..10

puts range.include?(5)  # Outputs: true
puts range.min  # Outputs: 1
puts range.max  # Outputs: 10

This should give you a good overview of how ranges work in Ruby. They're a powerful tool that can make your code cleaner and more efficient.

Creating ranges in Ruby: Use the range literal .. or ... to create ranges.
```
range = 1..5
```
Range class in Ruby: Ranges are instances of the Range class.
```
range = Range.new(1, 5)
```
Inclusive vs. exclusive ranges in Ruby: Inclusive ranges include the end value; exclusive ranges exclude it.
```
inclusive_range = 1..5
exclusive_range = 1...5
```
Using ranges with arrays in Ruby: Ranges can be used to extract portions of arrays.
```
array = [1, 2, 3, 4, 5]
sub_array = array[1..3]
```
Iterating through ranges in Ruby: Ranges can be used for iteration.
```
(1..5).each { |num| puts num }
```
Checking if a value is within a range in Ruby: Use the cover? method to check if a value is within a range.
```
range = 1..5
is_in_range = range.cover?(3)
```
Converting ranges to arrays in Ruby: Convert ranges to arrays using the to_a method.
```
range = 1..5
array = range.to_a
```

Ruby range methods: Ranges have useful methods like min, max, and size.

range = 1..5
min_value = range.min
max_value = range.max
size = range.size

Advanced range operations in Ruby: Ranges support operations like step for custom increments.
```
range = 1..10
range.step(2) { |num| puts num }
```
Ranges in Ruby case statements: Ranges can be used in case statements for range-based conditions.
```
score = 85

case score
when 90..100
  puts 'A'
when 80..89
  puts 'B'
else
  puts 'F'
end
```

Working with date ranges in Ruby: Ranges are commonly used with dates.

start_date = Date.new(2022, 1, 1)
end_date = Date.new(2022, 12, 31)
date_range = start_date..end_date

Using ranges with switch/case in Ruby: Utilize ranges in case statements for range-based conditions.

age = 25

case age
when 0..17
  puts 'Child'
when 18..64
  puts 'Adult'
else
  puts 'Senior'
end

Ruby range intersection and union: Ranges can be combined using & (intersection) and | (union).
```
range1 = 1..5
range2 = 3..7
intersection = range1 & range2
union = range1 | range2
```
Ruby range cover method: The cover? method checks if a range covers a given value.
```
range = 1..5
is_covered = range.cover?(3)
```