ASCII टेस्ट-ट्यूब का अनुकूलन करें

Question

आपको एएससीआईआई परीक्षण-ट्यूबों का एक गुच्छा दिया जाता है, आपका कार्य उपयोग किए जाने वाले परीक्षण-ट्यूबों की संख्या को कम करना है।

प्रत्येक टेस्ट ट्यूब इस तरह दिखता है:

|  |
|  |
|  |
|~~|
|  |
|  |
|  |
|  |
|__|

जाहिर है, ~~जल स्तर है। टेस्ट-ट्यूब भी खाली हो सकती है, जिस स्थिति में ~~अंदर कोई पात्र नहीं हैं । एकल ट्यूब में 8 जल स्तर इकाइयाँ हो सकती हैं।

आपको अलग-अलग जल स्तरों के साथ परीक्षण ट्यूबों की परिमित संख्या दी जाती है। आपको कम से कम टेस्ट-ट्यूब में पानी डालना होगा, और परिणाम का उत्पादन करना होगा।

|  | |  | |  | |  |         |~~| |  |
|  | |  | |  | |  |         |  | |  |
|  | |~~| |  | |  |         |  | |  |
|~~| |  | |  | |  |         |  | |~~|
|  | |  | |  | |  | ------> |  | |  |
|  | |  | |  | |  |         |  | |  |
|  | |  | |~~| |  |         |  | |  |
|  | |  | |  | |  |         |  | |  |
|__| |__| |__| |__|         |__| |__|

 05 + 06 + 02 + 00  ------>  08 + 05

जैसा कि आप देख सकते हैं, परीक्षण-ट्यूब एकल स्थान के साथ अलग हो जाते हैं। खाली ट्यूबों को आउटपुट में नहीं दिखाया जाना चाहिए। यह कोड गोल्फ है, इसलिए कम से कम बाइट्स जीत के साथ कोड।

परीक्षण के मामले: http://pastebin.com/BC0C0uii

हैप्पी गोल्फिंग!

Comments

क्या हम पानी का पुनर्वितरण भी कर सकते हैं? उदाहरण के लिए 7 + 6 आपके उदाहरण के लिए एक वैध आउटपुट होगा?

— मार्टिन एंडर

@MartinEnder आपको कम से कम ट्यूबों का उपयोग संभव होना चाहिए। मुझे लगता है कि इस मामले में स्वीकार्य है।

— जैकजैक

@StewieGriffin मैंने अभी तक यहाँ कुछ भी ऐसा नहीं देखा है, इसलिए अगर मुझे लगता है कि मैं एक

— दयालु

क्या अनुगामी व्हाट्सएप की अनुमति है?

— पुरकाकूदरी

बेहतर शीर्षक - "ऑप्टिमाइज़र ASCII टेस्ट ट्यूब बेबी"

— ऑप्टिमाइज़र

Answer 1

पायथ, 48 45 44 बाइट्स

jCssm+_B,*9\|_X+\_*8;ld\~*9;cUs*L/%2w\~_S8 8

इसे ऑनलाइन आज़माएं।

हर पंक्ति पर एक एकल अनुगामी स्थान प्रिंट करता है।

Answer 2

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

s=>s.replace(/~~|\n/g,c=>1/c?i++:n+=7-i,n=i=-1)&&`012345678`.replace(/./g,i=>`|${g(+i)}| `.repeat(n>>3)+`|${g(~n&7^i)}|
`,g=i=>i?i>7?`__`:`  `:`~~`)

एक अनुगामी लाइनफीड को आउटपुट करता है। संपादित करें: @Arnauld की कुछ मदद से 11 बाइट्स सहेजे गए।

Comments

s.replace(/~~/g,(_,i)=>n+=9-i/s.indexOf`\n`|0,n=0)4 बाइट्स बचाना चाहिए। आप इसके बजाय n -1 को इनिशियलाइज़ करना चाहते हैं n>>3और ~n&7^iएक और बाइट बचा सकते हैं।

— अरनौलड

@ अर्नुलद इस -1विचार के लिए धन्यवाद, लेकिन मैं इस replaceविचार में सुधार करने में सक्षम था ।

— नील

अच्छा! मुझे एहसास नहीं 1/"\n"था कि सच्चाई थी।

— अरनुलड

@Arnauld खैर, यह केवल केक पर टुकड़े करने का एक अतिरिक्त बाइट था ...

— नील

