บทนำ

ในความท้าทายนี้คุณจะได้รับเป็นข้อมูลป้อนเข้าเป็นตัวแทน ASCII ของตาข่าย (พื้นผิวที่กางออก) ของสี่เหลี่ยมลูกบาศก์ (กล่อง 3D) รูปแบบคือ:

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

ใบหน้าของลูกบาศก์แต่ละหน้าเป็นรูปสี่เหลี่ยมผืนผ้า#ล้อมรอบด้วย+-|-characters ด้านนอกของตาข่ายเต็มไปด้วย.s ตาข่ายจะมีทิศทางเดียวกันเสมอ: มีใบหน้าตรงกลางล้อมรอบด้วยใบหน้าที่อยู่ใกล้เคียงสี่ใบหน้าและคู่หน้ากลางอยู่ที่เส้นขอบด้านขวาของอินพุต อินพุตนั้นถูกเติมด้วย.s ไปเป็นรูปสี่เหลี่ยมผืนผ้าและจะไม่มีแถวหรือคอลัมน์เพิ่มเติมของ.s

งาน

งานของคุณคือนำอินพุทไดอะแกรมดังกล่าวข้างต้นและคำนวณปริมาตรของลูกบาศก์ที่มันแทนซึ่งเป็นเพียงผลคูณของความสูงความกว้างและความลึก คุณสามารถรับอินพุตเป็นสตริงที่คั่นด้วยบรรทัดใหม่หรืออาร์เรย์ของสตริง

ความยาวของแต่ละขอบคือระยะห่างระหว่าง+-characters ที่ปลายทั้งสอง ตัวอย่างเช่นขอบแนวนอน+--+มีความยาว 3 และขอบแนวตั้ง

+
|
|
|
+

มีความยาว 4 ความยาวต่ำสุดของขอบคือ 1 ตัวอย่างลูกบาศก์ข้างบนมีปริมาตร 2 * 3 * 4 = 24

กฎและการให้คะแนน

คุณสามารถเขียนโปรแกรมเต็มรูปแบบหรือฟังก์ชั่นและชนะนับไบต์ต่ำสุด

กรณีทดสอบ

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

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

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

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

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

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

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

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

เรติน่า , 29 28 ไบต์

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

¶\|
$`
y

ลองออนไลน์!

มีหลายวิธีในการเข้าถึงสิ่งนี้ใน Retina ขึ้นอยู่กับพื้นที่ที่คุณต้องการคูณด้วยด้านใดดังนั้นฉันไม่แน่ใจว่าวิธีนี้เหมาะสมอย่างไร แต่จริงๆแล้วมันสั้นกว่าที่ฉันคิดไว้มาก

ขณะนี้ฉันมีโซลูชันอื่นสองตัวที่นับจำนวนไบต์เดียวกันซึ่งดูเหมือนว่าสามารถเล่นกอล์ฟได้มากกว่าวิธีข้างต้น:

\G\..+¶

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

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

แม้ว่าในสิ่งเหล่านี้ฉันสามารถบันทึกแต่ละไบต์ได้ถ้าฉันสมมติว่าอินพุตจบลงด้วยการป้อนบรรทัดต่อท้าย แต่ฉันไม่ต้องการพึ่งพาสิ่งนั้น

และอีกอันยังอยู่ที่ 28 ไบต์ (อันนี้คูณสามด้านจริง ๆ แทนที่จะคูณหนึ่งด้านข้าง)

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

คำอธิบาย

แนวคิดหลักคือการคูณพื้นที่ของใบหน้าด้านบนด้วยความยาวของด้านแนวตั้งที่สัมผัสกับเส้นขอบความยาวของอินพุต

ฉันจะใช้อินพุตต่อไปนี้เป็นตัวอย่าง (มีความยาวด้าน 2, 3 และ 4 ดังนั้นพื้นที่ 24):

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

ด่านที่ 1: ถอดเสียง

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

regex \G\..+¶จับคู่บรรทัดที่ขึ้นต้นด้วย.และอยู่ติดกับบรรทัดก่อนหน้าทันที ดังนั้นนี่จึงตรงกับทุกบรรทัดที่มีใบหน้าด้านบน สเตจจะกลาย.เป็นxและตัวละครอื่น ๆ ทั้งหมด|+-#เข้าyด้วยกัน สิ่งนี้ทำให้เราได้ผลลัพธ์ดังต่อไปนี้:

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

นี่มีหนึ่งคอลัมน์yมากกว่าที่เราต้องการเพื่อแสดงพื้นที่ของใบหน้าด้านบน เราแก้ไขสิ่งนี้ด้วยขั้นตอนต่อไป

ขั้นตอนที่ 2: แทนที่

xy

ดังนั้นเราจึงจับคู่ a yที่นำหน้าด้วยx(ซึ่งเป็นหนึ่งในนั้นต่อบรรทัด) และลบทั้งคู่ออกจากสตริง เราได้รับสิ่งนี้:

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

ดังนั้นตอนนี้เราได้มีพื้นที่ของใบหน้าด้านบนที่เป็นตัวแทนจากจำนวนของys

ด่าน 3: แทนที่

¶\|
$`

