Erstellen Sie ein Ein-Pfad-Labyrinth

12

Erzeugen Sie bei einer ungeraden ganzen Zahl N (5 <= N <= 51) ein Labyrinth mit der Seitenlänge N , das den folgenden Anforderungen entspricht:

Das Labyrinth muss aus den Zeichen | -und bestehen +. Der |Charakter muss als vertikale Wand, der -Charakter als horizontale Wand +verwendet werden. Wenn sich diese Wand dreht, sollte der Charakter verwendet werden.

Die Breite des Pfades muss ein Zeichen sein.

Das Labyrinth muss sich mindestens viermal drehen.

Das Labyrinth muss Außenwände haben, die an zwei Stellen brechen: am Anfang und am Ende.

Das Labyrinth muss von Anfang bis Ende aus einem einzigen, nicht brechenden Pfad bestehen.

Das folgende Beispiel ist ein gültiges Labyrinth: ( N = 5)

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

Und für N = 7:

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

Denken Sie daran, das ist , also gewinnt der Code mit der geringsten Anzahl von Bytes.

Oliver Ni
quelle
9
Es ist nicht ein Labyrinth, es ist ein Labyrinth english.stackexchange.com/a/144103/199361
edc65
@ edc65 Eigentlich ist es nighter.
Oliver Ni
Ich bin mir nicht sicher "Das Labyrinth muss von Anfang bis Ende aus einem Weg bestehen, der nicht bricht." Bedeutet dies, dass es nur einen Pfad von Anfang bis Ende gibt oder dass die Anzahl der Pfade von Anfang bis Ende 1 beträgt? Kann es andere Wege mit Sackgassen geben? Separate Schleifen?
Xnor
Eine ungerade Ganzzahl sollte <50, <= 49 sein
pinkfloydx33
2
@ edc65 Ich nehme an, OP bedeutet weder.
Orlp

Antworten:

10

Jelly , 36 35 34 33 32 Bytes

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

TryItOnline!

Bauen Sie ein Nachtflugzeug andersherum zu den Beispielen wie:

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

Wie?

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

(jedes Byte gespeicherten ziemlich nicht-triviale Änderungen beteiligt, die Versionsgeschichte sehen , ob Sie daran interessiert sind, obwohl ich gerade bemerkt , dass Verbindung 1 ist die gleiche Byteanzahl als konventionellere wiederholen und kommen: _2⁶ẋ“ ||“|”j)

Jonathan Allan
quelle
5

JavaScript (ES6), 86 92 116

Fast eine Herausforderung der Kolmogorv-Komplexität ... Mit ein wenig Querdenken (inspiriert von der Antwort von @ Neil) kann es sehr viel kürzer sein. Einfach um 90 ° drehen

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

Prüfung

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
quelle
@Neil wow ich lerne jeden Tag was neues. Thanks
edc65
Tolle! Ich zähle 86 Bytes , übrigens
ETHproductions
@ETHproductions richtig. Thanks
edc65
4

Stapel, 216 Bytes

@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 sind umständlich in Batch , damit ich reflektiertes die Beispiele stattdessen gedreht.

Neil
quelle
Meinen Sie 90 ° drehen? Ich habe es versucht und in JS viel gespart.
Nochmals vielen
@ edc65 Ich wollte ursprünglich überlegen, aber du hast recht damit, dass ich stattdessen eine Rotation hatte.
Neil
3

PHP, 99 Bytes

Up-Down-Tore

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

PHP, 157 Bytes

links rechts Tore

<?=($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 Vielen Dank, dass Sie die Bytes minimiert haben

Jörg Hülsermann
quelle
1
Speichern Sie 3 Bytes, indem Sie "$ n =" \ n "zuweisen
Titus
1
$p("",$c*($c-4),...)anstelle von str_repeat(...,$c-4)(-2)
Titus
1
... und 3 weitere Bytes mit $p($n,$c-1," | ")statt$p("\n ",$c-1," | ")
Titus
1
Unnötige Parens bei ($c)%4(-2), $gaus dem Code entfernen (-1)
Titus
1
Up-to-Down-Version; unnötiger 3. Parameter für str_pad (-4), $c=$argv[1]-1anstelle von ($c=$argv[1])-1, <=$canstelle von <$cund $canstelle von $c-1(-3)
Titus
3

JavaScript (ES6), 87 Byte

Eine rekursive Funktion. Gibt einige nachgestellte Leerzeichen aus.

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

Prüfung

Arnauld
quelle
Oh wow, ich habe gerade eine Rekursion versucht und bin 9 Bytes länger geblieben. Gut gemacht :-)
ETHproductions
2

