प्रोग्रामिंग पहेलियाँ और टैको ट्रक

23

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ एक टैको ट्रक खोला है ! यह शब्द बाहर है और अब स्टैक एक्सचेंज नेटवर्क के सभी उपयोगकर्ता हमारे स्वादिष्ट, प्रामाणिक ASCII टैकोस की कोशिश कर रहे हैं । हमें यह सुनिश्चित करने के लिए आपकी सहायता की आवश्यकता है कि सभी को समय पर अपने आदेश प्राप्त हों। खाद्य ट्रकों के अंदर बहुत सारा कमरा नहीं है, इसलिए आपको अपने कोड को यथासंभव छोटा करना होगा।

अब कुछ ऑन-द-जॉब ट्रेनिंग के लिए।

आपका काम

एक पूर्ण प्रोग्राम लिखें जो एसटीडीआईएन से एक आदेश पढ़ता है या एक फ़ंक्शन जिसे इनपुट के रूप में एकल स्ट्रिंग ऑर्डर मिलता है। Tacos को STDOUT में मुद्रित किया जाता है, ऑर्डर करने के लिए बनाया गया है।

आदेश लेना

ग्राहक आपको STDIN या फ़ंक्शन तर्क के माध्यम से अपने आदेश देंगे। आदेश वांछित टॉपिंग की अल्पविराम-सीमांकित सूची के रूप में होंगे। जिस क्रम में टॉपिंग दिए गए हैं, वह उस क्रम को निर्धारित करता है जिसमें वे टैको में दिखाई देते हैं, जिसमें पहले सूचीबद्ध टॉपिंग नीचे और अंतिम शीर्ष पर होते हैं। यहाँ हम स्टॉक में रखते हैं:

  • फलियां
  • चावल
  • सब्जियों
  • सलाद
  • गुआकामोल
  • खट्टी मलाई
  • साल्सा

ग्राहक 1 टॉपिंग के रूप में ऑर्डर कर सकते हैं लेकिन 5 से अधिक टॉपिंग नहीं। टॉपिंग अलग होने की जरूरत नहीं है।

आप मान सकते हैं कि ग्राहक ऑर्डर देने से पहले मेनू से परिचित हैं और इस प्रकार सभी आदेशों में केवल वही सामग्री होगी जो हम स्टॉक करते हैं। यानी इनपुट हमेशा मान्य रहेगा।

टैकोस की सेवा

ग्राहक मांग करते हैं कि उनके टैकस को STDOUT पर मुद्रित किया जाए। वे अपने भोजन में कुछ प्रमुख या अनुगामी व्हाट्सएप के साथ ठीक हैं।

बाजार अनुसंधान से पता चलता है कि हर कोई शब्दों के रूप में टैकोस खाना चाहता है, और सभी कैप्स में शब्द बहुत अधिक स्वादिष्ट हैं। इस प्रकार हम बिना किसी रिक्त स्थान वाले सभी CAPS में टॉपिंग को सूचीबद्ध करेंगे।

कलापूर्ण प्रस्तुति के हित में, हम केवल एक टॉर्टिला में सामान नहीं रोक सकते हैं और इसे अच्छा कह सकते हैं, हमें धीरे-धीरे बाएं से दाएं, टॉपिंग और आवश्यकतानुसार पुनरावृत्ति करना है। प्रत्येक टॉपिंग को अपने आप में न्यूनतम 2 लाइनें मिलती हैं। नमूना पट्टिका का निरीक्षण करने के बाद यह सब स्पष्ट हो जाएगा।

सैंपल प्लेटर

आइए कुछ नमूना आदेशों पर एक नज़र डालें।

ग्राहक के आदेश: Beans,Veggies,Rice,Lettuce,Sour Cream

हम वितरित करते हैं:

   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

बहुत स्वादिष्ट लगता है, है ना? टॉपिंग 6 वर्णों को एक नई पंक्ति में लपेटता है और प्रत्येक पंक्ति को 2 वर्णों में भरने के लिए दोहराया जाता है, जिसे 12 वर्णों तक काट दिया जाता है। पहले घटक को अपनी शीर्ष रेखा पर 6 अक्षर मिलते हैं लेकिन दूसरी पंक्ति में केवल 4। यह सुनिश्चित करता है कि यह टॉर्टिला की तह में फिट बैठता है। इसी तरह, अंतिम घटक को हमेशा अपनी शीर्ष रेखा पर 4 और उसके दूसरे भाग पर 6 अक्षर मिलते हैं।

यदि कोई ग्राहक एक पंक्ति में एक ही टॉपिंग के दो आदेश देता है तो क्या होगा? उस घटक की लगातार सभी लाइनों के लिए उस घटक को लपेटते रहें।

ग्राहक के आदेश: Lettuce,Lettuce,Lettuce,Salsa

हम वितरित करते हैं:

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

ग्राहक के आदेश: Guacamole

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

केवल एक संघटक? शीर्ष पर 4 अतिरिक्त पात्रों का मूल्य दें।

महीने के कर्मचारी

कोड स्निपेट दिखाएं

खुश खाना पकाने!

code-golf  ascii-art 
— एलेक्स ए।
स्रोत

जवाबों:

3

जावास्क्रिप्ट (ईएस 6), 269 263 बाइट्स

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"

व्याख्या

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

परीक्षा

कोड स्निपेट दिखाएं

— user81655
स्रोत
बाउंटी अवधि के अंत में सबसे छोटा उत्तर के रूप में, आपको +50 का इनाम प्राप्त होता है! और सवाल पोस्ट किए जाने के एक सप्ताह बाद दो पोस्ट किए गए उत्तरों में से सबसे छोटा, आप प्रतिष्ठित चेक मार्क जीतते हैं। अच्छा काम और भाग लेने के लिए धन्यवाद! :)
— एलेक्स ए।
6

पायथन 3, 475 बाइट्स

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

यह शायद बहुत लंबा रास्ता है, लेकिन मैं भी कुछ पोस्ट कर सकता हूं!

— vpzomtrrfrt
स्रोत
मुझे लगता है कि आप की जगह ले सकता r=(r+["TORTIL"])[::-1]साथ r=["TORTIL"]+r[::-1]। range(0,l)भी हो सकता है range(l)।
— lirtosiast 3
1. स्टैक एक्सचेंज चार स्थानों के साथ टैब को बदल देता है, इसलिए यह आपके स्कोर को सत्यापित करना कठिन है। उन्हें फिर से बदलने के बाद, मैं 482 गिनता हूं। 2. आप if l==2:q=s[0];s=[q,q,q];l=3एक लाइन पर , जैसे, व्हाट्सएप पर सेव कर सकते हैं । 3. n(l)जैसा करता है वैसा ही करता है n(0,l)।
— डेनिस
@ डेनिस ऐसा कुछ है जो मैं # 1 के बारे में कर सकता हूं?
— vpzomtrrfrt
1
आप टैब के बजाय केवल एक स्थान का उपयोग कर सकते हैं। अजगर 3 वैसे भी उन्हें मिश्रण करने की अनुमति नहीं देता है।
— डेनिस
ठीक है, मैंने आपके सुझाव ले लिए हैं और इसे थोड़ा कम कर दिया है।
— vpzomtrrfrt
4

रूबी, 376 375 368 363 362 बाइट्स

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

एक काम अभी भी प्रगति में है।

(बोनस: आप जितने चाहें उतने टॉपिंग के साथ काम करते हैं, सिर्फ 5. नहीं, ज्यादातर इसलिए क्योंकि मैंने उस नियम को पहली बार नहीं देखा था> _ <)

Ungolfed संस्करण:

#!/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'
— Doorknob
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.