68

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

code-golf ascii-art kolmogorov-complexity J Atkin
la source

9

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.

Urne Magique De Pieuvre
la source

29

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=.)

Lynn
la source

21

Qu'est-ce que je ne fais même pas

Conor O'Brien

4

Ce langage a-t-il été spécialement conçu pour cette réponse?

Erdal G.

5

@ErdalG. Non. Même si CJam a bien été fabriqué par un membre régulier du PPCG ( aditsu ), il existe depuis assez longtemps. Vous trouverez tout cela sur le site. :)

Alex A.

@Alexa. Ok fais plus de sens maintenant. Je suis assez nouveau ici, merci! :)

Erdal G.

@ErdalG. Mon plaisir. Bienvenue sur le site!

Alex A.

13

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

Afficher l'extrait de code

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>

Développer l'extrait

utilisateur81655
la source

Pouvez-vous enregistrer un octet en utilisant à la .slice(-15)place?

Neil

La correction est facile, il suffit d’utiliser la partie minimale droite au lieu de la partie minimale gauche:__ __ n| |_| | n| |___n - n- n -n—

Neil

Très intelligent, bon travail!

J Atkin

@ Neil Ah, tu as raison. Merci pour le conseil!

user81655

5

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.

Conor O'Brien
la source

6

@Connor O'Brien, quel est donc l'eta sur cette explication: D

Rohan Jhunjhunwala

5

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!

nimi
la source

La ligne du bas devrait être - (U + 2014), pas un tiret ASCII; Je pense que cela signifie que vous perdez 2 octets.

Lynn

@Mauris: tu as raison. Fixe le. Merci d'avoir découvert.

nimi

Vous pouvez réellement terminer les périodes des lignes 1 à 3 plus tôt, en économisant 4 + 3 + 3 octets. (Ma réponse de CJam fait la même chose.)

Lynn

@Mauris: ah oui, car le premier cycle est coupé après 15 caractères. Merci!

nimi

4

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

utilisateur2064000
la source

4

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

beatcracker
la source

1

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

mazzy

4

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

kuldeep.kamboj
la source

2

1) Ne définissez pas de variable pour $s, utilisez-la directement dans votre boucle: foreach([…,…] as $d)2) Supprimez les espaces sauf si $d: foreach(… as$d)3) Utilisez une nouvelle ligne au lieu de "\n".

Blackhole

Monsieur, vous ne présentez pas la vérité. Votre code compte 182 caractères, mais 212 octets.

Tschallacka

@MichaelDibbets, Désolé pour la confusion entre octets et caractères, modifiée

kuldeep.kamboj

1

utilisez quelque chose comme mothereff.in/byte-counter pour compter les octets

Tschallacka

3

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.

Level River St
la source

Bien, mais vous pouvez économiser 3 octets en n’utilisant pas #define qet en codant en dur les valeurs.

Johan du Toit

2

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!

Mère fils
la source

2

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

Tschallacka
la source

supprime l'espace avant le et supprime les crochets -3 octets

Jörg Hülsermann

$x=$r(' ',3);peut être raccourci à$x=' ';

Jörg Hülsermann

Vous n'avez pas besoin des crochets pour la boucle foreach et `comme $ z` pourrait écrireas$z

Jörg Hülsermann

2

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

Zenadix
la source

Vous pouvez supprimer les espaces pour )for s in[...

Cyoce

2

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

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

Cplusplusplus
la source

2

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

dzaima
la source

revient à toutes les questions d'art ascii et éveille les votes de dzamia pour m'avoir littéralement tabassé sur eux tous avec SOGL à un moment donné

Urne Octopus Magique

1

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.

algmyr
la source

0

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

Kevin Cruijssen
la source

0

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

mazzy
la source

Aidez Trump à construire le mur!

Réponses:

05AB1E , 38 octets

CJam, 52 octets

Explication

JavaScript (ES6), 116 115 octets

Explication

Ungolfed

Tester

Jolf , 135 octets

Haskell, 116 118 108 octets

Utilitaires Bash + Linux ( 247 186 180 octets)

PowerShell, 103 100 caractères (105 octets sur le disque, 102 sans nomenclature)

Version non-golfée

Exemple d'utilisation

PHP 5.4 ( 182 175 caractères)

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

C, 148 octets

Vitsy , 121 octets

PHP5.5, 182 172 octets 168 octets

Python 3, 132 122 120 octets

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

SOGL V0.12 , 32 octets

Vim, 90 clés

Java 11, 236 235 231 229 octets

Powershell + fichier, 92 octets

Exemple d'utilisation