트럼프는 벽을 건설해야하며 당신은 그것을 할 것입니다! 그의 벽을 가장 효율적으로 만들기 위해 사용할 수있는 간단하고 반복 가능한 패턴을 만들었습니다.

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

트럼프는 그가 얼마나 많은 벽 세그먼트를 필요로하는지 알려줄 것이며, 이와 같이 보이도록 만들 것입니다.

패턴은 다음과 같습니다.

    __   __     <-- 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
    __   __        __   __        __   __        __   __        __   __
   |  |_|  |      |  |_|  |      |  |_|  |      |  |_|  |      |  |_|  |
___|       |______|       |______|       |______|       |______|       |___
-   -   -   -  -   -   -   -  -   -   -   -  -   -   -   -  -   -   -   -
 - - - - - - -  - - - - - - -  - - - - - - -  - - - - - - -  - - - - - - - 
- - - - - - - -- - - - - - - -- - - - - - - -- - - - - - - -- - - - - - - -
———————————————————————————————————————————————————————————————————————————

이 작업을 빨리 수행해야하므로 가능한 가장 짧은 프로그램을 작성하십시오!

_{그것이 도움이된다면, 나는 도전을 먼저 썼다.}

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을 base-4로 변환 :

11110011111311300003111121112111121212122121212100000000

11110011111311300003111121112111121212122121212100000000 문자가 바뀐 경우 :

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

이전 패턴은 8 개로 분할됩니다.

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

그런 다음, 회담을 통해 필요한만큼 오래 멈춘다.

CJam, 52 바이트

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

인쇄 할 수없는 ASCII 문자를 포함합니다. 첫 번째 문자열 리터럴의 16 진 덤프는 다음과 같습니다.

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

여기 사용해보십시오!

설명

위의 hexdump는 base-128 숫자로 해석되고 base 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=.

자바 스크립트 (ES6) 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 자로 자른 후 다음을 얻습니다.

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

언 골프

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>

Jolf , 135 바이트

상당한 골프가 가능합니다. 더 좋은 결과를 얻으려면 예쁜 인쇄를 끄고 출력을 지우십시오. 여기 사용해보십시오! . 또한 임의의 숫자를 더 쉽게 테스트 할 때 사용 하십시오 .

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

나중에 설명을 추가하겠습니다.

하스켈 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 바이트를 찾았습니다. 감사!

배쉬 + 리눅스 유틸리티 ( 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! 󰰹͠  

위 스크립트를 작성할 때 인쇄 할 수없는 문자가 관대하게 사용되었으므로 다음은 16 진 덤프입니다.

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, 103100 자 (디스크에서 105 바이트, BOM없이 102 개)

@ 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
    __   __        __   __        __   __    
   |  |_|  |      |  |_|  |      |  |_|  |   
___|       |______|       |______|       |___
-   -   -   -  -   -   -   -  -   -   -   -  
 - - - - - - -  - - - - - - -  - - - - - - - 
- - - - - - - -- - - - - - - -- - - - - - - -
—————————————————————————————————————————————

PHP 5.4, ( 182175 문자)

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

언 골프 버전

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

[블랙홀 제안에 따라 7 문자를 저장했습니다. ]

적은 바이트이지만 더 많은 문자를 가진 다른 버전

PHP 5.4, (176 자, 178 바이트)

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

str_repeat 함수를 사용하여 15 개의 m-dash 인스턴스를 하나의 대시로 바꾸십시오.

C, 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)는 명확성을 위해 포함 되기 전에 불필요한 줄 바꿈을 제외합니다 .

p4의 벽에 대한 문자를 인코딩 하는 마법의 숫자는 각각 문자열 0,1,2,3 에서 재구성됩니다." -|_"

1684300916 진수는 0x1010101입니다. 이것은 -그들 과 함께 라인 에 사용됩니다.

에 _의해 인코딩 되기 때문에 3맨 아랫 줄은 간단히로 인코딩 될 수 있습니다 -1. 이는 모든 비트가로 설정된 숫자입니다 1.

Vitsy , 121 바이트

이 작업을 수행하는 방법은 입력 시간에 각 줄에 하나씩 액세스하여 각 줄의 내용이 들어있는 스택을 제공하는 것입니다. 그런 다음 한 번에 한 줄을 출력합니다. 누군가 내가 더 깊이있는 설명을하고 싶다면, (현재 선물을 열고 있습니다 ...).

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

온라인으로 사용해보십시오!

PHP5.5, 182 172 바이트 168 바이트

@ kuldeep.kamboj의 답변을 기반으로합니다. 이것은 실제로 182 자이지만 182 바이트입니다. 벽이 조금 더 높기를 바랍니다. 그런 다음 좀 더 최적화를 할 수 있습니다. ;-)

이것은 @ JörgHülsermann 덕분에 168 바이트입니다.

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

파이썬 3 132 122 120 바이트

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

언 골프 드 :

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

Python 2 (161 자, 191 바이트)

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

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

Vim, 90 키

입력이 버퍼 자체에 있다고 가정하면 다음이 작업을 수행합니다 (가독성 만 줄 바꿈)

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

어디에 ^Mis return, ^[is escape, ^Kis ctrl+k및 ^Vis ctrl+v입니다.

패턴을 생성하는 훨씬 더 좋은 방법이있을 수 있기 때문에 이것은 상당히 약간 축소 될 수 있습니다.

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

온라인으로 사용해보십시오.
참고 : Java 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

Powershell + 파일, 92 바이트

powershell을 get-trumpwall.ps1(40 바이트) 저장

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

이름이 f포함 된 데이터 파일 저장 및 데이터에는 유니 코드 기호 및 Linux LF 만 포함됨 (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
    __   __        __   __        __   __        __   __        __   __
   |  |_|  |      |  |_|  |      |  |_|  |      |  |_|  |      |  |_|  |
___|       |______|       |______|       |______|       |______|       |___
-   -   -   -  -   -   -   -  -   -   -   -  -   -   -   -  -   -   -   -
 - - - - - - -  - - - - - - -  - - - - - - -  - - - - - - -  - - - - - - -
- - - - - - - -- - - - - - - -- - - - - - - -- - - - - - - -- - - - - - - -
———————————————————————————————————————————————————————————————————————————