ट्रम्प दीवार बनाने में मदद करें!

Question

ट्रम्प को निर्मित दीवार की आवश्यकता है और आप इसे करने जा रहे हैं! सबसे कुशलता से उसकी दीवार बनाने के लिए मैंने आपके लिए एक सरल, दोहराने योग्य पैटर्न बनाया है:

    __   __    
   |  |_|  |   
___|       |___
-   -   -   -  
 - - - - - - - 
- - - - - - - -
———————————————

ट्रम्प आपको बताएगा कि उसे कितने दीवार खंडों की आवश्यकता है और आप उन्हें इस तरह दिखने के लिए बनाएंगे।

यहाँ पैटर्न है:

    __   __     <-- 4-2-3-2-4          ' _ _ '
   |  |_|  |    <-- 3-1-2-1-1-1-2-1-3  ' | |_| | '
___|       |___ <-- 3-1-7-1-3          '_| |_'
-   -   -   -   <-- 1-3-1-3-1-3-1-1    '- - - - '
 - - - - - - -  <-- 1-1-...-1-1        ' - -...- - '
- - - - - - - - <-- 1-1-...-1-1        '- - ... - -'
——————————————— <-- 15                 Unicode U+2014

इनपुट हमेशा एक पूर्णांक> 0 होगा।

परीक्षण के मामलों:

1
    __   __    
   |  |_|  |   
___|       |___
-   -   -   -  
 - - - - - - - 
- - - - - - - -
———————————————

2
    __   __        __   __    
   |  |_|  |      |  |_|  |   
___|       |______|       |___
-   -   -   -  -   -   -   -  
 - - - - - - -  - - - - - - - 
- - - - - - - -- - - - - - - -
——————————————————————————————

5
    __   __        __   __        __   __        __   __        __   __
   |  |_|  |      |  |_|  |      |  |_|  |      |  |_|  |      |  |_|  |
___|       |______|       |______|       |______|       |______|       |___
-   -   -   -  -   -   -   -  -   -   -   -  -   -   -   -  -   -   -   -
 - - - - - - -  - - - - - - -  - - - - - - -  - - - - - - -  - - - - - - - 
- - - - - - - -- - - - - - - -- - - - - - - -- - - - - - - -- - - - - - - -
———————————————————————————————————————————————————————————————————————————

चूंकि आपको यह उपवास करने की आवश्यकता है, इसलिए सबसे छोटा कार्यक्रम संभव लिखें!

_{यदि यह मदद करता है, तो मैंने चुनौती पहले लिखी, शीर्षक अंतिम;)}

Answer 1

05AB1E , 38 बाइट्स

•4H’*»È%f·ù„áÅ'4•4B3ÝJ"_ -|"‡8ô€ûvy¹×»

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

•4H’*»È%f·ù„áÅ'4•     # Push '1724427993555739020619095486300160'
4B                    # Convert to base 4 (turns it into an 8x8 bitmap).
  3ÝJ"_ -|"‡          # Replace digits 0-3 with _, , -, or |.
            8ô        # Split into pieces of 8.
              €û      # Palindromize each piece.
                vy¹×» # For each row, dupe it n times (hori) and print it.

1724427993555739020619095486300160 को आधार -4 में परिवर्तित किया गया:

11110011111311300003111121112111121212122121212100000000

11110011111311300003111121112111121212122121212100000000 अक्षरों के साथ प्रतिस्थापित:

__ | |____| - - - - - -- - - - ________

पिछला पैटर्न 8 टुकड़ों में विभाजित:

    __  
   |  |_
___|    
-   -   
 - - - -
- - - - 
________

फिर आप तालमेल बनाते हैं, और इसे दोहराव के माध्यम से आवश्यकतानुसार लंबे समय तक बनाते हैं।

Answer 2

सीजेएम, 52 बाइट्स

F,ri*"s@;b6(MBZF,fu"128b6b"_ 
|-—"f=N/ff=zN*

