Programmierpuzzles und Taco Truck

23

Programming Puzzles & Code Golf hat einen Taco-Truck eröffnet ! Das Wort ist aus und jetzt kommen Benutzer aus dem gesamten Stack Exchange-Netzwerk, um unsere leckeren authentischen ASCII- Tacos zu probieren . Wir brauchen Ihre Hilfe, um sicherzustellen, dass jeder seine Bestellungen rechtzeitig erhält. In Food Trucks ist nicht viel Platz, daher muss Ihr Code so kurz wie möglich sein.

Nun zum Training am Arbeitsplatz.

Deine Arbeit

Schreiben Sie ein vollständiges Programm, das eine Anweisung von STDIN oder eine Funktion liest, die eine einzelne Zeichenfolgenreihenfolge als Eingabe erhält. Tacos werden auf Bestellung auf STDOUT gedruckt.

Bestellungen aufnehmen

Kunden geben Ihnen ihre Bestellungen über STDIN oder Funktionsargument. Bestellungen werden in Form einer durch Kommas getrennten Liste der gewünschten Beläge ausgeführt. Die Reihenfolge, in der die Beläge gegeben werden, bestimmt die Reihenfolge, in der sie im Taco erscheinen, wobei der erste aufgelistete Belag unten und der letzte oben steht. Folgendes halten wir auf Lager:

  • Bohnen
  • Reis
  • Gemüse
  • Salat
  • Guacamole
  • Sauerrahm
  • Salsa

Kunden können nur 1 Belag, aber nicht mehr als 5 Beläge bestellen. Die Beläge müssen nicht unterschiedlich sein.

Sie können davon ausgehen, dass die Kunden mit dem Menü vor der Bestellung vertraut sind und daher alle Bestellungen nur Zutaten enthalten, die wir auf Lager haben. Das heißt, die Eingabe ist immer gültig.

Tacos servieren

Kunden fordern, dass ihre Tacos an STDOUT gedruckt werden. Es geht ihnen gut, wenn in ihrem Essen ein Leerzeichen vor- oder nachgestellt ist.

Marktforschung zeigt, dass jeder Tacos als Worte essen möchte und Worte in Großbuchstaben viel geschmackvoller sind. So werden wir Beläge in ALL CAPS ohne Leerzeichen auflisten.

Im Interesse einer künstlerischen Präsentation können wir nicht einfach Sachen in eine Tortilla legen und als gut bezeichnen, wir müssen die Beläge vorsichtig von links nach rechts legen und nach Bedarf einwickeln und wiederholen. Jeder Belag erhält mindestens 2 Zeilen für sich. Dies wird alles klarer, wenn wir den Probenteller untersuchen.

Probenteller

Werfen wir einen Blick auf einige Musterbestellungen.

Der Kunde bestellt: Beans,Veggies,Rice,Lettuce,Sour Cream

Wir liefern:

   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

Sieht ziemlich lecker aus, oder? Die Zeilenumbrüche setzen sich nach 6 Zeichen in einer neuen Zeile fort und werden wiederholt, um jeweils 2 Zeilen zu füllen, die auf 12 Zeichen gekürzt sind. Die erste Zutat erhält 6 Zeichen in der obersten Zeile, aber nur 4 in der zweiten Zeile. Dies stellt sicher, dass es in die Falte der Tortilla passt. Ebenso erhält die letzte Zutat in der obersten Zeile immer 4 Zeichen und in der zweiten 6 Zeichen.

Was passiert, wenn ein Kunde zwei gleiche Toppings hintereinander bestellt? Wickeln Sie diese Zutat weiterhin in alle aufeinander folgenden Zeilen dieser Zutat ein.

Der Kunde bestellt: Lettuce,Lettuce,Lettuce,Salsa

Wir liefern:

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

Der Kunde bestellt: Guacamole

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

Nur eine Zutat? Gib 4 zusätzliche Charaktere oben drauf.

Mitarbeiter des Monats

Code-Snippet anzeigen

Viel Spaß beim Kochen!

code-golf ascii-art Alex A.
quelle

Antworten:

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"

Erläuterung

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

Prüfung

Code-Snippet anzeigen

user81655
quelle
Als kürzeste Antwort am Ende des Kopfgeldzeitraums erhalten Sie das Kopfgeld von +50! Und da die kürzeste der beiden Antworten eine Woche nach dem Absenden der Frage veröffentlicht wurde, erhalten Sie das begehrte Häkchen. Gute Arbeit und vielen Dank für die Teilnahme! :)
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:])

Es ist wahrscheinlich viel zu lang, aber ich kann auch etwas posten!

vpzomtrrfrt
quelle
Ich glaube , Sie können ersetzen r=(r+["TORTIL"])[::-1]mit r=["TORTIL"]+r[::-1]. range(0,l)kann auch sein range(l).
Lirtosiast
1. Stack Exchange ersetzt Tabulatoren durch vier Leerzeichen, sodass es schwierig ist, Ihre Punktzahl so zu überprüfen, wie sie ist. Nach dem erneuten Ersetzen zähle ich 482. 2. Sie können Leerzeichen sparen, indem Sie z. B. if l==2:q=s[0];s=[q,q,q];l=3eine einzelne Zeile einfügen . 3. n(l)macht dasselbe wie n(0,l).
Dennis
@ Tennis gibt es etwas, was ich gegen # 1 tun kann?
vpzomtrrfrt
1
Sie können statt eines Tabulators auch ein einzelnes Leerzeichen verwenden. In Python 3 ist das Mischen sowieso nicht möglich.
Dennis
Okay, ich habe deine Vorschläge aufgenommen und sie etwas kürzer gemacht.
Vpzomtrrfrt
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$/}

Noch in Arbeit.

(Bonus: Funktioniert mit so vielen Belägen, wie Sie möchten, nicht nur mit 5. Meistens, weil ich diese Regel anfangs nicht gesehen habe> _ <)

Ungolfed-Version:

#!/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'
Türknauf
quelle