Der Nobelpreisträger Erwin Schrödinger hat es satt, mit winzigen Haustieren zu experimentieren , und hat sich entschlossen, den nächsten Laser zu finden und auf Dinge zu schießen. Weil ... Wissenschaft!

Beschreibung

Sie erhalten zwei Punkte, die der Laser durchläuft, und die Größe eines Laserstrahls, und Sie müssen bestimmen, wohin der Laserstrahl gegangen sein muss , hätte gehen können und hätte nicht gehen können.

Der Laserstrahl kann horizontal, vertikal oder diagonal sein. Für einen Laserstrahl der Größe 1 sehen sie jeweils folgendermaßen aus:

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

Der diagonale Laserstrahl kann auch gekippt werden. Laserstrahlen der Größe 2 sehen folgendermaßen aus:

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

Um einen Laserstrahl der Größe (n) zu erhalten, nehmen Sie im Allgemeinen einfach den Laserstrahl der Größe (n-1) und fügen Sie auf beiden Seiten einen Laserstrahl der Größe (1) hinzu. Als letztes Beispiel sind hier alle möglichen Laserstrahlen der Größe 3 auf derselben "Tafel" dargestellt:

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

Diese "Tafel" hat immer Abmessungen von 20x20 (in Zeichen).

Eingang

Ihr Programm erhält fünf Ganzzahlen als Eingabe. Sie sind in der Reihenfolge x ₁ , y ₁ , x ₂ , y ₂ und der Größe des Laserstrahls. Sie müssen genau in dieser Reihenfolge genommen werden. Wenn Sie möchten, können Sie die geordneten (x, y) Paare als Array, Tupel, Liste oder anderen integrierten Datentyp verwenden, der zwei Werte speichert.

Beide als Eingabe angegebenen Punkte befinden sich innerhalb der Tafel und sind garantiert unterschiedlich (dh die beiden Punkte sind niemals gleich). Die Größe des Laserstrahls ist gebunden an 1 ≤ size < 20. Es wird immer mindestens einen möglichen Laserstrahl geben, der beide Punkte passiert.

Ausgabe

Ihr Programm muss ein 20x20-Raster mit den folgenden Zeichen ausgeben:

• # wenn jeder mögliche Laserstrahl, der die beiden Punkte passiert, auch diesen Punkt passiert.
• . wenn es keinen Laserstrahl gibt, der durch die beiden Punkte und diesen Punkt geht.
• ? wenn einige, aber nicht alle der möglichen Laserstrahlen diesen Punkt passieren.
• XWenn dies einer der beiden ursprünglichen Eingabepunkte ist (dies überschreibt den #).

Testfälle

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??????.....
..??????????????....
..???????????????...
..????????????????..
..?????????????????.
..??????????????????
..??????????????????
..????????.?????????
..????????..????????
..????????...???????

Die Testfälle wurden mit dem folgenden Ruby-Skript generiert, das sich in einem Stack-Snippet befindet, um vertikalen Platz zu sparen.

/*

#!/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

*/

Regeln

• Ihr Programm muss in der Lage sein, jeden der Testfälle in weniger als 30 Sekunden (auf einem vernünftigen Computer) zu lösen. Dies ist eher eine Überprüfung der geistigen Gesundheit, da mein Ruby-Testprogramm alle Testfälle nahezu augenblicklich löste.

• Das ist Code-Golf , also gewinnt die kürzeste Lösung.

C 291 280 277 265 Bytes

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);}

Kann kompiliert / ausgeführt werden mit:

gcc laser.c -o laser && echo "10 10 11 10 3" | ./Laser

Unten derselbe Code mit Leerzeichen und erklärenden Kommentaren:

// 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 Bytes

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("");}

Die Eingabe erfolgt von stdin und liest die 5 Zahlen in der festgelegten Reihenfolge.

Vor dem letzten Zerkleinerungsschritt:

#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("");
  }
}

Einige Erklärungen zu den wichtigsten Schritten:

• Array benthält den Zustand / das Ergebnis. Bit 0 wird für alle Pixel gesetzt, die von einem Strahl erreicht werden können. Bit 1 wird für alle Pixel gesetzt, die nicht von allen Strahlen abgedeckt werden.
• Die Funktion fwird für alle 4 Richtungen aufgerufen (vertikal, horizontal, beide Diagonalen). Ihre Argumente geben den Normalenvektor der Richtung an.
• In Funktion f:
  • Der Abstand beider Eingabepunkte zur Richtung wird ( dund e) als Skalarprodukt des Punktes mit dem übergebenen Normalenvektor berechnet .
  • Die Abstände werden bei Bedarf vertauscht, so dass dimmer kleiner oder gleich ist e.
  • Ist der Unterschied zwischen d und egrößer als die Breite des Strahls, sind in dieser Richtung keine Strahlen möglich.
  • Andernfalls durchlaufen Sie alle Pixel. Setzen Sie Bit 0, wenn das Pixel von einem Strahl erreicht werden kann, und Bit 1, wenn es nicht von allen Strahlen abgedeckt wird.
• Markieren Sie die beiden Eingabepunkte mit dem Wert 4. Da wir zur Verfolgung des Zustands die Bits 0 und 1 verwendet haben, was zu den Werten 0 bis 3 führt, ist dies der kleinste nicht verwendete Wert.
• Durchlaufen Sie die Pixel in bund konvertieren Sie die Werte im Bereich von 0 bis 4 in die entsprechenden Zeichen, während Sie sie ausdrucken.