Tantangan Anda adalah membuat regex yang cocok dengan setiap permutasi string itu sendiri, dan tidak ada yang lain. Pertandingan juga harus peka terhadap huruf besar-kecil.

Jadi, misalnya, jika regex Anda adalah:

ABC

Itu harus cocok (dan hanya cocok) string ini:

ABC
ACB
BAC
BCA
CAB
CBA

Seharusnya tidak cocok dengan hal-hal seperti:

AABC (contains an extra A)
ABCD (contains an extra D)
AC   (no B)
AAA  (no B and C, extra 2 A's)
abc  (case-sensitive)

Aturan:

• Anda diizinkan menggunakan rasa regex yang Anda sukai.
• Celah standar berlaku.
• Anda harus memiliki setidaknya dua karakter berbeda dalam kode Anda. Itu berarti solusi seperti 1tidak valid.
• Regex harus hanya berisi ASCII yang dapat dicetak, dan tidak ada yang lain.

JavaScript, 64 57 byte

4 byte dihapus berkat Martin Ender.

^(?!.*([^])(.*\1){3}]?)[$$[-^?!!.'''-*11{33}5577\\-]{57}$

Coba di sini.

Penjelasan (kedaluwarsa)

^                                  # Beginning of the string.
(?!.*                              # Match only the strings that don't contain...
  (.)(.*\1){4}                     #     5 occurrences of the same character.
  [^1]?[^1]?                       #     Something that doesn't matter.
)
[]zzz^(?!!!.**[)\\1{{44}}666]{64}  # 64 occurrences of these 16 characters.
                                   # Some are duplicated to make sure the regex
                                   # contains 4 occurrences of each character.
\z                                 # End of the string.

Perl dan PCRE regex, 280 byte

^(?=(.*z){2})(?=(.*\(){43})(?=(.*\)){43})(?=(.*\*){22})(?=(.*\.){23})(?=(.*0){2})(?=(.*1){6})(?=(.*2){16})(?=(.*3){7})(?=(.*4){4})(?=(.*5){1})(?=(.*6){3})(?=(.*7){2})(?=(.*8){2})(?=(.*9){1})(?=(.*=){22})(?=(.*\?){22})(?=(.*\\){11})(?=(.*\^){2})(?=(.*\{){23})(?=(.*\}){23}).{280}\z

(Sedikit) lebih mudah dibaca:

^
(?=(.*z){2})
(?=(.*\(){43})
(?=(.*\)){43})
(?=(.*\*){22})
(?=(.*\.){23})
(?=(.*0){2})
(?=(.*1){6})
(?=(.*2){16})
(?=(.*3){7})
(?=(.*4){4})
(?=(.*5){1})
(?=(.*6){3})
(?=(.*7){2})
(?=(.*8){2})
(?=(.*9){1})
(?=(.*=){22})
(?=(.*\?){22})
(?=(.*\\){11})
(?=(.*\^){2})
(?=(.*\{){23})
(?=(.*\}){23})
.{280}\z

Ini berjalan dalam O (2 ^ n) waktu seperti yang ditulis, sehingga sangat tidak efisien. Cara termudah untuk mengujinya adalah mengganti setiap kemunculan.* dengan .*?, yang menyebabkan case yang cocok diperiksa terlebih dahulu (artinya cocok dengan waktu linier, tetapi masih membutuhkan waktu eksponensial jika gagal mencocokkan).

Ide dasarnya adalah bahwa kita menegakkan panjang regex menjadi sama dengan 280, dan menggunakan pernyataan lookahead untuk memaksa setiap karakter dalam regex untuk muncul setidaknya beberapa kali, misalnya (?=(.*z){2})memaksa zkarakter untuk tampil setidaknya dua kali. 2+43+43+22+23+2+6+16+7+4+1+3+2+2+1+22+22+11+2+23+23adalah 280, jadi kami tidak dapat memiliki "ekstra" kemunculan karakter apa pun.

Ini adalah contoh pemrograman autogram , sebuah kalimat yang menggambarkan dirinya dengan mencantumkan jumlah setiap karakter yang dikandungnya (dan, dalam hal ini, juga total panjang). Saya cukup beruntung dalam membangunnya (biasanya Anda harus menggunakan brute force tetapi saya menemukan solusi ini saat menguji program brute-force saya sebelum saya sepenuhnya selesai menulisnya).

Perl dan PCRE regex, 253 byte, bekerja sama dengan Martin Ender

Saya berhipotesis bahwa mungkin ada solusi yang lebih pendek yang menghilangkan beberapa digit (kemungkinan besar 9, 8, atau 7). Martin Ender menemukan satu, ditunjukkan di bawah:

^(?=(.*z){2})(?=(.*\(){39})(?=(.*\)){39})(?=(.*\*){20})(?=(.*\.){21})(?=(.*0){4})(?=(.*1){6})(?=(.*2){11})(?=(.*3){6})(?=(.*4){3})(?=(.*5){2})(?=(.*6){3})(?=(.*9){4})(?=(.*=){20})(?=(.*\?){20})(?=(.*\\){9})(?=(.*\^){2})(?=(.*{){21})(?=(.*}){21}).{253}\z

Versi yang dapat dibaca:

^
(? = (. * z) {2})
(? = (. * * () {39})
(? = (. * *)) {39})
(? = (. * * *) {20})
(? = (. * *.) {21})
(? = (. * 0) {4})
(? = (. * 1) {6})
(? = (. * 2) {11})
(? = (. * 3) {6})
(? = (. * 4) {3})
(? = (. * 5) {2})
(? = (. * 6) {3})
(? = (. * 9) {4})
(? = (. * *) {20})
(? = (. * *?) {20})
(? = (. * \\) {9})
(? = (. * * ^) {2})
(? = (. * *) {21})
(? = (. *}) {21})
. {253} \ z