Đầu vào

• Ma trận nhị phân$M$ đại diện cho các bức tường của ngục tối.
• Vị trí$(x,y)$ của người chơi trong ngục tối.
• Hướng mà người chơi hiện đang phải đối mặt (0 = Bắc, 1 = Đông, 2 = Nam, 3 = Tây)$d$

Đầu ra

Một đại diện giả 3D của các bức tường nằm trong tầm nhìn của người chơi, như một nghệ thuật ASCII gồm ký tự.$30\times 10$

Dưới đây là một số khung đầu ra có thể, cùng với bản đồ và la bàn tương ứng để giúp giải quyết vấn đề (nhưng vẽ bản đồ và la bàn không phải là một phần của thách thức).

Đặc điểm kỹ thuật

Lĩnh vực xem

Người chơi có bức tường trong lĩnh vực của mình xem, dán nhãn từ đến . Dưới đây là vị trí của các bức tường so với người chơi (màu vàng), theo tất cả các hướng có thể.$13$$A$$M$

Vẽ tường

Các bức tường được cho là được vẽ từ đến$A$$M$ theo thứ tự chính xác này, với điều kiện là bất kỳ phần nào được vẽ trước đó có thể bị ghi đè bởi các bức tường gần hơn. Tất nhiên bạn có thể thực hiện nó khác nhau miễn là kết quả cuối cùng là như nhau.

Toàn bộ sản lượng được vẽ với 7 nhân vật khác nhau: " ", "'", ".", "|", "-", "_"và ":".

Bởi vì chi tiết hình dạng của các bức tường trong cơ thể của thử thách này sẽ khiến nó quá dài, thay vào đó chúng được cung cấp trong liên kết TIO sau:

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

Các ký tự không phải là một phần của một bức tường nhất định được đánh dấu bằng "?" trong các sơ đồ này. Chúng phải được coi là các ký tự 'trong suốt' hoàn toàn không được vẽ. Mặt khác, tất cả các không gian trong một bức tường là 'rắn' và phải ghi đè lên bất kỳ ký tự nào khác có thể đã được vẽ trước đó.

Quy tắc

Về đầu vào

• Bạn có thể lấy , , và ở bất kỳ định dạng hợp lý nào.$M$$x$$y$$d$
• Bạn có thể sử dụng tọa độ 0 được lập chỉ mục hoặc 1 chỉ mục.
• Bạn có thể sử dụng 4 giá trị khác nhau của sự lựa chọn của bạn cho các hướng.
• Ma trận được đảm bảo ít nhất là .$3\times 3$
• Bạn có thể cho rằng sẽ luôn có những bức tường bao quanh các cạnh.
• Người chơi được đảm bảo nằm trên một ô vuông trống.
• Đầu vào được đảm bảo là hợp lệ.

Về đầu ra

• Các bức tường phải được vẽ chính xác như mô tả.
• Tuy nhiên, định dạng đầu ra cũng linh hoạt: chuỗi đơn, mảng chuỗi, ma trận ký tự, v.v.
• Khoảng trắng hàng đầu và dấu vết được chấp nhận miễn là nó phù hợp.

Đây là mã golf .

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

Tất cả các trường hợp thử nghiệm đang sử dụng ma trận sau:

[ [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],
  [ 1, 0, 1, 1, 1, 0, 0, 0, 0, 1 ],
  [ 1, 0, 1, 0, 1, 0, 0, 1, 0, 1 ],
  [ 1, 0, 0, 0, 0, 0, 1, 1, 0, 1 ],
  [ 1, 0, 0, 1, 0, 0, 0, 1, 0, 1 ],
  [ 1, 0, 0, 1, 1, 0, 1, 1, 0, 1 ],
  [ 1, 1, 1, 1, 0, 0, 0, 0, 0, 1 ],
  [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 ],
  [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ] ]

Các đầu vào sau đang sử dụng tọa độ 0 được lập chỉ mục, với chỉ vào góc trên cùng bên trái.$(0,0)$

x=3, y=3, d=0
x=6, y=4, d=3
x=4, y=4, d=1
x=1, y=5, d=2
x=7, y=7, d=3
x=6, y=6, d=1
x=8, y=1, d=2
x=7, y=6, d=1

Sản lượng mong muốn:

------------------------------    ------------------------------
 x=3, y=3, d=0:                    x=6, y=4, d=3:
------------------------------    ------------------------------
__                          __    '.                          .'
  |'.                    .'|        |                        |  
  |   '.--------------.'   |        |----.                   |  
  |    |              |    |        |    | '.--------.       |  
  |    |              |    |        |    |  |        |       |  
  |    |              |    |        |    |  |        |       |  
  |    |              |    |        |    | .'--------'       |  
  |   .'--------------'.   |        |----'                   |  
__|.'                    '.|__      |                        |  
                                  .'                          '.
------------------------------    ------------------------------
 x=4, y=4, d=1:                    x=1, y=5, d=2:
------------------------------    ------------------------------
                            .'    __ ________________________ .'
                           |        |                        |  
-------.              .----|        |                        |  
       | '.--------.' |    |        |                        |  
       |  |        |  |    |        |                        |  
       |  |        |  |    |        |                        |  
       | .'--------'. |    |        |                        |  
-------'              '----|        |                        |  
                           |      __|________________________|  
                            '.                                '.
------------------------------    ------------------------------
 x=7, y=7, d=3:                    x=6, y=6, d=1:
------------------------------    ------------------------------
'.                                '.                            
  |'.                               |'.                         
  |   '.                            |   '.                      
  |    | '.                 .-      |    |--.--------.--------.-
  |    |  |:               :|       |    |  |        |        | 
  |    |  |:               :|       |    |  |        |        | 
  |    | .'                 '-      |    |--'--------'--------'-
  |   .'                            |   .'                      
  |.'                               |.'                         
.'                                .'                            
------------------------------    ------------------------------
 x=8, y=1, d=2:                    x=7, y=6, d=1:
------------------------------    ------------------------------
'.                          __    '.                            
  |'.                    .'|        |                           
  |   '.              .'   |        |----.--------------.-------
  |    | '.        .' |    |        |    |              |       
  |    |  |:      :|  |    |        |    |              |       
  |    |  |:      :|  |    |        |    |              |       
  |    | .'        '. |    |        |    |              |       
  |   .'              '.   |        |----'--------------'-------
  |.'                    '.|__      |                           
.'                                .'                            

Thử thách liên quan:

Thử thách này từ năm 2013 có liên quan mật thiết. Nhưng nó có một tiêu chí chiến thắng khác nhau (thử thách mã), một đặc điểm kỹ thuật lỏng lẻo hơn của đầu ra và yêu cầu I / O tương tác.

Sạch (với Snappy ), 800 785 670 644 byte

460 404 byte mã + chuỗi 360 242 byte bằng chữ
(đã thoát ở đây và trên TIO vì nó không hợp lệ UTF-8)

Bạn có thể xác minh độ dài của chữ ở đây.

