Alles einsteigen in den ASCII-Zug!

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

Sie sollten am besten darauf vorbereitet sein, mit dem Zug zu fahren, da Sie gleich den Zug bauen, mit dem Sie fahren werden. Geben Sie bei gegebener Zeichenfolge seinen vollständig geformten Zug aus, wie oben dargestellt. Das erste, was ausgegeben wird, ist immer die Engine, die Ihre Saite mitreißt, wie im Folgenden allein dargestellt:

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

Der Lokomotive folgen Eisenbahnwaggons, die jeden Charakter Ihrer kostbaren Fracht enthalten. Um beim Entladen Verwirrung zu vermeiden, hat Ihr Unternehmen Sie damit beauftragt, die Außenseiten dieser Fahrzeuge zu kennzeichnen. Die fraglichen Autos werden immer so aussehen:

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

Wobei die #für den Charakter repräsentativ ist, der sich im Laderaum befindet. Das Anketten des Motors an jedes Auto ist ebenfalls Teil Ihrer Arbeit, da Sie die Aufgabe haben, den reibungslosen Ablauf und den Erfolg dieser gesamten Sendung zu überwachen. Sobald Sie alle Wagen markiert und den Motor auf die Gleise gebracht haben, müssen Sie sicherstellen, dass der Zug montiert und fahrbereit ist.

Regeln

• Die einzige Eingabe, die Ihr Programm vornehmen sollte, ist eine einzelne Zeichenfolge.
• Der Motor muss immer ausgegeben werden, auch wenn Ihre Sendung leer ist.
• Jedes Auto kann nur einen Charakter aufnehmen, nicht zu viel Glück, sonst kann die Ware beschädigt werden.
• Sie müssen nur die folgenden druckbaren ASCII-Zeichen unterstützen: _-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
  Wenn Sie am Ende mehr tun, ist das auch in Ordnung, aber dies ist das absolute Minimum.
• 1-2 nachgestellte Leerzeichen sind zulässig, ebenso wie eine einzelne nachgestellte Zeile.
• Dies ist Code-Golf- Ascii-Art , die kürzeste Anzahl an Bytes.

05AB1E , 101 99 Bytes

Naiver erster Versuch.

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

Probieren Sie es online!

JavaScript (ES6), 149 144 Byte

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

Ich denke nicht, dass der Motor selbst komprimiert werden kann, aber vielleicht ist es möglich.

Testschnipsel

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

Probieren Sie es online!

Erläuterung

Auto und Motor sind in den Zeilen 3 bis 12 als zwei Sätze zu je fünf Zeichenfolgen codiert. Die Zeichenwerte sind um 1 versetzt, um die doppelten Anführungszeichen zu vermeiden, die in einer Befunge-Zeichenfolge nicht verwendet werden können.

Der Code baut den vollständigen Zeichensatz auf, der zum Rendern des Zugs auf dem Stapel erforderlich ist. Für jede Ausgabezeile wird zuerst ein entsprechender Wagen-String zum Stapel hinzugefügt, der so oft wiederholt wird, wie es für die Ladung erforderlich ist, und dann eine Kopie des entsprechenden Motor-Strings.

Nachdem jede Zeile erstellt wurde, wird ein Paar der Abwärtspfeile links von den Zeichenfolgen durch einen Rechtspfeil ersetzt, sodass die nächste Iteration der Schleife einem anderen Pfad durch den Code folgt, wobei ein anderes Zeichenfolgenpaar für das Auto und verwendet wird Motor.

Sobald alle Daten auf dem Stapel aufgebaut sind, gibt es eine letzte Rendering-Schleife, in der die Zeichen ausgeschrieben werden. Dabei wird jedes Mal 1 abgezogen, um die anfängliche Codierung zu berücksichtigen.

Als Bonus ist die Quelle in Form eines Geschützturms ausgelegt , falls der Zug angegriffen wird. Golfer haben meinen Geschützturm zerstört.

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

Übernimmt die Eingabe von STDIN; renn mit -nR.

