रेगेक्स (ECMAScript 2018 या .NET), 140 126 118 100 98 82 बाइट्स
^(?!(^.*)(.+)(.*$)(?<!^\2|^\1(?=(|(<?(|(?!\8).)*(\8|\3$){1}){2})*$).*(.)+\3$)!?=*)
यह 98 बाइट संस्करण की तुलना में बहुत धीमा है, क्योंकि ^\1लुकहैड से बचा हुआ है और इसके बाद इसका मूल्यांकन किया जाता है। एक सरल स्विचरू के लिए नीचे देखें जो गति को पुन: प्राप्त करता है। लेकिन इसके कारण, नीचे दिए गए दो TIO पहले की तुलना में एक छोटे परीक्षण मामले को पूरा करने तक सीमित हैं, और .NET एक अपने स्वयं के regex की जांच करने के लिए बहुत धीमा है।
इसे ऑनलाइन आज़माएं! (ECMAScript 2018)
इसे ऑनलाइन आज़माएं! (.NET)
18 बाइट्स (118 → 100) को छोड़ने के लिए, मैंने बेशर्मी से नील के रेगेक्स से एक बहुत अच्छा अनुकूलन चुरा लिया है जो नकारात्मक लुकबाइंड के अंदर एक लुकहेड लगाने की आवश्यकता से बचाता है (80 बाइट अप्रतिबंधित रेगेक्स की उपज)। धन्यवाद, नील!
यह अप्रचलित हो गया जब यह एक अविश्वसनीय 16 और बाइट्स (98 → 82) को गिरा दिया, जो कि जयता के विचारों के लिए धन्यवाद था, जिसके कारण 69 बाइट अप्रतिबंधित रेगेक्स हो गए! यह बहुत धीमा है, लेकिन यह गोल्फ है!
ध्यान दें कि (|(रेगेक्स को अच्छी तरह से जोड़ने के लिए नो-ऑप्स का परिणाम है। यह बहुत धीमी गति से मूल्यांकन करता है। ईसीएमएस्क्रिप्ट में उनका यह प्रभाव नहीं है क्योंकि शून्य-चौड़ाई वैकल्पिक मैचों को गैर-मैचों के रूप में माना जाता है ।
ECMAScript मात्राओं पर प्रतिबंध लगाता है, इसलिए यह प्रतिबंधित-स्रोत आवश्यकताओं को और अधिक सख्त बनाता है। हालाँकि, इस बिंदु पर यह इतनी अच्छी तरह से गोल्फ है कि मुझे नहीं लगता कि उस विशेष प्रतिबंध को उठाने से कोई और गोल्फिंग संभावनाएं खुलेंगी।
अतिरिक्त वर्णों के बिना इसे प्रतिबंध ( 101 69 बाइट्स) पास करने की आवश्यकता है :
^(?!(.*)(.+)(.*$)(?<!^\2|^\1(?=((((?!\8).)*(\8|\3$)){2})*$).*(.)+\3))
यह धीमा है, लेकिन यह सरल संपादन (सिर्फ 2 अतिरिक्त बाइट के लिए) सभी खोई हुई गति और अधिक प्राप्त करता है:
^(?!(.*)(.+)(.*$)(?<!^\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)
)
)
मैंने इसे आणविक लुकहेड ( 103 69 बाइट्स) का उपयोग करके इसे चर-लंबाई के लुकअप में बदलने से पहले लिखा था:
^(?!.*(?*(.+)(.*$))(?!^\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}
)*$
)
)
और अपने रेगेक्स को अच्छी तरह से जोड़ने में सहायता करने के लिए, मैं उपरोक्त रेगेक्स की भिन्नता का उपयोग कर रहा हूं:
(?*(.+)(.*$))(?!^\1$|(?*(.)+.*\2$)((((?!\3).)*(\3|\2$)){2})*$)\1
जब इसका उपयोग किया जाता है regex -xml,rs -o, तो यह इनपुट के एक सख्त विकल्प की पहचान करता है जिसमें हर वर्ण की एक समान संख्या होती है (यदि कोई मौजूद है)। निश्चित रूप से, मैं ऐसा करने के लिए एक गैर-रेगेक्स कार्यक्रम लिख सकता था, लेकिन इसमें मज़ा कहाँ होगा?
या 
abcbca -> False।