Todos a bordo del tren ASCII

45

¡Todos a bordo del tren 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-'

Es mejor que esté preparado para viajar en el tren, porque está a punto de construir el tren en el que viajará. Dada una cadena s, genera un tren completamente formado como se muestra arriba. Lo primero que sale siempre es el motor que tirará de su cuerda, como se muestra solo a continuación:

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

Siguiendo la locomotora hay vagones que contienen cada personaje de su preciosa carga. Para evitar confusiones al descargar, su empresa le ha encargado que etiquete el exterior de estos automóviles. Los autos en cuestión siempre se verán así:

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

Donde el #es representativo del personaje que está dentro de la bodega de "carga". Encadenar el motor a cada automóvil también es parte de su trabajo, ya que le encargaron supervisar la fluidez y el éxito de todo este envío. Entonces, una vez que haya etiquetado todos los autos y tenga el motor en las vías, debe asegurarse de que el tren esté ensamblado y listo para rodar.

Reglas

  • La única entrada que su programa debe tomar es una sola cadena.
  • El motor siempre debe tener salida, incluso si su envío está vacío.
  • Cada automóvil solo puede contener un personaje, no empujes tu suerte, puedes dañar los productos.
  • Solo necesita admitir los siguientes caracteres ASCII imprimibles: _-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
    si termina haciendo más, también está bien, pero este es el mínimo.
  • 1-2 espacios finales son aceptables, como lo es una nueva línea final.
  • Este es el , el menor recuento de bytes gana.
Urna de pulpo mágico
fuente
44
Vagamente relacionado.
Martin Ender
1
No creo que esto sea realmente una complejidad kolmogorov . Basado en esta meta publicación, esta pregunta ciertamente está en la línea entre ajustar y no ajustar nuestra definición y yo personalmente diría que no encaja en la etiqueta similar a esta pregunta que también pide un tipo de envoltura de cadena.
Wheat Wizard
55
Este es un hermoso arte ascii
CAD97
@WheatWizard es una mezcla de múltiples géneros. El motor caería bajo la complejidad de kolmogrov, todo bajo ASCII-Art y probablemente también caiga un poco en la manipulación de cadenas.
Urna mágica de pulpo
Tenía la impresión de que comprimir el patrón real del tren sería digno de la etiqueta; pero lo eliminaré para detener la discusión.
Magic Octopus Urn

Respuestas:

4

05AB1E , 101 99 bytes

Ingenuo primer intento.

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

Pruébalo en línea!

Emigna
fuente
Bueno, el código no se parece a un tren, pero está ganando ahora.
Magic Octopus Urn
37

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

No creo que el motor en sí pueda ser comprimido, pero quizás sea posible.

Fragmento de prueba

ETHproducciones
fuente
Muchos caracteres repetidos deberían poder extraer algunos bytes más de él.
Orion
17
Casi se puede ver el tren empaquetado en el código fuente :-)
Luis Mendo
15
Votados principalmente porque el código se parece a un tren
Rohan Jhunjhunwala
¡Puntos de bonificación porque se ejecuta allí mismo en el navegador!
DGM
6

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

Pruébalo en línea!

Explicación

El automóvil y el motor están codificados como dos conjuntos de cinco cadenas en las líneas 3 a 12. Los valores de los caracteres están apagados en 1 para evitar tener que lidiar con las comillas dobles que no se pueden usar en una cadena Befunge.

El código funciona al construir el conjunto completo de caracteres necesarios para representar el tren en la pila. Para cada línea de salida, primero se agrega una cadena de automóvil apropiada a la pila, se repite tantas veces como sea necesario para la carga, y luego una copia de la cadena de motor adecuada.

Después de que se haya construido cada línea, un par de flechas hacia abajo a la izquierda de las cuerdas se reemplaza con una flecha hacia la derecha, por lo que la siguiente iteración del bucle sigue una ruta diferente a través del código, usando un par de cuerdas diferentes para el automóvil y motor.

Una vez que todos los datos se han acumulado en la pila, hay un bucle de representación final que escribe los caracteres, restando 1 cada vez para tener en cuenta la codificación inicial.

Como beneficio adicional, la fuente está diseñada en forma de torreta , en caso de que el tren sea atacado. Los golfistas destruyeron mi torreta.

James Holderness
fuente
Los golfistas destruyeron mi torreta, LOL. +1. Sin embargo, está superando a C # y Java.
Zacharý
6

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

Toma entrada de STDIN; correr con -nR.

Comprimir el motor o la carreta requeriría más código para descomprimir de lo que ahorra en almacenamiento.
No veo más potencial aquí.

