Programmation de puzzles et de Taco Truck

23

Programmation Puzzles & Code Golf a ouvert un camion à tacos ! Le mot est sorti et maintenant les utilisateurs de partout dans le réseau Stack Exchange viennent essayer nos savoureux et authentiques tacos ASCII . Nous avons besoin de votre aide pour nous assurer que tout le monde reçoit ses commandes en temps opportun. Il n'y a pas beaucoup de place à l'intérieur des food trucks, vous aurez donc besoin que votre code soit le plus court possible.

Maintenant, pour une formation en cours d'emploi.

Votre travail

Écrivez un programme complet qui lit un ordre de STDIN ou une fonction qui obtient un ordre de chaîne unique en entrée. Les tacos sont imprimés sur STDOUT, fabriqués sur commande.

Prendre des commandes

Les clients vous donneront leurs commandes via STDIN ou argument de fonction. Les commandes prendront la forme d'une liste délimitée par des virgules des garnitures souhaitées. L'ordre dans lequel les garnitures sont données dicte l'ordre dans lequel elles apparaissent dans le taco, avec la première garniture répertoriée en bas et la dernière en haut. Voici ce que nous gardons en stock:

  • Des haricots
  • Riz
  • Légumes
  • Salade
  • Guacamole
  • Crème aigre
  • salsa

Les clients peuvent commander seulement 1 garniture mais pas plus de 5 garnitures. Les garnitures n'ont pas besoin d'être distinctes.

Vous pouvez supposer que les clients connaissent le menu avant de commander et donc toutes les commandes ne contiendront que des ingrédients que nous avons en stock. Autrement dit, l'entrée sera toujours valide.

Servir des tacos

Les clients exigent que leurs tacos soient imprimés sur STDOUT. Ils sont bien avec des espaces blancs en tête ou en queue dans leur nourriture.

Les études de marché montrent que tout le monde veut manger des tacos comme mots, et les mots en toutes lettres sont beaucoup plus savoureux. Ainsi, nous répertorierons les garnitures dans TOUS LES CAPS sans espaces.

Dans l'intérêt de la présentation artistique, nous ne pouvons pas simplement déposer des trucs dans une tortilla et l'appeler bonne, nous devons poser doucement les garnitures de gauche à droite, les emballer et les répéter au besoin. Chaque nappage obtient un minimum de 2 lignes pour lui-même. Tout deviendra plus clair une fois que nous aurons inspecté le plateau d'échantillons.

Plateau d'échantillons

Jetons un coup d'œil à quelques exemples de commandes.

Le client commande: Beans,Veggies,Rice,Lettuce,Sour Cream

Nous livrons:

   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

Semble assez savoureux, non? Les garnitures s'enroulent après 6 caractères sur une nouvelle ligne et sont répétées pour remplir 2 lignes chacune, tronquées à 12 caractères. Le premier ingrédient obtient 6 caractères sur sa ligne supérieure mais seulement 4 sur sa deuxième ligne. Cela garantit qu'il s'insère dans le pli de la tortilla. De même, le dernier ingrédient obtient toujours 4 caractères sur sa première ligne et 6 sur sa seconde.

Que se passe-t-il si un client commande deux des mêmes garnitures d'affilée? Continuez à emballer cet ingrédient pour toutes les lignes consécutives de cet ingrédient.

Le client commande: Lettuce,Lettuce,Lettuce,Salsa

Nous livrons:

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

Le client commande: Guacamole

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

Un seul ingrédient? Donnez 4 caractères supplémentaires en haut.

Employés du mois

Afficher l'extrait de code

Bonne cuisine!

code-golf ascii-art Alex A.
la source

Réponses:

3

JavaScript (ES6), 269 263 octets

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"

Explication

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

Tester

Afficher l'extrait de code

user81655
la source
Comme réponse la plus courte à la fin de la période de prime, vous recevez la prime de +50! Et comme la plus courte des deux réponses publiées une semaine après la publication de la question, vous gagnez la coche très convoitée. Beau travail et merci pour votre participation! :)
Alex A.
6

Python 3, 475 octets

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

C'est probablement beaucoup trop long, mais je peux aussi poster quelque chose!

vpzomtrrfrt
la source
Je pense que vous pouvez remplacer r=(r+["TORTIL"])[::-1]par r=["TORTIL"]+r[::-1]. range(0,l)peut aussi l'être range(l).
lirtosiast
1. Stack Exchange remplace les tabulations par quatre espaces, il est donc difficile de vérifier votre score tel quel. Après les avoir remplacés, je compte 482. 2. Vous pouvez économiser sur les espaces en mettant, par exemple, if l==2:q=s[0];s=[q,q,q];l=3sur une seule ligne. 3. n(l)fait la même chose que n(0,l).
Dennis
@Dennis est-ce que je peux faire quelque chose sur # 1?
vpzomtrrfrt
1
Vous pouvez simplement utiliser un seul espace au lieu d'un onglet. Python 3 ne permet pas de les mélanger de toute façon.
Dennis
D'accord, j'ai pris vos suggestions et je les ai raccourcies un peu.
vpzomtrrfrt
4

Rubis, 376 375 368 363 362 octets

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

Encore un travail en cours.

(Bonus: Fonctionne avec autant de garnitures que vous le souhaitez, pas seulement 5. Surtout parce que je n'ai pas vu cette règle au début> _ <)

Version non golfée:

#!/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'
Poignée de porte
la source