Programación de rompecabezas y camión de tacos

23

¡Programming Puzzles & Code Golf ha abierto un camión de tacos ! Se corrió la voz y ahora los usuarios de toda la red de Stack Exchange vienen a probar nuestros sabrosos y auténticos tacos ASCII . Necesitamos su ayuda para garantizar que todos reciban sus pedidos de manera oportuna. No hay mucho espacio dentro de los camiones de comida, por lo que necesitará que su código sea lo más breve posible.

Ahora para un poco de capacitación en el trabajo.

Tu trabajo

Escriba un programa completo que lea un pedido de STDIN o una función que obtenga un solo orden de cadena como entrada. Los tacos están impresos en STDOUT, hechos a pedido.

Tomando pedidos

Los clientes le darán sus pedidos a través de STDIN o argumento de función. Los pedidos serán en forma de una lista delimitada por comas de ingredientes deseados. El orden en que se dan las coberturas dicta el orden en que aparecen en el taco, con la primera cobertura en la parte inferior y la última en la parte superior. Esto es lo que tenemos en stock:

  • Frijoles
  • Arroz
  • Verduras
  • Lechuga
  • Guacamole
  • CCrea agria
  • Salsa

Los clientes pueden pedir tan solo 1 cobertor pero no más de 5 coberturas. Los ingredientes no necesitan ser distintos.

Puede suponer que los clientes están familiarizados con el menú antes de ordenar y, por lo tanto, todos los pedidos solo contendrán ingredientes que almacenamos. Es decir, la entrada siempre será válida.

Sirviendo tacos

Los clientes exigen que sus tacos se impriman en STDOUT. Están bien con algunos espacios en blanco iniciales o finales en su comida.

La investigación de mercado muestra que todos quieren comer tacos como palabras, y las palabras en mayúsculas son mucho más sabrosas. Por lo tanto, enumeraremos los ingredientes en TODAS LAS MAYÚSCULAS sin espacios.

En aras de la presentación artística, no podemos simplemente colocar cosas en una tortilla y llamarla buena, tenemos que colocar suavemente los ingredientes de izquierda a derecha, envolviendo y repitiendo según sea necesario. Cada relleno obtiene un mínimo de 2 líneas para sí mismo. Todo esto se aclarará una vez que inspeccionemos el plato de muestra.

Plato de muestra

Echemos un vistazo a algunos pedidos de muestra.

El cliente ordena: Beans,Veggies,Rice,Lettuce,Sour Cream

Entregamos:

   SOUR
  CREAMS
T LETTUC L
O ELETTU I
R RICERI T
T CERICE R
I VEGGIE O
L SVEGGI T
L BEANSB A
 A EANS L
  TORTIL

Se ve muy sabroso, ¿verdad? Los ingredientes se envuelven después de 6 caracteres en una nueva línea y se repiten para llenar 2 líneas cada uno, truncados a 12 caracteres. El primer ingrediente obtiene 6 caracteres en su línea superior pero solo 4 en su segunda línea. Esto asegura que encaje en el pliegue de la tortilla. Del mismo modo, el último ingrediente siempre obtiene 4 caracteres en su línea superior y 6 en su segundo.

¿Qué sucede si un cliente ordena dos de la misma cobertura en una fila? Siga envolviendo ese ingrediente para todas las líneas consecutivas de ese ingrediente.

El cliente ordena: Lettuce,Lettuce,Lettuce,Salsa

Entregamos:

T  SALS  L
O ASALSA I
R LETTUC T
T ELETTU R
I CELETT O
L UCELET T
L TUCELE A
 A TTUC L
  TORTIL

El cliente ordena: Guacamole

T        L
O        I
R        T
T        R
I        O
L  GUAC  T
L AMOLEG A
 A UACA L
  TORTIL

¿Solo un ingrediente? Otorga el valor de 4 personajes adicionales en la parte superior.

Empleados del mes

Mostrar fragmento de código

¡Feliz cocina!

code-golf  ascii-art 
— Alex A.
fuente

Respuestas:

3

JavaScript (ES6), 269 263 bytes

x=>eval('x=x.split`,`;p=o="";for(i=10;i--;){t=x[1]?x[i/2|0]:x[i>2|0];t!=p?r=(n=0,t?t.replace(s=" ",""):s).toUpperCase().repeat(99):0;m=r.slice(n,n+=p&&i?6:4);p&&i?0:m=s+m+s;p=t;o+=(i>7?t?s+s+m:"":i?"TORTILL"[7-i]+s+m+s+"LITROTA"[7-i]:` A${m}L`)+`\n`}')+"  TORTIL"

Explicación

x=>
  eval('                                          // use eval to save writin return and {}
    x=x.split`,`;                                 // convert ingredients to an array
    p=                                            // p = previous ingredient
      o="";                                       // o = output text
    for(i=10;i--;){                               // loop from top to bottom of taco
      t=x[1]?x[i/2|0]                             // t = ingredient text
        :x[i>2|0];                                // start a line early if 1 ingredient
      t!=p?r=                                     // r = repeated ingredient text
        (n=0,                                     // n = current index in repeated text
        t?t.replace(s=" ",""):s)                  // get the ingredient (or space)
        .toUpperCase().repeat(99):0;              // upper-case and repeat the ingredient
      m=r.slice(n,n+=p&&i?6:4);p&&i?0:m=s+m+s;    // m = text in the middle of the taco
      p=t;                                        // set p to current ingredient

      // Add the appropriate output
      o+=(i>7?t?s+s+m:"":i?"TORTILL"[7-i]+s+m+s+"LITROTA"[7-i]:` A${m}L`)+`\n`

    }                                             // implicit: eval returns o
  ')+"  TORTIL"                                   // return the output text

Prueba

Mostrar fragmento de código

— usuario81655
fuente
Como la respuesta más corta al final del período de recompensa, ¡recibes la recompensa de +50! Y como la más breve de las dos respuestas publicadas una semana después de la publicación de la pregunta, usted gana la codiciada marca de verificación. Buen trabajo y gracias por participar! :)
— Alex A.
6

