पुल ASCII कला में सब कुछ के लिए रूपक हैं

Question

( शीर्षक के लिए जिम वेस्ट से माफी के साथ , और बेतरतीब ढंग से सिस्को के लोगो द्वारा उनके लोगो का प्रतिनिधित्व करने के लिए प्रेरित: .:|:.:|:. अवधारणा के लिए)

इनपुट पूर्णांक को देखते हुए 1 <= n <= 255, nनिम्न निर्माण नियमों का पालन करते हुए दूरी के एक निलंबन पुल का ASCII कला प्रतिनिधित्व आउटपुट :

• पुल का प्रारंभ और अंत ( nदूरी में गिना नहीं जाता है ) हमेशा -|और |-, इसलिए पुल उचित रूप से इसके बगल के राजमार्गों से जुड़ सकता है।
• पुल नीचे की ओर विस्तार नहीं करता है (सड़क का स्तर, -पंक्ति से बना , नीचे पंक्ति है)।
• --एक पंक्ति में अधिकतम दो सड़क मार्ग हो सकते हैं , किसी भी लंबे समय तक समर्थन के लिए निलंबन केबल की आवश्यकता होती है।
• सस्पेंशन केबल \सड़क के ऊपर से |सीधे लाइनों में टावरों तक फैले हुए हैं।
• टावरों |को आसन्न निलंबन केबलों का समर्थन करने के लिए पर्याप्त लंबा होना चाहिए, लेकिन कोई लंबा नहीं।
• जब भी संभव हो केंद्र बिंदुओं के अनुकूल, पुल को मध्य बिंदु के बारे में बाएं से दाएं संतुलित होना चाहिए।
• उपरोक्त सभी को केबलों का एक न्यूनतमकरण करना चाहिए, लेकिन बस स्पष्ट होने के लिए, उपरोक्त नियमों का पालन करते हुए भी निलंबन केबलों की संख्या कम से कम होनी चाहिए।

दृश्य प्रतिनिधित्व प्रदान करने के लिए, यहाँ अपेक्षित आउटपुट हैं n = 1, 2, 3, ... 15-

1
-|-|-

2
-|--|-

3
-|\-/|-

4
-|\--/|-

5
 |\   /|
-|-\-/-|-

6
 |\    /|
-|-\--/-|-

7
 |\     /|
 | \   / |
-|--\-/--|-

8
 |\      /|
 | \    / |
-|--\--/--|-

9
 |\       /|
 | \     / |
 |  \   /  |
-|\--\-/--/|-

10
 |\        /|
 | \      / |
 |  \    /  |
-|\--\--/--/|-

11
 |\         /|
 | \       / |
 |  \     /  |
 |\  \   /  /|
-|-\--\-/--/-|-

12
 |\          /|
 | \        / |
 |  \      /  |
 |\  \    /  /|
-|-\--\--/--/-|-

13
 |\           /|
 | \         / |
 |  \       /  |
 |\  \     /  /|
 | \  \   /  / |
-|--\--\-/--/--|-

14
 |\            /|
 | \          / |
 |  \        /  |
 |\  \      /  /|
 | \  \    /  / |
-|--\--\--/--/--|-

15
 |\             /|
 | \           / |
 |  \         /  |
 |\  \       /  /|
 | \  \     /  / |
 |  \  \   /  /  |
-|\--\--\-/--/--/|-

इनपुट

एक एकल सकारात्मक पूर्णांक किसी भी सुविधाजनक प्रारूप में , n > 9।

उत्पादन

उपरोक्त निर्माण तकनीक के बाद ASCII- कला पुल।

नियम

• नए कथानक या व्हाट्सएप का नेतृत्व या अनुगमन सभी वैकल्पिक हैं, इसलिए जब तक कि पुल वर्ण स्वयं सही ढंग से पंक्तिबद्ध न हो जाएं।
• या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
• यदि संभव हो, तो कृपया ऑनलाइन परीक्षण वातावरण का लिंक शामिल करें ताकि लोग आपके कोड को आज़मा सकें!
• मानक खामियों को मना किया जाता है।
• यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

Comments

#RageQuit ( 05ab1e.tryitonline.net/… )

— मैजिक ऑक्टोपस Urn

@carusocomputing हाह, हार मत मानो! : D

— AdmBorkBork

मैंने हार नहीं मानी, बस कहीं और जाना था और अपनी प्रगति नहीं खोना चाहता था;)।

