Giới thiệu

Trong thử thách này, bạn được đưa ra làm đầu vào biểu diễn ASCII của mạng (bề mặt chưa mở) của một hình khối hình chữ nhật (hộp 3D). Định dạng này là:

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

Mỗi mặt của hình khối là một hình chữ nhật #được bao quanh bởi các +-|ký tự. Bên ngoài của mạng được lấp đầy với .s. Mạng sẽ luôn có cùng một hướng: có một mặt giữa được bao quanh bởi bốn mặt lân cận và mặt đối diện của mặt giữa nằm ở viền bên phải của đầu vào. Đầu vào được đệm với .s thành hình chữ nhật và sẽ không chứa thêm hàng hoặc cột của .s.

Nhiệm vụ

Nhiệm vụ của bạn là lấy một sơ đồ như trên và tính toán thể tích của hình khối mà nó đại diện, chỉ là sản phẩm của chiều cao, chiều rộng và chiều sâu của nó. Bạn có thể lấy đầu vào là một chuỗi được phân tách bằng dòng mới hoặc một chuỗi các chuỗi.

Độ dài của mỗi cạnh là khoảng cách giữa các +ký tự ở hai đầu của nó. Ví dụ: cạnh ngang +--+có chiều dài 3 và cạnh dọc

+
|
|
|
+

có chiều dài 4. Độ dài tối thiểu của một cạnh là 1. Ví dụ hình khối ở trên có thể tích 2 * 3 * 4 = 24.

Quy tắc và tính điểm

Bạn có thể viết một chương trình đầy đủ hoặc một hàm và số byte thấp nhất sẽ thắng.

Các trường hợp thử nghiệm

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

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

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

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

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

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

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

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

Võng mạc , 29 28 byte

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

¶\|
$`
y

Hãy thử trực tuyến!

Có rất nhiều cách để tiếp cận điều này ở Retina, tùy thuộc vào khu vực bạn muốn nhân với bên nào, vì vậy tôi không chắc điều này tối ưu đến mức nào, nhưng thực tế nó đã ngắn hơn rất nhiều so với tôi nghĩ.

Hiện tại tôi đã có hai giải pháp khác với cùng số byte có vẻ dễ chơi hơn một chút so với phương pháp trên:

\G\..+¶

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

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

Mặc dù trong những điều này tôi có thể lưu từng byte nếu tôi cho rằng đầu vào kết thúc bằng một dòng cấp dữ liệu, nhưng tôi không phải phụ thuộc vào điều đó.

Và một số khác, vẫn ở mức 28 byte (cái này thực sự nhân ba cạnh thay vì nhân một khu vực với một bên):

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

Giải trình

Ý tưởng chính là nhân diện tích của mặt trên cùng với chiều dài của cạnh dọc chạm vào đường viền dài của đầu vào.

Tôi sẽ sử dụng đầu vào sau đây làm ví dụ (nó có độ dài cạnh 2, 3 và 4, vì vậy diện tích là 24):

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

Giai đoạn 1: Chuyển ngữ

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

Regex \G\..+¶khớp với một dòng bắt đầu bằng .và ngay lập tức liền kề với dòng trước đó. Vì vậy, điều này phù hợp với tất cả các dòng có chứa mặt trên. Sân khấu tự biến .thành xvà tất cả các nhân vật khác (bất kỳ |+-#) vào y. Điều này cho chúng ta kết quả như sau:

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

Điều này có thêm một cột yhơn chúng ta cần biểu thị diện tích của mặt trên. Chúng tôi sửa lỗi này với giai đoạn tiếp theo.

Giai đoạn 2: Thay thế

xy

Vì vậy, chúng tôi khớp với một ycái đứng trước một x(chính xác là một trong số chúng trên mỗi dòng) và loại bỏ cả hai khỏi chuỗi. Chúng tôi nhận được điều này:

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

Vì vậy, bây giờ chúng ta đã có diện tích của mặt trên được biểu thị bằng số ys.

Giai đoạn 3: Thay thế

¶\|
$`

