इस चुनौती में, आपको पानी के गुब्बारे की ASCII कला को प्रदर्शित करना चाहिए, जिस गुब्बारे में पानी भरा है:

|  __||__  |
| / #   #\ |
| |######| |
| |######| |
| |######| |
| |######| |
| |######| |
| \######/ |
|          |
|          |
+----------+

गुब्बारा कैसे खींचना है

आकार का एक गुब्बारा प्रदर्शित करने के लिए n, निम्नलिखित चरणों का पालन करें (ध्यान दें: जब भी विभाजन चिह्न ( /) का उपयोग किया जाता है, तो यह पूर्णांक विभाजन का प्रतिनिधित्व करता है, नीचे गोल होता है):

|बाईं और दाईं ओर दस ऊर्ध्वाधर सलाखों ( ) से युक्त एक कंटेनर ड्रा करें -, तल पर दस डैश ( ) और +नीचे बाएं और नीचे दाएं कोने में एक प्लस चिह्न ( )। यह पूरी चीज़ को 12x11, और "अंदर" 10x10 बनाता है।
```
|          |
|          |
|          |
|          |
|          |
|          |
|          |
|          |
|          |
|          |
+----------+
```
शीर्ष पंक्ति के मध्य में केंद्रित दो ऊर्ध्वाधर पट्टियाँ (गुब्बारा खोलना) ड्रा करें, दोनों तरफ n/2अंडरस्कोर ( _) के साथ (इस उदाहरण के लिए, n5 होगा):
```
|  __||__  |
|          |
|          |
|          |
|          |
|          |
|          |
|          |
|          |
|          |
+----------+
```
इस शीर्ष पंक्ति के नीचे एक स्लैश ( /) और एक बैकस्लैश ( \) ड्रा करें, नीचे एक पंक्ति:
```
|  __||__  |
| /      \ |
|          |
|          |
|          |
|          |
|          |
|          |
|          |
|          |
+----------+
```
nपहचान की गई ऊर्ध्वाधर पट्टियों की पंक्तियों को ड्रा करें , और फिर (अब भी पहचाने जाने वाले) बैकलैश और स्लेश की जोड़ी की एक पंक्ति:
```
|  __||__  |
| /      \ |
| |      | |
| |      | |
| |      | |
| |      | |
| |      | |
| \      / |
|          |
|          |
+----------+
```
गुब्बारे को पानी से भरें, एक हैश चिन्ह ( #) द्वारा दर्शाया गया । सबसे कम पंक्ति पर शुरू करें, और ऊपर की ओर काम करें। यदि कोई पंक्ति पूरी तरह से नहीं भरी गई है, तो आप जहाँ चाहें (जहाँ नीचे उदाहरण में, उन्हें बेतरतीब ढंग से रखा गया है, होश के निशान लगा सकते हैं, लेकिन आप चाहें तो उन्हें बाईं ओर, कह सकते हैं)।
```
|  __||__  |
| / #   #\ |
| |######| |
| |######| |
| |######| |
| |######| |
| |######| |
| \######/ |
|          |
|          |
+----------+
```

अधिकतम n7 है, और न्यूनतम 0 है।

इनपुट

इनपुट एक पूर्णांक होगा i, जो हैश मार्क (पानी) की मात्रा है जिसे खींचना होगा।

यह कभी भी 2 से कम या 100 से अधिक नहीं होगा।

उत्पादन

आउटपुट nमें iहैश मार्क (पानी की इकाइयाँ) वाले आकार का एक गुब्बारा होना चाहिए , जहाँ nसबसे कम संभव आकार है जो iपानी की इकाइयों को पकड़ सकता है । चूंकि iहमेशा 2 या अधिक nहोगा , हमेशा 0 या अधिक होगा।

अधिकतम संभावित आकार का एक गुब्बारा खींचा जा सकता है n= 7. यदि आकार 7 का गुब्बारा निर्दिष्ट पानी की मात्रा को फिट नहीं कर सकता है, तो गुब्बारे का आकार:

|          |
|          |
|##  #  ###|
|##########|
|##########|
|##########|
|##########|
|##########|
|##########|
|##########|
+----------+

(ऊपर इनपुट i= 76 के लिए आउटपुट होना चाहिए । बिना कटा हुआ गुब्बारा की तरह, शीर्ष पंक्ति पर पानी की छः अतिरिक्त इकाइयाँ, कृपया व्यवस्थित की जा सकती हैं।)

परीक्षण के मामलों

क्यों एक परीक्षण मामला है, जब आप उन सभी को हो सकता है?

यहां i2 से 100 तक के सभी इनपुट का एनिमेटेड GIF दिया गया है :

2 से 100 तक सभी का एनीमेशन

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है।

code-golf ascii-art

— Doorknob
स्रोत

सम्बंधित।

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

2

ऑक्टेव, 523 बाइट्स

उन बाइट्स में से 23 सिर्फ n = 100 मामले के लिए हैं। शायद कोई और अधिक कुशल तरीका सुझा सकता है ...

n=input(0);x=zeros(11,6)+32;x(:,1)=124;x(11,:)=45;x(11,1)=43;
if n<5
w=3;h=2;a=2;
elseif n<7
w=3;h=3;a=2;
elseif n<17
w=4;h=4;a=4;
elseif n<37
w=5;h=6;a=6;
else
w=6;h=9;a=8;
end
if n<73
x(1,6)=124;x(1,9-w:5)=95;x(2,8-w)=47;x(3:1+h,8-w)=124;x(1+h,8-w)=92;x(2:1+h,9-w:6)=35;x=[x,fliplr(x)];x(2,5+w)=92;x(1+h,5+w)=47;x(2:1+floor((a*h-n)/a),9-w:4+w)=32;x(2+floor((a*h-n)/a),9-w+a-mod(a-n,a):4+w)=32;
else
x=[x,fliplr(x)];x(max(1,ceil((100-n)/10)):10,2:11)=35; if (n<100) x(ceil((100-n)/10),(2+mod(n,10)):11)=32; end
end
char(x)

परीक्षा

इनपुट: २१

आउटपुट:

| __ || __ |
| / \ |
| | | |
| | ### | |
| | ###### | |
| | ###### | |
| \ ###### / / |
| |
| |
| |
+ ---------- +

— सुडो rm -rf स्लेश
स्रोत

2

पायथन 2, 591 बाइट्स

मुझे कुछ समय लगा और यह शायद बहुत अधिक गोल्फ हो सकता है।

आशा है कि कोई बड़ी त्रुटि नहीं हैं।

r=[list(x)for x in ("|          |!"*10+"+----------+").split('!')]
s,t=[0]*4+[1]*2+[2]*10+[3]*4+[4]*16+[5]*6+[6]*22+[7]*8+[8]*29,[(4,2,2),(4,3,2),(3,4,4),(3,5,4),(2,6,6),(2,7,6),(1,8,8),(1,9,8),(0,9,10)]
a,b,c,d,e='|','/','\\','_','#'
def p(x,y,w):r[y][x]=w
def q(l):
 h,j,u=l
 p(5,0,a);p(6,0,a)
 for o in range(4-h):p(h+o+1,0,d);p(h+u-o,0,d)
 p(h,1,b);p(h+u+1,1,c)
 for o in range(j-2):p(h,o+2,a);p(h+u+1,o+2,a)
 p(h,j,c);p(h+u+1,j,b)
def w(i,l):
 h,j,u=l
 for o in range(i):x,y=o%u,o/u;p(h+x+1,j-y,e)
def f(i):
 n=s[i]
 l=t[n]
 if n<8:q(l)
 w(i,l)
 print "\n".join(["".join(x)for x in r])

उदाहरण रन:

f(34)

देता है:

|  __||__  |
| /####  \ |
| |######| |
| |######| |
| |######| |
| |######| |
| \######/ |
|          |
|          |
|          |
+----------+

— Heo
स्रोत

एक पानी का गुब्बारा भरें