Answer 3

पर्ल, 150 बाइट्स

कोड + -nध्वज के 149 बाइट्स ।

$l+=9-$.for/~~/g}if($l){$%=($v=$l/8)+($r=$l!=8);say"|~~| "x$v.($@="|  | ")x$r;say$:=$@x$%for$l%8..6;say$@x$v."|~~|"x$r;say$:for 2..$l%8;say"|__| "x$%

मैं सभी कोड की व्याख्या नहीं करूंगा, बस कुछ चीजें:
$l+=9-$.for/~~/gमायने रखता है कि इनपुट में कितना पानी है।
कोड का दूसरा भाग आउटपुट प्रिंट करता है। विचार के रूप में संभव के रूप में कई पूरी तरह से भरा ट्यूब डाल दिया है, और एक अंतिम एक जिसमें पानी बचा है (यदि कोई हो)। तो एल्गोरिथ्म 4 भागों में है: पानी की पहली पंक्ति (ट्यूबों के ऊपर) को प्रिंट करता है say"|~~| "x$v.($@="| | ")x$r:। तब तक, जब तक हम अंतिम ट्यूब के पानी के स्तर तक नहीं पहुँच जाते तब तक ट्यूबों के खाली हिस्सों को प्रिंट करें say$:=$@x$%for$l%8..6:। तब स्तर प्रिंट जहां पिछले ट्यूब पानी है: say$@x$v."|~~|"x$r। फिर, सभी शेष "खाली" स्तरों को प्रिंट करें say$:for 2..$l%8;:। और अंत में, नीचे की रेखा प्रिंट करें say"|__| "x$%:।
चर नाम पढ़ने के लिए ( $%और $@, $:) कठिन बनाते हैं , लेकिन जैसे कीवर्ड xऔर के लिए अनुमति देता हैfor एक स्थान के बिना चर के बाद लिखा जाना।

इसे चलाने के लिए:

perl -nE '$l+=9-$.for/~~/g}if($l){$%=($v=$l/8)+($r=$l!=8);say"|~~| "x$v.($@="|  | ")x$r;say$:=$@x$%for$l%8..6;say$@x$v."|~~|"x$r;say$:for 2..$l%8;say"|__| "x$%' <<< "|  | |  | |  | |  |
|  | |  | |  | |  |
|  | |~~| |  | |  |
|~~| |  | |  | |  |
|  | |  | |  | |  |
|  | |  | |  | |  |
|  | |  | |~~| |  |
|  | |  | |  | |  |
|__| |__| |__| |__| "

मैं बहुत संतुष्ट नहीं हूँ कि यह उत्तर कब तक है। मैंने अपने एल्गोरिथ्म से सर्वश्रेष्ठ बनाने की कोशिश की, लेकिन एक अलग दृष्टिकोण शायद कम हो सकता है। मैं जल्द ही इस पर काम करने की कोशिश करूंगा।

Comments

@JamesHolderness मैंने सभी परीक्षण मामलों की कोशिश की (और अब पुनः कोशिश की गई क्योंकि आप मुझ पर संदेह कर रहे थे) और यह मुझे ठीक लगता है। "पिछले एक" 3 ट्यूबों के साथ एक है: 4 में पानी के स्तर के साथ 2, और 1 के स्तर 2 पर पानी के साथ, सही? यदि ऐसा है, तो मैंने इसे आज़माया और यह पास्टबिन पर एक ही आउटपुट देता है

— दादा

@JamesHolderness ओह ठीक है, यह बहुत कुछ समझाता है! धन्यवाद :)

— दादा

Answer 4

Befunge, 144 138 बाइट्स

9>1-00p>~$~2/2%00gv
 |:g00_^#%4~$~$~+*<
$< v01!-g01+*8!!\*!\g00::-1</8+7:<p01-1<9p00+1%8-1:_@#:
_ ~>g!-1+3g:"|",,," |",,:>#^_$55+,10g:#^_@

इसे ऑनलाइन आज़माएं!

पहली दो पंक्तियाँ इनपुट की प्रक्रिया करती हैं, मूल रूप से प्रत्येक ट्यूब में पहले वर्ण को छोड़कर हर चीज को अनदेखा करती है जो एक स्तर मार्कर हो सकता है। हम उस वर्ण का ASCII मान लेते हैं, जिसे 2 और mod 2 से विभाजित करते हैं (हमें 1 या 0 देते हैं जो इस बात पर निर्भर करता है कि हम लेवल मार्कर पर हैं या नहीं), पंक्ति संख्या से गुणा करें (8 से नीचे की गिनती, इस प्रकार हमें दे उस ट्यूब के लिए स्तर का मूल्य), और इसे एक चालू कुल में जोड़ें।

