Programowanie zagadek i ciężarówka Taco

23

Programowanie zagadek i kodu Golf otworzył ciężarówkę taco ! To słowo jest już dostępne, a teraz użytkownicy z całej sieci Stack Exchange przyjeżdżają, aby wypróbować nasze smaczne, autentyczne tacos ASCII . Potrzebujemy Twojej pomocy, aby zapewnić, że wszyscy otrzymają swoje zamówienia w odpowiednim czasie. W ciężarówkach z jedzeniem nie ma zbyt wiele miejsca, więc kod musi być jak najkrótszy.

Teraz na szkolenie w miejscu pracy.

Twoja praca

Napisz pełny program, który odczytuje zamówienie ze STDIN lub funkcję, która pobiera dane wejściowe z jednego ciągu znaków. Tacos są drukowane na STDOUT, wykonywane na zamówienie.

Przyjmowanie zamówień

Klienci przekażą ci swoje zamówienia za pośrednictwem STDIN lub argumentu funkcji. Zamówienia będą miały postać rozdzielanych przecinkami listy żądanych dodatków. Kolejność nadawania dodatków określa kolejność ich pojawiania się w taco, przy czym pierwsza z nich znajduje się na dole, a ostatnia na górze. Oto, co mamy na stanie:

  • fasolki
  • Ryż
  • Warzywa
  • Sałata
  • guacamole
  • Kwaśna śmietana
  • Salsa

Klienci mogą zamówić tylko 1 polewę, ale nie więcej niż 5 polew. Polewy nie muszą być wyraźne.

Możesz założyć, że klienci znają menu przed złożeniem zamówienia, a zatem wszystkie zamówienia będą zawierać wyłącznie składniki, które mamy w magazynie. Oznacza to, że dane wejściowe zawsze będą prawidłowe.

Podawanie tacos

Klienci żądają, aby ich tacos były drukowane na STDOUT. Są w porządku z niektórymi wiodącymi lub końcowymi białymi miejscami w jedzeniu.

Badania rynku pokazują, że każdy chce jeść tacos jako słowa, a słowa we wszystkich czapkach są znacznie bardziej aromatyczne. W związku z tym wymienimy polewy WSZYSTKIMI CZAPAMI bez spacji.

W interesie artystycznej prezentacji nie możemy po prostu wrzucić tortilli i nazwać to dobrym, musimy delikatnie nakładać polewy od lewej do prawej, owijając i powtarzając w razie potrzeby. Każde polewa otrzymuje co najmniej 2 linie do siebie. Wszystko to stanie się wyraźniejsze, gdy skontrolujemy talerz próbki.

Próbny talerz

Rzućmy okiem na przykładowe zamówienia.

Klient zamawia: Beans,Veggies,Rice,Lettuce,Sour Cream

Dostarczamy:

   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

Wygląda całkiem smacznie, prawda? Polewy owijają się po 6 znakach do nowej linii i są powtarzane, aby wypełnić 2 linie każda, skrócona do 12 znaków. Pierwszy składnik otrzymuje 6 znaków w górnym wierszu, ale tylko 4 w drugim wierszu. Zapewnia to, że pasuje do zagięcia tortilli. Podobnie, ostatni składnik zawsze otrzymuje 4 znaki w górnym wierszu i 6 znaków w drugim.

Co się stanie, jeśli klient zamówi dwa takie same polewy z rzędu? Opakuj ten składnik dla wszystkich kolejnych linii tego składnika.

Klient zamawia: Lettuce,Lettuce,Lettuce,Salsa

Dostarczamy:

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

Klient zamawia: Guacamole

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

Tylko jeden składnik? Daj 4 dodatkowe wartości na górze.

Pracownicy miesiąca

Pokaż fragment kodu

Miłego gotowania!

code-golf ascii-art Alex A.
źródło

Odpowiedzi:

3

JavaScript (ES6), 269 263 bajtów

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"

Wyjaśnienie

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

Test

Pokaż fragment kodu

użytkownik 81655
źródło
Jako najkrótsza odpowiedź na koniec okresu nagrody, otrzymasz nagrodę w wysokości +50! I jako najkrótsza z dwóch opublikowanych odpowiedzi w tydzień po opublikowaniu pytania, wygrywasz upragniony znak wyboru. Dobra robota i dziękuję za udział! :)
Alex A.,
6

Python 3, 475 bajtów

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

To chyba zbyt długo, ale równie dobrze mogę coś opublikować!

vpzomtrrfrt
źródło
Myślę, że można zastąpić r=(r+["TORTIL"])[::-1]z r=["TORTIL"]+r[::-1]. range(0,l)może być również range(l).
lirtosiast,
1. Wymiana stosów zastępuje tabulatory czterema spacjami, więc trudno jest zweryfikować swój wynik. Po ich wymianie liczę 482. 2. Możesz zaoszczędzić na białych znakach, umieszczając np. W if l==2:q=s[0];s=[q,q,q];l=3jednym wierszu. 3. n(l)robi to samo co n(0,l).
Dennis,
@Dennis jest coś, co mogę zrobić z numerem 1?
vpzomtrrfrt,
1
Możesz użyć pojedynczej spacji zamiast tabulacji. Python 3 i tak nie pozwala na ich mieszanie.
Dennis,
Ok, wziąłem twoje sugestie i nieco je skróciłem.
vpzomtrrfrt
4

Rubinowy, 376 375 368 363 362 bajtów

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

Wciąż trwają prace.

(Bonus: działa z dowolną liczbą dodatków, nie tylko 5. Głównie dlatego, że początkowo nie widziałem tej zasady> _ <)

Wersja bez golfa:

#!/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'
Klamka
źródło