Хешове и keyword аргументи на блокове

Програмиране с Ruby

Курс във Факултета по Математика и Информатика към СУ

Решение на Втора задача от Петър Нетовски

Обратно към всички решения

Към профила на Петър Нетовски

Резултати

  • 5 точки от тестове
  • 0 бонус точки
  • 5 точки общо
  • 18 успешни тест(а)
  • 2 неуспешни тест(а)

Код

def get_next_point(snake, direction)
[snake.last[0] + direction[0], snake.last[1] + direction[1]]
end
def inside_map?(point, dimensions)
answer_one = point[0].between?(0, dimensions[:width] - 1)
answer_two = point[1].between?(0, dimensions[:height] - 1)
answer_one && answer_two
end
def generate_map_array(dimensions)
map = Array.new(dimensions[:width] * dimensions[:height]) { Array.new(2, 0) }
index = 0
while index < map.size
map[index][0] += index / dimensions[:width]
map[index][1] += index % dimensions[:height]
index += 1
end
map
end
def move(snake, direction)
new_snake = grow(snake, direction)
new_snake.delete_at(0) if new_snake != nil
new_snake
end
def grow(snake, direction)
new_snake = nil
next_point = get_next_point(snake, direction)
if snake.find_index(next_point) == nil
new_snake = snake.dup
new_snake << next_point
end
new_snake
end
def new_food(food, snake, dimensions)
points_not_in_use = generate_map_array(dimensions) - (snake + food)
random_index = rand(points_not_in_use.size)
points_not_in_use[random_index]
end
def obstacle_ahead?(snake, direction, dimensions)
next_point = get_next_point(snake, direction)
snake.find_index(next_point) != nil || !inside_map?(next_point, dimensions)
end
def danger?(snake, direction, dimensions)
if obstacle_ahead?(snake, direction, dimensions) == false
new_snake = move(snake, direction)
obstacle_ahead?(new_snake, direction, dimensions)
else
true
end
end

Лог от изпълнението

F..F................

Failures:

  1) #move moves snake up/right/left/down
     Failure/Error: expect(move(snake, [0, -1])).to eq([[2, 3], [2, 4], [2, 5], [2, 4]])
       
       expected: [[2, 3], [2, 4], [2, 5], [2, 4]]
            got: nil
       
       (compared using ==)
     # /tmp/d20151026-15631-1gpztlw/spec.rb:8:in `block (2 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:5:in `block (3 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:5:in `block (2 levels) in <top (required)>'

  2) #grow grows snake up/right/left/down
     Failure/Error: expect(grow(snake, [0, -1])).to eq([[2, 2], [2, 3], [2, 4], [2, 5], [2, 4]])
       
       expected: [[2, 2], [2, 3], [2, 4], [2, 5], [2, 4]]
            got: nil
       
       (compared using ==)
     # /tmp/d20151026-15631-1gpztlw/spec.rb:29:in `block (2 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:5:in `block (3 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:5:in `block (2 levels) in <top (required)>'

Finished in 0.01506 seconds
20 examples, 2 failures

Failed examples:

rspec /tmp/d20151026-15631-1gpztlw/spec.rb:4 # #move moves snake up/right/left/down
rspec /tmp/d20151026-15631-1gpztlw/spec.rb:25 # #grow grows snake up/right/left/down

История (5 версии и 0 коментара)

Петър обнови решението на 18.10.2015 00:27 (преди над 9 години)

