Cho một số nguyên N lẻ (5 <= N <= 51), tạo ra một mê cung có độ dài cạnh N theo các yêu cầu sau:

Mê cung phải bao gồm các nhân vật | -và +. Nó phải sử dụng |ký tự là một bức tường thẳng đứng, -nhân vật là một bức tường ngang và nếu bức tường đó quay, nhân vật +nên được sử dụng.

Độ rộng của đường dẫn phải là một ký tự.

Mê cung phải quay ít nhất bốn lần.

Mê cung phải có những bức tường bên ngoài, phá vỡ ở hai điểm: điểm bắt đầu và điểm kết thúc.

Mê cung phải bao gồm một con đường không phá vỡ, từ đầu đến cuối.

Ví dụ: sau đây là một mê cung hợp lệ: ( N = 5)

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

Và cho N = 7:

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

Hãy nhớ rằng, đây là mã golf , vì vậy mã có số byte ít nhất sẽ thắng.

Thạch , 36 35 34 33 32 byte

2*×5H_2Bị⁾ |
_3”-ẋ”+;;Çsẋ2U3¦ṁµY

Dùng thử trực tuyến!

Xây dựng một ™ sáng hơn theo cách khác xung quanh các ví dụ như:

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

Làm sao?

2*×5H_2Bị⁾ | - Link 1, pipes & spaces: n      e.g. 7
2*           - 2 raised to the nth power      e.g. 128
  ×5         - multiply by 5                  e.g. 640
    H        - halve                          e.g. 320
     _2      - subtract 2                     e.g. 318
       B     - convert to binary              e.g. [1,0,0,1,1,1,1,1,0]
        ị    - index into (1-based)
         ⁾ | - char list " |"                 e.g. " ||     |"

_3”-ẋ”+;;Çsẋ2U3¦ṁµY - Main link: n            e.g. 7
_3                  - n - 3                   e.g. 4
  ”-                - char list "-"
    ẋ               - repeat                  e.g. "----"
     ”+             - char list "+"
       ;            - concatenate             e.g. "+----"
         Ç          - call last link (1) as a monad
        ;           - concatenate             e.g. "+---- ||     |"" 
          s         - split into chunks of n  e.g. ["+---- |","|     |"]
           ẋ2       - repeat 2 times          e.g. ["+---- |",
                                                    "|     |",
                                              +-->  "+---- |",
                                              |     "|     |"]
              3¦    - apply to index 3:       |
             U      -    upend                +---  "| ----+"
                ṁ   - mould like n (i.e. repeat to fill)
                 µ  - monadic chain separation
                  Y - join with line feeds

(mỗi byte được lưu liên quan đến các thay đổi không tầm thường, hãy xem lịch sử chỉnh sửa nếu bạn quan tâm, mặc dù tôi chỉ nhận thấy rằng Liên kết 1 có cùng số byte như lặp lại và tham gia thông thường hơn _2⁶ẋ“ ||“|”j:)

JavaScript (ES6), 86 92 116

Gần như là một thử thách phức tạp kolmogorv ... Với một chút suy nghĩ bên lề (lấy cảm hứng từ câu trả lời của @ Neil), nó có thể rất ngắn. Chỉ cần quay 90 °

n=>`|${s=' '[r='repeat'](n-2)}|
| ${h='-'[r](n-3)}+
|${s}|
+${h} |
`[r](n).slice(n*~n)

Kiểm tra

f=
n=>`|${s=' '[r='repeat'](n-2)}|
| ${h='-'[r](n-3)}+
|${s}|
+${h} |
`[r](n).slice(n*~n)

function update() {
  var i=+I.value
  O.textContent=i&1? f(i): 'even'
}

update()

<input id=I value=7 min=5 max=49 step=2 type=number oninput="update()"><pre id=O><pre>

Mẻ, 216 byte