आउटपुट दूसरी दो लाइनों पर संभाला जाता है, अनिवार्य रूप से तीसरी लाइन के दूर दाईं ओर से शुरू होता है। हम पहले कुल जल स्तर 7 को विभाजित करके ट्यूबों की संख्या की गणना करते हैं। 7 द्वारा विभाजित। फिर जब सभी ट्यूबों की पंक्तियों पर पुनरावृत्ति होती है, तो हम एक विशिष्ट ट्यूब के अंदर प्रदर्शित करने के लिए वर्ण की गणना करते हैं ( टी , 0 के लिए नीचे की गिनती) दी गई पंक्ति ( आर , 8 से 0 से नीचे की गिनती) इस प्रकार है:

last_level = (total_water - 1)%8 + 1
level      = last_level*!t + 8*!!t
char_type  = !(level - r) - !r

परिकलित char_type , बॉटलमॉस्ट पंक्ति (ट्यूब का आधार) के लिए -1 है, किसी अन्य क्षेत्र के लिए 0 जो जल स्तर नहीं है, और जल स्तर के लिए 1 है। यह इस प्रकार आउटपुट के लिए उपयुक्त चरित्र के लिए सरल तालिका लुकअप के रूप में उपयोग किया जा सकता है (आप पंक्ति 4 की शुरुआत में इस तालिका को देख सकते हैं)।

Answer 5

हास्केल, 186 बाइट्स

