Ruby数组 #

arr = [1, "hello", :symbol, 3.14, [1, 2, 3]]
arr.class
arr.length

arr = [1, 2, 3, 4, 5]
arr = []
arr = [1, "hello", :symbol]
arr = %w[apple banana cherry]
arr = %i[one two three]
arr = %W[hello #{world}]
arr = %I[#{key}_one #{key}_two]

Array.new
Array.new(3)
Array.new(3, "x")
Array.new(3) { |i| i * 2 }
Array.new(3) { [] }
Array([])
Array(1..5)
Array("hello")

"hello".chars
1..5.to_a
(1..5).to_a
"a".."z".to_a
"a".upto("e").to_a
3.times.to_a

arr = ["a", "b", "c", "d", "e"]

arr[0]
arr[1]
arr[-1]
arr[-2]
arr[10]
arr.at(0)

arr = ["a", "b", "c", "d", "e"]

arr[0, 2]
arr[1, 3]
arr[0..2]
arr[0...2]
arr[1..-1]
arr[-3..-1]
arr.slice(0, 2)
arr.slice(0..2)

arr = ["a", "b", "c"]

arr.fetch(0)
arr.fetch(10)
arr.fetch(10, "default")
arr.fetch(10) { |i| "索引#{i}不存在" }

arr = [1, 2, 3, 4, 5]

arr.first
arr.first(2)
arr.last
arr.last(2)

arr = [1, 2, 3]

arr.push(4)
arr << 5
arr.unshift(0)
arr.insert(2, "a", "b")
arr.append(6)
arr.prepend(-1)

arr = [1, 2, 3, 4, 5]

arr.pop
arr.shift
arr.delete(3)
arr.delete_at(1)
arr.delete_if { |n| n > 3 }
arr.reject! { |n| n > 3 }
arr.compact!
arr.uniq!
arr.clear

arr = [1, 2, 3, 4, 5]

arr[0] = "a"
arr[1, 2] = ["b", "c"]
arr.replace([10, 20, 30])
arr.fill(0)
arr.fill("x", 1, 2)
arr.fill { |i| i * 10 }

arr = [3, 1, 2]

arr.sort!
arr.reverse!
arr.rotate!
arr.shuffle!
arr.map! { |n| n * 2 }
arr.select! { |n| n > 1 }
arr.flatten!
arr.compact!
arr.uniq!

arr = [1, 2, 3, 4, 5]

arr.include?(3)
arr.include?(10)
arr.member?(3)
arr.any? { |n| n > 3 }
arr.all? { |n| n > 0 }
arr.none? { |n| n < 0 }
arr.one? { |n| n == 3 }

arr = [1, 2, 3, 4, 5]

arr.find { |n| n > 3 }
arr.detect { |n| n > 3 }
arr.find_index { |n| n > 3 }
arr.index(3)
arr.rindex(3)
arr.index { |n| n > 3 }
arr.bsearch { |n| n >= 3 }
arr.bsearch_index { |n| n >= 3 }

arr = [1, 2, 2, 3, 3, 3]

arr.size
arr.length
arr.count
arr.count(2)
arr.count { |n| n > 2 }
arr.empty?
arr.nil?
arr.min
arr.max
arr.minmax
arr.sum
arr.average

arr = [1, 2, 3, 4, 5]

arr.each { |n| puts n }
arr.each_with_index { |n, i| puts "#{i}: #{n}" }
arr.each_index { |i| puts i }
arr.reverse_each { |n| puts n }

arr = [1, 2, 3, 4, 5]

arr.map { |n| n * 2 }
arr.map(&:to_s)
arr.collect { |n| n ** 2 }
arr.filter_map { |n| n * 2 if n.even? }

arr = [1, 2, 3, 4, 5]

arr.select { |n| n.even? }
arr.reject { |n| n.even? }
arr.find_all { |n| n > 2 }
arr.filter { |n| n > 2 }

arr = [1, 2, 3, 4, 5]

arr.reduce { |sum, n| sum + n }
arr.reduce(0) { |sum, n| sum + n }
arr.reduce(:+)
arr.reduce(1, :*)
arr.inject { |sum, n| sum + n }
arr.sum

arr = [1, 2, 3, 4, 5, 6]

arr.partition { |n| n.even? }
arr.group_by { |n| n.even? }
arr.slice_when { |a, b| a + 1 != b }.to_a
arr.chunk { |n| n.even? }.to_a
arr.chunk_while { |a, b| a <= b }.to_a

arr = [3, 1, 4, 1, 5, 9, 2, 6]

arr.sort
arr.sort.reverse
arr.sort { |a, b| b <=> a }
arr.sort_by { |n| -n }
arr.sort_by { |n| n.to_s }
arr.sort_by(&:abs)

arr = [1, 2, 3]

arr.permutation.to_a
arr.permutation(2).to_a
arr.combination.to_a
arr.combination(2).to_a
arr.repeated_permutation(2).to_a
arr.repeated_combination(2).to_a

arr = [1, 2, 3, 4, 5]

arr.rotate
arr.rotate(2)
arr.rotate(-2)
arr.reverse
arr.shuffle

arr = ["a", "b", "c"]

arr.join
arr.join(", ")
arr.to_s
arr.inspect
arr * ", "

arr = [[:a, 1], [:b, 2], [:c, 3]]

arr.to_h
Hash[arr]
Hash[*arr.flatten]

arr = [1, [2, 3], [4, [5, 6]]]

arr.flatten
arr.flatten(1)
arr.flatten!

arr = [[1, 2], [3, 4], [5, 6]]

arr.transpose

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

a | b
a - b
a & b
a + b

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

a.difference(b)
a.intersection(b)
a.union(b)

arr = [1, 2, 2, 3, 3, 3]

arr.uniq
arr.uniq!
arr.uniq { |n| n % 2 }

matrix = Array.new(3) { Array.new(3, 0) }
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
matrix = Array.new(3) { |i| Array.new(3) { |j| i * 3 + j + 1 } }

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

matrix[0][0]
matrix[1][2]
matrix.dig(1, 2)
matrix[0..1].map { |row| row[0] }

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

matrix.each do |row|
  row.each do |cell|
    puts cell
  end
end

matrix.each_with_index do |row, i|
  row.each_with_index do |cell, j|
    puts "[#{i}][#{j}] = #{cell}"
  end
end

matrix.flatten.each { |n| puts n }

def chunk_array(arr, size)
  arr.each_slice(size).to_a
end

chunk_array([1, 2, 3, 4, 5, 6, 7], 3)

def unique_preserve_order(arr)
  arr.each_with_object([]) do |item, result|
    result << item unless result.include?(item)
  end
end

unique_preserve_order([1, 2, 2, 3, 1, 4])

def flatten_depth(arr, depth = 1)
  return arr if depth == 0

  arr.reduce([]) do |result, item|
    if item.is_a?(Array) && depth > 0
      result + flatten_depth(item, depth - 1)
    else
      result + [item]
    end
  end
end

flatten_depth([1, [2, [3, [4]]]], 2)

def weighted_sample(arr, weights)
  total = weights.sum
  random = rand * total

  arr.each_with_index do |item, i|
    return item if random <= weights[i]
    random -= weights[i]
  end
end

weighted_sample(["a", "b", "c"], [1, 2, 3])

def group_count(arr)
  arr.each_with_object(Hash.new(0)) { |item, hash| hash[item] += 1 }
end

group_count([1, 2, 2, 3, 3, 3])