इसमें ASCII वर्णों का एक गुच्छा शामिल है। धक्का दिए गए पहले स्ट्रिंग शाब्दिक का हेक्सडंप है:

01 73 06 40 3B 62 36 28 1E 4D 07 42 5A 14 1B 46 2C 66 75

यहाँ यह कोशिश करो!

व्याख्या

उपरोक्त हेक्सडम्प को आधार -128 संख्या के रूप में व्याख्यायित किया गया है, फिर इस सूची को प्राप्त करने के लिए आधार 6 में परिवर्तित किया गया है:

[1 1 1 1 0 0 1 1 1 0 0 2
 1 1 1 3 1 1 3 0 3 1 1 3 2
 0 0 0 3 1 1 1 1 1 1 1 3 2
 4 1 1 1 2
 1 4 2
 4 1 2
 5]

इस के लिए, हम मानचित्रण लागू 0 → _, 1 → space, 2 → \n, 3 → |, 4 → -, 5 → —। यह हमें स्ट्रिंग:

    __   __
   |  |_|  |
___|       |
-   
 -
- 
—

इसमें प्रत्येक पंक्ति की "अवधि" होती है; यानी हम पांचवीं पंक्ति " -"को पाने के लिए साइकिल चला सकते हैं " - - - - - - - "।

फिर, हम इस उपप्रोग्राम को निष्पादित करते हैं:

N/               Split into lines.
  Ff*            Repeat each line 15 times (to cycle it).
     Ff<         Take the first 15 chars of each line.
        rif*     Repeat these chars input() times.
            N*   Join lines.

(नया संस्करण इसे थोड़े अलग तरीके से करता है कि मैं वास्तव में अपने चारों ओर अपने सिर को अच्छी तरह से लपेट नहीं सकता, क्योंकि यह उपयोग करता है ff=।)

Comments

यह क्या मैं भी नहीं है

— कॉनर ओ'ब्रायन

क्या यह भाषा विशेष रूप से इस उत्तर के लिए बनाई गई थी?

— एरडाल जी।

@ErdalG। हालांकि, सीजेएम वास्तव में एक पीपीसीजी नियमित ( एडिट्स ) द्वारा बनाया गया था , यह लगभग कुछ समय के लिए रहा है। आपको यह सब साइट पर मिलेगा। :)

— एलेक्स ए।

@AlexA। ठीक है अब अधिक समझ में आता है। मैं यहाँ काफी नया हूँ, धन्यवाद! :)

— एरडाल जी।

@ErdalG। मेरा सौभाग्य। साइट पर आपका स्वागत है!

— एलेक्स ए।

Answer 3

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

n=>"__   __    n|  |_|  |   n|       |___n -  n- n -n—".split`n`.map(l=>l.repeat(15).slice(-15).repeat(n)).join`
`

@Neil को एक बाइट धन्यवाद दिया !

व्याख्या

@Mauris की CJam विधि के समान ही सुंदर , लेकिन चरित्र मानचित्रण के बिना।

दीवार के हिस्से प्रारूप में हैं:

__   __    
|  |_|  |   
|       |___
 -  
- 
 -
—

क्योंकि यदि आप प्रत्येक पंक्ति को 15 बार दोहराते हैं:

...    __   __    __   __    __   __    
... |  |_|  |   |  |_|  |   |  |_|  |   
... |       |___|       |___|       |___
 -   -   -   -   -   -   -   -   -   -  
          - - - - - - - - - - - - - - - 
           - - - - - - - - - - - - - - -
                         ———————————————

और केवल पिछले 15 पात्रों को पाने के बाद,

    __   __    
   |  |_|  |   
___|       |___
-   -   -   -  
 - - - - - - - 
- - - - - - - -
———————————————

Ungolfed

