Наситившись експериментами над крихітними домашніми тваринами , Нобелівський призер Ервін Шрьодінгер вирішив знайти найближчий лазер і замість цього вистрілити в речі. Тому що ... наука!

Опис

Вам дадуть дві точки, через які проходить лазер, і розмір лазерного променя, і ви повинні визначити, куди повинен був піти лазерний промінь , міг піти, а не міг піти.

Лазерний промінь може бути горизонтальним, вертикальним або діагональним. Для лазерного променя розміром 1 вони виглядають приблизно так:

       #  #
       #   #
#####  #    #
       #     #
       #      #

Діагональний лазерний промінь також можна перевернути. Лазерні промені розміром 2 виглядають так:

       ###  ##
#####  ###  ###
#####  ###   ###
#####  ###    ###
       ###     ##

Загалом, щоб отримати лазерний промінь розміром (n), просто візьміть лазерний промінь розміром (n-1) і додайте лазерний промінь розміром (1) з обох сторін. Як остаточний приклад, ось усі можливі лазерні промені розміром 3, показані на одній "дошці":

###.....#####.....##
####....#####....###
#####...#####...####
.#####..#####..#####
..#####.#####.#####.
...###############..
....#############...
.....###########....
####################
####################
####################
####################
####################
.....###########....
....#############...
...###############..
..#####.#####.#####.
.#####..#####..#####
#####...#####...####
####....#####....###

Ця "дошка" завжди матиме розміри 20х20 (у символах).

Вхідні дані

Вашій програмі буде введено п'ять цілих чисел. Вони, по порядку, х ₁ , у ₁ , х ₂ , у ₂ , і розмір лазерного променя. Їх треба приймати саме в тому порядку. За бажанням ви можете взяти впорядковані (x, y) пари як масив, кортеж, список чи інший вбудований тип даних, який зберігає два значення.

Обидві точки, подані як вхідні дані, будуть знаходитись у дошці, і вони гарантовано будуть різними (тобто два бали ніколи не будуть однаковими). Розмір лазерного променя пов'язаний з1 ≤ size < 20 . Завжди знайдеться хоча б один можливий лазерний промінь, який проходить через обидві точки.

Вихідні дані

Ваша програма повинна вивести сітку 20х20 таких символів:

• # якщо кожен можливий лазерний промінь, який проходить через дві точки, також проходить через цю точку.
• . якщо немає лазерного променя, який проходить через дві точки і цю точку.
• ? якщо деякі, але не всі, можливі лазерні промені проходять через цю точку.
• Xякщо це одна з двох початкових вхідних точок (це перевищує значення #).

Тестові справи

7, 7, 11, 3, 1

..............#.....
.............#......
............#.......
...........X........
..........#.........
.........#..........
........#...........
.......X............
......#.............
.....#..............
....#...............
...#................
..#.................
.#..................
#...................
....................
....................
....................
....................
....................

18, 18, 1, 1, 2

#??.................
?X??................
??#??...............
.??#??..............
..??#??.............
...??#??............
....??#??...........
.....??#??..........
......??#??.........
.......??#??........
........??#??.......
.........??#??......
..........??#??.....
...........??#??....
............??#??...
.............??#??..
..............??#??.
...............??#??
................??X?
.................??#

10, 10, 11, 10, 3

?????..????????..???
??????.????????.????
????????????????????
????????????????????
.???????????????????
..??????????????????
????????????????????
????????????????????
????????????????????
????????????????????
??????????XX????????
????????????????????
????????????????????
????????????????????
????????????????????
..??????????????????
.???????????????????
????????????????????
????????????????????
??????.????????.????

3, 3, 8, 10, 4

??????????..........
??????????..........
??????????..........
???X??????..........
???##?????..........
???###????..........
????###????.........
.????###????........
..????###????.......
..?????##?????......
..??????X??????.....
..??????????????....
..???????????????...
..????????????????..
..?????????????????.
..??????????????????
..??????????????????
..????????.?????????
..????????..????????
..????????...???????

Тестові приклади були створені за допомогою наступного сценарію Ruby, розташованого всередині фрагмента стека для збереження вертикального простору.

/*

#!/usr/bin/ruby

$w = $h = 20

class Point
    attr_reader :x, :y
    def initialize x, y
        @x = x
        @y = y
    end
    def inspect
        "(#{@x}, #{@y})"
    end
    def == p
        @x == p.x && @y == p.y
    end
    alias eql? ==
    def hash
        @x * $h + @y
    end
    def valid?
        @x >= 0 && @y >= 0 && @x < $w && @y < $h
    end
end

module Angle
    HORIZONTAL = Point.new(1, 0)
    VERTICAL = Point.new(0, 1)
    DIAG1 = Point.new(1, 1)
    DIAG2 = Point.new(1, -1)
end

def line_points point, angle, size
    points = [point]

    while points[-1].valid?
        points.push Point.new(points[-1].x + angle.x, points[-1].y + angle.y)
    end
    points.pop
    while points[0].valid?
        points.unshift Point.new(points[0].x - angle.x, points[0].y - angle.y)
    end
    points.shift

    if size == 1
        points
    elsif size > 1
        a2 = case angle
            when Angle::HORIZONTAL then Angle::VERTICAL
            when Angle::VERTICAL then Angle::HORIZONTAL
            else Angle::VERTICAL  # HORIZONTAL also works
        end
        (size-1).times do |n|
            np1 = Point.new(point.x + a2.x*(n+1), point.y + a2.y*(n+1))
            np2 = Point.new(point.x - a2.x*(n+1), point.y - a2.y*(n+1))
            points.concat line_points np1, angle, 1 if np1.valid?
            points.concat line_points np2, angle, 1 if np2.valid?
        end
        points
    else
        throw 'something is very wrong'
    end
end

def generate_grid x1, y1, x2, y2, size
    p1 = Point.new(x1, y1)
    p2 = Point.new(x2, y2)
    lasers = []
    points = [Point.new((p1.x + p2.x) / 2, (p1.y + p2.y) / 2)]  # midpoint
    while points.length > 0
        point = points.pop
        new_lasers = Angle.constants
            .map{|angle| line_points point, Angle.const_get(angle), size }
            .select {|laser| laser.include?(p1) && laser.include?(p2) } -
            lasers
        if new_lasers.length > 0
            lasers.concat new_lasers
            points.push Point.new(point.x+1, point.y) if point.x+1 < $w
            points.push Point.new(point.x, point.y+1) if point.y+1 < $h
            points.push Point.new(point.x-1, point.y) if point.x-1 > 0
            points.push Point.new(point.x, point.y-1) if point.y-1 > 0
        end
    end
    grid = Array.new($h) { ?. * $w }
    lasers.each do |laser|
        laser.each do |point|
            grid[point.y][point.x] = ??
        end
    end
    lasers.reduce(:&).each do |point|
        grid[point.y][point.x] = ?#
    end
    grid[p1.y][p1.x] = 'X'
    grid[p2.y][p2.x] = 'X'
    grid
end

testcases = [
    [7, 7, 11, 3, 1],
    [18, 18, 1, 1, 2],
    [10, 10, 11, 10, 3],
    [3, 3, 8, 10, 4]
]

testcases.each do |test|
    puts test * ', '
    puts
    puts generate_grid(*test).map{|line| '    ' + line }
    puts
end

*/

Правила

• Ваша програма повинна мати можливість вирішувати кожен тестовий випадок за 30 секунд (на розумній машині). Це більше перевірка здоровості, оскільки моя тестова програма Ruby вирішила всі тестові випадки майже миттєво.

• Це код-гольф , тому найкоротше рішення виграє.

C, 291 280 277 265 байт

x,y,A,C,B,D,a,c,b,d,w,s,t;T(i){return abs(i)<2*w-1;}U(j,k){s+=T(j-k)*T(j)*T(k);t*=T(j-k)*j*k<1;}main(){for(scanf("%i%i%i%i%i",&a,&b,&c,&d,&w);y<20;y+=!x)s=0,t=1,U(A=a-x,C=c-x),U(B=b-y,D=d-y),U(A-B,C-D),U(A+B,C+D),putchar((x=++x%21)?".?#x"[!!s+t+(!A*!B+!C*!D)]:10);}

Можна скласти / запустити за допомогою:

gcc laser.c -o laser && echo "10 10 11 10 3" | ./лазер

Нижче той самий код із пробілами та пояснювальними коментарями:

// Integers...
x,y,A,C,B,D,a,c,b,d,w,s,t;

// Is true if i is in range (of something)
T(i){return abs(i)<2*w-1;}

// Tests if lasers (horizontal, vertical, diagonal, etc) can/must exist at this point
// T(j-k) == 0 iff the laser of this direction can exist
// s += 1 iff this laser direction can pass through this point
// t *= 1 iff this laser direction must pass through this point
U(j,k){
    s+=T(j-k)*T(j)*T(k);
    t*=T(j-k)*j*k<1;
}

main(){ 
    // Read input; p0=(a,b), p1=(c,d)
    for(scanf("%i%i%i%i%i",&a,&b,&c,&d,&w); y<20; y+=!x)

        // A, B, C and D represent delta-x and delta-y for each points
        // e.g.: if we're processing (2,3), and p0=(4,5), A=4-2, B=5-3
        // s != 0 iff (x,y) can have some laser through it
        // t == 1 iff all lasers pass through (x,y)
        // (!A*!B+!C*!D) == 1 iff (x,y) is either p0 or p1  
        s=0,t=1,U(A=a-x,C=c-x),U(B=b-y,D=d-y),U(A-B,C-D),U(A+B,C+D),
        putchar((x=++x%21)?".?#x"[!!s+t+(!A*!B+!C*!D)]:10);
}

C, 302 байти

b[400],x,y,s,t,w,d,e,g,k;f(u,v){d=u*x+v*y;e=u*s+v*t;if(e<d)k=e,e=d,d=k;for(k=0;k<400&d+w>e;++k)g=k%20*u+k/20*v,b[k]|=g>e-w&g<d+w|(g<d|g>e)*2;}main(){scanf("%d%d%d%d%d",&x,&y,&s,&t,&w);w=2*w-1;f(1,0);f(0,1);f(1,1);f(1,-1);b[y*20+x]=4;b[t*20+s]=4;for(k=0;k<400;)putchar(".#.?X"[b[k]]),++k%20?0:puts("");}

Введення береться зі stdin, читаючи 5 чисел у визначеному порядку.

Перед завершальним кроком зменшення розміру:

#include <stdio.h>
#include <stdlib.h>

int b[400], x, y, s, t, w, d, e, g, k;

void f(int u, int v) {
  d = u * x + v * y;
  e = u * s + v * t;
  if (e < d) k = e, e = d, d = k;
  if (d + w > e) {
    for (k = 0; k < 400; ++k) {
      g = u * (k % 20) + v * (k / 20);
      if (g > e - w && g < d + w) b[k] |= 1;
      if (g < d || g > e) b[k] |= 2;
    }
  }
}

int main() {
  scanf("%d%d%d%d%d", &x, &y, &s, &t, &w);
  w = 2 * w - 1;
  f(1, 0); f(0, 1); f(1, 1); f(1, -1);
  b[y * 20 + x] = 4;
  b[t * 20 + s] = 4;
  for (k = 0; k < 400; ) {
     putchar(".#.?X"[b[k]]);
     ++k % 20 ? 0 : puts("");
  }
}

Деякі пояснення основних кроків:

• Масив bутримує стан / результат. Біт 0 буде встановлений для всіх пікселів, до яких можна дістатись променем. Біт 1 буде встановлений для всіх пікселів, яких немає охоплені всіма променями.
• Функція fвикликається для всіх 4 напрямків (вертикальний, горизонтальний, обидві діагоналі). Його аргументи вказують нормальний вектор напрямку.
• У функції f:
  • Відстань обох вхідних точок відносно напрямку обчислюється ( dі e) як крапковий добуток точки з пройденим нормальним вектором.
  • При необхідності відстані змінюються так, щоб dзавжди було менше або дорівнює e.
  • Якщо різниця між d і eбільша за ширину променя, жодні балки в цьому напрямку не можливі.
  • В іншому випадку переведіть цикл на всі пікселі. Встановіть біт 0, якщо піксель досягається будь-яким променем, і біт 1, якщо він не охоплений усіма променями.
• Позначте дві вхідні точки значенням 4. Оскільки ми використовували біти 0 і 1 для відстеження стану, в результаті чого отримували значення від 0 до 3, це найменше невикористане значення.
• Переведіть петлю на пікселі bта перетворять значення в діапазоні від 0 до 4 у відповідний символ, друкуючи їх.