+def get_point_ahead(snake, direction)
+ [snake.last[0] + direction[0], snake.last[1] + direction[1]]
+end
+
+def outside_map?(point, dimensions)
+ answer_one = point[0].between?(0, dimensions[:width] - 1)
+ answer_two = point[1].between?(0, dimensions[:height] - 1)
+
+ answer_one || answer_two
+end
+
+def move(snake, direction)
+ new_snake = grow(snake, direction)
+ new_snake.delete_at(0) if new_snake != nil
+
+ new_snake
+end
+
+def grow(snake, direction)
+ new_snake = nil
+ if snake.find_index(get_point_ahead(snake, direction)) == nil
+ new_snake = snake.dup
+ new_snake << get_point_ahead(snake, direction)
+ end
+
+ new_snake
+end
+
+def new_food(food, snake, dimensions)
+ points_in_use = snake + food
+ random_point = [rand(dimensions[:width]), rand(dimensions[:height])]
+
+ random_point = [rand(dimensions[:width]), rand(dimensions[:height])] until
+ points_in_use.find_index(random_point) == nil
+
+ random_point
+end
+
+def obstacle_ahead?(snake, direction, dimensions)
+ point_ahead = get_point_ahead(snake, direction)
+
+ snake.find_index(point_ahead) != nil || outside_map?(point_ahead, dimensions)
+end
+
+def danger?(snake, direction, dimensions)
+ if obstacle_ahead?(snake, direction, dimensions) == false
+ new_snake = move(snake, direction)
+ obstacle_ahead?(new_snake, direction, dimensions)
+ else
+ true
+ end
+end

Петър обнови решението на 18.10.2015 00:37 (преди над 9 години)

def get_point_ahead(snake, direction)
[snake.last[0] + direction[0], snake.last[1] + direction[1]]
end
-def outside_map?(point, dimensions)
+def inside_map?(point, dimensions)
answer_one = point[0].between?(0, dimensions[:width] - 1)
answer_two = point[1].between?(0, dimensions[:height] - 1)
- answer_one || answer_two
+ answer_one && answer_two
end
def move(snake, direction)
new_snake = grow(snake, direction)
new_snake.delete_at(0) if new_snake != nil
new_snake
end
def grow(snake, direction)
new_snake = nil
if snake.find_index(get_point_ahead(snake, direction)) == nil
new_snake = snake.dup
new_snake << get_point_ahead(snake, direction)
end
new_snake
end
def new_food(food, snake, dimensions)
points_in_use = snake + food
random_point = [rand(dimensions[:width]), rand(dimensions[:height])]
random_point = [rand(dimensions[:width]), rand(dimensions[:height])] until
points_in_use.find_index(random_point) == nil
random_point
end
def obstacle_ahead?(snake, direction, dimensions)
point_ahead = get_point_ahead(snake, direction)
- snake.find_index(point_ahead) != nil || outside_map?(point_ahead, dimensions)
+ snake.find_index(point_ahead) != nil || !inside_map?(point_ahead, dimensions)
end
def danger?(snake, direction, dimensions)
if obstacle_ahead?(snake, direction, dimensions) == false
new_snake = move(snake, direction)
obstacle_ahead?(new_snake, direction, dimensions)
else
true
end
end

Петър обнови решението на 18.10.2015 00:43 (преди над 9 години)

-def get_point_ahead(snake, direction)
+def get_next_point(snake, direction)
[snake.last[0] + direction[0], snake.last[1] + direction[1]]
end
def inside_map?(point, dimensions)
answer_one = point[0].between?(0, dimensions[:width] - 1)
answer_two = point[1].between?(0, dimensions[:height] - 1)
answer_one && answer_two
end
def move(snake, direction)
new_snake = grow(snake, direction)
new_snake.delete_at(0) if new_snake != nil
new_snake
end
def grow(snake, direction)
new_snake = nil
- if snake.find_index(get_point_ahead(snake, direction)) == nil
+ next_point = get_next_point(snake, direction)
+ if snake.find_index(next_point) == nil
new_snake = snake.dup
- new_snake << get_point_ahead(snake, direction)
+ new_snake << next_point
end
new_snake
end
def new_food(food, snake, dimensions)
points_in_use = snake + food
random_point = [rand(dimensions[:width]), rand(dimensions[:height])]
random_point = [rand(dimensions[:width]), rand(dimensions[:height])] until
points_in_use.find_index(random_point) == nil
random_point
end
def obstacle_ahead?(snake, direction, dimensions)
- point_ahead = get_point_ahead(snake, direction)
+ next_point = get_next_point(snake, direction)
- snake.find_index(point_ahead) != nil || !inside_map?(point_ahead, dimensions)
+ snake.find_index(next_point) != nil || !inside_map?(next_point, dimensions)
end
def danger?(snake, direction, dimensions)
if obstacle_ahead?(snake, direction, dimensions) == false
new_snake = move(snake, direction)
obstacle_ahead?(new_snake, direction, dimensions)
else
true
end
end