n=>

  // array of wall line parts
  "__   __    n|  |_|  |   n|       |___n -  n- n -n—".split`n`

  .map(l=>       // for each wall line
    l.repeat(15) // repeat the line 15 times to create a complete wall line
    .slice(-15)  // each wall piece is only 15 characters long
    .repeat(n)   // repeat the wall n times
  )
  .join`
`                // output the resulting wall

परीक्षा

var solution = n=>"__   __    n|  |_|  |   n|       |___n -  n- n -n—".split`n`.map(l=>l.repeat(15).slice(-15).repeat(n)).join`
`

<input type="number" oninput="result.textContent=solution(+this.value)" />
<pre id="result"></pre>

Comments

क्या आप .slice(-15)इसके बजाय का उपयोग करके एक बाइट बचा सकते हैं ?

— नील

फिक्स आसान है, बस बाएं न्यूनतम भाग के बजाय दाएं न्यूनतम भाग का उपयोग करें:__ __ n| |_| | n| |___n - n- n -n—

— नील

बहुत चालाक, अच्छा काम!

— J Atkin

@ नील आह, आप सही कह रहे हैं। पारितोषिक के लिए धन्यवाद!

— user81655

Answer 4

जोल्फ , 135 बाइट्स

उल्लेखनीय गोल्फ किया जा सकता है। सुंदर प्रिंट बंद करें और बेहतर परिणाम के लिए आउटपुट को साफ़ करें। यहाँ कोशिश करो! । इसके अलावा, अधिक आसानी के साथ एक मनमानी संख्या का परीक्षण करने के लिए इसका उपयोग करें ।

oHpAt++++++++++++*"    __   __    "jH*"   |  |_|  |   "jH*"___|       |___"jH*j"-   -   -   -  "H*+*" -"7' jH*"- - - - - - - -"jH*M35j'—

मैं बाद में एक स्पष्टीकरण जोड़ूंगा।

Comments

@Connor O'Brien तो क्या एटा उस स्पष्टीकरण पर लग रहा है: D

— रोहन झुनझुनवाला

Answer 5

हास्केल, 116 118 108 बाइट्स

h n=take(n*15).cycle
f n=unlines$h n.h 1<$>lines"    __   __\n   |  |_|  |\n___|       |\n-   \n -\n- \n—"

उपयोग उदाहरण:

*Main> putStr $ f 3
    __   __        __   __        __   __    
   |  |_|  |      |  |_|  |      |  |_|  |   
___|       |______|       |______|       |___
-   -   -   -  -   -   -   -  -   -   -   -  
 - - - - - - -  - - - - - - -  - - - - - - - 
- - - - - - - -- - - - - - - -- - - - - - - -
—————————————————————————————————————————————

यह अन्य उत्तर के रूप में समान रणनीति का उपयोग करता है: दीवार की प्रत्येक पंक्ति पैटर्न का एक चक्र है, उदाहरण के लिए दूसरी अंतिम पंक्ति के लिए "-" (डैश + स्पेस)। प्रत्येक पैटर्न को दोहराएं, एक दीवार खंड प्राप्त करने के लिए 15 चार्ट लें, फिर से दोहराएं और खंडों के 15*nलिए nचार्ट लें।

संपादित करें: @Mauris को 10 बाइट मिलीं। धन्यवाद!

Comments

निचला रेखा होना चाहिए - (यू + 2014), एएससीआईआई डैश नहीं; मुझे लगता है कि इसका मतलब है कि आप 2 बाइट्स खो देते हैं।

— लिन

@ मोरिस: आप सही कह रहे हैं। ठीक कर दिया। पता लगाने के लिए धन्यवाद।

— नीमी

आप वास्तव में 1-3 + लाइनों को बचा सकते हैं, 4 + 3 + 3 बाइट्स को पहले की अवधि के लिए समाप्त कर सकते हैं। (मेरा सीजेएम जवाब एक ही बात करता है।)

— लिन

@ मौरिस: आह हां, क्योंकि 15 चक्रों के बाद पहला चक्र काट दिया जाता है। धन्यवाद!

— nimi

Answer 6

