Trump cần bức tường được xây dựng và bạn sẽ làm điều đó! Để xây dựng bức tường của anh ấy một cách hiệu quả nhất, tôi đã tạo ra một mẫu đơn giản, có thể lặp lại để bạn sử dụng:

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

Trump sẽ cho bạn biết anh ta cần bao nhiêu phân khúc tường và bạn sẽ xây dựng chúng để trông giống như thế này.

Đây là mẫu:

    __   __     <-- 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

Đầu vào sẽ luôn là số nguyên> 0.

Các trường hợp thử nghiệm:

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

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

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

Vì bạn cần phải làm điều này nhanh chóng, hãy viết chương trình ngắn nhất có thể!

_{Nếu nó giúp, tôi đã viết thử thách trước, tiêu đề cuối cùng;)}

05AB1E , 38 byte

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

Hãy thử trực tuyến!

•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 được chuyển đổi sang cơ sở-4:

11110011111311300003111121112111121212122121212100000000

11110011111311300003111121112111121212122121212100000000 với các ký tự được thay thế:

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

Mẫu trước chia thành 8 mảnh:

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

Sau đó, bạn palindromize, và làm cho nó miễn là cần thiết thông qua sự lặp lại.

CJam, 52 byte

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

Bao gồm một loạt các ký tự ASCII không thể in được. Số thập phân của chuỗi ký tự đầu tiên được đẩy là:

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

Hãy thử nó ở đây!

Giải trình

Số thập phân trên được hiểu là số cơ sở 128, sau đó được chuyển đổi thành cơ sở 6, để có được danh sách này:

[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]

Về điều này, chúng tôi áp dụng các bản đồ 0 → _, 1 → space, 2 → \n, 3 → |, 4 → -, 5 → —. Điều này cho chúng ta chuỗi:

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

Nó bao gồm "thời gian" của mỗi dòng; tức là chúng ta có thể chu kỳ dòng thứ năm " -"để có được " - - - - - - - ".

Sau đó, chúng tôi thực hiện chương trình con này:

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.

(Phiên bản mới thực hiện điều này theo một cách hơi khác mà tôi thực sự không thể quấn đầu quanh mình rất tốt, vì nó sử dụng ff=.)

JavaScript (ES6), 116 115 byte

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

Đã lưu một byte nhờ @Neil !

Giải trình

Khá giống với phương pháp CJam của @Mauris , nhưng không có ánh xạ ký tự.

Các bộ phận tường có định dạng:

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

bởi vì nếu bạn lặp lại mỗi dòng 15 lần bạn nhận được:

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

và sau khi cắt chỉ 15 ký tự cuối cùng bạn nhận được:

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

Ung dung

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

Kiểm tra

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>

Jolf , 135 byte

Chơi golf đáng kể có thể được thực hiện. Tắt in đẹp và xóa đầu ra để có kết quả tốt hơn. Hãy thử nó ở đây! . Ngoài ra, sử dụng điều này để kiểm tra một số tùy ý dễ dàng hơn.

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

Tôi sẽ thêm một lời giải thích sau.

Haskell, 116 118 108 byte

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

Ví dụ sử dụng:

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

Điều này sử dụng chiến lược tương tự như các câu trả lời khác ở đây: mỗi dòng của bức tường là một chu kỳ của mẫu, ví dụ "-" (dấu gạch ngang + dấu cách) cho dòng cuối cùng thứ hai. Lặp lại mỗi mẫu, lấy 15 ký tự để có một phân đoạn tường, lặp lại lần nữa và lấy 15*nký tự cho ncác phân đoạn.

Chỉnh sửa: @Mauris tìm thấy 10 byte. Cảm ơn!

Tiện ích Bash + Linux ( 247 186 180 byte)

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! 󰰹͠  

Vì các ký tự không thể in được đã được sử dụng rộng rãi trong việc xây dựng tập lệnh trên, đây là một hexdump:

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

PowerShell, 103 100 ký tự (105 byte trên đĩa, 102 w / o BOM)

Khá giống với phương thức @ user81655 .

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

Phiên bản ung dung

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

Ví dụ sử dụng

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

PHP 5.4, ( 182 175 ký tự)

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

Phiên bản Ungolfed

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

[7 ký tự được lưu bằng cách làm theo gợi ý Blackhole. ]

Một phiên bản khác có ít byte hơn nhưng nhiều ký tự hơn

PHP 5.4, (176 ký tự, 178 byte)

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

Chỉ cần thay thế 15 trường hợp của m-dash bằng một dấu gạch ngang bằng hàm str numpeat

C, 148 byte

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

Điểm loại trừ các dòng mới không cần thiết trước f(n)đó được bao gồm cho rõ ràng.

các số ma thuật pmã hóa các ký tự cho bức tường ở cơ sở 4, được xây dựng lại từ chuỗi " -|_" 0,1,2,3 tương ứng

16843009trong hex là 0x1010101. cái này được sử dụng cho các dòng có -trong chúng.

Bởi vì _được mã hóa bởi 3, dòng dưới cùng có thể được mã hóa đơn giản là -1, đó là số có tất cả các bit được đặt thành 1.

Vitsy , 121 byte

Cách tôi thực hiện điều này là bằng cách truy cập từng dòng một tại thời điểm đầu vào, đưa cho tôi ngăn xếp với nội dung của từng dòng. Sau đó, tôi xuất một dòng tại một thời điểm. Nếu bất cứ ai muốn tôi đưa ra một lời giải thích sâu sắc hơn, chỉ cần hỏi (tôi hiện đang mở quà, vì vậy ...).

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

Hãy thử trực tuyến!

PHP5.5, 182 172 byte 168 byte

dựa trên câu trả lời của @ kuldeep.kamboj, thực sự là 212 byte khi tôi viết bài này nhưng 182 ký tự. Tôi ước bức tường cao hơn một chút, sau đó tôi có thể thực hiện một số tối ưu hóa hơn nữa ;-)

cái này là 168 byte, nhờ @ 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])."
";}

Cái này là 172 byte

$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])."
";}

Cái này là 182 byte :-)

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

phiên bản vô văn hóa

$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])."
";
}

Python 3, 132 122 120 byte

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

Ung dung:

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

Python 2, (161 ký tự, 191 byte)

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

SOGL V0.12 , 32 byte

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

Hãy thử nó ở đây!

Giải trình:

...‘ ¾“ζ'¹*+'¹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

Vim, 90 phím

Giả sử đầu vào nằm trong bộ đệm, sau đây sẽ thực hiện công việc (dòng mới chỉ để dễ đọc)

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

đâu ^Mlà a return, ^[is escape, ^Kis ctrl+kvà ^Vis ctrl+v.

Điều này rất có thể được đánh golf xuống một chút, vì có thể có nhiều cách tốt hơn để tạo ra mô hình.

Java 11, 236 235 231 229 byte

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

Hãy thử trực tuyến.
LƯU Ý: Java 11 chưa có trên TIO, do đó, String.repeat(int)đã được mô phỏng repeat(String,int)(với cùng số byte).

Giải trình:

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

Tệp Powershell +, 92 byte

lưu quyền hạn vào get-trumpwall.ps1(40 byte)

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

lưu tệp dữ liệu với tên fvà dữ liệu chỉ chứa ký hiệu Unicode và Linux LF (52 byte):

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

bãi chứa hex:

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             │                          ◙—››

Ví dụ sử dụng

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