Programação de quebra-cabeças e caminhão Taco

23

A programação de quebra-cabeças e código Golf abriu um caminhão de taco ! A notícia acabou e agora usuários de toda a rede Stack Exchange estão experimentando nossas saborosas e autênticas tacos ASCII . Precisamos da sua ajuda para garantir que todos recebam seus pedidos em tempo hábil. Como não há muito espaço dentro dos caminhões de alimentos, você precisará que seu código seja o mais curto possível.

Agora, para algum treinamento no trabalho.

Seu emprego

Escreva um programa completo que leia um pedido de STDIN ou uma função que receba um único pedido de sequência como entrada. Os tacos são impressos em STDOUT, feitos sob encomenda.

Recebendo ordens

Os clientes darão seus pedidos via STDIN ou argumento de função. Os pedidos terão a forma de uma lista delimitada por vírgula de coberturas desejadas. A ordem em que as coberturas são dadas determina a ordem em que aparecem no taco, com a primeira cobertura listada na parte inferior e a última na parte superior. Aqui está o que mantemos em estoque:

  • Feijões
  • Arroz
  • Veggies
  • Alface
  • guacamole
  • Nata
  • salsa

Os clientes podem encomendar apenas 1 cobertura, mas não mais que 5 coberturas. Coberturas não precisam ser distintas.

Você pode supor que os clientes estejam familiarizados com o menu antes de fazer o pedido e, portanto, todos os pedidos conterão apenas os ingredientes que armazenamos. Ou seja, a entrada sempre será válida.

Servindo tacos

Os clientes exigem que suas tacos sejam impressas na STDOUT. Eles estão bem com alguns espaços em branco à esquerda ou à esquerda na comida.

Pesquisas de mercado mostram que todo mundo quer comer tacos como palavras, e as palavras em todas as letras são muito mais saborosas. Assim, listaremos coberturas em ALL CAPS sem espaços.

No interesse de apresentações artísticas, não podemos simplesmente colocar coisas em uma tortilha e chamar de bom, temos que colocar delicadamente coberturas da esquerda para a direita, embrulhando e repetindo conforme necessário. Cada cobertura recebe no mínimo 2 linhas. Tudo ficará mais claro quando inspecionarmos o prato de amostras.

Prato de amostras

Vamos dar uma olhada em alguns pedidos de amostra.

O cliente pede: Beans,Veggies,Rice,Lettuce,Sour Cream

Nós 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

Parece bem gostoso, né? As coberturas quebram após 6 caracteres em uma nova linha e são repetidas para preencher 2 linhas cada, truncadas em 12 caracteres. O primeiro ingrediente recebe 6 caracteres na linha superior, mas apenas 4 na segunda linha. Isso garante que ele se encaixe na dobra da tortilha. Da mesma forma, o último ingrediente sempre obtém 4 caracteres na linha superior e 6 na segunda.

O que acontece se um cliente pedir duas da mesma cobertura consecutiva? Continue embrulhando esse ingrediente para todas as linhas consecutivas desse ingrediente.

O cliente pede: Lettuce,Lettuce,Lettuce,Salsa

Nós 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

O cliente pede: Guacamole

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

Apenas um ingrediente? Dê 4 caracteres extras no topo.

Funcionários do mês

Mostrar snippet de código

Cozinha feliz!

code-golf  ascii-art 
— Alex A.
fonte

Respostas:

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"

Explicação

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

Teste

Mostrar snippet de código

— user81655
fonte
Como a resposta mais curta no final do período de recompensa, você recebe a recompensa de +50! E, como a menor das duas respostas postadas uma semana após a publicação da pergunta, você ganha a marca de seleção cobiçada. Bom trabalho e obrigado 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:])

Provavelmente é muito longo, mas eu também posso postar algo!

— vpzomtrrfrt
fonte
Eu acho que você pode substituir r=(r+["TORTIL"])[::-1]por r=["TORTIL"]+r[::-1]. range(0,l)também pode ser range(l).
— precisa saber é o seguinte
1. O Stack Exchange substitui as guias por quatro espaços, por isso é difícil verificar sua pontuação como está. Após substituí-los, conto 482. 2. Você pode economizar espaço em branco colocando, por exemplo, if l==2:q=s[0];s=[q,q,q];l=3em uma única linha. 3. n(l)faz o mesmo que n(0,l).
— Dennis
@ Dennis, há algo que eu possa fazer sobre o # 1?
— Vpzomtrrfrt
1
Você pode usar apenas um espaço em vez de uma guia. Python 3 não permite misturá-los de qualquer maneira.
— Dennis
Ok, aceitei suas sugestões e a tornei um pouco mais curta.
— precisa saber é o seguinte
4

Ruby, 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$/}

Ainda um trabalho em andamento.

(Bônus: funciona com tantas coberturas quanto você quiser, não apenas com 5. Principalmente porque eu não vi essa regra no início> _ <)

Versão não destruída:

#!/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'
— Maçaneta da porta
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.