बैश + लिनक्स उपयोगिताओं ( 247 186 180 बाइट्स)

read x
for i in {1..7}
do
tail -n +7 $0|gzip -dc|sed -nr "$i s/(.*)/$(printf '\\1%.0s' $(seq 1 $x))/p"
done
exit
ˈ ELzVSPPPȏǑ
\@\D񵠚k>ĄÚ ܋ɀÜ@r²uٞ5L! 󰰹͠  

चूंकि उपरोक्त स्क्रिप्ट के निर्माण में अप्राप्य पात्रों का उदारता से उपयोग किया गया है, यहाँ एक हेक्सडम्प है:

00000000  72 65 61 64 20 78 0a 66  6f 72 20 69 20 69 6e 20  |read x.for i in |
00000010  7b 31 2e 2e 37 7d 0a 64  6f 0a 74 61 69 6c 20 2d  |{1..7}.do.tail -|
00000020  6e 20 2b 37 20 24 30 7c  67 7a 69 70 20 2d 64 63  |n +7 $0|gzip -dc|
00000030  7c 73 65 64 20 2d 6e 72  20 22 24 69 20 73 2f 28  ||sed -nr "$i s/(|
00000040  2e 2a 29 2f 24 28 70 72  69 6e 74 66 20 27 5c 5c  |.*)/$(printf '\\|
00000050  31 25 2e 30 73 27 20 24  28 73 65 71 20 31 20 24  |1%.0s' $(seq 1 $|
00000060  78 29 29 2f 70 22 0a 64  6f 6e 65 0a 65 78 69 74  |x))/p".done.exit|
00000070  0a 1f 8b 08 00 45 4c 7a  56 02 03 53 50 50 50 88  |.....ELzV..SPPP.|
00000080  8f 87 11 0a 5c 40 5c 03  44 f1 35 60 5a 81 2b 3e  |....\@\.D.5`Z.+>|
00000090  1e c4 04 83 1a 20 9b 4b  17 c8 40 c2 5c 40 02 19  |..... .K..@.\@..|
000000a0  72 a1 72 75 b9 1e 35 4c  21 1e 01 00 f3 30 f0 f9  |r.ru..5L!....0..|
000000b0  8d 00 00 00                                       |....|
000000b4

Answer 7

PowerShell, 103 100 अक्षर (डिस्क पर 105 बाइट्स, 102 w / o BOM)

बहुत ज्यादा @ user81655 विधि के समान है ।

Param($c)'    __   __n   |  |_|  |n___|       |n-   n -n- n—'-split'n'|%{($_*15).Substring(0,15)*$c}

अनप्लग्ड संस्करण

# Assign input to variable,
Param($c)

# Split array of wall parts and send them down the pipeline
'    __   __n   |  |_|  |n___|       |n-   n -n- n—' -split 'n' |
    ForEach-Object { # For each piece of wall
        ($_*15) # Repeat the line 15 times to create a complete wall line
        .Substring(0,15) # Each wall piece is only 15 characters long
        *$c # Repeat the wall n times
    }

उदाहरण का उपयोग करें

PS> .\TrumpWall.ps1 3
    __   __        __   __        __   __    
   |  |_|  |      |  |_|  |      |  |_|  |   
___|       |______|       |______|       |___
-   -   -   -  -   -   -   -  -   -   -   -  
 - - - - - - -  - - - - - - -  - - - - - - - 
- - - - - - - -- - - - - - - -- - - - - - - -
—————————————————————————————————————————————

Comments

97 बाइट्स:param($c);' __ __n | |_| |n___| |n- n -n- n—'-split'n'|%{-join($_*15)[0..14]*$c}

— माज़ी

Answer 8

PHP 5.4, ( 182 175 अक्षर)

foreach(['    __   __    ','   |  |_|  |   ','___|       |___','-   -   -   -  ', ' - - - - - - - ','- - - - - - - -','———————————————'] as$d)echo str_repeat($d,$argv[1])."\n";

Ungolfed संस्करण

$s=['    __   __    ',
    '   |  |_|  |   ',
    '___|       |___',
    '-   -   -   -  ',
    ' - - - - - - - ',
    '- - - - - - - -',
    '———————————————'
];
foreach($s as $d) {
    echo str_repeat($d,$argv[1])."\n";
}

[[पात्रों को ब्लैकहोल सुझाव का पालन करके बचाया गया। ]

कम बाइट्स के साथ एक और संस्करण लेकिन अधिक वर्ण

PHP 5.4, (176 अक्षर, 178 बाइट्स)

foreach(['    __   __    ','   |  |_|  |   ','___|       |___','-   -   -   -  ',' - - - - - - - ','- - - - - - - -',str_repeat('—',15)] as$d)echo str_repeat($d,$argv[1])."\n";

बस str_repeat फ़ंक्शन के साथ डैश के 15 इंस्टेंस को m-डैश से बदलें

Comments

1) के लिए एक चर को परिभाषित न करें $s, इसे सीधे अपने लूप में उपयोग करें: foreach([…,…] as $d)2) इससे पहले जब तक स्थान न निकालें $d: foreach(… as$d)3) इसके बजाय एक नई रेखा का उपयोग करें "\n"।

— ब्लैकहोल

आप साहब सच को चित्रित नहीं कर रहे हैं। आपके कोड में 182 अक्षर हैं, लेकिन 212 बाइट्स हैं।

— शालचकाका

@MichaelDibbets, क्षमा करें, बाइट्स बनाम वर्णों के बारे में उलझन में, संशोधित

— kuldeep.kamboj

बाइट्स गिनने के लिए mothereff.in/byte-counter जैसी किसी चीज़ का उपयोग करें

— Tschallacka

Answer 9

सी, 148 बाइट्स

#define q 16843009
i;p[]={-1,q*17,q*68,q*16,-8388417,8577152,3936000};
f(n){for(i=n*105;i--;i%(15*n)||puts(""))putchar(" -|_"[p[i/15/n]>>i%15*2&3]);}

स्कोर अनावश्यक न्यूलाइन को शामिल नहीं करता है, f(n)जिसके पहले स्पष्टता शामिल है।

जादू संख्याएं pआधार 4 में दीवार के लिए वर्णों को एनकोड करती हैं, जो क्रमशः स्ट्रिंग 0,1,2,3 से पुनर्निर्माण की जाती हैं" -|_"

16843009हेक्स में है 0x1010101। यह -उनके साथ लाइनों के लिए प्रयोग किया जाता है।

क्योंकि _इसके द्वारा एन्कोड किया गया है 3, नीचे की रेखा को बस के रूप में एन्कोड किया जा सकता है -1, जो कि सभी बिट्स के साथ सेट की गई संख्या है 1।

Comments

अच्छा है लेकिन आप उपयोग नहीं करके #define qऔर मूल्यों को हार्डकोड करके 3 बाइट्स बचा सकते हैं।

— जोहान डू टिट

Answer 10

विटी , 121 बाइट्स

मैं यह कैसे करता हूं कि प्रत्येक लाइन एक समय इनपुट समय पर पहुंचती है, मुझे प्रत्येक पंक्ति की सामग्री के साथ ढेर देता है। फिर, मैं एक बार में एक लाइन आउटपुट करता हूं। अगर कोई चाहता है कि मैं और अधिक गहराई से स्पष्टीकरण दूं, तो बस पूछें (मैं वर्तमान में प्रस्तुत कर रहा हूं, इसलिए ...)।

V0v7\[v1+v&V\[vDvm]a]y\[?Z]
"    __   __    "
"   |  |_|  |   "
"___|       |___"
4\["-   "]Xr
6mXr" "
8\["- "]X
"—"e\D

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

Answer 11

PHP5.5, 182 172 बाइट्स 168 बाइट्स

@ kuldeep.kamboj के उत्तर पर आधारित है, जो वास्तव में 212 बाइट्स है, जो मैं यह लिखता हूं लेकिन 182 अक्षर। काश दीवार थोड़ी ऊंची होती, तो मैं कुछ और अनुकूलन कर सकता था ;-)

यह एक 168 बाइट्स है, @ JörgHülsermann की बदौलत

$r='str_repeat';$d=$r(' -',7);$x='   ';foreach(["$x __   __ $x","$x|  |_|  |$x","___|$x$x |___","-$x-$x-$x-  ","$d ","-$d",$r('—',15)] as$z){echo$r($z,$argv[1])."
";}

यह एक 172 बाइट्स है

$r='str_repeat';$d=$r(' -',7);$x=$r(' ',3);foreach(["$x __   __ $x","$x|  |_|  |$x","___|$x$x |___","-$x-$x-$x-  ","$d ","-$d",$r('—',15)] as$z){echo$r($z,$argv[1])."
";}

यह एक 182 बाइट्स है :-)

$r='str_repeat';$d=$r(' -',7);$x=$r(' ',4);foreach([$x.'__   __'.$x,'   |  |_|  |   ','___|       |___','-   -   -   -  ',$d.' ','-'.$d,$r('—',15)] as$z){echo $r($z,$argv[1]).'
';}

ungolfed संस्करण

$r='str_repeat';
$d=$r(' -',7);
$x=$r(' ',3);
$s=["$x __   __ $x",
    "$x|  |_|  |$x",
    "___|$x$x |___",
    "-$x-$x-$x-  ",
    "$d ",
    "-$d",
    $r('—',15)
];
foreach($s as $z) {
  echo$r($z,$argv[1])."
";
}

Comments

इससे पहले कि अंतरिक्ष को हटा दें और कोष्ठक को हटा दें -3 ​​बाइट्स

— Jörg Hülsermann

$x=$r(' ',3);को छोटा किया जा सकता है$x=' ';

— Jörg Hülsermann

आपको फॉर्च्यूप लूप के लिए कोष्ठक की आवश्यकता नहीं है और `$ z` के रूप में लिख सकते हैंas$z

— Jörg Hülsermann

Answer 12

पायथन 3, 132 122 120 बाइट्स

def f(n):[print((s*15*n)[:15*n])for s in['    __   __    ','   |  |_|  |   ','___|       |___','-   ', ' -', '- ', '—']]

Ungolfed:

def f(n):
    [print((s*15*n)[:15*n])for s in['    __   __    ',
                                    '   |  |_|  |   ',
                                    '___|       |___',
                                    '-   ',
                                    ' -',
                                    '- ',
                                    '—']]

Comments

आप प्राप्त करने के लिए रिक्त स्थान को हटा सकते हैं )for s in[...

— साइओस

Answer 13

पायथन 2, (161 अक्षर, 191 बाइट्स)

x=input();a=['    __   __    ','   |  |_|  |   ','___|       |___','-   -   -   -  ',' - - - - - - - ','- - - - - - - -','———————————————']
for i in a:print i*x

Answer 14

SOGL V0.12 , 32 बाइट्स

→↔\ιδ»►℮⁰}▒║ΙOģΠp~⁵‘ ¾“ζ'¹*+'¹n*

यह कोशिश करो!

स्पष्टीकरण:

...‘ ¾“ζ'¹*+'¹n*
...‘              push a string of the top 6 lines of 1 wall piece (no newlines)
     ¾“           push 8212
       ζ          convert to char from unicode codepoint
        '¹*       repeat 15 times
           +      add that to the previous compressed string
            '¹n   split into lines with length 15
               *  repeat horizontally input times

Comments

सभी एससीआई-कला के सवालों पर वापस जाता है और मुझे कुछ हद तक एसओजीएल के साथ उन सभी पर शाब्दिक रूप से पिटाई करने के लिए डैमिया को उकसाता है

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

Answer 15

विम, 90 कुंजी

यह मानते हुए कि इनपुट एक बफर में है, निम्न कार्य स्वयं करेगा (केवल पठनीयता के लिए नई सीमा)

"aDi    __   __    ^M   |  |_|  |   ^M___|       |___^M^[
4i-   ^[xo-^[Y7P8JY2PxA ^[GVr^K-M^Vgg$d@aP

कहां ^Mहै return, ^[है escape, ^Kहै ctrl+kऔर ^Vहै ctrl+v।

इसकी संभावना बहुत कम हो सकती है, क्योंकि पैटर्न बनाने के बहुत बेहतर तरीके हो सकते हैं।

Answer 16

जावा 11, 236 235 231 229 बाइट्स

n->{String w[]={"","","","","","",""},t="- ".repeat(7);for(;n-->0;w[0]+="x __x__x ",w[1]+="x|  |_|  |x",w[2]+="___|xx |___",w[3]+="-x-x-x-  ",w[4]+=" "+t,w[5]+=t+"-")w[6]+="_".repeat(15);return"".join("\n",w).replace("x","   ");}

इसे ऑनलाइन आज़माएं।
नोट: जावा 11 अभी तक TIO पर नहीं है, इसलिए (उसी बाइट-काउंट के लिए) का String.repeat(int)अनुकरण किया गया है repeat(String,int)।

स्पष्टीकरण:

n->{                                // Method with integer parameter and String return-type
  String w[]={"","","","","","",""},//  Start with seven empty rows
         t="- ".repeat(7);          //  Temp String to reduce bytes
  for(;n-->0;                       //  Loop `n` amount of times:
    w[0]+="x __x__x ",              //   Append to the first row
    w[1]+="x|  |_|  |x",            //   Append to the second row
    w[2]+="___|xx |___",            //   Append to the third row
    w[3]+="-x-x-x-  ",              //   Append to the fourth row
    w[4]+=" "+t,                    //   Append to the fifth row
    w[5]+=t+"-")                    //   Append to the sixth row
    w[6]+="_".repeat(15);           //   Append to the seventh row
  return"".join("\n",w)             //  Join all rows by new-lines
          .replace("x","   ");}     //  Then replace all "x" with three spaces,
                                    //  and return the result

Answer 17

पॉवर्सशेल + फ़ाइल, 92 बाइट्स

शक्तियों को बचाएं get-trumpwall.ps1(40 बाइट्स में)

param($c);gc f|%{-join($_*15)[0..14]*$c}

डेटा फ़ाइल को नाम fऔर डेटा के साथ सहेजें में यूनिकोड प्रतीक और लिनक्स एलएफ केवल (52 बाइट्स) हैं:

    __   __
   |  |_|  |
___|       |
-   
 -
- 
—

हेक्स डंप:

0000000000: 20 20 20 20 5F 5F 20 20 │ 20 5F 5F 0A 20 20 20 7C      __   __◙   |
0000000010: 20 20 7C 5F 7C 20 20 7C │ 0A 5F 5F 5F 7C 20 20 20    |_|  |◙___|
0000000020: 20 20 20 20 7C 0A 2D 20 │ 20 20 0A 20 2D 0A 2D 20      |◙-   ◙ -◙-
0000000030: 0A E2 80 94             │                          ◙—››

उदाहरण का उपयोग करें

PS> .\get-trumpwall.ps1 5
    __   __        __   __        __   __        __   __        __   __
   |  |_|  |      |  |_|  |      |  |_|  |      |  |_|  |      |  |_|  |
___|       |______|       |______|       |______|       |______|       |___
-   -   -   -  -   -   -   -  -   -   -   -  -   -   -   -  -   -   -   -
 - - - - - - -  - - - - - - -  - - - - - - -  - - - - - - -  - - - - - - -
- - - - - - - -- - - - - - - -- - - - - - - -- - - - - - - -- - - - - - - -
———————————————————————————————————————————————————————————————————————————