Một hoạt động đôi khi tôi làm khi tôi chán là viết một vài ký tự theo cặp. Sau đó tôi vẽ các đường (trên đỉnh không bao giờ bên dưới) để kết nối các ký tự này. Ví dụ tôi có thể viết $abcbac$ và sau đó tôi sẽ vẽ các dòng như:

Hoặc tôi có thể viết $abbcac$

Khi tôi đã vẽ những đường này, tôi cố gắng vẽ các vòng khép kín xung quanh các đoạn để vòng lặp của tôi không cắt bất kỳ đường nào tôi vừa vẽ. Ví dụ, trong vòng đầu tiên, vòng lặp duy nhất chúng ta có thể vẽ là xung quanh toàn bộ, nhưng trong vòng thứ hai, chúng ta có thể vẽ một vòng lặp chỉ quanh $b$ s (hoặc mọi thứ khác)

Nếu chúng ta chơi xung quanh với điều này trong một thời gian, chúng ta sẽ thấy rằng một số chuỗi chỉ có thể được rút ra để các vòng khép kín chứa tất cả hoặc không có chữ cái nào (như ví dụ đầu tiên của chúng ta). Chúng tôi sẽ gọi các chuỗi như vậy chuỗi liên kết tốt.

Lưu ý rằng một số chuỗi có thể được rút ra theo nhiều cách. Ví dụ $bbbb$ có thể được rút ra theo cả hai cách sau (và không bao gồm một phần ba):

hoặc là

Nếu một trong những cách này có thể được vẽ sao cho một vòng khép kín có thể được thực hiện để chứa một số ký tự mà không giao nhau với bất kỳ dòng nào, thì chuỗi đó không được liên kết tốt. (vì vậy $bbbb$ không được liên kết tốt)

Bài tập

Nhiệm vụ của bạn là viết một chương trình để xác định các chuỗi được liên kết tốt. Đầu vào của bạn sẽ bao gồm một chuỗi trong đó mỗi ký tự xuất hiện một số lần chẵn và đầu ra của bạn phải là một trong hai giá trị nhất quán riêng biệt, một nếu các chuỗi được liên kết tốt và mặt khác.

Ngoài ra, chương trình của bạn phải có ý nghĩa chuỗi liên kết tốt

• Mỗi nhân vật xuất hiện một số lần chẵn trong chương trình của bạn.

• Nó sẽ tạo ra giá trị trung thực khi thông qua chính nó.

Chương trình của bạn sẽ có thể tạo đầu ra chính xác cho bất kỳ chuỗi nào bao gồm các ký tự từ ASCII có thể in hoặc chương trình của riêng bạn. Với mỗi nhân vật xuất hiện một số lần chẵn.

Câu trả lời sẽ được ghi điểm khi độ dài của chúng tính theo byte với ít byte hơn là điểm tốt hơn.

Dấu

Một chuỗi không được liên kết tốt nếu tồn tại một chuỗi con nghiêm ngặt không trống liên tục sao cho mỗi ký tự xuất hiện một số lần chẵn trong chuỗi con đó.

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

abcbac -> True
abbcac -> False
bbbb -> False
abacbc -> True
abcbabcb -> True
abcbca -> False

Regex (ECMAScript 2018 hoặc .NET), 140 126 118 100 98 82 byte

^(?!(^.*)(.+)(.*$)(?<!^\2|^\1(?=(|(<?(|(?!\8).)*(\8|\3$){1}){2})*$).*(.)+\3$)!?=*)

Điều này chậm hơn nhiều so với phiên bản 98 byte, bởi vì phần ^\1bên trái của giao diện và do đó được đánh giá sau nó. Xem bên dưới để biết một switcheroo đơn giản mà lấy lại tốc độ. Nhưng do điều này, hai TIO dưới đây bị giới hạn trong việc hoàn thành một trường hợp thử nghiệm nhỏ hơn trước và .NET là quá chậm để kiểm tra biểu thức chính của nó.

Hãy thử trực tuyến! (ECMAScript 2018)
Hãy thử trực tuyến! (.MẠNG LƯỚI)

Để giảm 18 byte (118 → 100), tôi đã lấy trộm một cách tối ưu hóa thực sự tốt từ regex của Neil để tránh sự cần thiết phải nhìn vào bên trong giao diện tiêu cực (mang lại một regex không giới hạn 80 byte). Cảm ơn, Neil!

