Thỉnh thoảng khi tôi vẽ nguệch ngoạc, tôi vẽ một hình chữ nhật, bắt đầu bằng một đường chéo từ một trong các góc, và sau đó chỉ cần vạch ra một đường bằng cách "phản chiếu" nó bất cứ khi nào tôi chạm vào một cạnh của hình chữ nhật. Tôi tiếp tục với điều này cho đến khi tôi chạm vào một góc khác của hình chữ nhật (và hy vọng rằng tỷ lệ khung hình của hình chữ nhật của tôi không hợp lý;)). Điều này giống như truy tìm đường đi của tia laser chiếu vào hộp. Bạn sẽ tạo ra kết quả của điều đó với nghệ thuật ASCII.

Ví dụ, hãy xem xét một hộp có chiều rộng 5và chiều cao 3. Chúng tôi sẽ luôn bắt đầu ở góc trên cùng bên trái. Các #đánh dấu ranh giới của hộp. Lưu ý rằng chiều rộng và chiều cao đề cập đến kích thước bên trong.

#######    #######    #######    #######    #######    #######    #######
#\    #    #\    #    #\   \#    #\  /\#    #\  /\#    #\/ /\#    #\/\/\#
# \   #    # \  /#    # \  /#    # \/ /#    # \/ /#    #/\/ /#    #/\/\/#
#  \  #    #  \/ #    #  \/ #    # /\/ #    #\/\/ #    #\/\/ #    #\/\/\#
#######    #######    #######    #######    #######    #######    #######

Các thách thức

Với chiều rộng và chiều cao (dương) của hộp, bạn sẽ tạo ra kết quả cuối cùng là tìm ra tia laser. Bạn có thể viết chương trình hoặc hàm, lấy đầu vào qua STDIN (hoặc thay thế gần nhất), đối số dòng lệnh, đối số hàm và xuất kết quả qua STDOUT (hoặc thay thế gần nhất) hoặc thông qua các giá trị hoặc đối số trả về hàm.

Bạn có thể sử dụng bất kỳ định dạng danh sách, chuỗi hoặc số thuận tiện cho đầu vào. Đầu ra phải là một chuỗi đơn (trừ khi bạn in nó thành STDOUT, tất nhiên bạn có thể làm dần dần). Điều này cũng có nghĩa là bạn có thể lấy chiều cao trước và chiều rộng thứ hai - chỉ cần xác định định dạng đầu vào chính xác trong câu trả lời của bạn.

Không được có khoảng trắng hàng đầu cũng như dấu vết trên bất kỳ dòng nào của đầu ra. Bạn có thể tùy ý xuất một dòng mới duy nhất.

Bạn phải sử dụng không gian, /, \và #và tái tạo các trường hợp thử nghiệm chính xác như được hiển thị.

Các trường hợp thử nghiệm

2 2
####
#\ #
# \#
####

3 2
#####
#\/\#
#/\/#
#####

6 3
########
#\    /#
# \  / #
#  \/  #
########

7 1
#########
#\/\/\/\#
#########

1 3
###
#\#
#/#
#\#
###

7 5
#########
#\/\/\/\#
#/\/\/\/#
#\/\/\/\#
#/\/\/\/#
#\/\/\/\#
#########

22 6
########################
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
# /\  /\  /\  /\  /\  /#
#/  \/  \/  \/  \/  \/ #
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
########################

Pyth, 43 41 39 byte

K*\#+2QKVvzp<*QXX*dyivzQN\\_hN\/Q\#\#)K

Dùng thử trực tuyến: Trình biên dịch / thực thi Pyth . Nhập các số theo thứ tự sau: chiều cao dòng đầu tiên, chiều rộng dòng thứ hai.

Nhờ isaacg, người đã giúp tiết kiệm hai byte.

Giải trình:

Giải pháp của tôi không theo dõi tia laser, nó sử dụng một mẫu đơn giản bao gồm gcd. Nếu m, nlà kích thước của hộp, hãy d = gcd(m, n). Kích thước của mô hình là chính xác 2*d x 2*d.

Ví dụ: mẫu lặp lại cho 7 5

#########
#\/\/\/\#
#/\/\/\/#
#\/\/\/\#
#/\/\/\/#
#\/\/\/\#
#########

Là

\/
/\

( gcd(7, 5) = 1, kích thước của mẫu là 2 x 2)

Và mô hình lặp lại cho 22 6

########################
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
# /\  /\  /\  /\  /\  /#
#/  \/  \/  \/  \/  \/ #
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
########################

Là

\  /
 \/ 
 /\
/  \

( gcd(22, 6) = 2, kích thước của mẫu là 4 x 4)

Giải pháp của tôi thực hiện những điều sau đây cho mỗi dòng: nó chỉ đơn giản là tạo một dòng của mẫu, lặp lại vài lần và cắt nó ở cuối để nó khớp với hộp.

