ASCII बॉक्स के वॉल्यूम

Question

परिचय

इस चुनौती में, आपको एक आयताकार घनाभ (3 डी बॉक्स) के शुद्ध (सामने की सतह) के ASCII प्रतिनिधित्व इनपुट के रूप में दिया जाता है । प्रारूप यह है:

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

क्यूबॉइड का प्रत्येक चेहरा -चैचरों से #घिरा हुआ एस की एक आयत है +-|। नेट के बाहर .एस भर गया है । नेट में हमेशा एक ही अभिविन्यास होगा: उसके चार पड़ोसी चेहरों से घिरा एक मध्य चेहरा है, और मध्य चेहरे का समकक्ष इनपुट की दाईं सीमा पर है। इनपुट को .आयताकार आकार में एस के साथ गद्देदार किया जाता है और इसमें अतिरिक्त पंक्तियाँ या कॉलम नहीं होते हैं .।

काम

आपका कार्य ऊपर के रूप में एक आरेख इनपुट के रूप में लेना है, और यह प्रदर्शित करने वाले क्यूबॉइड की मात्रा की गणना करता है, जो कि इसकी ऊंचाई, चौड़ाई और गहराई का सिर्फ उत्पाद है। आप इनपुट को न्यूलाइन-सीमांकित स्ट्रिंग या स्ट्रिंग्स की एक सरणी के रूप में ले सकते हैं।

प्रत्येक किनारे की लंबाई +अपने दो छोरों पर -चावलियों के बीच की दूरी है। उदाहरण के लिए, क्षैतिज किनारे +--+की लंबाई 3 है, और ऊर्ध्वाधर किनारे

+
|
|
|
+

लंबाई है 4. एक किनारे की न्यूनतम लंबाई 1. उदाहरण के ऊपर के क्यूबॉइड में वॉल्यूम 2 ​​* 3 * 4 = 24 है।

नियम और स्कोरिंग

आप एक पूर्ण प्रोग्राम या फ़ंक्शन लिख सकते हैं, और सबसे कम बाइट काउंट जीतता है।

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

.++..
+++++
+++++
.++..
1

...++....
...||....
...||....
+--++--++
+--++--++
...||....
...||....
...++....
3

..+-+....
..|#|....
+-+-+-+-+
|#|#|#|#|
|#|#|#|#|
+-+-+-+-+
..|#|....
..+-+....
12

.+---+.....
++---++---+
||###||###|
||###||###|
||###||###|
++---++---+
.+---+.....
16

....++.....
....||.....
....||.....
....||.....
+---++---++
|###||###||
|###||###||
|###||###||
+---++---++
....||.....
....||.....
....||.....
....++.....
16

...+--+......
...|##|......
...|##|......
+--+--+--+--+
|##|##|##|##|
+--+--+--+--+
...|##|......
...|##|......
...+--+......
18

....+--+.......
....|##|.......
....|##|.......
....|##|.......
+---+--+---+--+
|###|##|###|##|
+---+--+---+--+
....|##|.......
....|##|.......
....|##|.......
....+--+.......
24

....+-----+..........
....|#####|..........
....|#####|..........
....|#####|..........
+---+-----+---+-----+
|###|#####|###|#####|
|###|#####|###|#####|
|###|#####|###|#####|
|###|#####|###|#####|
+---+-----+---+-----+
....|#####|..........
....|#####|..........
....|#####|..........
....+-----+..........
120

Comments

मुझे वास्तव में यह चुनौती पसंद है। क्योंकि इनपुट में बहुत अधिक अनावश्यक संरचना है, आयामों को पुनर्प्राप्त करने के लिए बहुत सारे विकल्प हैं।

— xnor

Answer 1

रेटिना , 29 28 बाइट्स

T`.p`xy`\G\..+¶
xy

¶\|
$`
y

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

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

