Todos a bordo do trem 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-'

É melhor você estar preparado para pegar o trem, porque está prestes a construir o trem em que estará andando. Dada uma corda s, produza um trem totalmente formado, como mostrado acima. A primeira coisa que sai é sempre o mecanismo que puxará sua corda, como mostrado abaixo:

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

Seguindo a locomotiva, há vagões contendo cada personagem de sua preciosa carga. Para economizar confusão ao descarregar, sua empresa encarregou você de rotular a parte externa desses carros. Os carros em questão sempre terão a seguinte aparência:

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

Onde o #é representativo do personagem que está dentro do porão de "carga". A ligação do motor a cada carro também faz parte do seu trabalho, pois você deve supervisionar a fluidez e o sucesso de todo o transporte. Assim, depois de rotular todos os carros e colocar o motor nos trilhos, você deve garantir que o trem esteja montado e pronto para rolar.

Regras

• A única entrada que seu programa deve receber é uma única sequência.
• O motor deve sempre ter saída, mesmo que sua remessa esteja vazia.
• Cada carro pode conter apenas um personagem, não empurre a sorte, pois pode danificar a mercadoria.
• Você precisa apenas suportar os seguintes caracteres ASCII imprimíveis: _-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
  Se você acabar fazendo mais, tudo bem também, mas esse é o mínimo necessário.
• 1-2 espaços à direita são aceitáveis, assim como uma nova linha à direita.
• Isso é código-golf ascii-art , menor número de bytes ganhos.

05AB1E , 101 99 bytes

Primeira tentativa ingênua.

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

Experimente online!

JavaScript (ES6), 149 144 bytes

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

Eu não acho que o próprio motor possa ser comprimido, mas talvez seja possível.

Snippet de teste

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 bytes

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_@>$$$$>,#

Experimente online!

Explicação

O carro e o motor são codificados como dois conjuntos de cinco cadeias nas linhas 3 a 12. Os valores dos caracteres são 1 em zero, para evitar ter que lidar com aspas duplas que não podem ser usadas em uma string Befunge.

O código funciona criando o conjunto completo de caracteres necessários para renderizar o trem na pilha. Para cada linha de saída, uma sequência de carros apropriada é primeiro adicionada à pilha, repetida quantas vezes forem necessárias para a carga e, em seguida, uma cópia da sequência de mecanismo apropriada.

Após a construção de cada linha, um par de setas para a esquerda das cordas é substituído por uma seta para a direita. Portanto, a próxima iteração do loop segue um caminho diferente no código, usando um par de cordas diferente para o carro e motor.

Depois que todos os dados foram construídos na pilha, há um loop de renderização final que grava os caracteres, subtraindo 1 a cada vez para contabilizar a codificação inicial.

Como um bônus, a fonte é projetada na forma de uma torre de armas , caso o trem seja atacado. Golfistas destruíram minha torre de armas.

PHP, 218 211 204 187 183 bytes

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

Recebe entrada do STDIN; corra com -nR.

A compactação do mecanismo ou vagão exigiria mais código para descompactar do que economiza no armazenamento.
Não vejo mais potencial aqui.

Python 2, 176 bytes

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

Exemplo:

print f('Python')

dá

    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 Bytes

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

Exemplo:

.\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-'

Possivelmente inválido! Se executado sem argumentos, ele tentará imprimir uma sequência vazia e será semelhante a:

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

Se executado com uma string de entrada vazia, ela retornará corretamente, no entanto:

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

(meio) Ungolfed:

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

a menor compressão no Powershell será +'c'*xonde c é o caractere x é o número de repetições, e isso é apenas para repetições à direita ou à direita, qualquer repetição na corda central exigirá um extra +e um extra "- portanto, não há sentido em que Posso ver a compactação economizando espaço, e o único conjunto de caracteres repetidos ___é de apenas 3 caracteres.

Explicação:

$l=($a=$args[0]).Length Pegue o primeiro argumento, coloque-o em $ a, depois pegue o tamanho de $ a e coloque-o em $ l, essas são as únicas variáveis ​​necessárias.

" o O O"+" ___ "*$l a maioria dos outros bits segue esse formato da parte esquerda e depois a parte direita vezes o número de caracteres necessários.

" o "+([char[]]$a|%{" | $_ |"})loop ( |%{}) a $ a como uma matriz de caracteres, portanto, foreach (char $_ in $a)para uma versão sem pipeline, coloque o caractere no texto.

essa é uma abordagem extremamente simples, mas como não consigo encontrar uma boa maneira de compactar as strings, parece a mais útil.

economizou 1 Byte graças ao briantist! e aqui eu estava pensando que isso não ficaria mais curto ..

Java, 361 bytes

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

    }
}

Exemplo

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

Perl, 137 bytes

132 bytes de código + 5 bytes para -pFsinalizadores.

ascii_train.pl:

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

Observe que eu adicionei -asinalizador no código, mas é apenas porque versões antigas do Perl exigem -aquando -Fé usado.

Para executá-lo:

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

A entrada deve ser fornecida sem uma nova linha final ( echo -npor exemplo).

Explicações:
Pelo que vi, é mais ou menos a mesma ideia que a resposta JavaScript da ETHProduction.
Não há muita coisa acontecendo: infelizmente os padrões são um pouco curtos para fazer com que o xoperador valha a pena ser usado.
Primeiro, s/./ | $& | /genvolve cada caractere da entrada com |(e espaços) para formar o segundo nível do trem.
Então, dentro dessa longa corda, tudo entre a !e uma nova linha é um padrão que desejamos repetir para construir os carros. Essa repetição é feita graças ao regex s/!(.*)/$1x@F/ge. (Eu usei !porque a entrada não pode conter).

C #, 277 bytes

Golfe:

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

Testando:

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

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

E...

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

Bytes C # 221

nada de especial está acontecendo aqui .. apenas criando cada linha e junte-se a elas com novas linhas.

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 bytes

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

Experimente online

Resultado:

    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 bytes

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

Experimente aqui!

Explicação:

..‘             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 bytes

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

Expandido

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

Amostra de execução

$ 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

Experimente online

Excel VBA, 218 bytes

Função de janela imediata VBE anônima que leva as entradas do intervalo [A1]e as saídas para a janela imediata 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)]

Formatado para facilitar a leitura

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

Saída de amostra

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