एक-पथ भूलभुलैया बनाएँ


12

एक विषम पूर्णांक को देखते हुए एन (5 <= एन <= 51), के साथ कंधे लंबाई एक उलझन उत्पन्न एन कि निम्न आवश्यकताओं को इस प्रकार है:

भूलभुलैया पात्रों से बना होना चाहिए | -और +। यह |एक ऊर्ध्वाधर दीवार के रूप में चरित्र का उपयोग करना चाहिए , -एक क्षैतिज दीवार के रूप में चरित्र, और यदि वह दीवार बदल जाती है, तो चरित्र +का उपयोग किया जाना चाहिए।

पथ की चौड़ाई एक वर्ण होनी चाहिए।

भूलभुलैया को कम से कम चार बार मोड़ना होगा।

भूलभुलैया में बाहरी दीवारें होनी चाहिए, जो दो बिंदुओं पर टूटती हैं: शुरुआत और अंत।

भूलभुलैया में शुरू से अंत तक एक गैर-ब्रेकिंग पथ शामिल होना चाहिए।

उदाहरण के लिए, निम्नलिखित एक वैध भूलभुलैया है: ( एन = 5)

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

और एन = 7 के लिए:

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

याद रखें, यह , इसलिए सबसे कम संख्या में बाइट्स जीतता है।


9
यह भूलभुलैया नहीं है, यह एक भूलभुलैया है english.stackexchange.com/a/144103/199361
edc65

@ edc65 वास्तव में, इसका हल्का।
ओलिवर नी

मैं स्पष्ट नहीं हूँ "भूलभुलैया शुरू से अंत तक एक गैर-ब्रेकिंग पथ से युक्त होना चाहिए।" क्या इसका मतलब यह है कि केवल एक-पथ है और यह शुरू से अंत तक है, या यह कि शुरू से अंत तक पथ की संख्या 1 है? क्या मृत सिरों वाले अन्य रास्ते हो सकते हैं? अलग छोरों?
xnor

अजीब पूर्णांक होना चाहिए <50, <= 49
Pinkfloydx33

2
@ edc65 मेरा मानना ​​है कि ओपी का मतलब न तो है।
orlp

जवाबों:


10

जेली , 36 35 34 33 32 बाइट्स

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

TryItOnline!

उदाहरण के लिए चारों ओर एक हल्का ™ बनाता है:

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

कैसे?

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

जावास्क्रिप्ट (ईएस 6), 86 92 116

लगभग एक कोल्मोगोरव-जटिलता चुनौती ... थोड़ा पार्श्व सोच (@ नील के उत्तर से प्रेरित) के साथ, यह बहुत कम हो सकता है। बस 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

गजब का! मैं 86 बाइट्स गिनता हूं , btw
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 ° घूमना? मैंने इसकी कोशिश की और जेएस में बहुत बचत की। धन्यवाद फिर से
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,"--+-");

@ टिट्स बाइट्स को छोटा करने के लिए धन्यवाद


1
'' $ n = "\ n" बताकर 3 बाइट्स बचाएं
टाइटस

1
$p("",$c*($c-4),...)str_repeat(...,$c-4)(-2) के बजाय
टाइटस

1
... और 3 बाइट्स के $p($n,$c-1," | ")बजाय$p("\n ",$c-1," | ")
टाइटस

1
अनावश्यक ($c)%4-2 (-2), $gकोड (-1) से हटा दें
टाइटस

1
अप-टू-नीचे-संस्करण; (-4), str_pad के लिए अनावश्यक 3 पैरामीटर $c=$argv[1]-1के बजाय ($c=$argv[1])-1, <=$cके बजाय <$cऔर $cके बजाय $c-1(-3)
टाइटस

3

जावास्क्रिप्ट (ईएस 6), 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

परीक्षा


अरे वाह, मैंने बस पुनरावृत्ति की कोशिश की और 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स्प्रिंटफ के बराबर, लेकिन कम) के साथ -रिक्त स्थान की एक संख्या के साथ किया जाता है %


2

जावा 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 के जेली उत्तर के रूप में एक समान ऊर्ध्वाधर आउटपुट का उपयोग किया ।

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

पायथन 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)

आउटपुट:

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

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 वें चरित्र को शुरुआत में आवश्यकतानुसार कई बार जोड़ता है। फिर 3rd लाइन (प्रत्यावर्तन |और ) को कई बार करता है।

केवल दिलचस्प बात यह है कि मैं प्रयोग किया जाता है mलाइन 6 जो की अनुमति देता है पर विकल्प ^और $एक नई पंक्ति के बाद क्रमश: मैच के लिए (सामान्य व्यवहार के अलावा) रिक्त स्ट्रिंग, और रिक्त स्ट्रिंग एक नई पंक्ति से पहले।


1

टी-एसक्यूएल, 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

लंबे उत्तर के लिए फिडल


0

जावास्क्रिप्ट (ईएस 6), 96 बाइट्स

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

मैं उम्मीद कर रहा था कि पुनरावृत्ति सबसे छोटा मार्ग होगा, और जाहिर है कि यह है ...

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.