Hôm nay là Purim, trong đó một tùy chỉnh là đưa ra các cookie hình tam giác với cách gọi là hamantaschen (số ít: hamantasch ). Một phong tục khác là uống nhiều rượu.

Tôi không phải là thợ làm bánh hoàn hảo nhất .... Tôi có rất nhiều hamantaschen có kích thước bất thường để đưa ra và rất nhiều bạn bè để tặng họ! Nếu tôi gửi cho bạn một hình ảnh của cookie của tôi, bạn có thể cho tôi biết tôi có bao nhiêu kích cỡ và điền? Nhưng vì đó là Purim và tôi quá say để đọc nhiều mã, nên nó cần phải là mã nhỏ như bạn có thể tạo.

Các định nghĩa

Kích thước

Một hamantasch có thể là bất kỳ kích thước . Hamantasch nhỏ nhất là cỡ 1 và trông như thế này:

/\  --
--  \/

Đôi khi, nhiều hamantaschen có thể chồng lên nhau . Hình dưới đây được tính là hai hamantaschen (một cỡ 1, một cỡ 2):

 /\
/\ \
----

Một số hamantaschen có điền . Điều này sẽ được chỉ định bằng cách điền vào tất cả các khoảng trắng bên trong bằng một ký tự. Lưu ý rằng kích thước 1 hamantaschen không thể có đầy.

Chúng tôi sẽ đặt tên hamantaschen dựa trên điền và kích thước. Chúng ta hãy sử dụng định dạng <filling> <size>và nếu không được lấp đầy, - <size>(bạn có thể sử dụng khoảng trắng thay vì -, nhưng đánh dấu không như vậy).

Đây là a . 2, a . 4và a - 3:

          /\
         /./\
 ----   /./  \
 \../  /./    \
  \/   --------

Đây là a @ 3, a . 2và a - 4:

          /\
         / /\
  /\    / /@@\
 /..\  / /@@@@\
 ----  --------

Đây là một cái gì đó khó khăn hơn. Xem làm thế nào & 2có ít điền hơn bạn mong đợi do nghiêng từ chồng chéo - 3? Nó có một - 1, & 2a - 3và a & 4:

--------
\   \/&/
 \  /\/
  \/&/
   \/

Đầu vào

Bạn sẽ được cung cấp một tệp văn bản hoặc một chuỗi hamantaschen (dòng mới theo dõi tùy chọn và khoảng trắng theo dõi được đệm tùy ý là chẵn).

Hạn mức

• Bạn có thể mong đợi chuỗi hợp lệ - nghĩa là, mọi ký tự không phải khoảng trắng đều đóng góp vào một hamantasch ngọt ngon (tại sao lại lãng phí bột?).
• Bạn cũng có thể mong đợi nó được điền đúng hay không - nghĩa là, mỗi hamantasch nó sẽ được điền đầy đủ với một ký tự ASCII nhất quán - ASCII 32 cho không được lấp đầy, hoặc bất cứ điều gì 32..127 cho điền (không bao gồm /, \và -).
• Những hamantaschen này không được xếp chồng lên nhau trong 3 không gian. Tất cả /và \sẽ được nhìn thấy. Tất cả -những gì không bị chặn bởi /và \sẽ được nhìn thấy. Làm đầy đến cuối cùng.
• Tất cả các hamantaschen sẽ có ít nhất một nửa đường ngang của chúng (làm tròn lên).
• Bất kỳ khối tiếp giáp nào chỉ lấp đầy hamantasch nhỏ nhất bao quanh nó.

Đầu ra

Trả về một danh sách "tên" của tất cả các hamantaschen có thể được tìm thấy đáp ứng các tiêu chí trên. Đầu ra có thể ở bất kỳ dạng nào bạn muốn (chuỗi, hàm băm, thiết bị xuất chuẩn, v.v.).

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

Trường hợp thử nghiệm số 1

