Kết xuất một mê cung ASCII

18

nhìn! Đó là một mê cung ASCII! Soo coolzors, amazeballs và công cụ.

+-+-----+---+
| |     |   |
| |  ++   | |
| |  ++ +-+ |
|       |   |
+-------+ | |
|         | |
+---------+-+

Nhưng, nhưng, nhưng ... thật đau đớn khi tìm ra hướng nào của tất cả các phần của mê cung đang diễn ra. Tôi chỉ muốn vẽ bố cục và mê cung làm cho nó trở nên thật tuyệt vời mà không mất nhiều thời gian.

Điều gì sẽ xảy ra nếu tôi có thể vẽ nó trong ...

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

Điều đó thật ngọt ngào!

Các quy tắc (Vì quy tắc là nguội):

  • Viết mã để chuyển đổi một chuỗi thành mê cung ascii và xuất kết quả.
  • Bất kỳ ký tự không phải khoảng trắng sẽ được đọc như một bức tường.
  • Mỗi char tường sẽ quyết định nhân vật nào dựa trên các hàng xóm của nó (chỉ theo các hướng Bắc, Nam, Đông và Tây).
    • Nếu một char không có hàng xóm không có khoảng trắng, nó sẽ là dấu cộng (+).
    • Nếu một char có hàng xóm theo cả hai chiều dọc (Bắc-Nam) và ngang (Đông-Tây), đó sẽ là một dấu cộng (+).
    • Nếu một char chỉ có hàng xóm theo hướng dọc (Bắc-Nam), nó sẽ là ký hiệu ống (|).
    • Nếu một char chỉ có hàng xóm theo hướng ngang (Đông-Tây), đó sẽ là dấu trừ (-).
  • Đầu vào có thể là một chuỗi đơn (với các dòng được phân tách bằng các ký tự dòng mới hoặc một chuỗi các chuỗi).
  • Tất cả các ký tự đầu vào sẽ là các ký tự ASCII có thể in được, bạn không cần phải xử lý các bộ ký tự mở rộng.
  • Sử dụng bất kỳ ngôn ngữ cũ nào bạn muốn.
  • Nếu có khoảng trắng trước một dòng, nó sẽ là cùng một lượng trên mỗi dòng. Bất kỳ khoảng trắng sau mỗi dòng đầu ra là tốt.
  • Cố gắng giải quyết nó với số byte nhỏ nhất.

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

1: Khung

Đầu vào:

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

Đầu ra:

+--------+
|        |
|        |
|        |
+--------+

2: Mê cung cổ điển

Đầu vào:

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

Đầu ra: 

--------+-------+
        |       |
| --+-+ | ----+ |
|   | | |     | |
| + | | +---- | |
|   | |       | | 
+-- | +----+- | |
|   | |    |  | | 
| --+ | ++ | -+
|     | ++    |  
+-----+-++----+--

3: Trứng xanh, người đàn ông.

Đầu vào:

I do not like green eggs and ham.
I do not like them, sam I am.
Would you like them here or there?
I would not like them anywhere!

Đầu ra:

| ++ +++ ++++ +++++ +++- -++ ----
| ++ +++ ++++ +++++ +++ + +++
+-+++ +++ ++++ ++++ ++++ ++ +++---
| +++-+ +++ ++++ ++-+ +++++++++

4: Đá

Đầu vào:

Word Icicle!
Word Icicle 
Word  cicle 
 ord  cicle 
 ord   icle 
 ord   i le 
 or    i le 
 or    i l  
 or      l  
 or         
  r

Đầu ra:

++++ ++++++-
++++ ++++++ 
++++  +++++ 
 +++  +++++ 
 +++   ++++ 
 +++   | ++ 
 ++    | ++ 
 ++    | |  
 ++      |  
 ++         
  |
code-golf  ascii-art 
— AJFaraday
nguồn
1
Không phải dòng thứ ba của trứng xanh và giăm bông kết thúc ---?
— LiefdeWen
1
Kết quả cho hàng xóm hỗn hợp vẫn chưa rõ ràng; không chắc chắn tại sao các cột băng sẽ có bất kỳ -s nào hoặc tại sao mê cung cổ điển không có bốn +s ở hàng dưới cùng.
— Neil
1
chúng ta có được phép lấy đầu vào dưới dạng một hình vuông được đệm bằng khoảng trắng (tức là ma trận) không? Là đầu ra được phép có thêm khoảng trắng xung quanh nó? Ngoài ra, bạn có thực sự có nghĩa smallest number of characters, không phải byte?
— dzaima
1
Tôi nghĩ rằng 1) mê cung cổ điển nên có một +ở giữa hàng 1 2) các !Icicles nên được thay thế bằng a -. Bạn có thể vui lòng kiểm tra lại những cái này không?
— Arnauld
1
Bởi whitespace, bạn chỉ có nghĩa là không gian? Tôi không muốn phải hỗ trợ các tab và có lẽ bạn cũng không muốn tôi chuyển đổi dòng mới
— Jo King