import StdEnv,Data.List,Data.Maybe,Codec.Compression.Snappy,Text
@a b|b<'~'=b=a
$m x y d=map(@' ')(foldl(\a b=[@u v\\u<-a&v<-b])['~~'..][join['
']k\\Just(Just 1)<-[mapMaybe(\e=e!?(x+[u,v,~u,~v]!!d))(m!?(y+[~v,u,v,~u]!!d))\\u<-[-2,2,-1,1,0,-1,1,0,-1,1,0,-1,1]&v<-[3,3,3,3,3,2,2,2,1,1,1,0,0]]&k<-nub[q\\w<-split"#"(snappy_uncompress"\211\6\44\41\41\41\55\56\40\41\40\174\72\5\4\60\55\47\40\41\41\41\43\41\41\41\176\56\55\r\1\24\56\40\41\176\174\40\r\1\4\174\72\72\r\0\0\47\r\46\35\72\25\1\31\103\0\41\25\24\35\113\176\25\0\31\133\11\224\r\152\20\56\40\40\40\41\21\217\10\40\47\56\31\14\4\40\174\126\14\0\4\56\47\21\74\0\47\1\74\1\340\r\220\25\242\11\1\25\250\25\360\11\1\25\253\376\30\0\21\30\25\333\11\1\24\47\41\41\43\137\137\11\154\20\41\40\40\174\47\r\344\1\157\5\341\1\11\5\336\172\11\0\34\56\47\41\137\137\174\56\47\1\347\20\43\176\176\40\137\132\1\0\4\40\41\75\211\76\1\0\1\356\5\150\116\1\0\376\35\0\376\35\0\126\35\0\132\347\0\20\137\174\41\43\47\101\337\51\74\41\133\122\4\0\10\56\47\40"),q<-let l=[[c\\c<-:rpad s 30'~']\\s<-split"!"w]in[l,map reverse l]]])

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

Nén Snappy thực sự làm khá tốt trong trường hợp này, mặc dù tập trung vào tốc độ, bởi vì có rất nhiều ký tự đơn chạy trong chuỗi được nén.

Chuỗi không nén (được #thay thế bằng \ncho rõ ràng) là:

!!!-. ! |:! |:!-' !!!
!!!~.--------. !~|        |:!~|        |:!~'--------' !!!
!!!~~~~~~~~~~.--------.!~~~~~~~~~~|        |!~~~~~~~~~~|        |!~~~~~~~~~~'--------'!!!
!!-------.   !       | '.!       |  |!       |  |!       | .'!-------'   !!
!!~~~~~~~.--------------.!~~~~~~~|              |!~~~~~~~|              |!~~~~~~~|              |!~~~~~~~|              |!~~~~~~~'--------------'!!
__      !  |'.   !  |   '.!  |    |!  |    |!  |    |!  |    |!  |   .'!__|.'   !
~~ ________________________ !~~|                        |!~~|                        |!~~|                        |!~~|                        |!~~|                        |!~~|                        |!~~|                        |!~~|________________________|!
'. !  |!  |!  |!  |!  |!  |!  |!  |!.' 

Điều này mã hóa các phiên bản bên trái của các thành phần màn hình khác nhau !thay vì dòng mới và ~thay vào đó ?, được đệm bên phải với ~30 ký tự trước khi thêm chính chúng và đảo ngược dòng của chúng vào danh sách tra cứu.

Phần còn lại của mã chỉ đơn giản là xử lý tra cứu tọa độ với các trường hợp ngoài giới hạn bị bỏ qua.

Python 2 , 864 854 848 826 810 byte

L=[zip(*[iter(w)]*30)for w in zip(*[iter("eJzdllESgyAMRL+5Rf7yRQ7AZbhIDl9BwTqzSVtHrbKffR0Mm13HEM5SFHIoadpNI3snDyaS6NCknhU+JfZOvq8kLoIBU1oEI+RTbiePGzBa3QM0rf78TGl17+CZr5ZrUXBN+ECfY1GvGKEqtDsSI4s6xTn5jgqyqNcTTnUjTQO2FAEqTC0ngCrtpywenX5le6or1SsGi9ZLBKt0HuXtVEeUNGdzG6EsRNmo2EzLxuBbqFH8njmfwnqGcl+VY+s5+5ezSYXVel4dxaRK/6F15SatK1frvm//y4aoT4Ckj6XWfY2cbvz2fLSCPiiVvR+3ZuerzDwPSqeSvgAP9woa".decode('base64').decode('zip'))]*300)]
E=enumerate
def f(m,x,y,d):
 D=eval(`[[' ']*30]*10`);w,h=len(m[0]),len(m);a=[m,zip(*m)[::-1]][d%2];x,y=[x,y,w+~x,h+~y,y,w+~x,h+~y,x][d::4];X=sum([[0]*(x<2)+list(l)[x-2+(x<2):x+3]for l in[l*2for l in[a,[l[::-1]for l in a[::-1]]][d/2]*2][y:y+4]],[])
 for d,w in zip(L,'sropqmklhfgca'):
  for j,l in E(d):
   for i,q in E(l):
    if q*X[ord(w)%32]>=' ':D[j][i]=q
 for l in D:print''.join(l)

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

Than , 500 332 byte

Ｆ⁴≔⮌Ｅ§θ⁰⁺00⭆θ§μλθ≔Ｅ✂θ⊖ζ⁺⁶ζ¹✂ι⊖η⁺⁶η¹θＦε≔⮌Ｅ§θ⁰⭆θ§μλθＢ³⁰χ Ｆ²«‖ＦΦ⪪⟦“ ｜0⟧Ｐ+Ｎ？⟧‹Ｇ”³¦⁰”{➙d⊟ＥＸ⍘k↧D({Ｖt⍘gＲd◨ⅉ^δ#T；”³¦¹“ ¶↖+9Ｇ₂pＦ^c1e⌈¬；”³χω⁰χ”{➙∧⊟∧◨ηü∧↖z↨⁸\G'λＩ∧¡∕⪫θＪoΣ³⊖Ｉ⊟ζ⊙”²¦⁰”{➙∧⊟∧◨ηü∨§·◧﹪d‹⟲ ＯzºκＦⅉＲï⎇”²¦⁷ω⁰χ”{➙∧⊟≔⊘⬤|↔3Ｚθ✂≔÷t⍘ε✂↨≔⧴×ld≕≡⌕m⟧6ψ=Ｚ”⁰¦⁰”}∧80ＫυgCAêＪm⟦↘/§‖Ｃk⮌Ｃ₂¡μ↗Ｗ”⁰¦²ω⁰χ”{⊟∨·◧¤∨¶⧴⬤2ＧＬ▷⁸ê5Ｇψ”⁰¦⁰⟧³Ｉ§⭆θ⭆³§μ⎇ι⊕ξ⁻⁵ξλ«Ｊ⁻⊟κײ⁹¬ι⊟κ⊟κ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Một cách tiếp cận nhàm chán, tôi sợ; rất nhiều in ấn chuỗi chữ nén. Giải trình:

Ｆ⁴≔⮌Ｅ§θ⁰⁺00⭆θ§μλθ

Pad mảng với hai 0s thêm ở mỗi bên.

≔Ｅ✂θ⊖ζ⁺⁶ζ¹✂ι⊖η⁺⁶η¹θ

Cắt một 7x7phần con của mảng tập trung vào tọa độ đã cho.

Ｆε≔⮌Ｅ§θ⁰⭆θ§μλθ

Xoay mảng phù hợp với hướng đã cho.

Ｂ³⁰χ 

(lưu ý dấu cách) Vẽ một ô trống 30×10để đầu ra luôn có kích thước phù hợp.

Ｆ²«‖

Vẽ mỗi nửa riêng biệt, phản ánh ở giữa.

ＦΦ⪪⟦...⟧³Ｉ§⭆θ⭆³§μ⎇ι⁻⁵ξ⊕ξλ«

Lấy một mảng các mô tả tường, chia thành các khối (chuỗi, tọa độ y, tọa độ x), lọc trên các khối đó có một bức tường ở vị trí có liên quan trong một nửa của mảng có liên quan và vòng qua các bức tường. Vị trí được tính bằng cách trích xuất 12 bức tường từ mảng và lập chỉ mục cho chúng bằng cách sử dụng chỉ số chunk vì đây là golfer hơn là định vị bức tường trực tiếp bằng chỉ số chunk.

Ｊ⁻⊟κײ⁹¬ι⊟κ⊟κ

Nhảy đến tọa độ của bức tường và in nó. Lưu ý rằng phản xạ phủ định tọa độ X từ [0, 30)đến (-30, 0]để trên một lượt, khung vẽ được dịch chuyển 29 ký tự sang trái một cách hiệu quả.

Ruby , 412 391 385 383 byte

->a,x,y,d{b=Array.new(97){[" "]*10}
e=[-1,0,1,0]
14.times{|i|m=-i%3-1
w=[31,25,15,9][n=i>2?4-i/3:(m*=2;3)]
(a*3)[y+n*e[d]+m*c=e[d-3]][x+n*c-m*e[d]]&&[p=w*(m*2-1)/2,r=[12,7,4,3][n]*m*m.abs+m/3].min.upto([q=w*(m*2+1)/2,r].max){|j|t=" .'"*9
b[j+15]=(p<j&&j<q ?%w{-%2s- -%4s- _%7s_}[-n]%"":t[k=(j^j>>9)%(36/-~n)]+"   :|  |    |"[k%13]*(k/3*2)+t[-k]).center(10).chars}}
b[0,30].transpose}

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

Đưa đầu vào là một mảng các giá trị trung thực / giả mạo (lưu ý 0là trung thực trong Ruby, nhưng nillà giả mạo.)

Xuất ra một mảng các ký tự.

Giải trình

Các khối được vẽ từ trước ra sau với khoảng cách ngiảm dần và vị trí bên này sang bên kia mđạp xe qua -1,1,0trái, phải, giữa. Khối giữa E ở hàng xa nhất thực sự được rút ra hai lần vì chúng ta cần kiểm tra cả khối A / B và khối C / D. n,mvà dđược sử dụng để sửa đổi xvà ycác giá trị cho mảng tìm kiếm a. Nếu xnằm ngoài phạm vi nilđược trả về cho một ô nằm ngoài phạm vi và không có lỗi nào được đưa ra, nhưng nếu ynằm ngoài phạm vi đó nilsẽ được trả về cho hàng và Ruby sẽ đưa ra một lỗi loại khi nó cố gắng tìm kiếm ô. Để tránh điều này, mảng được nhân ba theo hướng dọc trước khi tìm kiếm. Nếu một giá trị trung thực được tìm thấy, một khối được rút ra.

Đầu ra được xây dựng trong một mảng bgồm 10 phần tử đại diện cho các cột của đầu ra và được chuyển thành 10 hàng ở cuối hàm. Mặt trước đầy đủ của tất cả các khối được vẽ (cho dù nó có xuất hiện trong chế độ xem hay không) vì vậy cần có thêm không gian trong mảng để tránh các lỗi ngoài phạm vi. Phạm vi của các jgiá trị trong khung nhìn là từ -15để +14, điều này được bù đắp bởi 15 khi lưu vào mảng để cung cấp cho một loạt các 0đến 29. Đối với mỗi khối được vẽ, ba giá trị được tính toán: pvà qcho các góc bên trái và bên phải của bức tường phía trước và rcho mặt sau của bức tường bên. jđược lặp lại từ mức tối thiểu đến mức tối đa của ba giá trị này lần lượt vẽ các cột.

Có 3 loại đường: ngang -hoặc _dọc |, hoặc :chéo với một " .'"mẫu lặp lại . Trong đó p < j < qcác cột chứa khoảng trắng được giới hạn bằng -hoặc _được vẽ để tạo thành mặt trước. Ở đâu jngoài phạm vi này, các cột chứa không gian |hoặc :được vẽ có giới hạn từ t=" .'"để tạo thành các cạnh và / hoặc mặt bên. Điều này được quản lý bởi biến k=jnơi jtích cực hoặc k=-j-1nơi jtiêu cực. Số lượng ký tự giữa mũ trên và dưới là k/3*2. Để xử lý chính xác các cạnh bên ngoài của các khối xa nhất n=3, kphải lấy modulo 9, nhưng điều này không được thực hiện đối với các giá trị nhỏ hơn củan. kdo đó được đánh giá modulo để .36/-~n , trong đó-~nn+1

Mã bị đánh cắp

->a,x,y,d{
  b=Array.new(97){[" "]*10}                                        #Set up array for output, allow space for plotting outside viewport
  e=[-1,0,1,0]                                                     #Direction offsets from player position
  14.times{|i|                                                     #Iterate through all blocks including block E twice 
    m=-i%3-1                                                       #Cycle -1,1,0 = left, right, centre
    n=i>2?4-i/3:(m*=2;3)                                           #Distance n=4-i/3. But if i/3==0 n=3 and double m for blocks A,B 
    w=[31,25,15,9][n]                                              #Width of front face of block
    r=[12,7,4,3][n]*m*m.abs+m/3                                    #Value of j for back edge of block. m/3 offsets by -1 when m negative 
    (a*3)[y+n*e[d]+m*c=e[d-3]][x+n*c-m*e[d]]&&(                    #If a block is present at the location then
      [p=w*(m*2-1)/2,r].min.upto([q=w*(m*2+1)/2,r].max){|j|        #Calculate left and right edges of front of block p,q and iterate
        t=" .'"*9                                                  #t=character constant for diagonal lines 
        k=(j^j>>9)%(36/-~n)                                        #k=j for positive j=distance from centre. For negative j, k=-1-j by XOR with j>>9=-1. If n=3 take modulo 9 for correct output of outer side of block. 
        b[j+15]=(p<j&&j<q ?%w{-%2s- -%4s- _%7s_}[-n]%"":           #If j between p&q, draw horizontal lines separated by 2,4 or 7 spaces depending on value of n
        t[k]+"   :|  |    |"[k%13]*(k/3*2)+t[-k]).center(10).chars #else draw space or vertical line capped by diagonal markers
      }
    )
  }
b[0,30].transpose}                                                 #Truncate values outside viewport, transpose, and return value.