Đầu vào số 1:

          /\
         / /\
  /\    / /@@\
 /..\  / /@@@@\
 ----  --------
    /\
   /**\
  /*/\*\
 /*/..\*\
 --------

Đầu ra # 1:

. 2
. 2
- 4
@ 3
* 4

Trường hợp thử nghiệm # 2

Đầu vào số 2:

  /\----
 /\/\*\/
/ /\d\/
------

Đầu ra # 2:

- 3
- 2
d 2
- 1    
* 2
- 1

Bài kiểm tra số 3

Đầu vào số 3:

----
\/\/
/\/\  /\
---- /::\
     ----

Đầu ra # 3:

- 1
- 1
- 2
- 1
- 1
- 2
: 2

Bài kiểm tra số 4

Đầu vào số 4:

 /\/\
/ /\$\
-/--/\\
 --/--\
  /xxx/\
 /xxx/##\
 ---/----\
   /      \
   -------- 

Đầu ra số 4:

$ 2
x 4
- 3
- 2
- 4
- 1
- 1
# 2

Trường hợp kiểm tra không hợp lệ # 5

Đầu vào:

/\
\/

Đầu ra:

Bạn không cần phải xử lý việc này.

C #, 496 452 byte

Chỉnh sửa: tìm thấy một lỗi với giới hạn kiểm tra ... nhưng cũng làm mất một tải byte đã bị buộc phải hiểu mã của riêng tôi. Việc hủy chức năng cục bộ đã giúp một chút và loại bỏ mã cụ thể C # 7. Câu hỏi này đã được rất nhiều niềm vui.

using C=System.Console;class P{static void Main(){string D="",L;int W=0,H=0,z=0,d,q,c,j,b;for(;(L=C.ReadLine())!=null;H+=W=L.Length)D+=L;var B=new int[H];for(d=W;(d=-d)>0||++z<H*H;)for(c=1,q=z%H;c<=z/H&q%W+c<W&q>=d&q<H+d&&D[q]==(d>0?92:47)&D[j=q+c]==(d<0?92:47);q-=d+1,c+=2){for(b=0;j>q;)b+=D[--j-d]==45?2:0;for(char h='-',e;c==z/H&b>c;C.WriteLine(h+" "+c/2))for(b=c++;b>1;j=q+=d+1,b-=2)for(;j<q+b;)B[j]=h=B[j]<1&h==45&(e=D[j++])!=47&e!=92&e>32?e:h;}}}

Dùng thử trực tuyến

Hoàn thành chương trình, dự kiến ​​đầu vào đệm không gian để tiêu chuẩn vào, đầu ra thành tiêu chuẩn. Đầu ra là một mục nhập trên mỗi dòng, với nguồn cấp dữ liệu theo dõi. Cookies được xuất ra theo thứ tự tăng kích thước, phía trên bên trái đầu tiên. Tôi đã mất một thời gian để hiểu các quy tắc, nhưng tôi nghĩ rằng nó vượt qua tất cả các ví dụ được cung cấp.

Nó hoạt động bằng cách liên tục tìm kiếm toàn bộ lưới cho Hamantaschen hợp lệ, tăng kích thước 'được phép'. Đối với mỗi ô, nó kiểm tra lên và xuống, theo sau \và /ở hai bên càng xa càng tốt. Nếu nó thông báo rằng hàng tiếp theo có rất nhiều -và kích thước hiện tại là kích thước 'được phép', thì nó sẽ xác định điền và in ra mục.

Việc lấp đầy được tìm thấy bằng cách khám phá toàn bộ không gian của cookie, tìm kiếm một ô 'không sử dụng'. Khi tìm thấy một ô không sử dụng, nó được đánh dấu là đã sử dụng (vì chúng tôi tăng kích thước cho phép, chúng tôi biết rằng chúng tôi là cookie nhỏ nhất chứa nó) và chúng tôi ghi lại việc điền.

Mã định dạng và nhận xét:

using C=System.Console;

class P
{
    static void Main()
    {
        //   32
        // - 45
        // / 47
        // \ 92
        // range 32..127 (no mod for you)

        string D="", // the whole map
            L; // initally each line of the map, later each line of output

        int W=0, // width
            H=0, // length (width * height)
            z=0, // search tracker
            d, // check direction (this is backwards (1 byte saving!))
            q, // check tracker
            c, // counter (truely, this is the distance from the right to the left)
            //M, // c max (now inlined as z/H)
            j, // horiontal tracker
            b; // - count, and reverse counter

        // read map and width
        for(;(L=C.ReadLine())!=null; // read a line, while we can
                H+=W=L.Length) // record the width, and increment height
            D+=L; // add the line to the map

        var B=new int[H]; // whether this filling has been used already (0 -> false, >0 -> true)

        for(d=W; // init direction
            (d=-d)>0|| // swap direction, else increment z (this allows us to run the check for the same z twice with opposite direction)
            ++z<H*H; // for all M, for all q (z<H -> M=z/H=0 -> no valid cookies, so we can safetly skip them)
            )
            for(//M=z/H, // c allow (now inlined)
                c=1, // reset counter
                q=z%H; // note position
                c<=z/H& // counter check
                // no need for a left check: if we run off the left end, then the right check will necessarily fail
                q%W+c<W& // right check
                q>=d& // high check
                q<H+d&& // low check (short-circuit lookups)
                D[q]==(d>0?92:47)&D[j=q+c]==(d<0?92:47); // /\ or \/ check, and set j=q+c
                    q-=d+1, // move left tracker
                    c+=2) // increase counter (move right tracker)
            {
                // count the number of '-' into b
                for(b=0; // zero b
                    j>q; // for each element in the row below
                        ) // empty
                    b+=D[--j-d]==45?2:0; // add 2 to b if we tap a '-'

                // j = q

                // check valid before looking up cHaracter (so we don't mark unused stuff as taken)
                // if we are at the current max count, and we have enough -, then we are valid and should be commited
                for( // this runs either one or zero times, we only have a for here (rather than an if) so we can ditch a pair of braces
                    char h='-', // default filling
                         e; // filling we are considering
                    c==z/H&b>c;
                        C.WriteLine(h+" "+c/2)) // print filling and count
                    // continuously compute character
                    for(b=c++; // count b backwards, starting from c (add 1 to c so we can /2 in print)
                        b>1;j=q+=d+1,b-=2) // count q backwards toward z%H (where q came from), and b backwards toward 1 (for each row)
                        for(;j<q+b;) // for each cell in row
                            B[j]= // mark cell as taken (h,e > 0)
                            h= // record filling
                                B[j]<1& // check cell not already used
                                h==45& // '-'
                                (e=D[j++])!=47& // '/'
                                e!=92& // '\'
                                e>32 // ' '
                                ?e:h; // take first filling we can
                    // c runs out after this (exists both loops), so no need to action
            }
    }
}

Đầu ra cho 4 trường hợp thử nghiệm:

testcase #1
. 2
. 2
@ 3
- 4
* 4

testcase #2
- 1
- 1
- 2
d 2
* 2
- 3

testcase #3
- 1
- 1
- 1
- 1
- 2
- 2
: 2

testcase #4
- 1
- 1
- 2
$ 2
# 2
- 3
x 4
- 4