Wszyscy na pokładzie pociągu 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-'

Najlepiej przygotuj się na przejażdżkę pociągiem, ponieważ masz zamiar zbudować pociąg, którym będziesz jeździć. Biorąc pod uwagę ciąg s, wyjmij w pełni uformowany ciąg , jak pokazano powyżej. Pierwszą rzeczą, którą zawsze wypływa, jest silnik, który będzie ciągnął cięciwę, jak pokazano poniżej:

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

Za lokomotywą podążają wagony, które zawierają każdą postać cennego ładunku. Aby uniknąć nieporozumień podczas rozładunku, firma zleciła Ci oznakowanie zewnętrznej strony tych samochodów. Samochody, o których mowa, zawsze będą wyglądać tak:

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

Gdzie #jest reprezentatywna dla postaci, która znajduje się w luku bagażowym. Wiązanie silnika do każdego samochodu jest również częścią twojego zadania, ponieważ masz za zadanie nadzorować płynność i sukces całej przesyłki. Kiedy więc oznaczysz wszystkie samochody i umieścisz silnik na torach, musisz upewnić się, że pociąg jest zmontowany i gotowy do jazdy.

Zasady

• Jedyne dane, które powinien przyjąć Twój program, to pojedynczy ciąg.
• Silnik musi być zawsze włączony, nawet jeśli Twoja przesyłka jest pusta.
• Każdy samochód może pomieścić tylko jedną postać, nie pchaj szczęścia, bo możesz uszkodzić towar.
• Potrzebujesz tylko obsługi następujących znaków ASCII, które można wydrukować: _-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
  Jeśli w końcu zrobisz więcej, to też jest w porządku, ale jest to absolutne minimum.
• Dopuszczalne są 1-2 końcowe spacje, podobnie jak pojedyncza nowa linia.
• Jest to ascii-art code-golf , wygrywa najmniejsza liczba bajtów.

05AB1E , 101 99 bajtów

Naiwna pierwsza próba.

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

Wypróbuj online!

JavaScript (ES6), 149 144 bajtów

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

Nie sądzę, że sam silnik można skompresować, ale być może jest to możliwe.

Testowy fragment kodu

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 bajtów

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

Wypróbuj online!

Wyjaśnienie

Samochód i silnik są zakodowane jako dwa zestawy pięciu ciągów w liniach od 3 do 12. Wartości znaków są wyłączone o 1, aby uniknąć konieczności radzenia sobie z podwójnymi cudzysłowami, których nie można użyć w ciągu Befunge.

Kod działa poprzez zbudowanie pełnego zestawu znaków potrzebnych do renderowania pociągu na stosie. Dla każdego wiersza wyjściowego najpierw do stosu dodawany jest odpowiedni ciąg samochodowy, powtarzany tyle razy, ile to konieczne dla ładunku, a następnie jedna kopia odpowiedniego ciągu silnika.

Po zbudowaniu każdej linii para strzałek w dół po lewej stronie ciągów jest zastępowana strzałką w prawo, więc następna iteracja pętli przebiega inną ścieżką w kodzie, przy użyciu innej pary ciągów dla samochodu i silnik.

Po zgromadzeniu wszystkich danych na stosie powstaje końcowa pętla renderująca, która zapisuje znaki, odejmując 1 za każdym razem, aby uwzględnić początkowe kodowanie.

Jako bonus, źródło ma kształt wieży działowej , na wypadek zaatakowania pociągu. Golfiści zniszczyli moją wieżę.

PHP, 218 211 204 187 183 bajtów

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

Pobiera dane wejściowe z STDIN; biegać z -nR.

Kompresowanie silnika lub wagonu wymagałoby więcej kodu do dekompresji, niż oszczędza to miejsca na dysku.
Nie widzę tu już żadnego potencjału.

Python 2, 176 bajtów

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

Przykład:

print f('Python')

daje

    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 bajtów

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

Przykład:

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

Prawdopodobnie nieprawidłowy! Jeśli zostanie uruchomiony bez żadnych argumentów, spróbuje wydrukować jeden pusty ciąg znaków i będzie wyglądać następująco:

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

Jeśli zostanie uruchomiony z pustym ciągiem wejściowym, zwróci poprawnie:

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

(poniekąd) Ungolfed:

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

najkrótsza kompresja w Powershell będzie tam, +'c'*xgdzie c jest char, a x jest liczbą powtórzeń, i to tylko dla powtórzeń końcowych lub wiodących, każde powtórzenie łańcucha środkowego będzie wymagało dodatkowego +i dodatkowego "- więc nie ma sensu w tym, gdzie Widzę kompresję oszczędzającą dowolne miejsce, a jedynym powtarzanym zestawem ___znaków jest tylko 3 znaki.

Wyjaśnienie:

$l=($a=$args[0]).Length Weź pierwszy argument, umieść go w $ a, a następnie weź długość $ a i umieść w $ l, to jedyne potrzebne zmienne.

" o O O"+" ___ "*$l większość innych bitów jest zgodna z tym formatem lewej części, a następnie prawej części razy liczba wymaganych znaków.

" o "+([char[]]$a|%{" | $_ |"})loop ( |%{}) przez $ a jako tablicę char, więc foreach (char $_ in $a)dla wersji niepotokowej, następnie wstaw char do tekstu.

jest to bardzo proste podejście, ale ponieważ nie mogę znaleźć dobrego sposobu na kompresowanie ciągów obok tego, wydaje się to najbardziej przydatne.

zapisano 1 bajt dzięki briantist! i tutaj myślałem, że to nie będzie krótsze ..

Java, 361 bajtów

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

    }
}

Przykład

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

Perl, 137 bajtów

132 bajty kodu + 5 bajtów na -pFflagi.

ascii_train.pl:

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

Zauważ, że dodałem -aflagę do kodu, ale dzieje się tak tylko dlatego, że stare wersje Perla wymagają, -akiedy -Fjest używany.

Aby uruchomić:

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

Dane wejściowe muszą być dostarczane bez końcowej nowej linii ( echo -nna przykład).

Objaśnienia:
Z tego, co widziałem, jest to w przybliżeniu ten sam pomysł, co odpowiedź JavaScript ETHProduction.
Nie dzieje się wiele: niestety wzory są nieco za krótkie, aby xoperator był wart użycia.
Najpierw s/./ | $& | /gotacza każdy znak wejścia |(i spacjami), tworząc drugi poziom pociągu.
Następnie wewnątrz tego długiego sznurka wszystko od !a do nowej linii jest wzorem, który chcemy powtarzać, aby konstruować samochody. To powtórzenie odbywa się dzięki wyrażeniu regularnemu s/!(.*)/$1x@F/ge. (Użyłem, !ponieważ dane wejściowe nie mogą go zawierać).

C #, 277 bajtów

Gra w golfa:

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

Nie golfowany:

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

Testowanie:

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

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

I...

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 bajtów

nic specjalnego się tutaj nie dzieje ... po prostu tworząc każdą linię i łącząc je z nowymi liniami.

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 bajtów

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

Wypróbuj online

Wynik:

    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 bajtów

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

Wypróbuj tutaj!

Wyjaśnienie:

..‘             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 bajtów

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

Rozszerzony

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

Przykładowy przebieg

$ 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

Wypróbuj online

Excel VBA, 218 bajtów

Anonimowa funkcja bezpośredniego okna VBE, która przenosi dane wejściowe z zakresu [A1]i wyjścia do bezpośredniego okna 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)]

Sformatowane dla czytelności

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

Przykładowe dane wyjściowe

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