K*\#+2QK   implicit: Q is the second input number (=width)
K          K = 
 *\#+2Q        "#" * (2 + Q)
       K   print K (first line)

Vvzp<*QXX*dyivzQN\\_hN\/Q\#\#)K  implicit: vz is the first input number (=height)
VQ                               for N in [0, 1, ..., vz-1]:
           ivzQ                             gcd(vz,Q)
          y                               2*gcd(vz,Q)
        *d                           string with 2*gcd(vz,Q) space chars
       X       N\\                   replace the Nth char with \
      X           _hN\/              replace the -(N+1)th char with /
    *Q                               repeat Q times
   <                   Q           only use the first Q chars
  p                     \#\#       print "#" + ... + "#"
                            )    end for
                             K   print K

C, 256 byte

f(w,h){int i,j,x=1,y=1,v=1,u=1;char b[h+2][w+3];for(i=0;i<w+3;i++)for(j=0;j<h+2;j++)b[j][i]=!i||!j||i>w||j>h?i>w+1?0:35:32;while((x||y)&&(x<=w||y<=h))v=x&&w+1-x?v:(x-=v,-v),u=y&&h+1-y?u:(y-=u,-u),b[y][x]=v/u<0?47:92,x+=v,y+=u;for(i=0;i<h+2;i++)puts(b[i]);}

Tôi có thể có được điều này dưới 200, và tôi sẽ thêm một lời giải thích sau, nhưng tôi có thể có một bài báo trong vài giờ tôi nên làm thay thế.

J, 85 byte

Hãy để g = gcd(w,h). Chức năng lấp đầy các yếu tố của một w/g by h/gma trận với g by ggạch, có /'s và \' s trong đường chéo và chống chéo của họ. Mảng 4D kết quả được chuyển thành một hình 2D (bên trong hộp) sau đó được bao quanh bằng #. (Các số 0 1 2 3được sử dụng thay vì [space] / \ #và các số được thay đổi thành các ký tự ở cuối.)

Một tính toán dựa trên vị trí trực tiếp của tọa độ bên trong có thể mang lại giải pháp ngắn hơn một chút.

' \/#'echo@:{~3,.~3,.3,~3,,$[:,[:,"%.0 2 1 3|:((,:2*|.)@=@i.@+.){~[:(2&|@+/&:i.)/,%+.

Sử dụng:

   6 (' \/#'echo@:{~3,.~3,.3,~3,,$[:,[:,"%.0 2 1 3|:((,:2*|.)@=@i.@+.){~[:(2&|@+/&:i.)/,%+.) 22
########################
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
# /\  /\  /\  /\  /\  /#
#/  \/  \/  \/  \/  \/ #
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
########################

Hãy thử trực tuyến tại đây.

Máy tính Desmos - Không cạnh tranh để giúp kiến ​​thức thêm

Hãy thử trực tuyến!

Đầu vào:

h as height of box, with 0-indexing
w as width of box, with 0-indexing

Trung gian:

Let b = gcd(h,w),
Let c = |b-h%2b| Or |b-mod(h,2b)|

• gcd (h, w) đại diện cho mẫu số chung lớn nhất
• A% B , như trong Javascript, hoặc mod (A, B) , như trong Fortran, đại diện cho hoạt động mô đun , trên khoảng [0, B).

Công thức, viết tắt:

(|b-(x+y)%2b|-c)(|b-(x-y)%2b|-c)=0

Đầu ra:

x as x position, 0-indexed, where the ball will land when released
y as y position, 0-indexed, where the ball will land when released

Làm thế nào nó hoạt động:

(|b-(x+y)%2b|-c)*(|b-(x-y)%2b|-c)=0
                ^ OR operation - |b-(x+y)%2b|-c=0 or |b-(x-y)%2b|-c=0
|b-(x+/-y)%2b|-c = 0
|b-(x+/-y)%2b| = c
|b-(x+/-y)%2b| = c means (b-(x+/-y))%2b = + or -c 
b-(x+/-y)%2b = +/- c -> b +/- c = (x+/-y)%2b -> (x+/-y) = n*2*b + b +/- c 
Where n is integer.  This will force patterns to repeat every 2b steps in x and y.  
Initial pattern n=0: (x +/- y) = b +/- c -> y = +/- x + b +/- c
In the x positive and y positive plane only, these correspond to lines of positive and 
negative slope, set at intercept b, offset by c on either side.

Chương trình không đáp ứng tiêu chí cuối cùng - tạo ra nghệ thuật hộp và đường ASCII, vì vậy tôi đang gửi thông tin không cạnh tranh để giúp người khác hoàn thành thử thách. Lưu ý rằng để Desmos hoạt động khi c = 0 hoặc c = b, một hệ số bù nhỏ 0,01 đã được giới thiệu, vì Desmos dường như có giới hạn của Mod (A, B) thay vì (0, B) thay vì [0, B )