Создайте односторонний лабиринт

12

Учитывая нечетное целое число N (5 <= N <= 51), сгенерируйте лабиринт с длиной стороны N, которая соответствует следующим требованиям:

Лабиринт должен состоять из символов | -и +. Он должен использовать |персонажа как вертикальную стену, -персонаж как горизонтальную стену, и если эта стена поворачивается, персонаж +должен использоваться.

Ширина пути должна быть одним символом.

Лабиринт должен поворачиваться как минимум четыре раза.

Лабиринт должен иметь внешние стены, которые ломаются в двух точках: в начале и в конце.

Лабиринт должен состоять из одного неразрывного пути, от начала до конца.

Например, следующее является допустимым лабиринтом: ( N = 5)

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

И для N = 7:

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

Помните, что это , поэтому выигрывает код с наименьшим количеством байтов.

Оливер Ни
источник
9
Это не лабиринт, это лабиринт english.stackexchange.com/a/144103/199361
edc65
@ edc65 На самом деле, его ночь.
Оливер Ни
Мне не ясно, «Лабиринт должен состоять из одного неразрывного пути, от начала до конца». Означает ли это, что существует только один путь от начала до конца или что число путей от начала до конца равно 1? Могут ли быть другие пути с тупиками? Отдельные петли?
xnor
Нечетное целое число должно быть <50, <= 49
pinkfloydx33
2
@ edc65 Я полагаю, что OP означает ни то, ни другое.
orlp

Ответы:

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)

Джонатан Аллан
источник
5

JavaScript (ES6), 86 92 116

Почти сложность колмогорва ... С небольшим боковым размышлением (вдохновленным ответом @ 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
источник
@ Ней вау, каждый день я узнаю что-то новое. Спасибо
edc65
Удивительный! Я считаю 86 байтов , кстати
ETHproductions
@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:!=^|%

|В пакетном режиме это неудобно, поэтому я решил повернуть вместо этого примеры.

Нил
источник
Вы имеете в виду поворот на 90 °? Я попробовал это и многое сохранил в JS.
Еще
@ 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 Спасибо за миниализацию байтов

Йорг Хюльсерманн
источник
1
сохранить 3 байта, присваивая `$ n =" \ n "
Тит
1
$p("",$c*($c-4),...)вместо str_repeat(...,$c-4)(-2)
Тит
1
... и еще 3 байта $p($n,$c-1," | ")вместо$p("\n ",$c-1," | ")
Тит
1
ненужные парены в ($c)%4(-2), убрать $gиз кода (-1)
Тит
1
до-к-вниз версии; ненужный 3-й параметр для 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
источник
Ого, я только что попробовал рекурсию и закончил на 9 байт дольше. Молодцы :-)
ETHproductions
2

Рубин 72 или 69 байт

Лямбда-функция. Как показано, возвращает строку, разделенную символом новой строки. Удалите * $ /, чтобы вернуть массив строк.

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

Рисует лабиринт, повернутый на 90 градусов из примеров. Для каждой строки выбирается строка формата (например, +%s |для 1-й строки (нулевая строка отсутствует), и %sона заменяется подходящим числом -или пробелами с использованием %оператора (эквивалентно sprintf, но короче.)

Уровень реки St
источник
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;}

Использовал аналогичный вертикальный вывод как ответ Jelly @JonathanAllan .

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

Выход:

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


+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
Кевин Круйссен
источник
извините, но 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])

repl.it

Создает внутреннюю стену, xкак '+---- |'и внутренний коридор, yкак '| |'
Затем строит список [x,y,x[::-1],y]( x[::-1]является обратным x)
Затем повторяет этот список nраз (как один список), с *nи усекает его до первых nзаписей, с (...)[:n], присоединяется список с переводами строк, с '\n'.join(...)и выводит результат.

Джонатан Аллан
источник
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))

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)

Выход:

+---- |
|     |
| ----+
|     |
+---- |
|     |
| ----+
|     |
+---- |
|     |
| ----+
rnso
источник
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, затем добавляет в начало 2-й и 3-й символ каждой строки столько раз, сколько необходимо. Затем дублирует 3-ю строку (чередуя |и ) столько раз, сколько необходимо.

Единственная интересная вещь, которую я использовал, - это mопция в строке 6, которая позволяет ^и $сопоставляет (в дополнение к обычному поведению) пустую строку после новой строки и пустую строку перед новой строкой.

Райли
источник
1

T-SQL, 123/79 байт

Golfed:

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 байтов:

Golfed:

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

Скрипка для длинного ответа

t-clausen.dk
источник
0

JavaScript (ES6), 96 байт

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

Я надеялся, что рекурсия окажется самым коротким маршрутом, и, видимо, это ...

ETHproductions
источник