— मैजिक ऑक्टोपस Urn

@carusocomputing अहा। तो, #RageTemporatelyWalkAway की तरह।

— AdmBorkBork

Answer 1

05AB1E , 79 59 58 बाइट्स

"\  "×¹<;£R.sð«¹3‹ið}.BvyD¹Éi¨}R„\/„/\‡«'|.øð.ø}ð'-‡¹2›i»}

इसे ऑनलाइन आज़माएं! ।

स्पष्टीकरण:

"\  "×                                                     # Push n copies of "\  ".
      ¹<;£                                                 # Push a[0:(n-1)/2] 
          R.s                                              # Reverse, get substrings.
             ð«                                            # Append a space.
               ¹3‹ið}                                      # If n < 3, push a space.
                     .B                                    # Boxify.
                       vy                      }           # For each...
                         D¹Éi¨}R                           # Dupe, if n is odd, a[0:-1].
                                „\/„/\‡                    # Reverse the slashes.
                                       «'|.øð.ø            # Surround with | and a space.
                                                ð'-‡       # Replace spaces with "-".
                                                    ¹2›i } # If it's more than 2...
                                                        »  # Join stack by newlines.

बेहतर समाधान मिला, कुंजी निम्नलिखित के लिए प्रत्येक संख्या के लिए निम्न सरणियों को वापस करना था:

1=[" "]
2=["  "]
3=["\"]
4=["\ "]
5=["\"," \"]
6=["\"," \ "]
7=["\"," \","  \"]
8=["\"," \","  \ "]
Etc...

Answer 2

पायथन 2, 173 बाइट्स

i=input()
f=lambda b:'-|'+b[::-1].replace('/','\\')+-~(~i%2)*'-'+b+'|-'
b=(i*'/--')[:~-i/2]
for x in range(1,~-i/2):print f((len(b)-x)*'-'+b[:x]).replace('-',' ')
print f(b)

B के मान को मिरर करें और केंद्रीय जोड़ें "-"
f=lambda b:'-|'+b[::-1].replace('/','\\')+-~(~i%2)*'-'+b+'|-'
बेस पैटर्न (नीचे की रेखा का दाहिना आधा)
b=(i*'/--')[:~-i/2]
गैर-निचले परतों के लिए लूप
for x in range(1,~-i/2):
बेस पैटर्न के पहले x अक्षर प्राप्त करें और साथ पूरा करें - "
(len(b)-x)*'-'+b[:x]
सभी को बदलें - प्रिंट करने के लिए रिक्त स्थान के साथ सभी लेयर्स (नीचे को छोड़कर)
print f().replace('-',' ')
प्रिंट लेयर लेयर
print f(b)

Comments

आपको अपने पोस्ट में कच्चे संस्करण (बिना किसी टिप्पणी के) को शामिल करना चाहिए

— FlipTack

Answer 3

Befunge, 150 बाइट्स

45&3+:00p4+2/:10p`-v
*\00g1-\`*2*+\1-!+v>1+:20p55+00g>::::00g1--!\:20g+00g-:0`\3%!
`1\*!%3\`0:-\g02:\<^_@#-g01<:,$_^#`\0:-1,g3+**4!-g01g02!:+*3*
 |\/-

इसे ऑनलाइन आज़माएं!

मैंने कोड का एक ungolfed संस्करण भी प्रदान किया है जो पुल के निर्माण में उपयोग की जाने वाली वास्तुकला को बेहतर ढंग से प्रदर्शित करता है।

        >4                                         5v
        v+3                                       <&<
        >:00                                     p4+v
        v-`p0                                   1:/2<
*+\1-!+v>1+:20p55+00g>::::00g1--!\:20g+00g-:0`\3%!*\00g1-\`*2
-\g02:\<^_@#-g01<:,$_^#`\0:-1,g6+7+**4!-g01g02!:>#+<v*!%3\`0:
        |\/->3#*                             *#`^#1\<

इसे ऑनलाइन आज़माएं!

टावर्स इनपुट और पैरामीटर इनिशियलाइज़ेशन को हैंडल करते हैं। डेक दो छोरों से बना होता है जो पुल के उन हिस्सों की गणना करता है जिन्हें प्रत्येक x, y समन्वय के लिए आउटपुट की आवश्यकता होती है। और नींव उन पुल भागों के लिए चरित्र तालिका रखती है, साथ ही कुछ अन्य पूरी तरह से असंबंधित कोड।

विस्तृत विवरण

हम आउटपुट क्षेत्र की चौड़ाई और ऊंचाई की गणना करके शुरू करते हैं जो पुल को रेंडर करने के लिए पुनरावृत्त होने की आवश्यकता होगी।

w  = n + 3                (stored at 0,0)
h  = (w + 4)/2            (stored at 1,0)

ध्यान दें कि y श्रेणी शून्य-आधारित नहीं है। प्रारंभिक मान है 5 - (h<5)और इसे h (वर्तमान मूल्य 2,0 पर संग्रहीत) तक पुनरावृत्त किया जाता है। एक्स मूल्य से दोहराया है w नीचे 0 करने के लिए और ढेर पर संग्रहीत है।

आंतरिक लूप बूलियन स्थितियों की एक श्रृंखला है जो यह निर्धारित करता है कि क्या कोई विशेष x , y समन्वय किसी भी स्थान से मेल खाता है, जिसके लिए गैर-स्थान वर्ण की आवश्यकता होती है। ये गणना दो स्लाइडिंग ऑफसेट पर आधारित हैं जो निलंबन केबलों के मार्ग का अनुसरण करते हैं।

loff = y + x - w
roff = y - x 

विभिन्न परिस्थितियों को तब निम्नानुसार निर्धारित किया जाता है:

left_tower       = (x == w-1)
left_suspension  = (loff > 0) and (loff%3 == 0) and (x < w-1)
right_tower      = (x == 1)
right_suspension = (roff > 0) and (roff%3 == 0) and (x > 1)
bridge_deck      = (y == h)

इन स्थितियों को सही चरित्र ऑफसेट में अनुवाद करने के लिए, हमें बस उनमें से प्रत्येक को एक उपयुक्त ऑफसेट द्वारा गुणा करने और परिणाम प्राप्त करने की आवश्यकता है। यह गणना की जाती है क्योंकि स्थितियों का मूल्यांकन किया जाता है। तो यह कुछ इस तरह दिखता है:

char_offset =  left_tower
char_offset += left_suspension * 2
char_offset += right_tower
char_offset += right_suspension * 3
char_offset += !char_offset * bridge_deck * 4

ध्यान दें कि Bridge_deck मूल्य आधार पर जाता है कि क्या कोई अन्य शर्त पूरी हुई है, क्योंकि एक निलंबन या टॉवर चरित्र डेक पर पूर्वता ले जाएगा।

अंतिम परिणाम प्लेफील्ड की अंतिम पंक्ति पर वर्ण तालिका में एक ऑफसेट है। हम बस उस चरित्र को आउटपुट करते हैं और लूप दोहराते हैं।

Comments

एक स्पष्टीकरण प्रदान करने के लिए देखभाल? उन सभी के साथ हो जाता है और इसका पालन करना कठिन होता है

— MildlyMilquetoast

आप केवल एक पोस्ट करने के बाद मैं बाउंटी जोड़ दिया, अगर कोई और नहीं धड़कता है तो मैं आपको 100 का पुरस्कार दूंगा।

— मैजिक ऑक्टोपस Urn

@carusocomputing मुझे पता है कि आप इस से बेहतर की उम्मीद कर रहे थे, लेकिन अभी भी बहुत समय है, और इसे विशेष रूप से एक बार नोटिस किया जाना चाहिए क्योंकि यह विशेष रुप से प्रदर्शित सूची के शीर्ष पर है।

— जेम्स होल्डरनेस 23

यह अपने आप में एक शांत जवाब है, इसमें पहले से ही मेरे मुकाबले वोट अधिक हैं; बेहतर निश्चित रूप से सही शब्द नहीं है।

— मैजिक ऑक्टोपस Urn

Answer 4

बैच, 241 बाइट्स

@echo off
set t=set s=
%t%
for /l %%i in (1,1,%1)do call %t% %%s%%
%t% !%s%! 
for /l %%i in (5,2,%1)do call:l 0
:l
%t%%s:\ = \%
%t%%s: /=/ %
%t%%s:!   =!\  %
%t%%s:   !=  /!%
%t%%s:\  !=\ /!%
if %1 gtr 0 %t%%s: =-%
echo %s:!=^|%

नोट: पंक्ति 5 पर ट्रेलिंग स्पेस। रिक्त स्थान की एक पंक्ति का निर्माण करके शुरू होता है, फिर आवश्यकतानुसार केबल जोड़ना, सड़क के साथ किसी भी रिक्त स्थान को बदलकर समाप्त होने वाली वांछित ऊंचाई तक टॉवर बनाना।

Answer 5

WinDbg, 312 बाइट्स

r$t4=@$t0+4;.block{j3>@$t0'r$t5=1';r$t5=(@$t0-1)/2};f8<<16 L@$t4*@$t5 2d;f8<<16 L@$t4*(@$t5-1) 20;.for(r$t1=0;@$t1<@$t5;r$t1=@$t1+1){eb2000001+@$t4*@$t1 7c;e1fffffe+@$t4*(1+@$t1) 7c;j2<@$t0'.for(r$t2=@$t1;@$t2>=0;r$t2=@$t2-3){e2000002+@$t4*@$t1+@$t2 5c;e1fffffd+@$t4*(1+@$t1)-@$t2 2f}'};da/c@$t4 8<<16 L@$t4*@$t5

इनपुट छद्म रजिस्टर सेट करके किया जाता है $t0।

मुझे ऐसा लगता है कि दोनों को मिलाने का एक तरीका होना चाहिए for छोरों को एक में ... शायद कुछ अन्य गोल्फिंग अवसर भी ...

यह एक पूरे क्षेत्र को सड़क से भरने के द्वारा काम करता है, फिर सभी लेकिन अंतिम पंक्ति को अंतरिक्ष के साथ बदल देता है, और अंत में कॉलम और केबल का निर्माण करता है।

r$t4 = @$t0+4;                                * Set width to input+4
.block                                        * Code block, needed for some reason...
{                                             * and .block+j is shorter than .if/.else
    j 3>@$t0                                  * If input is less than 3...
    '
        r$t5 = 1                              * ...set height to 1
    ';                                        * Implicit else...
        r$t5 = (@$t0-1)/2                     * ...set height to (input-1)/2
};
f 8<<16 L@$t4*@$t5 2d;                        * Fill area with -
f 8<<16 L@$t4*(@$t5-1) 20;                    * Fill all but last row with space
.for(r$t1=0; @$t1<@$t5; r$t1=@$t1+1)          * For each row
{
    eb 2000001+@$t4*@$t1 7c;                  * Build the left column with |
    e 1fffffe+@$t4*(1+@$t1) 7c;               * Build the right column (e is the same as last e* call, ie- eb)
    j 2<@$t0                                  * If input is more than 2...
    '
        .for(r$t2=@$t1; @$t2>=0; r$t2=@$t2-3) * ...Enumerate from counter back to 0
        {
            e 2000002+@$t4*@$t1+@$t2 5c;      * Build left cables with \
            e 1fffffd+@$t4*(1+@$t1)-@$t2 2f   * Build right cables with /
        }
    '
};
da /c@$t4 8<<16 L@$t4*@$t5                    * Print the string in lines of length width

1-15 का नमूना उत्पादन:

0:000> .for(r$t0=1;@$t0<10;r$t0=@$t0+1){.printf"%d\n",@$t0;r$t4=@$t0+4;.block{j3>@$t0'r$t5=1';r$t5=(@$t0-1)/2};f8<<16 L@$t4*@$t5 2d;f8<<16 L@$t4*(@$t5-1) 20;.for(r$t1=0;@$t1<@$t5;r$t1=@$t1+1){eb2000001+@$t4*@$t1 7c;e1fffffe+@$t4*(1+@$t1) 7c;j2<@$t0'.for(r$t2=@$t1;@$t2>=0;r$t2=@$t2-3){e2000002+@$t4*@$t1+@$t2 5c;e1fffffd+@$t4*(1+@$t1)-@$t2 2f}'};da/c@$t4 8<<16 L@$t4*@$t5}
1
Filled 0x5 bytes
Filled 0x0 bytes
02000000  "-|-|-"
2
Filled 0x6 bytes
Filled 0x0 bytes
02000000  "-|--|-"
3
Filled 0x7 bytes
Filled 0x0 bytes
02000000  "-|\-/|-"
4
Filled 0x8 bytes
Filled 0x0 bytes
02000000  "-|\--/|-"
5
Filled 0x12 bytes
Filled 0x9 bytes
02000000  " |\   /| "
02000009  "-|-\-/-|-"
6
Filled 0x14 bytes
Filled 0xa bytes
02000000  " |\    /| "
0200000a  "-|-\--/-|-"
7
Filled 0x21 bytes
Filled 0x16 bytes
02000000  " |\     /| "
0200000b  " | \   / | "
02000016  "-|--\-/--|-"
8
Filled 0x24 bytes
Filled 0x18 bytes
02000000  " |\      /| "
0200000c  " | \    / | "
02000018  "-|--\--/--|-"
9
Filled 0x34 bytes
Filled 0x27 bytes
02000000  " |\       /| "
0200000d  " | \     / | "
0200001a  " |  \   /  | "
02000027  "-|\--\-/--/|-"
10
Filled 0x38 bytes
Filled 0x2a bytes
02000000  " |\        /| "
0200000e  " | \      / | "
0200001c  " |  \    /  | "
0200002a  "-|\--\--/--/|-"
11
Filled 0x4b bytes
Filled 0x3c bytes
02000000  " |\         /| "
0200000f  " | \       / | "
0200001e  " |  \     /  | "
0200002d  " |\  \   /  /| "
0200003c  "-|-\--\-/--/-|-"
12
Filled 0x50 bytes
Filled 0x40 bytes
02000000  " |\          /| "
02000010  " | \        / | "
02000020  " |  \      /  | "
02000030  " |\  \    /  /| "
02000040  "-|-\--\--/--/-|-"
13
Filled 0x66 bytes
Filled 0x55 bytes
02000000  " |\           /| "
02000011  " | \         / | "
02000022  " |  \       /  | "
02000033  " |\  \     /  /| "
02000044  " | \  \   /  / | "
02000055  "-|--\--\-/--/--|-"
14
Filled 0x6c bytes
Filled 0x5a bytes
02000000  " |\            /| "
02000012  " | \          / | "
02000024  " |  \        /  | "
02000036  " |\  \      /  /| "
02000048  " | \  \    /  / | "
0200005a  "-|--\--\--/--/--|-"
15
Filled 0x85 bytes
Filled 0x72 bytes
02000000  " |\             /| "
02000013  " | \           / | "
02000026  " |  \         /  | "
02000039  " |\  \       /  /| "
0200004c  " | \  \     /  / | "
0200005f  " |  \  \   /  /  | "
02000072  "-|\--\--\-/--/--/|-"

Answer 6

जावा 8, 423 , 412 बाइट्स

11 बाइट्स ने क्रिक्सी लिथोस को धन्यवाद दिया

golfed:

void f(int n){int i,j,k,t=n/2+n%2,u=t-2,q;char v=45;char[][]a=new char[t-1][n+4];for(char[]c:a)Arrays.fill(c,' ');a[u][0]=v;a[u][n+3]=v;for(q=0;q<t-1;q++){a[q][1]='|';a[q][n+2]='|';}for(i=t+1;i>1;i--){if((t-i)%3==0){k=u;for(j=i;j>1;j--)a[k--][j]='\\';}else a[u][i]=v;}for(i=n/2+2;i<n+2;i++){if((i-n/2-3)%3==0){k=u;for(j=i;j<n+2;j++)a[k--][j]='/';}else a[u][i]=v;}for(char[]w:a)System.out.println(new String(w));}

ungolfed:

void f(int n){
    int i,j,k,t=n/2+n%2,u=t-2;
    char v=45;
    char[][] a=new char[t-1][n+4];
    for (char[]c : a) Arrays.fill(c,' ');
    a[u][0]=v;
    a[u][n+3]=v;

    // left and right columns
    for (int q=0;q<t-1;q++){
        a[q][1]='|';
        a[q][n+2]='|';
    }
    // left part of base
    for (i=t+1;i>1;i--){
        if ((t-i)%3==0){
            k=u;
            for (j=i;j>1;j--)
                a[k--][j]='\\';
        }
        else a[u][i]=v;
    }
    // right part of base
    for (i=n/2+2;i<n+2;i++){
        if ((i-n/2-3)%3==0){
            k=u;
            for (j=i;j<n+2;j++)
                a[k--][j]='/';
        }
        else a[u][i]=v;
    }
    for (char[]w : a) System.out.println(new String(w));
}

Comments

आप इस उत्तर को कई तरीकों से गोल्फ कर सकते हैं, सबसे पहले, आप एक बयान में अपनी सभी int i,j,k,t=n/2+n%2,u=t-2,q=0char v="-";char v=45;abc%xyz==0abc%xyz<1

— अंतरंग घोषणाएँ

@KritiiLithos thx! पहले 2 को अंतिम रूप से संपादित नहीं किया

— Bobas_Pett