Befunge, 276 270 byte

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 sett med fem strenger på linje 3 til 12. Tegnverdiene er av med 1 for å unngå å måtte håndtere de dobbelte anførselstegnene som ikke kan brukes i en Befunge-streng.

Koden fungerer ved å bygge opp hele settet med tegn som trengs for å gjengi toget på stabelen. For hver linje med utgang legges først en passende bilstreng til bunken, gjentas så mange ganger som nødvendig for lasten, og deretter en kopi av den aktuelle motorstrengen.

Etter at hver linje er konstruert, erstattes et par nedpiler til venstre for strengene med en høyre pil, så neste iterasjon av sløyfen følger en annen bane gjennom koden, ved å bruke en annen par strenger for bilen og motoren.

Når alle dataene er bygd opp på bunken, er det en siste gjengesløyfe som skriver ut tegnene, og trekker 1 hver gang for å gjøre rede for den første kodingen. .

Som en bonus er kilden utformet i form av et kanontårn , i tilfelle toget kommer under angrep . Golfere ødela pistolreturen min.

Kommentarer

• Golfspillere ødela pistolreturen min, LOL. +1. Likevel ‘ slår C # og Java.

PHP, 218 211 204 187 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]; 

Tar innspill fra STDIN; kjør med -nR .

Komprimering av motor eller vogn ville trenge mer kode for å dekomprimere enn den sparer på lagring.
Jeg ser ikke mer potensial her.

Kommentarer

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

Python 2, 176 byte

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

gir

 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 byte

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

Muligens ugyldig! Hvis du kjører uten argumenter i det hele tatt, vil den prøve å skrive ut en tom streng, og se ut som:

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

Hvis du kjører med en tom inndatastreng, returnerer den riktig imidlertid:

.\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 kommer til å være +"c"*x der c er char og x er antall repetisjoner, og det er bare for etterfølgende eller ledende repetisjoner, alle sentre-streng repetisjoner vil kreve en ekstra + og en ekstra " – så det er ingen vits i dette hvor jeg kan se komprimering som sparer plass, og det eneste gjentatte tegnsettet er ___ som bare er tre tegn.

Forklaring:

$l=($a=$args[0]).Length Ta den første arg , legg den i $ a, og ta lengden på $ a og sett den i $ l, dette er de eneste variablene du trenger.

" o O O"+" ___ "*$l det meste av de andre bitene følger dette formatet av t han venstre del og deretter høyre del ganger antall nødvendige tegn.

" o "+([char[]]$a|%{" | $_ |"}) loop (|%{}) gjennom $ a som en char-array, så foreach (char $_ in $a) for en ikke-rørledningsversjon, og sett deretter char i teksten.

Dette er en ekstremt enkel tilnærming, men fordi jeg ikke finner en god måte å komprimere strengene forbi dette, virker det som det mest nyttige.

lagret 1 byte takk til briantist! og her tenkte jeg at dette ikke ville bli kortere ..

Kommentarer

• Du gjorde ikke ‘ trenger ikke å håndtere argumenter :).
• @carusocomputing yay, takk for at du ga meg beskjed.
• Fint! Du kan spare 1 byte ved å endre [char[]]$a til $a[0..$l] 🙂
• ah brukte char array før jeg erklærte $l og glemte helt om det. takk for det!

Java, 361 byte

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 vet at ‘ har vært halvert i året, men du kan golf ganske mye (også ved å fjerne mellomrom): 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 enda mer hvis du bytter ut new java.util.Scanner(System.in).nextLine() med v[0] som alternativ i put ( 279 byte ) Prøv det her .

Perl, 137 byte

132 byte kode + 5 byte for -pF flagg.

ascii_train.pl:

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

Merk at jeg la til -a flagg i koden, men det er bare fordi gamle versjoner av Perl krever -a -F brukes.

For å kjøre den:

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

input må leveres uten en endelig ny linje (med for eksempel echo -n).

Forklaringer:
Fra det jeg har sett, er det omtrent den samme ideen som JavaScript-svar fra ETHProduction.
Det er ikke mye som skjer: dessverre er mønstrene litt for korte for å gjøre x operatør verdt å bli brukt.
Først, s/./ | $& | /g omgir hvert tegn i inngangen med | (og mellomrom) for å danne toget andre nivå.
Så inne i lang streng, alt mellom en ! og en ny linje er et mønster vi ønsker å gjenta for å konstruere bilene. Den repetisjonen gjøres takket være regex s/!(.*)/$1x@F/ge. (Jeg brukte ! fordi inngangen ikke kan inneholde den).

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

Testing:

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 byte

ingenting spesielt skjer her .. bare å opprette hver linje og bli med 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)[] 

Utvidet

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

Eksempelkjøring

$ 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 byte

Anonym VBE umiddelbar vindusfunksjon som tar input fra område [A1] og utganger til VBE-øyeblikkelige vindu

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

Formatert for lesbarhet

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

Eksempel på utdata

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