@echo off
set s=
for /l %%i in (4,1,%1)do call set s=-%%s%%
set b= %s:-= %
set r=! %s%+
set s=+%s% !
call:e
for /l %%i in (5,2,%1)do call:l
:l
echo ^|%b%^|
set t=%s%
set s=%r%
set r=%t%
:e
echo %s:!=^|%

|s là vụng về trong Batch vì vậy tôi đã phản ánh xoay các ví dụ thay thế.

PHP, 99 byte

lên đến cổng

for($s=str_pad("\n| ",$c=$argv[1],"-")."+\n";$i++<$c;)echo$i%2?$s=strrev($s):str_pad("|",$c-1)."|";

PHP, 157 byte

cổng bên trái

<?=($p=str_pad)($n="\n",$c=1+$argv[1],"+---").$p($n,$c-1,"|   ")." #|"[$c%4].str_repeat($p($n,$c,"| "),$c-5).$p($n,$c-1,"  | ")."|# "[$c%4].$p($n,$c,"--+-");

@Titus Cảm ơn bạn đã minialize các byte

JavaScript (ES6), 87 byte

Một hàm đệ quy. Xuất ra một vài dấu cách.

f=(n,w=n,s=' -'[n&1].repeat(w-3),c='|+'[n&1])=>n?`
`+(n&2?c+s+' |':'| '+s+c)+f(n-1,w):s

Kiểm tra

f=(n,w=n,s=' -'[n&1].repeat(w-3),c='|+'[n&1])=>n?`
`+(n&2?c+s+' |':'| '+s+c)+f(n-1,w):s

console.log(f(9));

Ruby 72 hoặc 69 byte

Hàm Lambda. Như được hiển thị, trả về một chuỗi phân tách dòng mới. Xóa * $ / để trả về một chuỗi các chuỗi.

->n{(1..n).map{|i|"|%s |+%s || %s|| %s+"[i%4*5,5]%(" -"[i%2]*(n-3))}*$/}