मुझे वर्तमान में एक ही बाइट काउंट पर दो अन्य समाधान मिल गए हैं जो उपरोक्त दृष्टिकोण से थोड़ा अधिक गोल्फ के समान प्रतीत होते हैं:

\G\..+¶

¶\|
$'¶
G`\.
T`.|+

¶\||\+¶\.\D+
$'¶
G`\.
T`.|+

हालांकि इनमें से मैं प्रत्येक बाइट को बचा सकता था यदि मुझे लगता है कि इनपुट एक अनुगामी लाइनफीड के साथ समाप्त होता है, लेकिन मुझे उस पर भरोसा नहीं करना होगा।

और एक अन्य, अभी भी 28 बाइट्स पर (यह वास्तव में एक तरफ एक क्षेत्र को गुणा करने के बजाय तीन पक्षों को गुणा करता है):

\G\.
x
-(?<=^.+)
$`
¶\|
$`
x

व्याख्या

मुख्य विचार इनपुट की लंबाई सीमा को छूने वाले ऊर्ध्वाधर पक्ष की लंबाई से चेहरे के क्षेत्र को गुणा करना है।

मैं एक उदाहरण के रूप में निम्नलिखित इनपुट का उपयोग करूंगा (इसमें 2, 3 और 4 की लंबाई है, इसलिए 24 का क्षेत्र):

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

चरण 1: अनुवादक

T`.p`xy`\G\..+¶

रेगेक्स \G\..+¶एक ऐसी रेखा से मेल खाता है, जो शुरू होता है .और तुरंत पिछली पंक्ति के समीप होता है। तो यह उन सभी रेखाओं से मेल खाता है जिनमें शीर्ष चेहरा होता है। मंच ही में बदल जाता .है xऔर अन्य सभी पात्रों (किसी भी |+-#) में y। यह हमें निम्न परिणाम देता है:

xxxyyyyyxxxxxxx
xxxyyyyyxxxxxxx
xxxyyyyyxxxxxxx
+--+---+--+---+
|##|###|##|###|
+--+---+--+---+
...|###|.......
...|###|.......
...+---+.......

यह yशीर्ष चेहरे के क्षेत्र का प्रतिनिधित्व करने की आवश्यकता की तुलना में एक और स्तंभ है । हम इसे अगले चरण के साथ ठीक करते हैं।

स्टेज 2: प्रतिस्थापित करें

xy

तो हम एक मैच yसे पहले एक x(जो प्रति पंक्ति उनमें से एक है) और उन दोनों को स्ट्रिंग से हटा देते हैं। हमें यह मिलता है:

xxyyyyxxxxxxx
xxyyyyxxxxxxx
xxyyyyxxxxxxx
+--+---+--+---+
|##|###|##|###|
+--+---+--+---+
...|###|.......
...|###|.......
...+---+.......

तो अब हम शीर्ष चेहरे के क्षेत्र को yएस की संख्या द्वारा दर्शाया गया है ।

चरण 3: प्रतिस्थापित करें

¶\|
$`

हमारा लक्ष्य इस क्षेत्र Aको लापता की लंबाई से गुणा करना है , जो कि |एक लाइन की शुरुआत में प्लस 1 की संख्या है । हालांकि, यह वास्तव में एक संख्या से गुणा करना आसान है n+1क्योंकि हम पहले ही Aस्ट्रिंग में एक प्रति प्राप्त कर चुके हैं। । यदि हम nचीजों को प्रतिस्थापित करते हैं A, तो हम उसकी n+1प्रतियों के साथ समाप्त होते हैं A। यह हमारे लिए चीजों को बहुत आसान बनाता है।

इसलिए हम |मैच के सामने हर चीज के साथ लाइनफीड के तुरंत बाद किसी को भी बदल देते हैं । यह स्ट्रिंग को बहुत अधिक मात्रा में काटता है और इसे हमारी आवश्यकता से काफी बड़ा बनाता है, लेकिन yपरिणाम समाप्त होने की संख्या आपको दिख रही है:

xxyyyyxxxxxxx
xxyyyyxxxxxxx
xxyyyyxxxxxxx
+--+---+--+---+xxyyyyxxxxxxx
xxyyyyxxxxxxx
xxyyyyxxxxxxx
+--+---+--+---+##|###|##|###|
+--+---+--+---+
...|###|.......
...|###|.......
...+---+.......

स्टेज 4: मैच

y

जो कुछ बचा है, वह एस की संख्या को गिनने के लिए है y, जो अंत में दशमलव संख्या के रूप में छपा है।

Answer 2

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

lambda l:l[0].find('+')*~l[0].count('-')*~`l`.count("'|")

एक फ़ंक्शन जो स्ट्रिंग की सूची में लेता है।

3 आयामों को अलग-अलग निर्धारित करता है:

l[0].find('+')
+पहली पंक्ति में पहले का सूचकांक ।

-~l[0].count('-')
-पहली पंक्ति में संकेतों की संख्या ।

~`l`.count("'|")
सूची से शुरू होने वाली पंक्तियों की संख्या |, सूची के स्ट्रिंग प्रतिनिधित्व के माध्यम से इसके पहले एक प्रतीक है।

---

62 बाइट्स:

def f(l):a=l[0].find('+');print(len(l[0])/2-a)*(len(l)-a+~a)*a

एक फ़ंक्शन जो स्ट्रिंग की सूची में लेता है और परिणाम प्रिंट करता है।

पहली पंक्ति में एक आयाम aको सूचकांक के रूप में ढूँढता है +। अन्य दो आयाम इससे अनुमानित हैं और इनपुट आयत की चौड़ाई और ऊंचाई।

63-बाइट विकल्प, आयामों को अलग से खोजना:

lambda l:l[0].find('+')*~l[0].count('-')*~zip(*l)[0].count('|')

Answer 3

बैश + कोरुटिल्स, 83, 77 बाइट्स

संपादन:

• "यहां स्ट्रिंग" का उपयोग करके और regexp को थोड़ा अनुकूलित करके 6 बाइट्स सहेजे गए

golfed

bc<<<`sed -rn '1{s/(.+)[^\.]*\1/(0\1)*(0/
s/\./+1/gp;a)*(-1
}
/^[+|]/a+1
'`\)

व्याख्या की

Sed के साथ रूपांतरण :