Python 3, 475 bytes

n=range
s=input().upper().replace(" ","").split(",")[::-1]
s=sum(zip(s,s),tuple())
t=""
p=0
l=len(s)
if l==2:q=s[0];s=[q,q,q];l=3
r=[]
e=" "
f=e*4
d=[f," AL ","L  A","L  T","I  O","T  R","R  T","O  I","T  L",f,f]
for i in n(l):
 h=s[i]
 c=6
 a=""
 if i==0 or i==l-1:c=4
 if t!=h:
  p=0
  t=h
 for x in n(0,c):
  a+=h[p]
  p+=1
  if p==len(h):
   p=0
 if c==4:a=e+a+e
 r+=[a]
r=["TORTIL"]+r[::-1]
for i in n(0,11):
 y=10-i
 x=d[y]
 m=e*6
 if y<=l:m=r[y]
 print(x[:2]+m+x[2:])

Probablemente sea demasiado tiempo, ¡pero también puedo publicar algo!

— vpzomtrrfrt
fuente
Creo que puedes reemplazarlo r=(r+["TORTIL"])[::-1]con r=["TORTIL"]+r[::-1]. range(0,l)También puede ser range(l).
— lirtosiast el
1. Stack Exchange reemplaza las pestañas con cuatro espacios, por lo que es difícil verificar su puntaje tal como está. Después de volver a reemplazarlos, cuento 482. 2. Puede ahorrar en espacios en blanco colocando, por ejemplo, if l==2:q=s[0];s=[q,q,q];l=3en una sola línea. 3. n(l)hace lo mismo que n(0,l).
— Dennis
@ Dennis, ¿hay algo que pueda hacer sobre el # 1?
— vpzomtrrfrt
1
Podrías usar un solo espacio en lugar de una pestaña. Python 3 no permite mezclarlos de todos modos.
— Dennis
Bien, tomé sus sugerencias y las hice un poco más cortas.
— vpzomtrrfrt
4

Rubí, 376 375 368 363 362 bytes

->a{p='ALLITROT'.chars
s='LATORTIL'.chars
t=['  TORTIL']
c=[*a.split(?,).chunk(&:upcase)]
c.map.with_index{|x,i|n=x[1].size*2
w=x[0].tr(' ','')*9*n
[n+=i==0?1:0,w.sub!(/..../,' \0 ')]if i==c.size-1
w.chars.each_slice(6).take(n).reverse.map{|l|t=["#{p.shift||' '} #{l*''} #{s.shift||' '}"]+t}}
p.map{|x|t=[x+' '*8+s.shift]+t}
t[-2].sub! /(.{6})../,' \1'
t.join$/}

Todavía un trabajo en progreso.

(Bonificación: funciona con tantos ingredientes como desee, no solo 5. Principalmente porque no vi esa regla al principio> _ <)

Versión sin golf:

#!/usr/bin/env ruby

def make_taco ingredients
    # These three variables make up the tortilla.
    prefixes = 'ALLITROT'.chars
    suffixes = 'LATORTIL'.chars
    taco = ['  TORTIL']
    # .chunk is a Ruby builtin that's *incredibly* useful for this challenge.
    chunks = ingredients.split(',').chunk{|x| x}.to_a
    # Loop through every chunk of equal ingredients.
    chunks.each_with_index do |ingredient, idx|
        # Get the number of lines the group of ingredients should take up.
        count = ingredient[1].length * 2
        # *9 because that's guaranteed to be enough ingredient.
        wrapped = ingredient[0].upcase.sub(' ','') * 9 * count
        # If this is the last element...
        if idx == chunks.length - 1
            # Add spaces strategically to position the top "layer."
            wrapped.sub! /..../, ' \0 '
            # If this is also the first element...
            if idx == 0
                # We need to make one more row.
                count += 1
            end
        end
        # Arrange the ingredient like so, and then for each "layer"...
        wrapped.chars.each_slice(6).take(count).reverse.each do |line|
            # Add it to the taco, along with prefixes/suffixes if they exist.
            taco.push "#{prefixes.shift || ' '} #{line * ''} " +
                "#{suffixes.shift || ' '}"
        end
    end
    # Fill in the rest of the prefixes and suffixes we didn't use.
    prefixes.each do |prefix|
        taco.push prefix + ' ' * 8 + suffixes.shift
    end
    # Fix the "offset" on the second-to-last line.
    taco[1].sub! /(.{6})../, ' \1'
    # Since we've been building the taco bottom-up, reverse, join, and return.
    taco.reverse.join("\n")
end

puts make_taco 'Beans,Veggies,Rice,Lettuce,Sour Cream'
puts
puts make_taco 'Lettuce,Lettuce,Lettuce,Salsa'
puts
puts make_taco 'Guacamole'
— Pomo de la puerta
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.