Mục tiêu của chúng tôi ở đây là nhân số diện tích này Avới độ dài cạnh bị thiếu, đó là số |ở đầu dòng cộng 1. Tuy nhiên, thực sự dễ dàng hơn để nhân với một số n+1vì chúng tôi đã có một bản sao của Achuỗi . Nếu chúng ta thay thế nmọi thứ bằng A, chúng ta sẽ có n+1bản sao của A. Điều này làm cho mọi thứ dễ dàng hơn nhiều đối với chúng tôi.

Vì vậy, chúng tôi chỉ cần thay thế bất kỳ |ngay lập tức sau khi linefeed bằng mọi thứ ở phía trước trận đấu. Điều này xâu chuỗi khá nhiều và làm cho nó lớn hơn một chút so với chúng ta cần, nhưng số lượng ykết thúc là kết quả mà chúng ta đang tìm kiếm:

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

Giai đoạn 4: Trận đấu

y

Tất cả những gì còn lại là để đếm số ys, được in dưới dạng số thập phân ở cuối.

Python 2, 57 byte

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

Một hàm có trong một danh sách các chuỗi.

Xác định 3 chiều riêng biệt:

l[0].find('+')
Chỉ số của hàng đầu tiên +trong hàng đầu tiên.

-~l[0].count('-')
Số lượng các -dấu hiệu trong hàng đầu tiên.

~`l`.count("'|")
Số lượng hàng bắt đầu bằng |ký hiệu, thông qua biểu diễn chuỗi của danh sách có ký hiệu trích dẫn trước nó.

62 byte:

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

Một hàm lấy trong danh sách các chuỗi và in kết quả.

Tìm một chiều alàm chỉ số của +hàng đầu tiên. Hai kích thước khác được suy ra từ nó và chiều rộng và chiều cao của hình chữ nhật đầu vào.

Một thay thế 63 byte, tìm các kích thước riêng biệt:

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

Bash + lõi, 83, 77 byte

CHỈNH SỬA:

• Đã lưu 6 byte, bằng cách sử dụng "Here String" và tối ưu hóa regrec một chút

Chơi gôn

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

Giải thích

Biến đổi với sed :

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

Loại bỏ các dòng mới bằng cách sử dụng backticks, chắp thêm)

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

Thức ăn kết quả biểu hiện cho bc

=> 24

Kiểm tra

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

1

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

3

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

24

Hãy thử trực tuyến! (sử dụng mở rộng số học bash, thay vì bc , vì cái sau không có sẵn)

Ốc , 19 byte

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

_{Hãy thử trực tuyến.}

Ý tưởng là chúng ta bắt đầu ở đâu đó trên rìa ngoài cùng bên phải của mạng, và sau đó đi đến một nơi nào đó trong khuôn mặt quan trọng nhất. Chiều dài của cạnh và diện tích của khuôn mặt được nhân với cơ chế đếm tất cả các đường dẫn khớp.

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)

Kiểm tra

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>

Hồng ngọc, 44

Hoạt động theo nguyên tắc tương tự với các câu trả lời khác: tìm cái đầu tiên +để tìm độ sâu, tìm cái tiếp theo .sau +để tìm chiều rộng và đếm số lượng |ở cuối dòng và thêm 1 để tìm chiều cao.

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

vô dụng trong chương trình thử nghiệm

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 byte

Đặt Wvà Htương ứng là chiều rộng và chiều cao của đầu vào - không phải là hộp. Sau đó, kích thước hộp A, Bvà Clàm theo các quy tắc:

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

Hình dưới đây cho thấy những gì A, Bvà C, về mặt tên cạnh:

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

Do đó các công thức trên. Chương trình này sẽ tính toán A, suy luận các giá trị của Bvà Cvà cuối cùng là tính sản phẩm của họ.

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

Hãy thử trực tuyến!

Phiên bản cũ - Cách tiếp cận khác - 26 byte

|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 byte

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

Hãy thử trực tuyến!

Giải trình:

Âm lượng của hộp có thể được tính bằng cách nhân số .s trên dòng đầu tiên trước bất kỳ ký tự nào khác, với số lượng +và -s trên dòng đầu tiên - 1 và số dòng bắt đầu bằng |+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