Titus
fuente
a&$c=$argn en lugar de""<$c=$argv[1]
Jörg Hülsermann
@ JörgHülsermann Sí, esta publicación era antigua. :)
Titus
4

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

Ejemplo:

print f('Python')

da

    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-'
TFeld
fuente
4

Powershell, 167166 bytes

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

Ejemplo:

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

Posiblemente inválido! Si se ejecuta sin ningún argumento, intentará imprimir una cadena vacía y se verá así:

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

Sin embargo, si se ejecuta con una cadena de entrada vacía, volverá correctamente:

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

(un poco) Sin golfista:

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

la compresión más corta en Powershell será +'c'*xdonde c es el carácter yx es el número de repeticiones, y eso es solo para repeticiones finales o iniciales, cualquier repetición de cadena central requerirá un extra +y un extra ", por lo que no tiene sentido en esto donde Puedo ver la compresión ahorrando espacio, y el único conjunto ___de caracteres repetido es el de solo 3 caracteres.

Explicación:

$l=($a=$args[0]).Length Tome el primer argumento, póngalo en $ a, luego tome la longitud de $ a y póngalo en $ l, estas son las únicas variables que necesita.

" o O O"+" ___ "*$l la mayoría de los otros bits siguen este formato de la parte izquierda y luego la parte derecha multiplica por el número de caracteres requeridos.

" o "+([char[]]$a|%{" | $_ |"})bucle ( |%{}) a través de $ a como una matriz de caracteres, foreach (char $_ in $a)por lo que para una versión sin canalización, luego coloque el carácter en el texto.

Este es un enfoque extremadamente simple, pero debido a que no puedo encontrar una buena manera de comprimir las cadenas más allá de esto, parece ser el más útil.

guardado 1 Byte gracias a briantist! y aquí estaba pensando que esto no se acortaría más ...

colsw
fuente
No tuvo que manejar ningún argumento :).
Urna mágica del pulpo del
@carusocomputing yay, gracias por hacérmelo saber.
colsw
¡Agradable! Puede guardar 1 byte cambiando [char[]]$aa $a[0..$l] :)
briantist
ah estaba usando char array antes de declarar $ly lo olvidé por completo. ¡gracias por eso!
colsw
2

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

    }
}

Ejemplo

java
    o O O   ___     ___     ___     ___     
   o       | j |   | a |   | v |   | a |   
  TS__[O]  |___|   |___|   |___|   |___|   
 {======|_|"""""|_|"""""|_|"""""|_|"""""|
./o--000'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'
Bobas_Pett
fuente
1
Sé que ha sido la mitad de un año, pero puedes jugar bastante al golf (también eliminando espacios): 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 ) O incluso más si lo reemplazas new java.util.Scanner(System.in).nextLine()con v[0]una entrada alternativa ( 279 bytes ) Pruébalo aquí .
Kevin Cruijssen
2

Perl, 137 bytes

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

ascii_train.pl:

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

Tenga en cuenta que agregué una -amarca en el código, pero es solo porque las versiones antiguas de Perl requieren -acuándo -Fse usa.

Para ejecutarlo:

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

La entrada debe suministrarse sin una nueva línea final (con, echo -npor ejemplo).

Explicaciones:
Por lo que he visto, es más o menos la misma idea que la respuesta de JavaScript de ETHProduction.
No están sucediendo muchas cosas: lamentablemente, los patrones son un poco cortos para que xvalga la pena utilizar al operador.
Primero, s/./ | $& | /grodea cada carácter de la entrada con |(y espacios) para formar el segundo nivel del tren.
Luego, dentro de esa larga cadena, todo entre una !y una nueva línea es un patrón que deseamos repetir para construir los autos. Esa repetición se hace gracias a la expresión regular s/!(.*)/$1x@F/ge. (Solía !porque la entrada no puede contenerlo).

Dada
fuente
1

C #, 277 bytes

Golfizado:

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

Sin golf:

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

Pruebas:

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

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

Y...

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-'
Pete Arden
fuente
1

C # 221 bytes

no pasa nada especial aquí ... solo crea cada línea y únelas con nuevas líneas.

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);};
Stefan
fuente
1

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

Pruébalo en línea

Salida:

    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-'
Johan du Toit
fuente
1

SOGL V0.12 , 57 56 bytes

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

Pruébalo aquí!

Explicación:

..‘             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
dzaima
fuente
1

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

Ejecución de la muestra

$ 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

Pruébalo en línea

jq170727
fuente
0

Excel VBA, 218 bytes

Función de ventana inmediata anónima de VBE que toma la entrada del rango [A1]y las salidas a la ventana inmediata de 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)]

Formateado para facilitar la lectura

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

Salida de muestra

    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-'
Taylor Scott
fuente