import Data.Lists
z=[8,7..0]
f x|s<-sum[i*length j-i|(i,j)<-zip z$splitOn"~~"<$>lines x],s>0=unlines$(\i->(#i)=<<(min 8<$>[s,s-8..1]))<$>z|1<2=""
l#i|i==l="|~~| "|i<1="|__| "|1<2="|  | "

उपयोग उदाहरण:

*Main> putStr $ f "|  | |  | |  | |  |\n|  | |  | |  | |  |\n|  | |~~| |  | |  |\n|~~| |  | |  | |  |\n|  | |  | |  | |  |\n|  | |  | |  | |  |\n|  | |  | |~~| |  |\n|  | |  | |  | |  |\n|__| |__| |__| |__|"
|~~| |  | 
|  | |  | 
|  | |  | 
|  | |~~| 
|  | |  | 
|  | |  | 
|  | |  | 
|  | |  | 
|__| |__| 

हर लाइन पर एक अनुगामी स्थान डालता है। यह काम किस प्रकार करता है:

              lines x      -- split the input string at newlines             
      splitOn"~~"<$>       -- split every line on "~~"
    zip z                  -- pair every line with its water level, i.e.
                           -- first line = 8, 2nd = 7 etc.
   [i*length j-i|(i,j)   ] -- for each such pair take the number of "~~" found
                           -- times the level
 s<-sum                    -- and let s be the sum, i.e. the total amount of water

  s>0                      -- if there's any water at all

          [s,s-8..1]       -- make a list water levels starting with s
                           -- down to 1 in steps of 8
       min 8<$>            -- and set each level to 8 if its greater than 8
                           -- now we have the list of water levels for the output
  \i->(#i)=<<(  )<$>z      -- for each number i from 8,7..0 map (#i) to the
                           -- list of output water levels and join the results
unlines                    -- join output lines into a single string (with newlines)

l#i                        -- pick a piece of tube:
                           --  |__|  if l==0
                           --  |~~|  if l==i
                           --  |  |  else



  |1<2=""                  -- if there's no water in the input, return the
                           -- empty string

मुख्य दर्द एक फ़ंक्शन की कमी थी जो मायने रखता है कि एक स्ट्रिंग में कितनी बार एक विकल्प होता है। इसमें countहै Data.Text, लेकिन इसे आयात करने से नाम संघर्ष का एक गुच्छा होता है जो हल करने के लिए बहुत महंगा है।

Answer 6

पायथन, 261 बाइट्स

i=input().split('\n')
t=0
R=range(9)[::-1]
for n in R:t+=i[n].count('~')/2*(8-n)
m=t%8
e=t/8
o=t/8+1
T='|~~| '
b='|  | '
B='|__| '
n='\n'
if m:
 print T*e+b
 for n in R:
    if n==m:print b*e+T
    else:print b*o
 print B*o
elif t<1:1
else:print T*e+(n+b*e)*7+(n+B)*e

मुझे लगता है कि कुछ ऐसा है जो मुझे याद आ रहा है। इसके अलावा, अगर newlines का एक गुच्छा रिक्त आउटपुट के लिए प्रशंसनीय है, तो मैं कुछ बाइट्स खो सकता हूं। जैसे इनपुट लेता है '| | | | | |\n| | | | | |\n| | | | | |\n| | | | | |\n| | | | | |\n| | | | | |\n| | | | | |\n| | | | | |\n|__| |__| |__|'।

Answer 7

रूबी , 139 बाइट्स

(कोड के 138 बाइट प्लस एक बाइट के लिए -n)

n||=0;b=gsub(/~~/){n=n+9-$.}[0,5];END{8.times{|i|puts (b*(n/8)).tr(?_,i>0??\ :?~)+(n%8>0?b.tr(?_,(8-i==n%8)??~:?\ ):"")};puts b*((n+7)/8)}

इसे ऑनलाइन आज़माएं!

कुछ स्पष्टीकरण:

इस प्रोग्राम को -nस्विच की आवश्यकता है ।

n - पानी का काउंटर।

b- ट्यूब निर्माण के लिए टेम्पलेट; बराबरी"|__| "

i - ट्यूब निर्माण के दौरान वर्तमान लाइन इंडेक्स।

gsub(/~~/){... }- यह gsubकेवल जल स्तर गिनने के लिए गाली देता है। gsubवास्तव में इसका विस्तार होता है Kernel.gsub, जो इसके बराबर है $_.gsub!। यह अनावश्यक रूप से वर्तमान रेखा ( $_) को हेरफेर करता है ; हालाँकि, यह b=… के [0,5]बजाय अधिक संक्षिप्त कार्य के लिए अनुमति देता है b=$_[0,5]।

n=n+9-$.- जल स्तर को मापने के लिए, अभिव्यक्ति पूर्व-परिभाषित चर का उपयोग $.करती है, जो वर्तमान इनपुट लाइन संख्या को वहन करती है । इसने मुझे स्पष्ट लूप चर को खोने की अनुमति दी।

b=gsub(/~~/){… }[0,5]- टेम्पलेट के रूप में सबसे बाईं ट्यूब के नीचे स्थित है। (मुझे लगता है कि "काहिरा में हाथी" पैटर्न की तरह थोड़ा सा लगता है क्योंकि नीचे की रेखा जीतती है।)
चूंकि ट्यूब के नीचे से पानी कभी gsubनहीं दिखता है, हम वहां होने पर कुछ भी नहीं बदलेंगे; इसलिए अंत में, bहमेशा बराबर होता है "|__| "।

END{... }- पूरे इनपुट स्ट्रीम को संसाधित करने के बाद कहा जाता है। मैं इस चरण का उपयोग लक्ष्य ट्यूबों के निर्माण के लिए करता हूं।

i>0??\ :?~- बस के लिए कम हाथ है i > 0 ? " " : "~"।

अद्यतन 1: चर, gsubचाल और END{… }चरण पर जोड़ा गया विवरण ।

अपडेट 2: (by 0 बाइट्स कुल मिलाकर)

• के n||=0बजाय का उपयोग करें n=n||0 (-1 बाइट)
• (+1 बाइट) के लिए मलूक लिया-n

Answer 8

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

यह कार्यक्रम ASCII और संख्या स्वरूपों दोनों में जल स्तर के साथ पूर्ण इच्छित उत्पादन बनाता है।

w,x,y=[],[],[];a,b,s=" ------> ","~","";y=input().split("\n")
for i in [i for i in zip(*y) if "_" in i][::2]:w+=[8-i.index(b)] if b in i else [0]
u=sum(w)
while u:x+=[[8],[u]][u<8];u-=x[-1]
for i,k in enumerate(y):
    s+=k+"%s"%[a," "*9][i!=4]
    for j,l in enumerate(x):
        c=["  ","__"][i==8];s+="|%s| "%(c,b*2)[l==8-i]
    s+="\n"
s+="\n"
for i in w:s+=" %02d  "%i
s+="\b"+a
for i in x:s+=" %02d  "%i
print(s)