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

Prøv det online!

Forklaring

Bilen og motoren er kodet som to sæt med fem strenge på linie 3 til 12. Tegnværdierne er slukket med 1 for at undgå at skulle håndtere de dobbelte anførselstegn, som ikke kan bruges i en Befunge-streng.

Koden fungerer ved at opbygge det fulde sæt tegn, der er nødvendigt for at gengive toget på stakken. For hver linje med output tilføjes først en passende bilstreng til stakken, gentages så mange gange som nødvendigt for lasten og derefter en kopi af den relevante motorstreng.

Når hver linje er konstrueret, erstattes et par nedpile til venstre for strengene med en højre pil, så den næste iteration af sløjfen følger en anden sti gennem koden ved hjælp af en anden par strenge til bilen og motoren.

Når alle data er bygget op på stakken, er der en endelig gengivelsessløjfe, der skriver tegnene ud og trækker 1 hver gang for at tage højde for den oprindelige kodning .

Som en bonus er kilden designet i form af et kanontårn , hvis toget kommer under angreb . Golfspillere ødelagde mit kanontårn.

Kommentarer

• Golfspillere ødelagde mit kanontårn, LOL. +1. Alligevel ‘ s slår C # og Java.

PHP, 218211204187 183 byte

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

Tager input fra STDIN; kør med -nR .

Komprimering af motoren eller vogn ville kræve mere kode for at dekomprimere, end den sparer på lager.
Jeg ser ikke mere potentiale her.

Kommentarer

• a&$c=$argn i stedet for ""<$c=$argv[1]
• @J ö rgH ü lsermann Ja, dette indlæg var gammelt. 🙂

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

Eksempel:

print f("Python") 

giver

 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 

Eksempel:

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

Muligvis ugyldig! Hvis det køres uden args overhovedet, prøver det at udskrive en tom streng og ser ud som:

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

Hvis den køres med en tom inputstreng, vender den tilbage korrekt dog:

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

(kinda) Ungolfed:

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

korteste komprimering i Powershell er bliver +"c"*x hvor c er tegnet og x er antallet af gentagelser, og det er kun til efterfølgende eller førende gentagelser, enhver centerstreng gentagelser vil kræve en ekstra + og en ekstra " – så der er ikke noget punkt i dette, hvor jeg kan se komprimering sparer plads, og det eneste gentagne char-sæt er ___ hvilket kun er 3 tegn.

Forklaring:

$l=($a=$args[0]).Length Tag den første arg , sæt det i $ a, tag derefter længden på $ a og sæt det i $ l, det er de eneste variabler, du har brug for.

" o O O"+" ___ "*$l det meste af de andre bits følger dette format af t han venstre del og derefter højre del gange antallet af krævede tegn.

" o "+([char[]]$a|%{" | $_ |"}) loop (|%{}) gennem $ a som en char-array, så foreach (char $_ in $a) til en ikke-pipeline-version, og sæt derefter char i teksten.

Dette er en ekstrem enkel tilgang, men fordi jeg ikke kan finde en god måde at komprimere strengene forbi dette, virker det som det mest nyttige.

gemt 1 byte takket være briantist! og her tænkte jeg, at dette ikke ville blive kortere ..

Kommentarer

• Du gjorde ikke ‘ behøver ikke håndtere args :).
• @carusocomputing yay, tak fordi du fortæller mig.
• Dejligt! Du kan gemme 1 byte ved at ændre [char[]]$a til $a[0..$l] 🙂
• ah brugte char array, før jeg erklærede $l og glemte helt om det. tak for det!

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

Eksempel

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

Kommentarer

• Jeg ved, at det ‘ er halveret et år, men du kan golf ganske lidt (også ved at fjerne mellemrum): interface C{static void main(String[]v){String n="\n",b=" o O O ",c=" o ",d=" TS__[O] ",e=" {======|",f="./o--000'";for(String x:new java.util.Scanner(System.in).nextLine().split("")){b+="___ ";c+="| "+x+" | ";d+="|___| ";e+="_|\"\"\"\"\"|";f+="\"`-0-0-'";}System.out.print(b+n+c+n+d+n+e+n+f);}} ( 318 bytes ) Eller endnu mere, hvis du erstatter new java.util.Scanner(System.in).nextLine() med v[0] som alternativ i put ( 279 bytes ) Prøv det her .

Perl, 137 byte

132 byte kode + 5 byte til -pF flag.

ascii_train.pl:

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

Bemærk at jeg tilføjede -a flag i koden, men det er kun fordi gamle versioner af Perl kræver -a -F bruges.

For at køre det:

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

input skal leveres uden en endelig ny linje (f.eks. med echo -n).

Forklaringer:
Fra hvad jeg har set, er det omtrent den samme idé som ETHProduction “s JavaScript-svar.
Der foregår ikke meget: desværre er mønstrene lidt for korte for at gøre x operatør værd at blive brugt.
Først, s/./ | $& | /g omgiver hvert tegn i inputet med | (og mellemrum) for at danne toget andet niveau.
Derefter inde i det lang streng, alt mellem en ! og en ny linje er et mønster, vi ønsker at gentage for at konstruere bilerne. Denne gentagelse er gjort takket være regex s/!(.*)/$1x@F/ge. (Jeg brugte ! fordi input ikke kan indeholde det).

SOGL V0.12 , 57 56 byte

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

Prøv det her!

Forklaring:

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

C #, 277 byte

Golfet:

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

Test:

Console.Write(new AllAboardTheASCIITrain().T("")); o O O o TS__[O] {======| ./ o--000" 

Og …

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

der sker ikke noget særligt her .. bare opretter hver linje og slutter sig til dem med nye linjer.

 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 byte

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

Prøv det online

Ou tput:

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

Jq 1.5 , 178 byte

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

Udvidet

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

Prøvekørsel

$ 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 

Prøv det online

Excel VBA, 218 Bytes

Anonym VBE øjeblikkelig vinduesfunktion, der tager input fra område [A1] og output til det øjeblikkelige VBE-vindue

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

Formateret til læsbarhed

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

Eksempeloutput

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