Tôi đã phải di chuyển các dòng IP lên thay vì xuống để sử dụng dọc nếu ở dòng thứ 3. Nếu IP đang đi xuống, đường thẳng đứng nếu sẽ buộc đỉnh của ngăn xếp là 1 khi nhấn theo chiều ngang sau, nếu gửi sai hướng.

Haskell, 64 56 byte

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

Hãy thử trực tuyến!

Giải trình

Đầu vào dự kiến ​​là một danh sách các chuỗi cho mỗi dòng, vì vậy trong ftham số xlà dòng đầu tiên và rdanh sách các dòng còn lại.

1. fst(span(>'+')x)trả về .-prefix của dòng đầu tiên dưới dạng chuỗi, vì vậy length(fst(span(>'+')x))là thứ nguyên đầu tiên d1.
2. Một sự hiểu biết danh sách có thể đóng vai trò là bộ lọc, ví dụ ['-' | '-' <- x]trả về một chuỗi tất cả -trong dòng đầu tiên, do đó 1 + length['-' | '-' <- x]mang lại kích thước thứ hai d2.
3. Tương tự, số lượng |trong hàng đầu tiên có thể được tính, 1 + length['|' | '|':_ <- r]chiều thứ ba cũng vậy d3.

Việc hiểu danh sách của 2. và 3. có thể được rút ngắn 1+sum[1|'-'<-x]và 1+sum[1|'|':_<-r]bằng cách xây dựng một danh sách những cái cho mỗi lần xuất hiện của '-' hoặc '|' và sau đó lấy tổng. Chúng tôi cũng có thể đặt bên ngoài 1+vào danh sách hiểu bằng cách phụ thêm -để xvà "|"để rđến năng suất sum[1|'-'<-'-':x]và sum[1|'|':_<-"|":r]. Bây giờ chúng ta có thể kết hợp cả hai cách hiểu danh sách bằng cách đặt cả hai vị từ vào cùng một mức độ hiểu: sum[1|'|':_<-"|":r,'-'<-'-':x]Thuận tiện điều này tính toán chính xác sản phẩm của hai chiều bởi vì đối với danh sách Fvà Gcách hiểu danh sách sau đây là sản phẩm của Cartesian F x G =[(a,b)|a<-F,b<-G].

Cuối cùng, thay vì nhân 1. với sự kết hợp của 2. và 3. chúng ta có thể sử dụng >>toán tử trong danh sách: F>>Glặp lại G length Fthời gian và nối kết quả. Vì vậy, fst(span(>'+')x)>>[1|'|':_<-"|":r,'-'<-'-':x]lặp lại danh sách d2*d3những d1lần, đưa ra một danh sách d1*d2*d3những lần sau đó được tổng hợp để có được âm lượng.

Java 8, 185 129 byte

cảm ơn Zgarb cho -56 byte

đánh gôn

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;}

vô dụng:

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;
}

Giải trình

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

trong đó avà blà kích thước của cơ sở và hlà chiều cao. Bạn có thể tìm thấy hbằng cách đếm các hdòng đầu tiên nơi bạn bắt đầu bằng a ..

Java, 112 byte

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);}

Mở rộng:

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 byte

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

Lưu ý: "$args"|% i*f + là phím tắt cho"$args".indexOf('+')

Giải trình

Giải thích tốt lấy từ câu trả lời của Osable :

Đặt Wvà Htương ứng là chiều rộng và chiều cao của đầu vào - không phải là hộp. Sau đó, kích thước hộp A, Bvà Clàm theo các quy tắc:

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

Hình dưới đây cho thấy những gì A, Bvà C, về mặt tên cạnh:

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

Và Clà vị trí của đầu tiên +trong dòng đầu tiên của đầu vào.

Kịch bản thử nghiệm:

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

Đầu ra:

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

Ngôn ngữ Wolfram (Mathicala) , 64 byte

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

Hãy thử trực tuyến!

Sử dụng số lượng ., |và \ncác nhân vật trong các đầu vào để giải quyết cho âm lượng. Có vẻ ngu ngốc vì có một dòng mới thực sự thay thế \n.

Nếu A, Bvà Clà các cạnh, thì . = 2C(A+2C), | = 5B+4C-9và \n = B+2C, vì vậy chúng ta có thể giải cho âm lượng ABCtheo ba số ký tự này.