Ruby 72 oder 69 Bytes

Lambda-Funktion. Gibt wie gezeigt eine durch Zeilenumbrüche getrennte Zeichenfolge zurück. Löschen Sie * $ /, um ein Array von Zeichenfolgen zurückzugeben.

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

Zeichnet ein um 90 Grad gedrehtes Labyrinth aus den Beispielen. Für jede Zeile wird eine Formatzeichenfolge ausgewählt (z. B. +%s |für die erste Zeile (es gibt keine nullte Zeile) und diese mit dem Operator %sdurch eine entsprechende Anzahl von -oder Leerzeichen ersetzt %(entspricht sprintf, ist jedoch kürzer).

Level River St
quelle
2

Java 7, 228 Bytes

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

Verwendete eine ähnliche vertikale Ausgabe wie @JonathanAllans Gelee-Antwort .

Ungolfed & Testcode:

Probieren Sie es hier aus.

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

Ausgabe:

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


+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
|                       |
| ----------------------+
|                       |
+---------------------- |
Kevin Cruijssen
quelle
Entschuldigung, aber Given an odd integer N (5 <= N <= 51), generate a maze with side length N. Sie haben anscheinend eine andere Ober- und Unterseite für Ihre ...
Destructible Lemon
@DestructibleWatermelon Ich habe darüber gelesen. Mein Code entsprach dennoch allen Regeln / Anforderungen. Na ja, ich habe auf meine ursprüngliche Antwort zurückgesetzt, die die gleiche Breite wie die Höhe verwendet hat.
Kevin Cruijssen
1

Python 2, 89 Bytes

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

repl.it

Erstellt eine interne Wand, xwie '+---- |'und einen internen Korridor, ywie. '| |'
Erstellt dann eine Liste von [x,y,x[::-1],y]( x[::-1]ist eine Umkehrung von x).
Wiederholt dann diese Listenzeiten n(als einzelne Liste) mit *nund schneidet sie bis zu den ersten nEinträgen mit (...)[:n], zusammen Die Liste mit Zeilenumbrüchen, mit '\n'.join(...)und druckt das Ergebnis.

Jonathan Allan
quelle
1

Schläger 187 Bytes

Verwenden des Anzeigemusters von @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)))

Testen:

(f 10)

Ausgabe:

+---- |
|     |
| ----+
|     |
+---- |
|     |
| ----+
|     |
+---- |
|     |
| ----+
rnso
quelle
1

GNU sed 140 Bytes

Beinhaltet +1 für -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

Probieren Sie es online!

Nimmt Eingaben unärgerlich auf ( siehe Konsens) ).

Grundsätzlich wird das Labyrinth der Größe 5 eingefügt und dann das zweite und dritte Zeichen jeder Zeile so oft wie nötig an den Anfang angehängt. Dann dupliziert die 3. Zeile (abwechselnd |und ) so oft wie nötig.

Die einzige interessante Sache , die ich verwendet , ist die mOption auf Linie 6 , die erlaubt ^und $jeweils (zusätzlich zu dem normalen Verhalten) , um die leere Zeichenkette nach einem Newline und die leere Zeichenkette , bevor eine neue Zeile zu entsprechen.

Riley
quelle
1

T-SQL, 123/79 Bytes

Golf gespielt:

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

Wenn Sie schummeln und nur ein schmales Labyrinth bilden, kann das Skript auf 79 Bytes heruntergespielt werden:

Golf gespielt:

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

Geige für die lange Antwort

t-clausen.dk
quelle
0

JavaScript (ES6), 96 Byte

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

Ich hatte gehofft, dass Rekursion der kürzeste Weg sein würde, und anscheinend ist es ...

ETHproductions
quelle