Câu trả lời:

11

APL (Dyalog Unicode) , 57 35 byte SBCS

Bí22 nhờ một giải pháp mới lạ của ngn .

Hàm ẩn danh lấy một ma trận ký tự làm đối số.

{⊃'+-|+'↓⍨2⊥5 4 2⊃¨⊂⍱∘⌽⍨' '≠,⍵}⌺3 3

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

{... }⌺3 3 trên mỗi 3-by-3 khu phố, áp dụng các chức năng sau:

 ,⍵ ravel (làm phẳng)

 ' '≠ Boolean nơi không gian

 ⍱∘⌽⍨ rằng nó ngược lại (bao gồm cả không phải trên cùng dưới cùng, không phải bên trái NOR)

 5 4 2⊃¨⊂chọn 5 ngày , 4 ngày , và 2 nd yếu tố từ đó toàn bộ danh sách
  tức là tự trống rỗng, không thẳng đứng, không ngang

 2⊥ đánh giá trong cơ sở-2 (nhị phân)
  tức là ≥4: trống tự; 3: không có hàng xóm; 2: không có hàng xóm ngang; 1: không thẳng đứng; 0: có cả hai

 '+-|+'↓⍨ bỏ nhiều phần tử từ chuỗi này
  tức là tự rỗng : ; một mình : +; hàng xóm dọc (s) chỉ : |+; ngang : -|+; cả hai:+-|+

 ⊃ chọn phần tử đầu tiên (phần đệm có khoảng
  trắng nếu không có sẵn) tức là tự rỗng : ; một mình : +; hàng xóm dọc (s) chỉ : |; ngang : -; cả hai:+

Giải pháp cũ

Hàm ẩn danh lấy một ma trận ký tự làm đối số.

{' +-|+'⊃⍨1⍳⍨(' '=5⊃,⍵),(∧/,⊢)∨/2 2⍴1⌽' '≠(9⍴0 1)/,⍵}⌺3 3

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

{... }⌺3 3 trên mỗi 3-by-3 khu phố, áp dụng các chức năng sau:

 ,⍵ ravel (làm phẳng)

 (... )/ bộ lọc bằng cách sử dụng mặt nạ sau:

  9⍴0 1 định hình lại theo chu kỳ [0,1]đến chiều dài 9 (chọn N, W, E, S)

 ' '≠ Boolean nơi không gian

 1⌽ xoay một bước trái; [W,E,S,N]

 2 2⍴ định hình lại ma trận 2 nhân 2; [[W,E],[S,N]]

 ∨/ giảm hàng HOẶC giảm: [horizontal,vertical]

 (... ) áp dụng các chức năng ngầm như sau:

  ⊢ nhận dạng; [horizontal,vertical]

  ∧/, đi trước bởi sự giảm AND của nó; [both,horizontal,vertical]

 (... ), thêm vào trước sau:

  ,⍵ ravel (san phẳng) khu phố

  5⊃ chọn phần tử thứ 5 (chính nó)

  ' '= Boolean nếu không gian (tức là trống)

 Bây giờ chúng tôi có [empty,both,horizontal,vertical]

 1⍳⍨ chỉ số ngoài cùng bên trái 1 (cho 5 nếu không có hàng xóm)

 ' +-|+'⊃⍨ sử dụng để chọn biểu tượng

   

— Adám
nguồn
6

JavaScript (ES6), 110 byte

Định dạng I / O: mảng các chuỗi.

a=>a.map((s,y)=>s.replace(/\S/g,(_,x)=>'+|-+'[[-1,p=0,1,2].map(c=>p|=(a[y+c%2]||0)[x+~-c%2]>' '?c&1||2:0)|p]))

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

Hoặc 108 byte bằng cách sử dụng một ma trận các ký tự thay thế.

— Arnauld
nguồn
6

Python 2 , 181 168 byte

cảm ơn Leaky Nun cho -13 byte

m=input()
f=lambda x,y:(['']+m+[''])[y+1][x:x+1]>' '
print[[(c<'!')*' 'or'+-|+'[f(x+1,y)|f(x-1,y)|2*f(x,y+1)|2*f(x,y-1)]for x,c in enumerate(r)]for y,r in enumerate(m)]

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

— lò nướng
nguồn
5

MATLAB, 113 110 101 byte

