Puzzle di programmazione e Taco Truck

23

Puzzle di programmazione e codice Golf ha aperto un camion taco ! La parola è finita e ora gli utenti di tutta la rete Stack Exchange stanno arrivando per provare i nostri gustosi tacos ASCII . Abbiamo bisogno del tuo aiuto per garantire che tutti ricevano i loro ordini in modo tempestivo. Non c'è molto spazio all'interno dei camion di cibo, quindi avrai bisogno che il tuo codice sia il più corto possibile.

Ora per un po 'di formazione sul posto di lavoro.

Il tuo lavoro

Scrivi un programma completo che legge un ordine da STDIN o una funzione che ottiene un singolo ordine di stringa come input. I tacos sono stampati su STDOUT, realizzati su ordinazione.

Prendendo ordini

I clienti ti daranno i loro ordini tramite STDIN o argomento della funzione. Gli ordini saranno sotto forma di un elenco delimitato da virgole dei condimenti desiderati. L'ordine in cui vengono dati i condimenti determina l'ordine in cui appaiono nel taco, con il primo elencato in cima e l'ultimo in cima. Ecco cosa teniamo in stock:

  • fagioli
  • Riso
  • Verdure
  • Lattuga
  • guacamole
  • Panna acida
  • salsa

I clienti possono ordinare solo 1 topping ma non più di 5 topping. I condimenti non devono essere distinti.

Puoi presumere che i clienti abbiano familiarità con il menu prima di ordinare e quindi tutti gli ordini conterranno solo ingredienti che immagazziniamo. Cioè, l'input sarà sempre valido.

Tacos al servizio

I clienti chiedono che i loro tacos vengano stampati su STDOUT. Stanno bene con alcuni spazi bianchi iniziali o finali nel loro cibo.

Le ricerche di mercato mostrano che tutti vogliono mangiare tacos come parole e le parole in maiuscolo sono molto più saporite. Quindi elencheremo i condimenti in TUTTE LE MAIUSCOLE senza spazi.

Nell'interesse della presentazione artistica, non possiamo limitarci a buttare roba in una tortilla e chiamarla buona, dobbiamo posare delicatamente condimenti da sinistra a destra, avvolgendoli e ripetendoli secondo necessità. Ogni topping ottiene un minimo di 2 righe per sé. Tutto ciò diventerà più chiaro quando esamineremo il piatto di campionamento.

Piatto di esempio

Diamo un'occhiata ad alcuni ordini di esempio.

Il cliente ordina: Beans,Veggies,Rice,Lettuce,Sour Cream

Consegnamo:

   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

Sembra abbastanza gustoso, vero? I condimenti si avvolgono dopo 6 caratteri in una nuova riga e vengono ripetuti per riempire 2 righe ciascuno, troncati a 12 caratteri. Il primo ingrediente ottiene 6 caratteri nella sua riga superiore ma solo 4 nella sua seconda riga. Questo assicura che si adatti alla piega della tortilla. Allo stesso modo, l'ultimo ingrediente ottiene sempre 4 caratteri nella sua riga superiore e 6 nella sua seconda.

Cosa succede se un cliente ordina due uguali topping di fila? Continua a avvolgere quell'ingrediente per tutte le righe consecutive di quell'ingrediente.

Il cliente ordina: Lettuce,Lettuce,Lettuce,Salsa

Consegnamo:

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

Il cliente ordina: Guacamole

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

Un solo ingrediente? Dai in cima 4 personaggi extra.

Dipendenti del mese

Mostra snippet di codice

Buona cucina!

code-golf  ascii-art 
— Alex A.
fonte

Risposte:

3

JavaScript (ES6), 269 263 byte

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"

Spiegazione

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

Mostra snippet di codice

— user81655
fonte
Come risposta più breve alla fine del periodo di ricompensa, ricevi la ricompensa di +50! E poiché la più breve delle due risposte postate una settimana dopo la pubblicazione della domanda, vinci l'ambito segno di spunta. Bel lavoro e grazie per aver partecipato! :)
— Alex A.
6

Python 3, 475 byte

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

Probabilmente è troppo lungo, ma potrei anche pubblicare qualcosa!

— vpzomtrrfrt
fonte
Penso che puoi sostituirlo r=(r+["TORTIL"])[::-1]con r=["TORTIL"]+r[::-1]. range(0,l)può anche essere range(l).
— lirtosiast
1. Stack Exchange sostituisce le schede con quattro spazi, quindi è difficile verificare il tuo punteggio così com'è. Dopo averli sostituiti, conto 482. 2. Puoi salvare su spazi bianchi inserendo, ad esempio, if l==2:q=s[0];s=[q,q,q];l=3su una sola riga. 3. n(l)fa lo stesso di n(0,l).
— Dennis,
@Dennis c'è qualcosa che posso fare per il n. 1?
— vpzomtrrfrt,
1
Potresti semplicemente usare uno spazio singolo invece di una scheda. Python 3 non consente comunque di mescolarli.
— Dennis,
Ok, ho preso i tuoi suggerimenti e li ho resi leggermente più brevi.
— vpzomtrrfrt,
4

Ruby, 376 375 368 363 362 byte

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

Sono ancora in corso lavori.

(Bonus: funziona con tutti i condimenti che vuoi, non solo 5. Principalmente perché all'inizio non ho visto quella regola> _ <)

Versione non golfata:

#!/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'
— Maniglia
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.