number1 = 0 #numbers the user will enter
number2 = 0
between_number_max_cycle_length = 0 #the value of the biggest cycle between number1 and number2

#will attempt to make it break down the number that is entered in, and inside it
#will count the number of cycles it goes threw, And this value will be returned
#to the number_cyle for the users number.
def break_down_number (number_,cycle_length_) #cycle_length is for users number (SET TO ZERO)
  if number_ % 2 == 0 #number is even
    number_ = number_ / 2 #divide it by 2
  else #odd number
    number_ = (number_ * 3) + 1 #times by 3 and add 1
  end
  cycle_length_ += 1 #add 1 to length of cycle each time we break down the number
  if number_ != 1 #if number not broken down to 1 yet then
    break_down_number(number_,cycle_length_) #algorithm continues
  else
    return (cycle_length_ + 1) #add 1 to cycle_length to include the last value
  end
end

#gets users numbers in range of 1 to 999,999
until number1 <= 999_999 and number2 <= 999_999 and number1 >= 1 and number2 >= 1
  puts "Please enter in 2 numbers from 1 to 999,999."
  number1 = gets.chomp.to_i
  number2 = gets.chomp.to_i #make the string INTS
  puts ""
end

#we go from number 1 up to number 2 and check each number for its cycle length
#if its larger then the MAX_length it is updated and kept...
number1.upto(number2) {|x|
  if break_down_number(x,0) > between_number_max_cycle_length
    between_number_max_cycle_length = break_down_number(x,0)
  end
}

#the output displayed exactly as challenge asks for...
puts "#{number1} #{number2} #{between_number_max_cycle_length}"

def break_down_number(number_, cycle_length)
    number_ = number_%2 ? number_*3+1 : number/2
    cycle_length += 1
    if number != 1
        break_down_number(number_, cycle_length_)
    end
    cycle_length_ += 1
end

@results = {1 => 1}

def max_cycle_for(n)
   while(@results[n].nil?)
      @results[n] = max_cycle_for(n % 2 == 0 ? n / 2 : n * 3 + 1) + 1
   end
   @results[n]
end

num_1 = gets.to_i
num_2 = gets.to_i
puts "#{num_1} #{num_2} #{(num_1..num_2).collect{|a| max_cycle_for(a)}.max}"

ROWS, COLUMNS = 5, 5 #change to edit the MINESWEEPER GRID SIZE
MINE_PERCENTAGE = 0.10 # 0.10 = 10%  // 0.50 = 50% (Make sure its ZERO . PERCENT
mine_tile = Array.new(ROWS) {Array.new(COLUMNS){"."}} #2D array with no mines
MINES = (MINE_PERCENTAGE * (ROWS * COLUMNS)).round #rounded amount of mines in grid
MINES.times{|mines| mine_tile[rand(ROWS)][rand(COLUMNS)] = "*"} #init random mines

#print out the grid with the mines and spaces
ROWS.times{|rows| COLUMNS.times{|columns|print mine_tile[rows][columns]}
  puts}
puts

#solves the grid using numbers representing the amount of mines near it by
# going threw the rows, each row it goes threw the columns (2D array).
#it finds the mines "*" and then it runs a BOX around the mine making it number 1
# for each time that tile is hit.  I added if's to make sure the BOX check wont
# go outside the array range.
ROWS.times {|rows| COLUMNS.times{|columns| if mine_tile[rows][columns] == "*"
      ((rows - 1) <= 0 ? 0 : (rows - 1)).upto((rows + 1) >= (ROWS - 1) ? (ROWS - 1) : (rows + 1)){|solve_row|
        ((columns - 1) <= 0 ? 0 : (columns - 1)).upto((columns + 1) >= (COLUMNS - 1) ? (COLUMNS - 1) : (columns + 1)){|solve_column|
          if mine_tile[solve_row][solve_column] != "*"
            if mine_tile[solve_row][solve_column] == "."
              mine_tile[solve_row][solve_column] = 1
            else
              mine_tile[solve_row][solve_column] += 1
            end
          end
        }
      }
    end
  }
}
#prints the grid with mines after its SOLVED
ROWS.times{|rows| COLUMNS.times{|columns|print mine_tile[rows][columns]}
  puts}

ROWS, COLUMNS = 5, 5
MINE_PERCENTAGE = 0.2
@mine_grid = Array.new(ROWS + 2){Array.new(COLUMNS+2){}}
# scatter some mines on the field
(1..ROWS).each do |r|
  (1..COLUMNS).each do |c|
    @mine_grid[r][c] = rand < MINE_PERCENTAGE ? "*" : nil
  end
end

# method to print the field
def print_grid
  (1..ROWS).each do |r|
    (1..COLUMNS).each do |c|
      print [nil,0].include?(@mine_grid[r][c]) ? "." : @mine_grid[r][c]
    end
    print "\n"
  end
end

# method to count the mines around any particular cell
def count_cell(r,c)
  (@mine_grid[r-1][c-1..c+1] +
  @mine_grid[r][c-1..c+1] +
  @mine_grid[r+1][c-1..c+1]).count{|a| a == "*"}
end

# solve everything
(1..ROWS).each do |r|
  (1..COLUMNS).each do |c|
    @mine_grid[r][c] = count_cell(r,c) unless @mine_grid[r][c] == "*"
  end
end

print_grid