Петър обнови решението на 18.10.2015 10:30 (преди над 9 години)

def get_next_point(snake, direction)
[snake.last[0] + direction[0], snake.last[1] + direction[1]]
end
def inside_map?(point, dimensions)
answer_one = point[0].between?(0, dimensions[:width] - 1)
answer_two = point[1].between?(0, dimensions[:height] - 1)
answer_one && answer_two
end
+def generate_map_array(dimensions)
+ map = Array.new(dimensions[:width] * dimensions[:height]) { Array.new(2, 0) }
+ index = 0
+ while index < map.size
+ map[index][0] += index / dimensions[:width]
+ map[index][1] += index % dimensions[:height]
+ index += 1
+ end
+
+ map
+end
+
def move(snake, direction)
new_snake = grow(snake, direction)
new_snake.delete_at(0) if new_snake != nil
new_snake
end
def grow(snake, direction)
new_snake = nil
next_point = get_next_point(snake, direction)
if snake.find_index(next_point) == nil
new_snake = snake.dup
new_snake << next_point
end
new_snake
end
def new_food(food, snake, dimensions)
- points_in_use = snake + food
- random_point = [rand(dimensions[:width]), rand(dimensions[:height])]
-
- random_point = [rand(dimensions[:width]), rand(dimensions[:height])] until
- points_in_use.find_index(random_point) == nil
-
- random_point
+ points_not_in_use = generate_map_array(dimensions) - (snake + food)
+ random_index = rand(points_not_in_use.size)
+ points_not_in_use[random_index]
end
def obstacle_ahead?(snake, direction, dimensions)
next_point = get_next_point(snake, direction)
snake.find_index(next_point) != nil || !inside_map?(next_point, dimensions)
end
def danger?(snake, direction, dimensions)
if obstacle_ahead?(snake, direction, dimensions) == false
new_snake = move(snake, direction)
obstacle_ahead?(new_snake, direction, dimensions)
else
true
end
end

Петър обнови решението на 18.10.2015 12:53 (преди над 9 години)

def get_next_point(snake, direction)
[snake.last[0] + direction[0], snake.last[1] + direction[1]]
end
def inside_map?(point, dimensions)
answer_one = point[0].between?(0, dimensions[:width] - 1)
answer_two = point[1].between?(0, dimensions[:height] - 1)
answer_one && answer_two
end
def generate_map_array(dimensions)
map = Array.new(dimensions[:width] * dimensions[:height]) { Array.new(2, 0) }
index = 0
while index < map.size
map[index][0] += index / dimensions[:width]
map[index][1] += index % dimensions[:height]
index += 1
end
map
end
def move(snake, direction)
new_snake = grow(snake, direction)
new_snake.delete_at(0) if new_snake != nil
new_snake
end
def grow(snake, direction)
new_snake = nil
next_point = get_next_point(snake, direction)
if snake.find_index(next_point) == nil
new_snake = snake.dup
new_snake << next_point
end
new_snake
end
def new_food(food, snake, dimensions)
points_not_in_use = generate_map_array(dimensions) - (snake + food)
random_index = rand(points_not_in_use.size)
+
points_not_in_use[random_index]
end
def obstacle_ahead?(snake, direction, dimensions)
next_point = get_next_point(snake, direction)
snake.find_index(next_point) != nil || !inside_map?(next_point, dimensions)
end
def danger?(snake, direction, dimensions)
if obstacle_ahead?(snake, direction, dimensions) == false
new_snake = move(snake, direction)
obstacle_ahead?(new_snake, direction, dimensions)
else
true
end
end