Vẽ một mê cung xoay 90 độ từ các ví dụ. Đối với mỗi dòng, một chuỗi định dạng được chọn (ví dụ +%s |cho dòng thứ nhất (không có dòng zeroth) và %sđược thay thế bằng số lượng -hoặc khoảng trắng thích hợp sử dụng %toán tử (tương đương với sprintf, nhưng ngắn hơn.)

Java 7, 228 byte

String c(int n){String a="+x |",b="|y|\n",x,y,r=x=y="";int i=0;for(;i++<n-2;){x+=i>1?"-":"";y+=" ";}a=a.replace("x",x);b=b.replace("y",y);for(i=0;i<n;i++)r+=i%4<1?a+"\n":(i-2)%4==0?new StringBuffer(a).reverse()+"\n":b;return r;}

Sử dụng một đầu ra dọc tương tự như @JonathanAllan Jelly câu trả lời 's .

Mã thử nghiệm & mã hóa:

Hãy thử nó ở đây.

class M{
  static String c(int n){
    String a = "+x |",
           b = "|y|\n",
           x = "",
           y = "",
           r = "";
    int i = 0;
    for (; i++ < n-2;){
      x += i > 1
            ? "-"
            : "";
      y += " ";
    }
    a = a.replace("x", x);
    b = b.replace("y", y);
    for(i = 0; i < n; i++){
      r += i % 4 < 1
            ? a+"\n"
            : (i-2) % 4 == 0
               ? new StringBuffer(a).reverse()+"\n"
               : b;
    }
    return r;
  }

  public static void main(String[] a){
    System.out.println(c(7));
    System.out.println();
    System.out.println(c(25));
  }
}

Đầu ra:

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


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

Python 2, 89 byte

def f(n):x='+'+'-'*(n-3)+' |';y='|'+' '*(n-2)+'|';print'\n'.join(([x,y,x[::-1],y]*n)[:n])

thay thế

Xây dựng một bức tường bên trong x, như '+---- |'và một hành lang bên trong y, như '| |'
Then xây dựng một danh sách [x,y,x[::-1],y]( x[::-1]là đảo ngược x)
Sau đó lặp lại danh sách đó nlần (như một danh sách) *n, và cắt nó thành các nmục đầu tiên , với (...)[:n], tham gia danh sách với các nguồn cấp dữ liệu, với '\n'.join(...)và in kết quả.

Vợt 187 byte

Sử dụng mẫu hiển thị của @Jonathan ALLan

(let*((u "+---- |")(v "|     |")(sr(λ(s)(list->string(reverse(string->list s)))))(g #t)(d displayln)
(p(λ()(d(if g u(sr u)))(set! g(if g #f #t)))))(for((i(ceiling(/ n 2))))(p)(d v))(p))

Ung dung:

(define (f n)
  (let* ((sr (lambda(s)
               (list->string
                (reverse
                 (string->list s)))))
         (u "+---- |")
         (v "|     |")
         (g #t)
         (d displayln)
         (p (lambda()
              (d (if g u (sr u)))
              (set! g (if g #f #t)))))
    (for ((i (ceiling (/ n 2))))
      (p)
      (d v))
    (p)))

Kiểm tra:

(f 10)

Đầu ra:

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

GNU sed 140 byte

Bao gồm +1 cho -r

s/1{5}//
h
s/^/+---+\n|   |\n| | |\n  |  \n--+--/
/1/!b
:w
s/^..(..)[^$]*/\1&/gm
s/11//
/1/bw
G
:h
s/\n[^\n]*\n([^\n]*\n)/&\1/
s/1//
/1/bh

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

Đưa đầu vào trong unary ( xem sự đồng thuận này ).

Về cơ bản, nó chèn mê cung kích thước 5, sau đó nối thêm ký tự thứ 2 và thứ 3 của mỗi dòng vào đầu nhiều lần nếu cần. Sau đó nhân đôi dòng thứ 3 (xen kẽ |và ) nhiều lần nếu cần.

Điều thú vị duy nhất mà tôi đã sử dụng là mtùy chọn trên dòng 6 cho phép ^và$ khớp tương ứng (ngoài hành vi thông thường) chuỗi trống sau một dòng mới và chuỗi trống trước một dòng mới.

T-SQL, 123/79 byte

Chơi gôn

DECLARE @i INT=7

,@ INT=0z:PRINT
STUFF(CHOOSE(@%4+1,'+- |','|  |','| -+','|  |'),3,0,REPLICATE(IIF(@%2=0,'-',' '),@i))SET
@+=1IF @<@i GOTO z

Ung dung:

DECLARE @i INT = 9

DECLARE @i INT=7

,@ INT=0
z:
  PRINT 
    STUFF(CHOOSE(@%4+1,'+- |','|  |','| -+','|  |'),3,0,
      REPLICATE(IIF(@%2=0,'-',' '),@i))
  SET @+=1
IF @<@i GOTO z

Nếu bạn gian lận và chỉ tạo ra một mê cung hẹp, kịch bản có thể được giảm xuống còn 79 byte:

Chơi gôn

DECLARE @i INT = 9

,@ INT=0z:PRINT CHOOSE(@%4+1,'+- |','|  |','| -+','|  |')SET @+=1IF @<@i GOTO z

Ung dung:

DECLARE @i INT = 9

,@ INT=0
z:
  PRINT CHOOSE(@%4+1,'+- |','|  |','| -+','|  |')
  SET @+=1
IF @<@i GOTO z

Fiddle cho câu trả lời dài

JavaScript (ES6), 96 byte

f=(n,w=n-3)=>(h="-".repeat(w),n&2?`+${h} |`:`| ${h}+`)+(n>1?`
| ${" ".repeat(w)}|
`+f(n-2,w):"")

Tôi đã hy vọng đệ quy sẽ trở thành con đường ngắn nhất, và rõ ràng đó là ...