....+--+....... => (0+1+1+1+1)*(0+1+1+1 )*(-2 +1
. =>()
. =>()
. =>()
. =>()
+ => +1
| => +1
+ => +1
. =>()
. =>()
. =>()
. =>()

Backticks, append का उपयोग कर नई कहानियों से छुटकारा

=> (0+1+1+1+1)*(0+1+1+1 )*(-2 +1 +1 +1 +1)

परिणामी अभिव्यक्ति को ई.पू.

=> 24

परीक्षा

./box <<EOF
.++..
+++++
+++++
.++..
EOF

1

./box <<EOF
...++....
...||....
...||....
+--++--++
+--++--++
...||....
...||....
...++....
EOF

3

./box <<EOF
....+--+.......
....|##|.......
....|##|.......
....|##|.......
+---+--+---+--+
|###|##|###|##|
+---+--+---+--+
....|##|.......
....|##|.......
....|##|.......
....+--+.......
EOF

24

इसे ऑनलाइन आज़माएं! (का उपयोग करता है, गणित विस्तार पार्टी की योजना बनाई के बजाय ईसा पूर्व , के रूप में उत्तरार्द्ध उपलब्ध नहीं है)

Answer 4

घोंघे , 19 बाइट्स

AM
=~d^.+\+.+l.+^.2

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

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

AM   ,, A -> count all matching paths
     ,, M -> first char matched is the one in the current direction
     ,,      from the starting location, rather than directly on it
=~          ,, check that we are on the right edge of the grid
d ^.+ \+    ,, go down, matching one or more non-'.' characters, then a '+'
.+          ,, go down one or more times
l .+        ,, go left one or more times
^. 2        ,, match two further characters which aren't '.' to the left

Answer 5

जावास्क्रिप्ट (ईएस 6), 67 91

s=>(a=~-s.search`
`/2-(b=s.indexOf`+`))*b*(s.split`
`.length-1-2*b)

परीक्षा

F=
s=>(a=~-s.search`
`/2-(b=s.indexOf`+`))*b*(s.split`
`.length-1-2*b)

out=x=>O.textContent+=x+'\n\n'

;`.++..
+++++
+++++
.++..
1

...++....
...||....
...||....
+--++--++
+--++--++
...||....
...||....
...++....
3

..+-+....
..|#|....
+-+-+-+-+
|#|#|#|#|
|#|#|#|#|
+-+-+-+-+
..|#|....
..+-+....
12

.+---+.....
++---++---+
||###||###|
||###||###|
||###||###|
++---++---+
.+---+.....
16

....++.....
....||.....
....||.....
....||.....
+---++---++
|###||###||
|###||###||
|###||###||
+---++---++
....||.....
....||.....
....||.....
....++.....
16

...+--+......
...|##|......
...|##|......
+--+--+--+--+
|##|##|##|##|
+--+--+--+--+
...|##|......
...|##|......
...+--+......
18

....+--+.......
....|##|.......
....|##|.......
....|##|.......
+---+--+---+--+
|###|##|###|##|
+---+--+---+--+
....|##|.......
....|##|.......
....|##|.......
....+--+.......
24

....+-----+..........
....|#####|..........
....|#####|..........
....|#####|..........
+---+-----+---+-----+
|###|#####|###|#####|
|###|#####|###|#####|
|###|#####|###|#####|
|###|#####|###|#####|
+---+-----+---+-----+
....|#####|..........
....|#####|..........
....|#####|..........
....+-----+..........
120`
.split('\n\n').forEach(t=>{
  t=t.split('\n')
  k=+t.pop()
  t=t.join('\n')
  v=F(t)
  out(v+' '+k +' '+(v==k?'OK':'KO')+'\n'+t)
})

<pre id=O></pre>

Answer 6

रूबी, ४४

अन्य उत्तरों के समान सिद्धांत पर काम करता है: +गहराई खोजने के लिए पहले ढूंढें, चौड़ाई खोजने के .बाद अगला +खोजें, और |पंक्ति के अंत में संख्या गिनें और ऊंचाई खोजने के लिए 1 जोड़ें।

->s{(s=~/\+/)*($'=~/\./)*s.split("|
").size}

परीक्षण कार्यक्रम में अपुष्ट

f=->s{(s=~/\+/)*    # index of first match of /\+/ in s
($'=~/\./)*         # $' is a special variable, contains string to right of last match. index of /\./ in $' 
s.split("|
").size}            # split the string at |\n to form an array and count the members

puts f[".++..
+++++
+++++
.++.."]

puts f["...++....
...||....
...||....
+--++--++
+--++--++
...||....
...||....
...++...."]

#etc.

Answer 7

05AB1E , 21 बाइट्स

चलो Wऔर Hइनपुट की चौड़ाई और ऊंचाई क्रमशः - बॉक्स नहीं। फिर, बॉक्स आयाम A, Bऔर Cइन नियमों का पालन करें:

W = 2(A+C)+1
H = B+2C+1

नीचे दिए चित्र क्या A, Bऔर Cबढ़त के नाम के संदर्भ में, कर रहे हैं:

....AAAA.......
....|##|.......
....|##|.......
....|##|.......
B---+--CCCCC--+
B###|##|###|##|
B---+--+---+--+
....|##|.......
....|##|.......
....|##|.......
....+--+.......

इसलिए उपरोक्त सूत्र। इस कार्यक्रम के computes A, के मूल्यों deduces Bऔर Cऔर अंत में अपने उत्पाद गणना करता है।

S'.ÊO<D¹g<;-(D·|g-()P

S'.Ê                  From each character of the first line, yield 0 if it is '.' or 1 otherwise. The result is stored in an array
    O<D               A = sum(array) - 1
       ¹g<;-(D        C = (W-1)/2 - A
              ·|g-(   B = H-1-2*C
                   )  Yield [A,C,B]
                    P Take the product and implicitly display it

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

पूर्व संस्करण - विभिन्न दृष्टिकोण - 26 बाइट्स

|vyS'.Ê})¬O<sø¬O<s€O¬Ê1k)P

|                          Take the input as an array of lines (strings)
 vy                        For each line
   S'.Ê                    For each character in the line, yield 0 if it is '.' or 1 otherwise
       }                   End For
        )                  Wrap the results as an array
         ¬O<               A = sum(first_line) - 1
            sø             Transpose the box pattern
              ¬O<          B = sum(first_line) - 1 ; since the pattern is transposed, it corresponds to the first column
                 s€O       Sum every line from the transposed pattern
                    ¬Ê1k   C = index of the first line that has a different sum from the first line
                        )  Yield [A, B, C]
                         P Take the product A*B*C and implicitly display it

Answer 8

बेफुज 93 , 56 बाइट्स

~2%#^_1+
  @.*+<
`"z"~<|:`~0+
5*\`#^_\1>*\~7
%2~\<\+1_^#

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

स्पष्टीकरण:

बॉक्स की मात्रा की संख्या से गुणा करके गणना की जा सकती .है किसी भी अन्य पात्रों से पहले पहली पंक्ति पर है, की संख्या से +और -1, और लाइनों है कि एक साथ शुरू की संख्या - पहली पंक्ति पर रों |+ 1।

~2%#^_1+         Uses the ASCII value % 2 of a character to count the .s

%2~\<\+1_^#      IP wraps around to the bottom. Counts the non . chars
                 Works because ("+" % 2) == ("-" % 2) == 1

5*\`#^_\1>*\~7   Multiplies the previous 2 results and cycles through
                 characters until it hits a newline or EOF

`"z"~<|:`~0+     Adds 1 to the 3rd dimension if the following char is a "|"
                 Also checks for EOF; If there is more input, goes back to
                 previous line. Otherwise, goes to the last line

  @.*+<          Adds 1 to the 3rd dimension, multiplies it to the rest,
                 prints the volume, and ends the program

यदि 3 डी लाइन में वर्टिकल का उपयोग करने के लिए मुझे नीचे की बजाय आईपी अप लाइनों को स्थानांतरित करना पड़ा। यदि IP नीचे लाइनों में जा रहा था, तो ऊर्ध्वाधर अगर स्टैक के शीर्ष को 1 क्षैतिज होने पर मजबूर करेगा जब निम्नलिखित क्षैतिज मार अगर, गलत दिशा में भेज रहा है।

Answer 9

हास्केल, 64 56 बाइट्स

f(x:r)=sum$fst(span(>'+')x)>>[1|'|':_<-"|":r,'-'<-'-':x]

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

व्याख्या

इनपुट में प्रत्येक पंक्ति के लिए तार की एक सूची होने की उम्मीद है, इसलिए fपैरामीटर xपहली पंक्ति और rशेष लाइनों की सूची है।

1. fst(span(>'+')x).स्ट्रिंग के रूप में पहली पंक्ति का -prefix लौटाता है , इसलिए length(fst(span(>'+')x))पहला आयाम है d1।
2. एक सूची समझ फिल्टर के रूप में कार्य कर सकती है, उदाहरण के लिए पहली पंक्ति में ['-' | '-' <- x]सभी का एक स्ट्रिंग देता है -, इसलिए 1 + length['-' | '-' <- x]दूसरा आयाम देता है d2।
3. |पहली पंक्ति में एनालॉग की संख्या को गिना जा सकता है, इसलिए 1 + length['|' | '|':_ <- r]तीसरा आयाम है d3।

2. और 3. की ​​सूची समझ को छोटा किया जा सकता है 1+sum[1|'-'<-x]और 1+sum[1|'|':_<-r]'-' '' '' की प्रत्येक घटना के लिए लोगों की एक सूची बनाकर। और फिर राशि ले रहा है। हम आगे बाहरी रख सकते हैं 1+जोड़कर सूची समझ में -करने के लिए xऔर "|"करने के लिए rउपज के लिए sum[1|'-'<-'-':x]और sum[1|'|':_<-"|":r]। अब हम दोनों सूची समझ को एक ही समझ में डालकर दोनों को जोड़ सकते हैं: sum[1|'|':_<-"|":r,'-'<-'-':x]आसानी से यह दो आयामों के उत्पाद की गणना करता है क्योंकि सूचियों के लिए Fऔर Gनिम्नलिखित सूची की समझ कार्टेसियन उत्पाद है F x G =[(a,b)|a<-F,b<-G]।

अंत में, गुणा करने के बजाय 1. 2 और 3 के संयोजन के साथ। हम >>सूचियों पर ऑपरेटर का उपयोग कर सकते हैं : बार F>>Gदोहराता G length Fहै और परिणाम को बदलता है। तो एक बार fst(span(>'+')x)>>[1|'|':_<-"|":r,'-'<-'-':x]की सूची को दोहराता है, उन d2*d3लोगों की d1एक सूची तैयार करता d1*d2*d3है जो तब वॉल्यूम प्राप्त करने के लिए अभिव्यक्त होते हैं।

Comments

आप इनपुट को स्ट्रिंग की एक सूची के रूप में ले सकते हैं, जिसके लिए आवश्यकता को हटा सकते हैं lines।

— ज़गरब

@Zgarb धन्यवाद, यह कुछ बाइट्स बचाता है।

— लकोनी 11

Answer 10

जावा 8, 185 129 बाइट्स

-56 बाइट्स के लिए ज़गारब को धन्यवाद

golfed:

int g(String[]i){int h=0;for(String k:i){if(k.charAt(0)=='.')h++;else break;}return((i[0].length()-2*h-1)/2)*(i.length-2*h-1)*h;}

ungolfed:

int g(String[] i) {
    int h = 0;
    for (String k : i) {
        if (k.charAt(0) == '.') h++;
        else break;
    }
    return ((i[0].length()-2*h-1)/2)*(i.length-2*h-1)*h;
}

व्याख्या

a*b*h = ((length_of_line-2*h-1)/2)*(number_of_lines-2*h-1)*h

जहां aऔर bआधार के आयाम हैं और hऊंचाई है। आप hपहली hपंक्तियों की गिनती करके पा सकते हैं जहां आप एक के साथ शुरू करते हैं .।

Comments

आप इनपुट को एक सरणी या स्ट्रिंग्स के रूप में ले सकते हैं, इसलिए इसे मैन्युअल रूप से विभाजित करने की कोई आवश्यकता नहीं है।

— जर्बर्ब डे

oops thx, इसे ठीक करना ...

— Bobas_Pett

Answer 11

जावा, 112 बाइट्स

int v(String[]s){int a=s[0].lastIndexOf('+')-s[0].indexOf('+'),b=s[0].length()/2-a;return a*b*(s.length-2*b-1);}

विस्तारित:

int v(String[] s)
{
  // length of the edge in the first line
  int a = s[0].lastIndexOf('+') - s[0].indexOf('+');
  // length of the second edge
  // int b = s[0].length() - 2 * a - 1; <-- multiplied by 2
  int b = s[0].length()/2 - a; // <-- hack, length is always odd
  // length of the third edge in ()
  // volume
  return a * b * (s.length - 2 * b - 1);
} // end method v

Answer 12

पॉवरशेल, 68 67 बाइट्स

($c="$args"|% i*f +)*($args[0].Length/2-.5-$c)*($args.Count-1-2*$c)

नोट: के "$args"|% i*f + लिए शॉर्टकट है"$args".indexOf('+')

व्याख्या

Osable के उत्तर से अच्छी व्याख्या मिली :

चलो Wऔर Hइनपुट की चौड़ाई और ऊंचाई क्रमशः - बॉक्स नहीं। फिर, बॉक्स आयाम A, Bऔर Cइन नियमों का पालन करें:

W = 2(A+C)+1
H = B+2C+1

नीचे दिए चित्र क्या A, Bऔर Cबढ़त के नाम के संदर्भ में, कर रहे हैं:

CCCCAAAA.......
....|##|.......
....|##|.......
....|##|.......
B---+--+---+--+
B###|##|###|##|
B---+--+---+--+
....|##|.......
....|##|.......
....|##|.......
....+--+.......

और इनपुट की पहली पंक्ति में Cपहले की स्थिति है +।

टेस्ट स्क्रिप्ट:

$f = {

($c="$args"|% i*f +)*($args[0].Length/2-.5-$c)*($args.Count-1-2*$c)

}

@(

,(1, ".++..",
     "+++++",
     "+++++",
     ".++..")

,(3,"...++....",
    "...||....",
    "...||....",
    "+--++--++",
    "+--++--++",
    "...||....",
    "...||....",
    "...++....")

,(12,"..+-+....",
     "..|#|....",
     "+-+-+-+-+",
     "|#|#|#|#|",
     "|#|#|#|#|",
     "+-+-+-+-+",
     "..|#|....",
     "..+-+....")

,(16,".+---+.....",
     "++---++---+",
     "||###||###|",
     "||###||###|",
     "||###||###|",
     "++---++---+",
     ".+---+.....")

,(16,"....++.....",
     "....||.....",
     "....||.....",
     "....||.....",
     "+---++---++",
     "|###||###||",
     "|###||###||",
     "|###||###||",
     "+---++---++",
     "....||.....",
     "....||.....",
     "....||.....",
     "....++.....")

,(18,"...+--+......",
     "...|##|......",
     "...|##|......",
     "+--+--+--+--+",
     "|##|##|##|##|",
     "+--+--+--+--+",
     "...|##|......",
     "...|##|......",
     "...+--+......")


,(24,"....+--+.......",
     "....|##|.......",
     "....|##|.......",
     "....|##|.......",
     "+---+--+---+--+",
     "|###|##|###|##|",
     "+---+--+---+--+",
     "....|##|.......",
     "....|##|.......",
     "....|##|.......",
     "....+--+.......")

,(120,"....+-----+..........",
      "....|#####|..........",
      "....|#####|..........",
      "....|#####|..........",
      "+---+-----+---+-----+",
      "|###|#####|###|#####|",
      "|###|#####|###|#####|",
      "|###|#####|###|#####|",
      "|###|#####|###|#####|",
      "+---+-----+---+-----+",
      "....|#####|..........",
      "....|#####|..........",
      "....|#####|..........",
      "....+-----+..........")

) | % {
    $expected,$s = $_
    $result = &$f @s
    "$($result-eq$expected): $result"
}

आउटपुट:

True: 1
True: 3
True: 12
True: 16
True: 16
True: 18
True: 24
True: 120

Answer 13

वोल्फ्राम भाषा (गणितज्ञ) , 64 बाइट्स

(2(x=#@"
")-(y=#@"|")-9)((9-5x+y)^2-9#@".")/54&@*CharacterCounts

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

की संख्या का उपयोग करता है ., |और \nइनपुट में पात्रों मात्रा के लिए हल करने के लिए। यह बेवकूफ लगता है क्योंकि इसके स्थान पर एक वास्तविक नई लाइन है \n।

यदि A, Bऔर C, पक्ष हैं, तो . = 2C(A+2C), | = 5B+4C-9और \n = B+2C, इसलिए हम ABCइन तीन वर्ण गणनाओं के संदर्भ में वॉल्यूम के लिए हल कर सकते हैं ।