เป้าหมายของเราคือการคูณพื้นที่นี้Aด้วยความยาวด้านที่หายไปซึ่งคือจำนวน|ที่จุดเริ่มต้นของบรรทัดบวก 1 อย่างไรก็ตามจริงๆแล้วมันง่ายกว่าที่จะคูณด้วยตัวเลขn+1เพราะเรามีหนึ่งสำเนาAอยู่ในสตริงแล้ว . ถ้าเราเปลี่ยนnสิ่งที่มีAเราจบลงด้วยสำเนาของn+1 Aสิ่งนี้ทำให้เราง่ายขึ้นมาก

ดังนั้นเราจึงเปลี่ยนใหม่|ทันทีหลังจากป้อนบรรทัดด้วยทุกสิ่งที่อยู่ตรงหน้าการแข่งขัน mangles นี้สตริงค่อนข้างมากและทำให้มันค่อนข้างใหญ่กว่าที่เราต้องการ แต่จำนวนys กลายเป็นผลลัพธ์ที่เราต้องการ:

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

ด่าน 4: เข้าคู่

y

สิ่งที่เหลืออยู่คือการนับจำนวนys ซึ่งจะถูกพิมพ์เป็นตัวเลขทศนิยมในตอนท้าย

Python 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('|')

Bash + coreutils 83, 77 ไบต์

การแก้ไข:

• บันทึก 6 ไบต์โดยใช้ "Here String" และเพิ่มประสิทธิภาพ regexp เล็กน้อย

แข็งแรงเล่นกอล์ฟ

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 ผนวก)

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

ฟีดผลลัพธ์ที่แสดงออกถึงbc

=> 24

ทดสอบ

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

1

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

3

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

24

ลองออนไลน์! (ใช้ส่วนขยายเลขคณิตของ bash แทน bcเนื่องจากไม่มีส่วนหลัง)

หอยทาก , 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

JavaScript (ES6), 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>

ทับทิม, 44

ทำงานบนหลักการที่คล้ายกันกับคำตอบอื่น ๆ : หาคนแรก+ที่ค้นหาความลึกค้นหาถัดไป.หลังจาก+เพื่อค้นหาความกว้างและนับจำนวน|เมื่อสิ้นสุดบรรทัดและเพิ่ม 1 เพื่อค้นหาความสูง

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

ungolfed ในโปรแกรมทดสอบ

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.

05AB1E , 21 ไบต์

อนุญาตWและHเป็นความกว้างและความสูงของอินพุตตามลำดับ - ไม่ใช่กล่อง จากนั้นขนาดกล่องA, BและCปฏิบัติตามกฎเหล่านี้:

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

แสดงให้เห็นว่ารูปต่อไปนี้สิ่งที่A, BและCอยู่ในแง่ของชื่อขอบ:

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

ดังนั้นสูตรข้างต้น โปรแกรมนี้จะคำนวณA, ฉงนฉงายค่าของ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

Befunge 93 , 56 bytes

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

ลองออนไลน์!

คำอธิบาย:

ปริมาตรของกล่องสามารถคำนวณได้โดยการคูณจำนวน.s ในบรรทัดแรกก่อนอักขระอื่นใดด้วยจำนวน+และ-s ในบรรทัดแรก - 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

ฉันต้องย้าย IP อัพไลน์แทนการลงเพื่อใช้แนวดิ่งถ้าในบรรทัดที่ 3 หาก IP กำลังลงเส้นแนวตั้งถ้าจะบังคับให้ด้านบนของสแต็กเป็น 1 เมื่อกดปุ่มแนวนอนต่อไปนี้ถ้าส่งไปในทิศทางที่ผิด

Haskell, 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. Analogously จำนวน|ในแถวแรกสามารถนับเพื่อให้เป็นสามมิติ1 + length['|' | '|':_ <- r]d3

รายการความเข้าใจที่ 2 และ 3 สามารถย่อให้สั้นลง1+sum[1|'-'<-x]และ1+sum[1|'|':_<-r]สร้างรายการของสิ่งที่เกิดขึ้นในแต่ละ '-' หรือ '|' แล้วนำผลรวม เรายังสามารถใส่ด้านนอก1+เข้ามาในความเข้าใจของรายการโดยการผนวก-การxและ"|"การrให้ผลผลิตและsum[1|'-'<-'-':x] sum[1|'|':_<-"|":r]ตอนนี้เราสามารถรวม comprehensions รายการทั้งโดยการวางทั้งภาคในความเข้าใจเดียวกัน: sum[1|'|':_<-"|":r,'-'<-'-':x]ทำเลที่สะดวกสบายนี้คำนวณว่าสินค้าของสองมิติเพราะรายการFและความเข้าใจรายการต่อไปนี้เป็นผลิตภัณฑ์คาร์ทีเซียนGF 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คนที่จะสรุปแล้วขึ้นจะได้รับการปรับระดับเสียง

Java 8, 185 129 ไบต์

ขอบคุณ Zgarb สำหรับ -56 ไบต์

แข็งแรงเล่นกอล์ฟ:

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.

Java, 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

Powershell, 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

ภาษา Wolfram (Mathematica) , 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ในแง่ของการนับตัวละครทั้งสามนี้