Tous à bord du train ASCII!

    o O O   ___     ___     ___     ___     ___     ___     ___     ___     ___  
   o       | C |   | O |   | D |   | E |   |   |   | G |   | O |   | L |   | F | 
  TS__[O]  |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___| 
 {======|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|
./o--000'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'

Vous feriez mieux de vous préparer à monter dans le train, car vous êtes sur le point de construire le train sur lequel vous allez rouler. Avec une chaîne s, sortez un train complètement formé comme décrit ci-dessus. La première chose à produire est toujours le moteur qui tirera votre chaîne, comme illustré ci-dessous:

    o O O 
   o      
  TS__[O] 
 {======| 
./o--000' 

La locomotive suit les wagons contenant chaque personnage de votre précieuse cargaison. Pour éviter toute confusion lors du déchargement, votre société vous a demandé d'étiqueter l'extérieur de ces wagons. Les voitures en question ressembleront toujours à ceci:

   ___ 
  | # |
  |___|
_|"""""|
"`-0-0-'

Où le #est représentatif du personnage qui se trouve dans la soute "cargo". Le chaînage du moteur à chaque voiture fait également partie de votre travail, car vous avez été chargé de superviser la fluidité et le succès de toute cette expédition. Donc, une fois que vous avez étiqueté toutes les voitures et que le moteur est sur les rails, vous devez vous assurer que le train est assemblé et prêt à rouler.

Règles

• La seule entrée que votre programme devrait prendre est une seule chaîne.
• Le moteur doit toujours être sorti, même si votre envoi est vide.
• Chaque voiture ne peut contenir qu'un seul personnage, ne poussez pas votre chance, vous risqueriez d'endommager les marchandises.
• Vous n'avez besoin que de prendre en charge les caractères ASCII imprimables suivants: _-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
  Si vous en faites plus, c'est très bien aussi, mais c'est le strict minimum.
• Un ou deux espaces de fin sont acceptables, de même qu'un simple retour à la ligne.
• C'est le code-golf ascii-art , le plus petit nombre d'octets gagnés.

05AB1E , 101 à 99 octets

Naive première tentative.

"    o O O   o"ð7×"TS__[O] {======|./o--000'"J5ä¹v… _ €ÐJy“ | ÿ |   |___| _|"""""|"`-0-0-'“«5ä})øJ»

Essayez-le en ligne!

JavaScript (ES6), 149 144 octets

s=>`    o O Oa   ___  
   o     a  | $& | 
  TS__[O]a  |___| 
 {======|a_|"""""|
./o--000'a"\`-0-0-'`.replace(/a(.*)/g,(_,c)=>s.replace(/./g,c))

Je ne pense pas que le moteur lui-même puisse être compressé, mais c'est peut-être possible.

Extrait de test

let f =

s=>`    o O Oa   ___  
   o     a  | $& | 
  TS__[O]a  |___| 
 {======|a_|"""""|
./o--000'a"\`-0-0-'`.replace(/a(.*)/g,(_,c)=>s.replace(/./g,c))

O.innerHTML = f("CODE GOLF")

<input value="CODE GOLF" oninput="O.innerHTML=f(this.value.replace(/\n/g,'&lt;br&gt;'))"><br>
<pre id=O></pre>

Befunge, 276 270 octets

p1p~:7>7+#:`#~_$:v
>#p0p10:p00:+1g00_v#:
v"!!```!!!"v>0p01g\-0g1+53p  
v"!}!#!}!!"v0 p115<
v"!}```}!!"v^:-1<
v"}#####}`">00g:|
>"(.1.1.a#"^+<v1<
v"P!P!p!!! "v5>g00p
v"!!!!!p!!!"v6
v"^P\``TU!!"vp
v"}>>>>>>|!"v+
>"(111..p0/"v6
v-1:g110">>"<g
>:11p!#v_p011^
#-:#1_@>$$$$>,#

Essayez-le en ligne!

Explication

La voiture et le moteur sont codés sous forme de deux ensembles de cinq chaînes sur les lignes 3 à 12. Les valeurs de caractère sont décalées de 1 afin d'éviter de devoir traiter les guillemets doubles qui ne peuvent pas être utilisés dans une chaîne Befunge.

Le code fonctionne en construisant l'ensemble des caractères nécessaires pour rendre le train sur la pile. Pour chaque ligne de sortie, une chaîne de voiture appropriée est d'abord ajoutée à la pile, répétée autant de fois que nécessaire pour le chargement, puis une copie de la chaîne de moteur appropriée.

Une fois que chaque ligne est construite, une paire de flèches vers le bas situées à gauche des chaînes est remplacée par une flèche vers la droite. La prochaine itération de la boucle suit un chemin différent dans le code, en utilisant une paire de chaînes différente pour la voiture et moteur.

Une fois que toutes les données ont été créées sur la pile, une dernière boucle de rendu écrit les caractères, en soustrayant 1 à chaque fois pour prendre en compte le codage initial.

En prime, la source est conçue sous la forme d'une tourelle , au cas où le train serait attaqué. Les golfeurs ont détruit ma tourelle.

PHP, 218 211 204 187 183 octets

    o O O<?for(;$y<5;print"\n".["   o     ","  TS__[O]"," {======|","./o--000'"][+$y++])for($p=0;$c=a&$argn[$p++];)echo["   ___  ","  | $c | ","  |___| ",'_|"""""|',"\"`-0-0-'"][+$y];

Prend la contribution de STDIN; courir avec -nR.

Compresser le moteur ou le wagon demanderait plus de code à décompresser qu'il n'en économiserait sur le stockage.
Je ne vois plus de potentiel ici.

Python 2, 176 octets

lambda i:'\n'.join(map(''.join,zip(*[["    o O O","   o     ","  TS__[O]"," {======|","./o--000'"]]+[["   ___  ",'  | '+x+' | ',"  |___| ",'_|"""""|',"\"`-0-0-'"]for x in i])))

Exemple:

print f('Python')

donne

    o O O   ___     ___     ___     ___     ___     ___  
   o       | P |   | y |   | t |   | h |   | o |   | n | 
  TS__[O]  |___|   |___|   |___|   |___|   |___|   |___| 
 {======|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|
./o--000'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'

Powershell, 167 166 octets

$l=($a=$args[0]).Length;"    o O O"+"   ___  "*$l;"   o     "+($a[0..$l]|%{"  | $_ |"});"  TS__[O]"+"  |___| "*$l;" {======|"+'_|"""""|'*$l;"./o--000'"+'"`-0-0-'''*$l

Exemple:

.\train.ps1 "PowerShell!"
    o O O   ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___  
   o       | P |   | o |   | w |   | e |   | r |   | S |   | h |   | e |   | l |   | l |   | ! |
  TS__[O]  |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___| 
 {======|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|
./o--000'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'

Peut-être invalide! S'il est exécuté sans argument, il essaiera d'imprimer une chaîne vide et ressemblera à ceci:

    o O O
   o       |  |
  TS__[O]
 {======|
./o--000'

Si exécuté avec une chaîne d'entrée vide, il retournera correctement cependant:

.\train.ps1 ""
    o O O
   o     
  TS__[O]
 {======|
./o--000'

(un peu) Ungolfed:

$l=($a=$args[0]).Length
"    o O O"+"   ___  "*$l
"   o     "+($a[0..$l]|%{"  | $_ |"})
"  TS__[O]"+"  |___| "*$l
" {======|"+'_|"""""|'*$l
"./o--000'"+'"`-0-0-'''*$l

La compression la plus courte dans Powershell sera +'c'*xoù c est le caractère et x est le nombre de répétitions, et ce n'est que pour les répétitions en tête ou en tête, toute répétition de chaîne centrale nécessitera un extra +et un extra "- il n'y a donc aucun point en cela Je peux voir la compression économiser de l’espace, et le seul jeu de caractères répété ___est de 3 caractères seulement.

Explication:

$l=($a=$args[0]).Length Prenez le premier argument, mettez-le dans $ a, puis prenez la longueur de $ a et mettez-le dans $ l, ce sont les seules variables dont vous avez besoin.

" o O O"+" ___ "*$l la plupart des autres bits suivent ce format de la partie gauche puis de la partie droite multiplié par le nombre de caractères requis.

" o "+([char[]]$a|%{" | $_ |"})loop ( |%{}) via $ a en tant que tableau de caractères, donc foreach (char $_ in $a)pour une version non-pipeline, mettez le caractère dans le texte.

C'est une approche extrêmement simple, mais comme je ne trouve pas un bon moyen de compresser les chaînes au-delà, cela semble être le plus utile.

sauvé 1 Byte grâce à briantist! et ici je pensais que cela ne serait pas plus court ..

Java, 361 octets

class C {static void main(String[]v){Scanner q = new Scanner(System.in);String i = q.nextLine();String[] t = {"    o O O   ", "   o       ", "  TS__[O]  ", " {======|", "./o--000'",};for (char c: i.toCharArray()) {t[0]+="___     ";t[1]+="| # |   ".replace('#',c);t[2]+="|___|   ";t[3]+="_|\"\"\"\"\"|";t[4]+="\"`-0-0-'";}for(String p:t) System.out.println(p);}}

class C {
    static void main(String[]v)  {
        Scanner q = new Scanner(System.in);
        String i = q.nextLine();
        String[] t = {
                "    o O O   ",
                "   o       ",
                "  TS__[O]  ",
                " {======|",
                "./o--000'",
        };
        for (char c: i.toCharArray()) {
            t[0]+="___     ";
            t[1]+="| # |   ".replace('#',c);
            t[2]+="|___|   ";
            t[3]+="_|\"\"\"\"\"|";
            t[4]+="\"`-0-0-'";
        }
        for(String p:t)
            System.out.println(p);

    }
}

Exemple

java
    o O O   ___     ___     ___     ___     
   o       | j |   | a |   | v |   | a |   
  TS__[O]  |___|   |___|   |___|   |___|   
 {======|_|"""""|_|"""""|_|"""""|_|"""""|
./o--000'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'

Perl, 137 octets

132 octets de code + 5 octets pour les -pFdrapeaux.

ascii_train.pl:

#!/usr/bin/perl -apF
s/./  | $& | /g;$_="    o O O!   ___  
   o     $_
  TS__[0]!  |___| 
 {======|!".'_|"""""|'."
./o--000'!\"`-0-0-'";s/!(.*)/$1x@F/ge

Notez que j'ai ajouté -aflag dans le code, mais c'est uniquement parce que les anciennes versions de Perl exigent -aquand -Fest utilisé.

Pour l'exécuter:

echo -n "code-golf" | perl ascii_train.pl

L'entrée doit être fournie sans nouvelle ligne (avec echo -npar exemple).

Explications:
D'après ce que j'ai vu, c'est à peu près la même idée que la réponse JavaScript d'ETHProduction.
Il n'y a pas grand chose à faire: malheureusement, les schémas sont un peu trop courts pour rendre l' xopérateur digne d'être utilisé.
Tout d'abord, s/./ | $& | /gentoure chaque caractère de l'entrée avec |(et des espaces) pour former le deuxième niveau du train.
Ensuite, à l'intérieur de cette longue chaîne, tout ce qui se situe entre a !et une nouvelle ligne est un motif que nous souhaitons répéter pour construire les voitures. Cette répétition est faite grâce à la regex s/!(.*)/$1x@F/ge. (J'ai utilisé !parce que l'entrée ne peut pas le contenir).

C #, 277 octets

Golfé:

string T(string s){var o=new string[]{"     o O O","   o        ","   TS__[O]","  {======|","./ o--000'" };for(int i=0;i<s.Length;i++){o[0]+="   ___  ";o[1]+="| # |   ".Replace("#",s[i]+"");o[2]+="  |___| ";o[3]+="_|\"\"\"\"\"|";o[4]+="\"`-0-0-'";}return string.Join("\r\n",o);

Ungolfed:

public string T(string s)
{
  var o = new string[] { "     o O O", "   o        ", "   TS__[O]",
    "  {======|", "./ o--000'" };

  for (int i = 0; i < s.Length; i++)
  {
    o[0] += "   ___  ";
    o[1] += "| # |   ".Replace("#", s[i] + "");
    o[2] += "  |___| ";
    o[3] += "_|\"\"\"\"\"|";
    o[4] += "\"`-0-0-'";
  }

  return string.Join("\r\n", o);
}

Essai:

Console.Write(new AllAboardTheASCIITrain().T(""));

     o O O
   o        
   TS__[O]
  {======|
./ o--000'

Et...

Console.Write(new AllAboardTheASCIITrain().T("Programming Puzzles & Code Golf"));

     o O O   ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___  
   o        | P |   | r |   | o |   | g |   | r |   | a |   | m |   | m |   | i |   | n |   | g |   |   |   | P |   | u |   | z |   | z |   | l |   | e |   | s |   |   |   | & |   |   |   | C |   | o |   | d |   | e |   |   |   | G |   | o |   | l |   | f |   
   TS__[O]  |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___| 
  {======|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|
./ o--000'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'

C # 221 octets

rien de spécial ne se passe ici .. il suffit de créer chaque ligne et de les joindre avec de nouvelles lignes.

s=>{var t=new[]{"    o O O","   o     ","  TS__[O]"," {======|","./o--000'"};foreach(var c in s){t[0]+="   ___  ";t[1]+=$"  | {c} | ";t[2]+="  |___| ";t[3]+="_|\"\"\"\"\"|";t[4]+="\"`-0-0-'";}return string.Join("\n",t);};

C, 217 212 208 octets

i;f(char*t){char d[]="    o O O   o       TS__[O] {======|./o--000'   ___    | C |   |___| _|\"\"\"\"\"|\"`-0-0-'",*p;for(;i<5;i++){printf("%.9s",d+i*9);for(p=t;d[57]=*p++;)printf("%.8s",d+45+i*8);puts("");}}

Essayez-le en ligne

Sortie:

    o O O   ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___  
   o       | C |   | O |   | D |   | E |   |   |   | G |   | O |   | L |   | F |   |   |   | I |   | N |   |   |   | C | 
  TS__[O]  |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___| 
 {======|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|
./o--000'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'

SOGL V0.12 , 57 56 octets

Τ¡ā↓mΛC┌─⁵℮Ƨ⅛□→(š;∞⅟¹°⅔Ζ‽ζ÷⁴‘9n,{"s=Ο!NθæιžGš‼t╬¼Xg`‘8n┼

Essayez-le ici!

Explication:

..‘             push a compressed string of the locomotive in a single line
   9n           split in line lengths of 9
     ,{         for each character in the input
       "..‘       push a compressed string of a wagon in a single line
           8n     split to line lengths of 8
             ┼    add horizontally

Jq 1.5 , 178 octets

[["    o O O   o       TS__[O] {======|./o--000'"|_nwise(9)]]+[range(length)as$i|[.[$i:$i+1]|"   ___    | \(.) |   |___| _|\"\"\"\"\"|\"`-0-0-'"|_nwise(8)]]|transpose|map(add)[]

Étendu

# engine
def E:"    o O O   o       TS__[O] {======|./o--000'"|_nwise(9);

# car (note string interpolation)
def C:"   ___    | \(.) |   |___| _|\"\"\"\"\"|\"`-0-0-'"|_nwise(8);

  # generate train
  [[E]] + [range(length) as $i| [.[$i:$i+1] |C]]

  # combine rows and concatenate strings     
| transpose | map(add)[]

Échantillon échantillon

$ jq -MRr train.jq <<< "golf"
    o O O   ___     ___     ___     ___  
   o       | g |   | o |   | l |   | f | 
  TS__[O]  |___|   |___|   |___|   |___| 
 {======|_|"""""|_|"""""|_|"""""|_|"""""|
./o--000'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'

$ wc -c < train.jq
  178

Essayez-le en ligne

Excel VBA, 218 octets

Fonction de fenêtre immédiate VBE anonyme qui prend les entrées de la plage [A1]et les envoie à la fenêtre immédiate VBE

[B1]=[Len(A1)]:?"    o O O"[Rept("   ___  ",B1)]:?"   o     ";:For i=1To[B1]:?"  | "Mid([A1],i,1)" | ";:Next:?:?"  TS__[O]"[Rept("  |___| ",B1)]:?" {======|"[Rept("_|""""""""""|",B1)]:?"./o--000'"[Rept("""`-0-0-'",B1)]

Formaté pour la lisibilité

[B1]=[Len(A1)]
?"    o O O"[Rept("   ___  ",B1)]
?"   o     ";:For i=1To[B1]:?"  | "Mid([A1],i,1)" | ";:Next:?:
?"  TS__[O]"[Rept("  |___| ",B1)]:
?" {======|"[Rept("_|""""""""""|",B1)]:
?"./o--000'"[Rept("""`-0-0-'",B1)]

Exemple de sortie

    o O O   ___     ___     ___     ___     ___     ___     ___     ___     ___     ___     ___  
   o       | V |   | B |   | A |   |   |   | E |   | x |   | p |   | r |   | e |   | s |   | s | 
  TS__[O]  |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___|   |___| 
 {======|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|_|"""""|
./o--000'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'