function F(A)
B=A>32
c=[1 1 1]
f=@(c)conv2(B,c,'s')>1
h=f(c)
v=f(c')
char((13*h+92*v-94*(h&v)).*B+32)

Chuyển đổi đầu vào thành logic, áp dụng tích chập theo chiều ngang và dọc và kết hợp các đầu ra để tạo ra các ký tự tương ứng.

3 byte được lưu bởi @Adriaan để cho tôi biết rằng bạn có thể làm tắc nghẽn đầu ra trong PPCG: P

9 byte được lưu nhờ nhiều bình luận @flawr!

— Hướng dẫn não
nguồn
2

Võng mạc 0.8.2 , 92 byte

\S
0
(?<=(.)*)0(?=(?>.*\n(?<-1>.)*)0)|0(?=(.)*)(?<=0(?>(?<-2>.)*\n.*))
1
T`d`+|`\b.\b
T`d`-+

Hãy thử trực tuyến!Yêu cầu đầu vào hình chữ nhật. Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

\S
0

Thay đổi tất cả các khoảng trắng thành 0s.

(?<=(.)*)0(?=(?>.*\n(?<-1>.)*)0)|0(?=(.)*)(?<=0(?>(?<-2>.)*\n.*))
1

Tìm tất cả các 0s với một cái khác 0ngay phía trên hoặc bên dưới trong cùng một cột và thay đổi chúng thành 1. Hiện 1tại chúng là những nơi có hàng xóm dọc, trong khi 0s không có hàng xóm dọc.

T`d`+|`\b.\b

Tìm tất cả các chữ số không có hàng xóm ngang. Các 0s cũng không có hàng xóm dọc, vì vậy chúng trở thành +s, trong khi 1s có hàng xóm dọc, vì vậy chúng trở thành |s.

T`d`-+

Các chữ số còn lại có hàng xóm ngang. Các 1s cũng có hàng xóm dọc, vì vậy chúng trở thành +s, trong khi 0s chỉ có hàng xóm nằm ngang, vì vậy chúng trở thành -s.

— Neil
nguồn
1

Python 3 , 336 byte

def g(s):
 h,j,s=' +|-+','',s.splitlines()
 s+=['']
 for n in range(len(s)):
  s[n]+=' '
  for i in range(len(s[n])-1):
   l,r,k=s[n][i-1],s[n][i+1],0
   try:u=s[n-1][i]
   except:u=' '
   try:d=s[n+1][i]
   except:d=' '
   if not s[n][i]==' ':
    k+=1
    if not u==d==' ':k+=1
    if not l==r==' ':k+=2
   j+=h[k]
  j+='\n'
 print(j)

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

Tôi đã phải sử dụng rất nhiều mã để xử lý các lỗi trường hợp cạnh.

— akozi
nguồn
1

C (gcc) , 143 byte

char**y,*z,h,v;f(char**x){for(y=x;*y;++y)for(z=*y;*z;++z)if(*z-32){h=z[1]-32|z[-1]-32;v=y[1][z-*y]-32|y[-1][z-*y]-32;*z=h?v?43:45:(v?'|':43);}}

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

Hàm f sửa đổi một chuỗi các chuỗi tại chỗ. Khu vực xung quanh mảng phải được đệm bằng khoảng trắng (một chút hạn chế). Mặc dù điều này không đáp ứng chính xác các yêu cầu mà hầu hết các giải pháp đang sử dụng, nó vẫn tuân thủ các quy tắc nếu chúng ta nói rằng chúng ta đại diện cho một dòng mới với hai khoảng trắng (và lấy chuỗi các chuỗi kết thúc bằng dòng mới).

Ung dung

f(char**x){
    char **y;
    for (y = x; *y; ++y) {
        char *z;
        for (z = *y; *z; ++z) {
            if (*z != ' ') {
                if (z[1] != ' ' || z[-1] != ' ') {
                    // Horizontal exists
                    if (y[1][z-*y] != ' ' || y[-1][z-*y] != ' ')
                        // Vertical exists
                        *z = '+';
                    else
                        *z = '-';
                } else {
                    // Horizontal doesn't exist
                    if (y[1][z-*y] != ' ' || y[-1][z-*y] != ' ')
                        // Vertical exists
                        *z = '|';
                    else
                        *z = '+';
                }
            }
        }
    }
}

Đây là một thách thức thú vị của số học con trỏ. Sử dụng phép lặp con trỏ kiểu C, dễ dàng có được các hàng xóm nằm ngang, nhưng các hàng dọc thì khó khăn hơn. May mắn là con trỏ y vẫn ở xung quanh (chỉ đến giá trị ban đầu của z) vì vậy tôi có thể suy ra chỉ mục của mình từ nó và sử dụng nó để truy cập cùng một phần tử trên một hàng khác. Nó cảm thấy viết rất sai y[-1][z-*y]khi nó bay vào mặt của bất kỳ phong cách hợp lý!

— LambdaBeta
nguồn
— trần mèo
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookie và Chính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.