Trump a besoin que le mur soit construit et vous allez le faire! Pour construire son mur le plus efficacement possible, j'ai créé un modèle simple et reproductible que vous pouvez utiliser:

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

Trump vous dira combien de segments de mur il a besoin et vous les construirez pour ressembler à ceci.

Voici le motif:

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

L'entrée sera toujours un entier> 0.

Cas de test:

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

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

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

Comme vous devez le faire rapidement, écrivez le programme le plus court possible!

_{Si cela peut aider, j'ai écrit le défi en premier, le titre en dernier;)}

05AB1E , 38 octets

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

Essayez-le en ligne!

•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 convertis en base 4:

11110011111311300003111121112111121212122121212100000000

111100111113113000033111121212111121212122121212100000000 avec les caractères remplacés:

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

Modèle précédent divisé en 8 morceaux:

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

Ensuite, vous palindromisez et faites-le aussi longtemps que nécessaire par répétition.

CJam, 52 octets

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

Inclut un groupe de caractères ASCII non imprimables. L'hexdump du premier littéral de chaîne poussé est:

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

Essayez-le ici!

Explication

L'hexdump ci-dessus est interprété comme un nombre base 128, puis converti en base 6 pour obtenir cette liste:

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

Pour cela, nous appliquons la cartographie 0 → _, 1 → space, 2 → \n, 3 → |, 4 → -, 5 → —. Cela nous obtient la chaîne:

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

Il consiste en la "période" de chaque ligne; c'est-à-dire que nous pouvons parcourir la cinquième ligne " -"pour obtenir " - - - - - - - ".

Ensuite, nous exécutons ce sous-programme:

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.

(La nouvelle version le fait d'une manière légèrement différente. En fait, je ne parviens pas très bien à me comprendre, car elle utilise ff=.)

JavaScript (ES6), 116 115 octets

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

Enregistré un octet grâce à @Neil !

Explication

Quasiment la même chose que la méthode CJam de @Mauris , mais sans le mappage des caractères.

Les parties du mur sont au format:

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

parce que si vous répétez chaque ligne 15 fois, vous obtenez:

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

et après avoir coupé les 15 derniers caractères, vous obtenez:

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

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

Tester

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 octets

Le golf considérable peut être fait. Désactivez les belles impressions et effacez la sortie pour un meilleur résultat. Essayez-le ici! . En outre, utilisez ceci pour tester un nombre arbitraire plus facilement.

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

Je vais ajouter une explication plus tard.

Haskell, 116 118 108 octets

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

Exemple d'utilisation:

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

Ceci utilise la même stratégie que les autres réponses ici: chaque ligne du mur correspond à un cycle du motif, par exemple, "-" (tiret + espace) pour l'avant-dernière ligne. Répétez chaque motif, prenez 15 caractères pour obtenir un segment de mur, répétez-le et prenez des 15*ncaractères pour les nsegments.

Edit: @Mauris trouvé 10 octets. Merci!

Utilitaires Bash + Linux ( 247 186 180 octets)

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

Puisque les caractères non imprimables ont été généreusement utilisés dans la construction du script ci-dessus, voici un 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 caractères (105 octets sur le disque, 102 sans nomenclature)

Quasiment la même chose que la méthode @ user81655 .

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

Version non-golfée

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

Exemple d'utilisation

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

PHP 5.4 ( 182 175 caractères)

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

Version non-golfée

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

[7 caractères enregistrés en suivant la suggestion de Blackhole. ]

Une autre version avec moins d'octets mais plus de caractères

PHP 5.4, (176 caractères, 178 octets)

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

Il suffit de remplacer 15 instances de m-dash par un tiret avec la fonction str_repeat

C, 148 octets

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

Score exclut la nouvelle ligne inutile avant f(n)qui est incluse pour plus de clarté.

les nombres magiques dans pcodent les caractères du mur en base 4, qui sont reconstruits à partir de la chaîne " -|_" 0,1,2,3 respectivement

16843009dans l'hex est 0x1010101. Ceci est utilisé pour les lignes avec -en eux.

Parce que _est codé par 3, la ligne du bas peut être codée simplement comme -1, c'est-à-dire le nombre avec tous les bits mis à 1.

Vitsy , 121 octets

Pour ce faire, vous devez accéder à chaque ligne une à une fois, en me donnant des piles avec le contenu de chaque ligne. Ensuite, je produis une ligne à la fois. Si quelqu'un veut que je donne une explication plus détaillée, il suffit de demander (j'ouvre actuellement des cadeaux, alors ...).

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

Essayez-le en ligne!

PHP5.5, 182 172 octets 168 octets

basé sur la réponse de @ kuldeep.kamboj, qui est en réalité de 212 octets au moment où j'écris ceci, mais 182 caractères. Je souhaite que le mur soit un peu plus haut, alors je pourrais faire plus d'optimisation ;-)

celui-ci est de 168 octets, grâce à @ 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])."
";}

Celui-ci est de 172 octets

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

Celui-ci est de 182 octets :-)

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

version non-lisée

$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 octets

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['    __   __    ',
                                    '   |  |_|  |   ',
                                    '___|       |___',
                                    '-   ',
                                    ' -',
                                    '- ',
                                    '—']]

Python 2, (161 caractères, 191 octets)

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

SOGL V0.12 , 32 octets

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

Essayez-le ici!

Explication:

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

En supposant que l’entrée se trouve dans une mémoire tampon seule, le travail suivant fera le travail (nouvelle ligne uniquement pour des raisons de lisibilité)

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

où ^Mest un return, ^[est escape, ^Kest ctrl+ket ^Vest ctrl+v.

Il est fort probable que cela risque d’être gâché un peu, car il existe peut-être de bien meilleurs moyens de générer ce schéma.

Java 11, 236 235 231 229 octets

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

Essayez-le en ligne.
REMARQUE: Java 11 n'est pas encore sur TIO et String.repeat(int)a donc été émulé avec repeat(String,int)(pour le même nombre d'octets).

Explication:

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 + fichier, 92 octets

enregistrer le PowerShell dans get-trumpwall.ps1(40 octets)

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

enregistrer le fichier de données avec le nom fet les données contient le symbole Unicode et Linux LF uniquement (52 octets):

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

vidage hexadécimal:

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

Exemple d'utilisation

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