রেজেক্স (ECMAScript 2018 বা .NET), 140 126 118 100 98 82 বাইট
^(?!(^.*)(.+)(.*$)(?<!^\2|^\1(?=(|(<?(|(?!\8).)*(\8|\3$){1}){2})*$).*(.)+\3$)!?=*)
এটি 98 বাইট সংস্করণের তুলনায় অনেক ধীর ^\1গতিযুক্ত , কারণ লুকোচূড়ার বামদিকে রয়েছে এবং এর পরে এটি মূল্যায়ন করা হয়। গতি আবার ফিরে আসে এমন একটি সাধারণ স্যুইচারুর জন্য নীচে দেখুন। তবে এর কারণে, নীচের দুটি টিআইও পূর্বের তুলনায় একটি ছোট পরীক্ষার সেটটি সীমাবদ্ধ করার জন্য সীমাবদ্ধ এবং নেট নেট তার নিজস্ব রেজেক্স পরীক্ষা করতে খুব ধীর।
এটি অনলাইন চেষ্টা করুন! (ECMAScript 2018)
এটি অনলাইনে ব্যবহার করে দেখুন! (.Net)
18 বাইট (118 → 100) নামার জন্য , আমি নির্লজ্জভাবে নীলের রেইগেক্স থেকে একটি দুর্দান্ত অপ্টিমাইজেশন চুরি করেছি যা নেতিবাচক লুকবিহিনের ভিতরে লুকআপের প্রয়োজনকে এড়িয়ে চলেছে (একটি 80 বাইট অব্যাহত রেজেক্স ফলন করেছে)। ধন্যবাদ, নীল!
জয়তেয়ার ধারণাগুলির জন্য এটি একটি অবিশ্বাস্য 16 টি বাইট (98 → 82) বাদ দিলে তা অপ্রচলিত হয়ে পড়েছিল যা 69 বাইটের সীমাহীন রেগেক্সের কারণ হতে পারে! এটি অনেক ধীর, তবে এটি গল্ফ!
দ্রষ্টব্য যে (|(রেজেক্সকে ভাল-সংযুক্ত করার জন্য কোনও বিকল্প নেই এটি নেট। এর অধীনে খুব ধীরে ধীরে মূল্যায়ন করার ফলাফল রয়েছে। ECMAScript এ এগুলির প্রভাব নেই কারণ শূন্য-প্রস্থের alচ্ছিক ম্যাচগুলিকে অ-মিল হিসাবে বিবেচনা করা হয় ।
ECMAScript দাবিতে কোয়ান্টিফায়ারগুলিকে নিষিদ্ধ করে, তাই এটি সীমাবদ্ধ-উত্সের প্রয়োজনীয়তাগুলি আরও শক্ত করে তোলে । যাইহোক, এই মুহুর্তে এটি এতটা সুসজ্জিত যে আমি মনে করি না যে এই বিশেষ সীমাবদ্ধতাটি হ্রাস করা আরও গল্ফিংয়ের সম্ভাবনা খুলে দেবে।
অতিরিক্ত অক্ষর ছাড়াই এটি বিধিনিষেধ ( 101 pass 69 বাইট) পাস করার জন্য প্রয়োজনীয় :
^(?!(.*)(.+)(.*$)(?<!^\2|^\1(?=((((?!\8).)*(\8|\3$)){2})*$).*(.)+\3))
এটি ধীর গতিযুক্ত, তবে এই সাধারণ সম্পাদনাটি (মাত্র ২ টি অতিরিক্ত বাইটের জন্য) সমস্ত হারিয়ে যাওয়া গতি এবং আরও অনেক কিছু ফিরে পায়:
^(?!(.*)(.+)(.*$)(?<!^\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।