Das Komprimieren des Motors oder Wagens würde mehr Code zum Dekomprimieren erfordern, als Speicherplatz spart.
Ich sehe hier kein Potenzial mehr.

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

Beispiel:

print f('Python')

gibt

    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

Beispiel:

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

Möglicherweise ungültig! Wenn es überhaupt ohne Argumente ausgeführt wird, wird versucht, eine leere Zeichenfolge zu drucken, und es sieht so aus:

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

Wenn es mit einer leeren Eingabezeichenfolge ausgeführt wird, wird es jedoch korrekt zurückgegeben:

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

(irgendwie) Ungolfed:

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

Die kürzeste Komprimierung in Powershell ist, +'c'*xwenn c das Zeichen und x die Anzahl der Wiederholungen ist. Dies gilt nur für abschließende oder führende Wiederholungen. Für Wiederholungen in der Mitte der Zeichenfolge ist ein Extra +und ein Extra erforderlich "Ich kann sehen, dass die Komprimierung Speicherplatz spart, und der einzige Zeichensatz, der wiederholt wird ___, besteht aus nur 3 Zeichen.

Erläuterung:

$l=($a=$args[0]).Length Nehmen Sie das erste Argument, schreiben Sie es in $ a, nehmen Sie dann die Länge von $ a und schreiben Sie es in $ l. Dies sind die einzigen Variablen, die Sie benötigen.

" o O O"+" ___ "*$l Die meisten anderen Bits folgen diesem Format des linken Teils und dann des rechten Teils multipliziert mit der Anzahl der erforderlichen Zeichen.

" o "+([char[]]$a|%{" | $_ |"})loop ( |%{}) durch $ a als char-Array, also foreach (char $_ in $a)für eine Nicht-Pipeline-Version, dann setze das Zeichen in den Text.

Dies ist ein äußerst einfacher Ansatz, aber da ich keine gute Möglichkeit finde, die Zeichenfolgen nach diesem Ansatz zu komprimieren, scheint er am nützlichsten zu sein.

1 Byte gespart dank briantist! und hier dachte ich, das würde nicht kürzer werden ..

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

    }
}

Beispiel

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 Byte Code + 5 Byte für -pFFlags.

ascii_train.pl:

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

Beachten Sie, dass ich das -aFlag im Code hinzugefügt habe , aber nur, weil alte Versionen von Perl erfordern, -awann -Fverwendet wird.

Um es auszuführen:

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

Die Eingabe muss ohne abschließenden Zeilenumbruch erfolgen ( echo -nz. B. mit).

Erklärungen:
Soweit ich gesehen habe, ist es ungefähr die gleiche Idee wie die JavaScript-Antwort von ETHProduction.
Es ist nicht viel los: Leider sind die Muster ein bisschen zu kurz, damit der xBediener es wert ist, verwendet zu werden.
Zunächst s/./ | $& | /gumgibt jedes Zeichen des Eingangs mit |(und Zwischenräumen) , um die zweite Ebene der Bahn zu bilden.
Dann ist in dieser langen Schnur alles zwischen einer !und einer Newline ein Muster, das wir wiederholen möchten, um die Autos zu konstruieren. Diese Wiederholung erfolgt dank der Regex s/!(.*)/$1x@F/ge. (Ich habe verwendet, !weil die Eingabe es nicht enthalten kann).

C #, 277 Bytes

Golf gespielt:

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

Testen:

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

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

Und...

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 Bytes

Hier passiert nichts Besonderes ... erstelle einfach jede Zeile und verbinde sie mit neuen Zeilen.

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

Probieren Sie es online aus

Ausgabe:

    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┼

Probieren Sie es hier aus!

Erläuterung:

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

Erweitert

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

Probelauf

$ 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

Probieren Sie es online aus

Excel VBA, 218 Bytes

Anonyme VBE-Direktfensterfunktion, die Eingaben aus dem Bereich [A1]und Ausgaben in das VBE-Direktfenster übernimmt

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

Zur besseren Lesbarkeit formatiert

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

Beispielausgabe

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