Điều đó đã trở nên lỗi thời khi nó giảm thêm 16 byte đáng kinh ngạc (98 → 82) nhờ ý tưởng của jaytea dẫn đến một regex không giới hạn 69 byte! Nó chậm hơn nhiều, nhưng đó là golf!

Lưu ý rằng các (|(no-op để tạo regex được liên kết tốt có kết quả làm cho nó đánh giá rất chậm trong .NET. Chúng không có hiệu ứng này trong ECMAScript vì các đối sánh tùy chọn có độ rộng bằng không được coi là không khớp .

ECMAScript cấm các bộ định lượng trên các xác nhận, do đó, điều này làm cho việc đánh gôn trở thành nguồn bị hạn chế yêu cầu nên khó khăn hơn. Tuy nhiên, tại thời điểm này, nó được chơi golf tốt đến mức tôi không nghĩ việc dỡ bỏ hạn chế cụ thể đó sẽ mở ra bất kỳ khả năng chơi gôn nào nữa.

Không có các ký tự phụ cần thiết để vượt qua các hạn chế ( 101 69 byte):

^(?!(.*)(.+)(.*$)(?<!^\2|^\1(?=((((?!\8).)*(\8|\3$)){2})*$).*(.)+\3))

Tuy chậm, nhưng chỉnh sửa đơn giản này (chỉ cần thêm 2 byte) sẽ lấy lại tất cả tốc độ đã mất và hơn thế nữa:

^(?!(.*)(.+)(.*$)(?<!^\2|(?=\1((((?!\8).)*(\8|\3$)){2})*$)^\1.*(.)+\3))

^
(?!
    (.*)               # cycle through all starting points of substrings;
                       # \1 = part to exclude from the start
    (.+)               # cycle through all ending points of non-empty substrings;
                       # \2 = the substring
    (.*$)              # \3 = part to exclude from the end
    (?<!               # Assert that every character in the substring appears a total
                       # even number of times.
        ^\2            # Assert that our substring is not the whole string. We don't
                       # need a $ anchor because we were already at the end before
                       # entering this lookbehind.
    |                  # Note that the following steps are evaluated right to left,
                       # so please read them from bottom to top.
        ^\1            # Do not look further left than the start of our substring.
        (?=
            # Assert that the number of times the character \8 appears in our
            # substring is odd.
            (
                (
                    ((?!\8).)*
                    (\8|\3$) # This is the best part. Until the very last iteration
                             # of the loop outside the {2} loop, this alternation
                             # can only match \8, and once it reaches the end of the
                             # substring, it can match \3$ only once. This guarantees
                             # that it will match \8 an odd number of times, in matched
                             # pairs until finding one more at the end of the substring,
                             # which is paired with the \3$ instead of another \8.
                ){2}
            )*$
        )
        .*(.)+         # \8 = cycle through all characters in this substring
        # Assert (within this context) that at least one character appears an odd
        # number of times within our substring. (Outside this negative lookbehind,
        # that is equivalent to asserting that no character appears an odd number
        # of times in our substring.)
        \3             # Skip to our substring (do not look further right than its end)
    )
)

Tôi đã viết nó bằng cách sử dụng lookahead phân tử ( 103 69 byte) trước khi chuyển đổi nó thành lookbehind có độ dài thay đổi:

^(?!.*(?*(.+)(.*$))(?!^\1$|(?*(.)+.*\2$)((((?!\3).)*(\3|\2$)){2})*$))

^
(?!
    .*(?*(.+)(.*$))       # cycle through all non-empty substrings;
                          # \1 = the current substring;
                          # \2 = the part to exclude from the end
    (?!                   # Assert that no character in the substring appears a
                          # total even number of times.
        ^\1$              # Assert that our substring is not the whole string
                          # (i.e. it's a strict substring)
    |
        (?*(.)+.*\2$)    # \3 = Cycle through all characters that appear in this
                          # substring.
        # Assert (within this context) that this character appears an odd number
        # of times within our substring.
        (
            (
                ((?!\3).)*
                (\3|\2$)
            ){2}
        )*$
    )
)

Và để hỗ trợ làm cho regex của tôi được liên kết tốt, tôi đã sử dụng một biến thể của regex trên:

(?*(.+)(.*$))(?!^\1$|(?*(.)+.*\2$)((((?!\3).)*(\3|\2$)){2})*$)\1

Khi được sử dụng regex -xml,rs -o, điều này xác định một chuỗi con nghiêm ngặt của đầu vào có chứa số chẵn của mỗi ký tự (nếu tồn tại). Chắc chắn, tôi có thể đã viết một chương trình phi regex để làm điều này cho tôi, nhưng đâu sẽ là niềm vui trong đó?

Thạch, 20 byte

ĠẈḂẸẆṖÇ€Ạ
ĠẈḂẸ
ẆṖÇ€Ạ

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

Dòng đầu tiên được bỏ qua. Nó chỉ ở đó để thỏa mãn điều kiện mỗi nhân vật xuất hiện một số lần chẵn.

Các dòng tiếp theo đầu tiên Ġroups chỉ số bởi giá trị của họ. Sau đó, nếu chúng ta lấy độ dài của mỗi danh sách con trong danh sách kết quả ( Ẉ), chúng ta sẽ nhận được số lần mỗi ký tự xuất hiện. Để kiểm tra xem có bất kỳ số nào trong số này là số chẵn hay không, chúng tôi lấy số cuối cùng Ḃcủa mỗi số và hỏi xem có Ẹtồn tại giá trị trung thực (không khác không) không.

Do đó, liên kết trợ giúp này trả về việc một chuỗi con không thể được khoanh tròn.

Trong liên kết chính, chúng tôi lấy tất cả các chuỗi con của đầu vào ( Ẇ), Ṗtắt cái cuối cùng (để chúng tôi không kiểm tra xem toàn bộ chuỗi có thể được khoanh tròn không) và chạy liên kết trợ giúp ( Ç) trên €chuỗi con ach. Kết quả là liệu các Ạchuỗi con có thể được khoanh tròn hay không.

J , 34 byte

2:@':.,|~*'>1(#.,)*/@(1>2|#/.~)\.\

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

-8 byte nhờ FrownyFrog

nguyên

J , 42 byte

(*#'.,012&|@~#')=1#.[:,([:*/0=2&|@#/.~)\.\

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

giải trình

(*#'.,012&|@~#') = 1 #. [: , ([: */ 0 = 2&|@#/.~)\.\

(*#'.,012&|@~#')                                       NB. this evaluates to 1
                                                       NB. while supplying extra
                                                       NB. chars we need.  hence...
                 =                                     NB. does 1 equal...
                   1 #.                                NB. the sum of...
                        [: ,                           NB. the flatten of...
                             (                  )\.\   NB. the verb in parens applied
                                                       NB. to every suffix of every
                                                       NB. prefix, ie, all contiguous 
                                                       NB. substrings
                             ([: */ 0 = 2&|@#/.~)      NB. def of verb in paren:
                                             /.~       NB. when we group by each
                                                       NB. distinct char...
                              [: */                    NB. is it the case that
                                                       NB. every group...
                                           @#          NB. has a length...
                                    0 = 2&|            NB. divisible by 2...

Python 3.8 (tiền phát hành) , 66 byte

lambda l,b={id}:len({str(b:=b^{c})for(c)in l})<len(l)#,<^fmnost{}#

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

Thời đại của biểu thức chuyển nhượng là ở chúng ta. Với PEP 572 có trong Python 3.8, việc chơi golf sẽ không bao giờ giống nhau. Bạn có thể cài đặt bản xem trước dành cho nhà phát triển sớm 3.8.0a1 tại đây .

Biểu thức gán cho phép bạn sử dụng :=để gán cho một biến nội tuyến trong khi đánh giá giá trị đó. Ví dụ, (a:=2, a+1)cho (2, 3). Điều này tất nhiên có thể được sử dụng để lưu trữ các biến để tái sử dụng, nhưng ở đây chúng ta tiến thêm một bước và sử dụng nó như một công cụ tích lũy trong sự hiểu biết.

Ví dụ: mã này tính các khoản tiền tích lũy [1, 3, 6]

t=0
l=[1,2,3]
print([t:=t+x for x in l])

Lưu ý làm thế nào với mỗi lần vượt qua mức độ hiểu danh sách, tổng tích lũy tđược tăng lên xvà giá trị mới được lưu trữ trong danh sách được tạo ra bởi sự hiểu biết.

Tương tự, b:=b^{c}cập nhật tập hợp các ký tự bđể chuyển đổi xem nó có bao gồm ký tự chay không và đánh giá giá trị mới của b. Vì vậy, mã [b:=b^{c}for c in l]lặp lại các ký tự ctrong lvà tích lũy tập hợp các ký tự được thấy một số lần lẻ trong mỗi tiền tố không trống.

Danh sách này được kiểm tra các bản sao bằng cách làm cho nó trở thành một mức độ hiểu được thiết lập thay vào đó và xem liệu độ dài của nó có nhỏ hơn độ dài không s, điều đó có nghĩa là một số lần lặp lại đã bị thu gọn. Nếu vậy, việc lặp lại có nghĩa là trong phần sđược nhìn thấy ở giữa những khoảng thời gian đó, mỗi ký tự gặp phải một số chẵn, làm cho chuỗi không được liên kết tốt. Python không cho phép các tập hợp không thể thay đổi, vì vậy các bộ bên trong được chuyển đổi thành chuỗi.

Tập hợp bđược khởi tạo như một đối số tùy chọn và được sửa đổi thành công trong phạm vi hàm. Tôi đã lo lắng điều này sẽ làm cho chức năng không thể tái sử dụng, nhưng nó dường như thiết lập lại giữa các lần chạy.

Đối với hạn chế nguồn, các ký tự không ghép đôi được nhồi trong một nhận xét ở cuối. Viết for(c)in lthay vì for c in lhủy bỏ các parens thêm miễn phí. Chúng tôi đưa idvào bộ ban đầu b, vô hại vì nó có thể bắt đầu như bất kỳ bộ nào, nhưng bộ trống không thể được viết {}vì Python sẽ tạo một từ điển trống. Vì các chữ cái ivà dnằm trong số những người cần ghép nối, chúng ta có thể đặt hàm idở đó.

Lưu ý rằng mã đầu ra booleans phủ định, vì vậy nó sẽ tự cung cấp chính xác False.

Python 2 , 74 byte

bmn0=f=lambda s,P={0},d=[]:s<" "if(P in d)else+f(s[f<s:],P^{s[0^0]},[P]+d)

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

Lặp lại qua chuỗi, theo dõi Pcác bộ ký tự đã thấy một số lần lẻ cho đến nay. Danh sách dlưu trữ tất cả các giá trị trong quá khứ Pvà nếu thấy dòng điện Pđã có d, điều này có nghĩa là trong các ký tự được nhìn thấy kể từ thời điểm đó, mỗi ký tự đã xuất hiện một số lần chẵn. Nếu vậy, hãy kiểm tra xem chúng tôi đã trải qua toàn bộ đầu vào chưa: nếu có, hãy chấp nhận vì toàn bộ chuỗi được ghép nối như mong đợi và từ chối.

Bây giờ về hạn chế nguồn. Các nhân vật cần ghép đôi được nhét vào những nơi vô hại khác nhau, được gạch chân dưới đây:

bmn0=f=lambda s,P={0},d=[]:s<" "if(P in d)else+f(s[f<s:],P^{s[0^0]},[P]+d)
_____              _              _      _    _    ___        ___    

Các f<sđánh giá 0trong khi ghép nối một f, lợi dụng tên hàm cũng được fxác định (theo thời gian hàm được gọi.) 0^0Hấp thụ một ^ký hiệu.

Các 0trong P={0}là đáng tiếc: bằng Python {}kết quả là một dict trống chứ không phải là một tập rỗng như chúng ta muốn, và ở đây chúng ta có thể đưa vào bất kỳ yếu tố phi vật và nó sẽ là vô hại. Tôi không thấy bất cứ điều gì rảnh rỗi để đưa vào, và đã đưa vào 0và sao chép nó vào bmn0, tốn 2 byte. Lưu ý rằng các đối số ban đầu được đánh giá khi hàm được xác định, vì vậy các biến chúng ta tự xác định không thể được đặt ở đây.

Perl 6 , 76 byte

*.comb[^*X+(^*).map(^*)].grep({$_&[&]($_)}).none.Bag{*}.none%2#*^+XBob2rec%#

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

Bất cứ lambda nào trả về một Ngã ba Không có nút giao nào có thể được boolized thành giá trị trung thực / falsey. Tuy nhiên, tôi khuyên bạn không nên loại bỏ ?kết quả trả về kết quả trả về, nếu không đầu ra sẽ khá lớn .

Giải pháp này là một chút phức tạp hơn cần thiết, do một số chức năng có liên quan được bỏ liên kết, ví dụ như .., all, >>, %%vv Nếu không có những hạn chế nguồn, điều này có thể là 43 byte:

*.comb[^*X.. ^*].grep(?*).one.Bag{*}.all%%2

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

Giải trình:

*.comb                     # Split the string to a list of characters
      [^*X+(^*).map(^*)]   # Get all substrings, alongside some garbage
                        .grep({$_&[&]($_)})        # Filter out the garbage (empty lists, lists with Nil values)
                                           .none                 # Are none of
                                                .Bag{*}          # The count of characters in each substring
                                                       .none%2   # All not divisible by 2

                                               #*^+XBob2rec%#    And garbage to even out character counts

Perl 5 -p, 94, 86, 78 byte

m-.+(?{$Q|=@q&grp,$\|=$&eq$_^!grep+/^/&(@m=$g=~/\Q$_/g),($g=$&)=~/./g})(?!)-}{

ouput 0 nếu liên kết tốt 1 nếu không.

78 byte

86 byte

94 byte

Làm thế nào nó hoạt động

• -pvới }{thủ thuật kết thúc để xuất $\ở cuối
• m-.+(?{.. })(?!)-, để thực thi mã trên tất cả các chuỗi con không trống ( .+trước tiên khớp với toàn bộ chuỗi và sau khi thực thi mã giữa (?{.. })backtracks vì không bắt buộc(?!)
• $Q|=@q&grp, rác vì hạn chế nguồn
• $\|=số nguyên theo bit hoặc gán, nếu có gần 1, $\sẽ là 1 (đúng), theo mặc định, nó là rỗng (sai)
• $&eq$_trường hợp sbustring là toàn bộ chuỗi được x bit bit ^với "không có ký tự lẻ"
• ($g=$&)=~/./gđể sao chép chuỗi con phù hợp vào $g(vì sẽ bị quá tải sau trận đấu regex tiếp theo) và trả về mảng ký tự của chuỗi con.
• /^/ rác mà ước tính đến 1
• grep1 &(@m=$g=~/\Q$_/g),cho mỗi ký tự trong chuỗi con có được mảng ký tự $gkhớp với chính nó, mảng trong vô hướng ước lượng kích thước của nó và grepđể lọc các bộ điều khiển có sự xuất hiện kỳ ​​lạ 1&xtương đương vớix%2==1

Võng mạc , 150 96 byte

^(?!(.*)(.+)(.*)$(?<!^\2|^\1(?:(^?(?:(?!\6).)*\6){2})*(|(?!\6).)*(?!.+\6.*\3$)(.){1,}\3)(?!,<)?)

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm, bao gồm cả chính nó. Chỉnh sửa: Đánh xuống regex ban đầu một chút công bằng với sự trợ giúp từ @Deadcode, sau đó được sao lưu ít hơn một chút ngông cuồng để duy trì bố cục nguồn. Giải trình:

^(?!(.*)(.+)(.*)$

Khẳng định rằng không có chuỗi con \3nào tồn tại phù hợp với các ràng buộc sau.

(?<!^\2|

Khẳng định rằng chuỗi con không phải là toàn bộ chuỗi gốc.

^\1(?:(^?(?:(?!\6).)*\6){2})*(|(?!\6).)*(?!.+\6.*\3$)(.){1,}\3)(?!,<)?)

Khẳng định rằng không có ký tự nào \6như vậy:

• nó không xuất hiện giữa chính ký tự (độc quyền) và phần cuối của chuỗi con
• nó xuất hiện một số lần chẵn giữa thời điểm bắt đầu của chuỗi con và chính nó (độc quyền)

Để vượt qua ràng buộc bố cục nguồn, tôi đã thay thế ((((bằng (?:(^?(?:(và ((bằng (|(. Tôi vẫn có một nguồn hạn chế ))trái và các nhân vật !()1<{}còn sót lại, vì vậy tôi đã thay đổi một +thành {1,}và chèn vô dụng (?!,<)?để tiêu thụ phần còn lại.

C # (Trình biên dịch tương tác Visual C #) , 208 206 200 198 byte

x=>!x.GroupBy(c=>c).Any(g=>g.Count()%2>0)&!Enumerable.Repeat(x.Count,x.Count*x.Count).Where(
(l,i)=>i%l>0&!x.Skip(i/l).Take(i%l).GroupBy(c=>c).Any(g=>g.Count()%2>0)
).Any()/*>!oyAnC0EmeablR*WhiS/T*/

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

-2 byte nhờ @KevinCruijssen!

Cuối cùng cũng nhận được dưới 200, vì vậy bây giờ tôi có thể hoàn thành việc chơi golf :) Tôi đã kết thúc việc tạo ra một TIO thứ hai để kiểm tra mọi thứ dựa trên câu trả lời trước đó.

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

Những điều làm cho nhiệm vụ này khó khăn:

• Toán tử bình đẳng ==không được phép
• Toán tử tăng / gán ++không được phép
• All()Chức năng Linq không được phép

Mã nhận xét dưới đây:

// anonymous function that takes an IList as input
x=>
  // the first condition makes sure the string even
  // counts of each character
  !x.GroupBy(c=>c).Any(g=>g.Count()%2>0)&
  // the second condition generates all proper substrings of x
  // and tests for any that contain even character counts
  // the string length `l` is repeated `l*l` times
  !Enumerable.Repeat(x.Count,x.Count*x.Count)
    .Where((l,i)=>
      // check that the substring length is greater than 0
      i%l>0&
      // use skip/take to generate a substring
      // and check for a character count thats odd
      // negate the result meaning we have found
      // a substring that invalidates the input
      !x.Skip(i/l).Take(i%l)
        .GroupBy(c=>c).Any(g=>g.Count()%2>0)
    )
    // if any invalid substrings are found
    // then the result in invalid
    // the comment string at the end is needed
    // to make the program well-linked
    .Any()/*>!oyAnC0EmeablR*WhiS/T*/

Python 2 , 108 byte

lambda d,e=enumerate:min(max(d[l:l+b].count(k)%2for(k)in d)for b,c in e(d[2:],2)for l,f in e(d) )#b =:x+.%2#

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

-2 cảm ơn Ørjan Johansen .

Brachylog , 16 byte

sᶠb∋p~j&sᶠb∋p~j&

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

In false.cho các trường hợp trung thực và true.cho các trường hợp giả mạo . Phiên bản TIO quá chậm để tự xử lý, nhưng rõ ràng nó được liên kết tốt vì đây là một chuỗi với các ký tự duy nhất được lặp lại hai lần.

Giải trình

    Input is a string: "abcacbaa"
sᶠ  Find all substrings: ["abcacbaa","abcacba","abcacb",..,"a"]
b   Behead (now the proper substrings remain): ["abcacba","abcacb",..,"a"]
∋   Take one of them: "abcacb"
p   Permute it: "abcabc"
~j  It is some string repeated twice: "abc"
&   Get the input again: "abcacbaa"
    Then repeat the above.
    If the constraints can be satisfied, the result is true, otherwise false.

05AB1E , 22 20 byte

Œε¢Pà}KŒIKεSIS¢ÈP}àÈ

Đầu ra 1nếu chuỗi được liên kết tốt và 0nếu chuỗi không được liên kết tốt.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

Chương trình cơ sở là ŒsKεsS¢ÈP}à( 11 byte ), xuất ra 0nếu được liên kết tốt và 1nếu không được liên kết tốt. Dấu È(is_even) là một bán không đảo ngược đầu ra, vì vậy 1đối với các chuỗi được liên kết tốt và 0cho các chuỗi không được liên kết tốt. Các phần khác là không tuân thủ các quy tắc thách thức.

Œε¢Pà}K         # No-ops: substrings, map, count, product, maximum, close map, remove
                # Due to the last remove, we're back at the (implicit) input again
Π              # Take the substrings of the input
 IK             # Remove the input itself from that list of substrings
   ε            # Map each substring to:
    S           #  No-op: transform the substring into a list of characters
     IS         #  Get the input-string as a list of characters
       ¢        #  Count the occurrence of each character in the current substring
        È       #  Check which counts are even (1 if truthy; 0 if falsey)
         P      #  Take the product of that
          }à    # After the map: check if any are truthy by taking the maximum
            È   # Semi no-op: check if this maximum is even (0 becomes 1; 1 becomes 0)
                # (and output the result implicitly)