รับจำนวนเต็มคี่N (5 <= N <= 51) สร้างเขาวงกตที่มีความยาวด้านNที่เป็นไปตามข้อกำหนดต่อไปนี้:

เขาวงกตต้องประกอบด้วยตัวอักษรและ | - +มันจะต้องใช้|ตัวละครเป็นกำแพงแนวตั้ง-ตัวละครเป็นผนังแนวนอนและหากผนังนั้นเปลี่ยน+ควรใช้ตัวละคร

ความกว้างของเส้นทางต้องเป็นอักขระหนึ่งตัว

เขาวงกตต้องหมุนอย่างน้อยสี่ครั้ง

เขาวงกตจะต้องมีผนังด้านนอกแบ่งที่สองจุด: จุดเริ่มต้นและจุดสิ้นสุด

เขาวงกตจะต้องประกอบด้วยเส้นทางที่ไม่แตกเส้นทางเดียวตั้งแต่ต้นจนจบ

ตัวอย่างเช่นต่อไปนี้เป็นเขาวงกตที่ถูกต้อง: ( N = 5)

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

และสำหรับN = 7:

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

จำไว้ว่านี่คือcode-golfดังนั้นโค้ดที่มีจำนวนไบต์น้อยที่สุดจะเป็นผู้ชนะ

เยลลี่ , 36 35 34 33 32 ไบต์

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

TryItOnline!

สร้าง nighter ™ในลักษณะอื่น ๆ เช่น:

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

อย่างไร?

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

(แต่ละไบต์บันทึกที่เกี่ยวข้องกับการเปลี่ยนแปลงอย่างเป็นธรรมไม่น่ารำคาญดูประวัติการแก้ไขหากคุณสนใจ แต่ผมเพิ่งสังเกตเห็นว่าการเชื่อมโยงที่ 1 คือการนับไบต์เช่นเดียวกับการทำซ้ำแบบเดิมมากขึ้นและเข้าร่วม: _2⁶ẋ“ ||“|”j)

JavaScript (ES6), 86 92 116

เกือบจะเป็นความท้าทายที่ซับซ้อนของ kolmogorv ... ด้วยการคิดนอกกรอบเล็กน้อย (ได้รับแรงบันดาลใจจากคำตอบของ @ Neil) มันอาจสั้นกว่านี้มาก แค่เลี้ยว 90 °

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

ทดสอบ

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>

แบตช์ 216 ไบต์

@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 อึดอัดใจในแบทช์ดังนั้นฉันจึงแสดงตัวอย่างที่หมุนแล้วแทน

PHP, 99 ไบต์

ขึ้นไปลงประตู

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

PHP, 157 ไบต์

ประตูด้านซ้ายซ้าย

<?=($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ขอขอบคุณสำหรับการลดขนาดไบต์

JavaScript (ES6), 87 ไบต์

ฟังก์ชั่นวนซ้ำ ส่งออกช่องว่างต่อท้ายไม่กี่

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

ทดสอบ

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 หรือ 69 ไบต์

ฟังก์ชั่นแลมบ์ดา ดังที่แสดงแล้วส่งคืนสตริงที่คั่นด้วยบรรทัดใหม่ ลบ * $ / เพื่อส่งกลับอาร์เรย์ของสตริง

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

ดึงเขาวงกตที่หมุนได้ 90 องศาจากตัวอย่าง สำหรับแต่ละบรรทัดสตริงรูปแบบจะถูกเลือก (ตัวอย่างเช่น+%s |สำหรับบรรทัดที่ 1 (ไม่มีบรรทัด zeroth) และ%sจะถูกแทนที่ด้วยหมายเลข appopriate -หรือช่องว่างโดยใช้%โอเปอเรเตอร์ (เทียบเท่ากับ sprintf แต่สั้นกว่า)

Java 7, 228 ไบต์

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

ใช้การส่งออกในแนวตั้งที่คล้ายกันเป็น@JonathanAllan 's คำตอบวุ้น

Ungolfed & รหัสการทดสอบ:

ลองที่นี่

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

เอาท์พุท:

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


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

Python 2, 89 ไบต์

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

repl.it

สร้างผนังภายในxเช่น'+---- |'และทางเดินภายในyเช่น'| |'
นั้นสร้างรายการของ[x,y,x[::-1],y]( x[::-1]เป็นย้อนกลับของx)
แล้วซ้ำว่ารายการnครั้ง (เป็นรายการเดียว) ด้วย*nและตัดทอนมันจะเป็นครั้งแรกที่nรายการที่มี(...)[:n]ร่วม รายการที่มีการป้อนบรรทัดด้วย'\n'.join(...)และพิมพ์ผลลัพธ์

แร็กเก็ต 187 ไบต์

ใช้รูปแบบการแสดงผลโดย @JonathanAllan

(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))

Ungolfed:

(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)))

การทดสอบ:

(f 10)

เอาท์พุท:

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

GNU ทำงานได้ 140 ไบต์

รวม +1 สำหรับ -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

ลองออนไลน์!

รับอินพุตเป็น unary ( ดูข้อตกลงนี้ )

โดยพื้นฐานแล้วมันจะแทรกเขาวงกตขนาด 5 จากนั้นผนวกอักขระที่ 2 และ 3 ของแต่ละบรรทัดเข้ากับจุดเริ่มต้นหลาย ๆ ครั้งตามต้องการ จากนั้นทำซ้ำบรรทัดที่ 3 (สลับ|และ) ซ้ำหลาย ๆ ครั้งตามต้องการ

สิ่งเดียวที่น่าสนใจที่ฉันใช้คือmตัวเลือกในบรรทัดที่ 6 ซึ่งอนุญาต^และ$จับคู่ตามลำดับ (นอกเหนือจากพฤติกรรมปกติ) สตริงว่างหลังจากขึ้นบรรทัดใหม่และสตริงว่างก่อนขึ้นบรรทัดใหม่

T-SQL, 123/79 ไบต์

แข็งแรงเล่นกอล์ฟ:

DECLARE @i INT=7

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

Ungolfed:

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

หากคุณโกงและสร้างเขาวงกตที่แคบสคริปต์จะสามารถลงไปได้ที่ 79 ไบต์:

แข็งแรงเล่นกอล์ฟ:

DECLARE @i INT = 9

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

Ungolfed:

DECLARE @i INT = 9

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

ซอสำหรับคำตอบที่ยาว

JavaScript (ES6), 96 ไบต์

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

ฉันหวังว่าการสอบถามซ้ำจะกลายเป็นเส้นทางที่สั้นที่สุดและเห็นได้ชัดว่ามันคือ ...