生成单路径迷宫

12

给定一个奇数N（5 <= N <= 51），生成一个边长为N的迷宫，其遵循以下要求：

迷宫必须由字符 | -和组成+。它必须将|角色用作垂直墙，将-角色用作水平墙，并且如果该墙转弯，+则应使用角色。

路径的宽度必须是一个字符。

迷宫必须转动至少四次。

迷宫必须具有外壁，该壁在两个点处断裂：起点和终点。

从头到尾，迷宫必须包含一条不间断的路径。

例如，以下是有效的迷宫：（N = 5）

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

对于N = 7：

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

请记住，这是code-golf，所以字节数最少的代码将获胜。

code-golf  ascii-art  maze 
— 倪
source
9
这不是迷宫，而是迷宫english.stackexchange.com/a/144103/199361
— edc65
@ edc65实际上，它的夜晚。
— 奥利弗·尼
我不清楚“从开始到结束，迷宫必须由一条不间断的路径组成”。这是否意味着只有一条路径并且是从开始到结束，或者从开始到结束的路径数是1？会有其他死胡同的道路吗？单独的循环？
— xnor
奇数整数应为<50，<= 49
— pinkfloydx33
2
@ edc65我认为OP都不是。
— orlp

Answers:

10

果冻，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）

— 乔纳森·艾伦
source
5

的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>
展开摘要

— edc65
source
@Neil哇，我每天都学到新东西。谢谢
— edc65
惊人！我数了86个字节，顺便说一句
— ETHproductions '16
@ETHproductions正确。谢谢
— edc65
4

批处理，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为在批处理别扭所以反射旋转的例子来代替。

— 尼尔
source
您是说旋转90°吗？我尝试过，并在JS中节省了很多。再次感谢
— edc65
@ edc65我原本打算进行反射，但是您没错，我最终还是轮换了。
— 尼尔
3

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谢谢您最小化字节

— 约格·赫尔瑟曼
source
1
通过分配`$ n =“ \ n”节省3个字节
— Titus
1
$p("",$c*($c-4),...)而不是str_repeat(...,$c-4)（-2）
— 泰特斯
1
...以及另外3个字节，$p($n,$c-1," | ")而不是$p("\n ",$c-1," | ")
— Titus
1
($c)%4（-2）中不必要的括号，$g从代码（-1）中删除
— Titus
1
从上到下的版本；对于str_pad不必要第三参数（-4），$c=$argv[1]-1而不是($c=$argv[1])-1，<=$c代替<$c和$c代替$c-1（-3）
— 泰特斯
3

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

测试

显示代码段

— Arnauld
source
哦，我刚刚尝试了递归，结果却增加了9个字节。做得好:-)
— ETHproductions '16
2

Ruby 72或69个字节

Lambda函数。如图所示，返回以换行符分隔的字符串。删除* $ /以返回字符串数组。

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

从示例绘制一个旋转90度的迷宫。对于每一行，选择一个格式字符串（例如+%s |，对于第一行（没有第零行）），并使用运算符将%s替换为适当数量的-或空格%（等效于sprintf，但更短）。

— Level River St
source
2

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的Jelly answer类似的垂直输出。

取消测试代码：

在这里尝试。

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

输出：

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


+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
— 凯文·克鲁伊森
source
借口，但是Given an odd integer N (5 <= N <= 51), generate a maze with side length N。您的顶面和底面长度似乎有所不同...
— 破坏的柠檬
@DestructibleWatermelon我读完了。我的代码仍然符合所有规则/要求。嗯，我已经回滚到原来的答案，该答案使用与高度相同的宽度。
— 凯文·克鲁伊森
1

Python 2，89个字节

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

代表

构建一个内部壁，x，像'+---- |'和内部走廊，y一样'| |'
然后建立的一个列表[x,y,x[::-1],y]（x[::-1]是的反向x）
。然后重复该列表n的时间（作为一个单一的列表），与*n和其截短到第一n条目，具有(...)[:n]，连接带有换行符的列表，带有'\n'.join(...)，并打印结果。

— 乔纳森·艾伦
source
1

球拍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))

取消高尔夫：

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

输出： 

+---- |
|     |
| ----+
|     |
+---- |
|     |
| ----+
|     |
+---- |
|     |
| ----+
— 恩索
source
1

GNU sed 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

在线尝试！

以一元形式输入（请参阅此共识）。

基本上，它会插入大小为5的迷宫，然后根据需要将每行的第二个和第三个字符追加到开头。然后根据需要重复第三行（交替显示|和）。

我使用的唯一有趣的东西是第m6行的选项，该选项允许^和$匹配（除了正常行为）换行符之后的空字符串和换行符之前的空字符串。

— 赖利
source
1

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

取消高尔夫：

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

取消高尔夫：

DECLARE @i INT = 9

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

拨弄长答案

— 克劳森
source
0

JavaScript（ES6），96个字节

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

我希望递归将成为最短的路线，显然这是 ...

— ETH生产
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.