Regex ที่ไม่มีวันจับคู่กับสิ่งใด ๆ

นี่อาจฟังดูเป็นคำถามโง่ ๆ แต่ฉันได้คุยกับเพื่อนนักพัฒนาบางคนเป็นเวลานานและฟังดูเหมือนเป็นเรื่องสนุกที่คิด

ดังนั้น; ความคิดของคุณเป็นอย่างไร - Regex มีลักษณะอย่างไรที่จะไม่จับคู่กับสตริงใด ๆ เลย!

แก้ไข : ทำไมฉันถึงต้องการสิ่งนี้? ประการแรกเพราะฉันคิดว่ามันน่าสนใจที่จะนึกถึงการแสดงออกเช่นนี้และประการที่สองเพราะฉันต้องการมันสำหรับสคริปต์

ในสคริปต์นั้นฉันกำหนดพจนานุกรมเป็น Dictionary<string, Regex>ในบทที่ผมกำหนดเป็นพจนานุกรมสิ่งนี้ประกอบด้วยสตริงและนิพจน์ตามที่คุณเห็น

จากพจนานุกรมนั้นฉันสร้างเมธอดที่ทุกคนใช้พจนานุกรมนี้เป็นเพียงข้อมูลอ้างอิงเกี่ยวกับวิธีการทำงานของพวกเขาหนึ่งในนั้นจะจับคู่นิพจน์ทั่วไปกับไฟล์บันทึกที่แยกวิเคราะห์

ถ้านิพจน์ตรงกับนิพจน์อื่น Dictionary<string, long>ถูกเพิ่มค่าที่นิพจน์ส่งกลับ ดังนั้นในการตรวจจับข้อความบันทึกใด ๆ ที่ไม่ตรงกับนิพจน์ในพจนานุกรมฉันจึงสร้างกลุ่มใหม่ชื่อ "ไม่ทราบ"

ในกลุ่มนี้ทุกสิ่งที่ไม่ตรงกับสิ่งอื่นจะถูกเพิ่มเข้ามา แต่เพื่อป้องกันการแสดงออกที่ไม่ตรงกัน (โดยไม่ได้ตั้งใจ) ในบันทึกข้อความฉันจึงต้องสร้างนิพจน์ที่แน่นอนที่สุดไม่เคยตรงกันไม่ว่าฉันจะให้สตริงใดก็ตาม

ดังนั้นคุณมีเหตุผลของฉันที่ "ไม่ใช่คำถามจริง" ...

นี่เป็นเรื่องง่ายมากแม้ว่าจะขึ้นอยู่กับการนำไปใช้งาน / แฟล็ก *:

$a

จะจับคู่อักขระaหลังสิ้นสุดสตริง โชคดี.

คำเตือน:
นิพจน์นี้มีราคาแพง - จะสแกนทั้งบรรทัดค้นหาจุดยึดท้ายบรรทัดจากนั้นจะไม่พบaและส่งคืนการจับคู่เชิงลบ (ดูความคิดเห็นด้านล่างสำหรับรายละเอียดเพิ่มเติม)

^*เดิมทีฉันไม่ได้คิดมากเกี่ยวกับ regexp โหมดหลายสายซึ่ง$ตรงกับจุดสิ้นสุดของบรรทัดด้วย ในความเป็นจริงมันจะจับคู่สตริงว่างก่อนขึ้นบรรทัดใหม่ดังนั้นอักขระธรรมดาอย่างaจะไม่ปรากฏหลังจาก$นั้น

เลเวอเรจnegative lookahead:

>>> import re
>>> x=r'(?!x)x'
>>> r=re.compile(x)
>>> r.match('')
>>> r.match('x')
>>> r.match('y')

RE นี้มีความขัดแย้งในแง่และดังนั้นจะไม่ตรงกับสิ่งใด

หมายเหตุ:
ใน Python re.match ()จะเพิ่มจุดยึดเริ่มต้นของสตริงโดยปริยาย ( \A) ไปยังจุดเริ่มต้นของนิพจน์ทั่วไป จุดยึดนี้มีความสำคัญต่อประสิทธิภาพ: หากไม่มีสิ่งนี้ระบบจะสแกนสตริงทั้งหมด ผู้ที่ไม่ได้ใช้ Python จะต้องการเพิ่มจุดยึดอย่างชัดเจน:

\A(?!x)x

สิ่งที่พลาด:

^\b$

ไม่สามารถจับคู่ได้เนื่องจากสตริงว่างไม่มีขอบเขตของคำ ทดสอบใน Python 2.5

มองไปรอบ ๆ:

(?=a)b

สำหรับมือใหม่ regex: การมองไปข้างหน้าในเชิงบวก(?=a)จะทำให้แน่ใจว่าอักขระถัดไปคือaแต่ไม่เปลี่ยนตำแหน่งการค้นหา (หรือรวม "a" ในสตริงที่ตรงกัน) ตอนนี้ตัวอักษรต่อไปคือการยืนยันที่จะเป็นaส่วนหนึ่งที่เหลืออยู่ของ regex (ที่b) bตรงกับเฉพาะถ้าตัวอักษรต่อไปคือ ดังนั้น regex นี้จะจับคู่เฉพาะในกรณีที่อักขระเป็นทั้งสองตัวaและbในเวลาเดียวกัน

a\bcซึ่ง\bคือการแสดงออกเป็นศูนย์ที่มีความกว้างที่ตรงกับขอบเขตของคำ

มันไม่สามารถปรากฏตรงกลางของคำซึ่งเราบังคับให้ใช้

$.

.^

$.^

(?!)

การจับคู่สูงสุด

a++a

อย่างน้อยหนึ่งaตามด้วยจำนวนเท่าใดก็ได้aโดยไม่มีการย้อนกลับ จากนั้นลองจับคู่อีกaครั้ง

หรือนิพจน์ย่อยอิสระ

นี้จะเทียบเท่ากับการวางในการแสดงออกย่อยอิสระตามมาด้วยอีกa+a

(?>a+)a

Perl 5.10 รองรับคำควบคุมพิเศษที่เรียกว่า "กริยา" ซึ่งอยู่ใน(*...)ลำดับ (เปรียบเทียบกับ(?...)ลำดับพิเศษ) ในนั้นรวมถึง(*FAIL)คำกริยาที่ส่งกลับจากนิพจน์ทั่วไปทันที

โปรดทราบว่าคำกริยาจะถูกนำไปใช้ใน PCRE หลังจากนั้นไม่นานดังนั้นคุณสามารถใช้คำกริยาใน PHP หรือภาษาอื่น ๆ โดยใช้ไลบรารี PCRE ได้เช่นกัน (คุณไม่สามารถใช้ Python หรือ Ruby ได้พวกเขาใช้เอนจิ้นของตัวเอง)

\B\b

\bจับคู่ขอบเขตคำ - ตำแหน่งระหว่างตัวอักษรกับตัวอักษรที่ไม่ใช่ตัวอักษร (หรือขอบเขตสตริง)
\Bเป็นส่วนเติมเต็ม - ตรงกับตำแหน่งระหว่างตัวอักษรสองตัวหรือระหว่างตัวอักษรที่ไม่ใช่

พวกเขาไม่สามารถจับคู่ตำแหน่งใด ๆ ร่วมกันได้

ดูสิ่งนี้ด้วย:

• ขอบเขตของคำ
• รูปแบบนี้ไม่ตรงกับบางตำแหน่ง
• แรงบันดาลใจ

ดูเหมือนว่าจะได้ผล:

$.

ประมาณ$^หรืออาจจะ(?!)? 

เร็วที่สุดคือ:

r = re.compile(r'a^')
r.match('whatever')

'a' สามารถเป็นอักขระที่ไม่ใช่อักขระพิเศษ ('x', 'y') การใช้งานของ Knio อาจจะบริสุทธิ์กว่าเล็กน้อย แต่อันนี้จะเร็วกว่าสำหรับสตริงทั้งหมดที่ไม่ได้ขึ้นต้นด้วยอักขระใด ๆ ที่คุณเลือกแทนที่จะเป็น 'a' เพราะจะไม่จับคู่หลังอักขระตัวแรกแทนที่จะเป็นตัวที่สองในกรณีเหล่านั้น

Python ไม่ยอมรับ แต่ Perl จะ:

perl -ne 'print if /(w\1w)/'

นิพจน์ทั่วไปนี้ (ในทางทฤษฎี) ควรพยายามจับคู่จำนวนws ที่ไม่มีที่สิ้นสุด (คู่) เนื่องจากกลุ่มแรกเกิด()ซ้ำในตัวเอง ดูเหมือนว่า Perl จะไม่ออกคำเตือนใด ๆ แม้ว่าจะอยู่ภายใต้use strict; use warnings;ก็ตามดังนั้นฉันถือว่ามันถูกต้องเป็นอย่างน้อยและการทดสอบ (ขั้นต่ำ) ของฉันไม่ตรงกับสิ่งใด ๆ ดังนั้นฉันจึงส่งคำเตือนไปให้คุณวิจารณ์

[^\d\D]หรือ(?=a)bหรือa$aหรือa^a

สิ่งนี้ใช้ไม่ได้กับ Python และภาษาอื่น ๆ อีกมากมาย แต่ใน Javascript regex []เป็นคลาสอักขระที่ถูกต้องซึ่งไม่สามารถจับคู่ได้ ดังนั้นสิ่งต่อไปนี้ควรล้มเหลวทันทีไม่ว่าอินพุตจะเป็นอย่างไร:

var noMatch = /^[]/;

ฉันชอบมันมากกว่า/$a/เพราะว่าสำหรับฉันมันสื่อถึงเจตนาของมันอย่างชัดเจน และสำหรับเวลาที่คุณต้องการฉันต้องการเพราะฉันต้องการทางเลือกสำหรับรูปแบบที่คอมไพล์แบบไดนามิกตามข้อมูลที่ผู้ใช้ป้อน เมื่อรูปแบบไม่ถูกต้องฉันต้องแทนที่ด้วยรูปแบบที่ไม่ตรงกับอะไร ตัวย่อมีลักษณะดังนี้:

try {
    var matchPattern = new RegExp(someUserInput);
}
catch (e) {
    matchPattern = noMatch;
}

ตัวอย่างทั้งหมดที่เกี่ยวข้องกับการจับคู่ขอบเขตเป็นไปตามสูตรเดียวกัน สูตรอาหาร:

1. ใช้ตัวจับคู่ขอบเขตใดก็ได้: ^, $, \ b, \ A, \ Z, \ z

2. ทำตรงข้ามกับสิ่งที่ตั้งใจไว้

ตัวอย่าง:

^ และ \ A มีไว้สำหรับการเริ่มต้นดังนั้นอย่าใช้ตั้งแต่ต้น

^ --> .^
\A --> .\A

\ b ตรงกับขอบเขตของคำดังนั้นให้ใช้ระหว่าง

\b --> .\b.

$, \ Z และ \ z มีไว้สำหรับการสิ้นสุดดังนั้นอย่าใช้ในตอนท้าย

$ --> $.
\Z --> \Z.
\z --> \z.

คนอื่น ๆ เกี่ยวข้องกับการใช้ lookahead และ lookbehind ซึ่งใช้ได้กับการเปรียบเทียบแบบเดียวกัน: ถ้าคุณให้ lookahead ในเชิงบวกหรือเชิงลบตามด้วยสิ่งที่ตรงกันข้าม

(?=x)[^x]
(?!x)x

หากคุณมองไปในทางบวกหรือลบตามหลังสิ่งที่ตรงกันข้าม

[^x](?<=x)
x(?<!x)

รูปแบบของพวกเขาอาจเป็นรูปแบบดังกล่าวมากกว่าและการเปรียบเทียบเช่นนั้นมากขึ้น

คำตอบที่ดีมากมาย!

คล้ายกับคำตอบของ @ nivk ฉันต้องการแบ่งปันการเปรียบเทียบประสิทธิภาพสำหรับ Perl สำหรับรูปแบบต่างๆของ regex ที่ไม่ตรงกัน

1. อินพุต: สตริง ascii สุ่มหลอก (ต่างกัน 25,000 บรรทัดความยาว 8-16):

ความเร็ว Regex:

Total for   \A(?!x)x: 69.675450 s, 1435225 lines/s
Total for       a\bc: 71.164469 s, 1405195 lines/s
Total for    (?>a+)a: 71.218324 s, 1404133 lines/s
Total for       a++a: 71.331362 s, 1401907 lines/s
Total for         $a: 72.567302 s, 1378031 lines/s
Total for     (?=a)b: 72.842308 s, 1372828 lines/s
Total for     (?!x)x: 72.948911 s, 1370822 lines/s
Total for       ^\b$: 79.417197 s, 1259173 lines/s
Total for         $.: 88.727839 s, 1127041 lines/s
Total for       (?!): 111.272815 s, 898692 lines/s
Total for         .^: 115.298849 s, 867311 lines/s
Total for    (*FAIL): 350.409864 s, 285380 lines/s

2. อินพุต: / usr / share / dict / words (100,000 คำในภาษาอังกฤษ)

ความเร็ว Regex:

Total for   \A(?!x)x: 128.336729 s, 1564805 lines/s
Total for     (?!x)x: 132.138544 s, 1519783 lines/s
Total for       a++a: 133.144501 s, 1508301 lines/s
Total for    (?>a+)a: 133.394062 s, 1505479 lines/s
Total for       a\bc: 134.643127 s, 1491513 lines/s
Total for     (?=a)b: 137.877110 s, 1456528 lines/s
Total for         $a: 152.215523 s, 1319326 lines/s
Total for       ^\b$: 153.727954 s, 1306346 lines/s
Total for         $.: 170.780654 s, 1175906 lines/s
Total for       (?!): 209.800379 s, 957205 lines/s
Total for         .^: 217.943800 s, 921439 lines/s
Total for    (*FAIL): 661.598302 s, 303540 lines/s

(Ubuntu บน Intel i5-3320M, Linux kernel 4.13, Perl 5.26)

ฉันเชื่ออย่างนั้น

\Z RE FAILS! \A

ครอบคลุมแม้กระทั่งกรณีที่นิพจน์ทั่วไปมีแฟล็กเช่น MULTILINE, DOTALL เป็นต้น

>>> import re
>>> x=re.compile(r"\Z RE FAILS! \A")
>>> x.match('')
>>> x.match(' RE FAILS! ')
>>>

ฉันเชื่อว่า (แต่ฉันยังไม่ได้เปรียบเทียบ) ว่าความยาว (> 0) ของสตริงระหว่าง\Zและ\Aเวลาใดควรจะคงที่

(*FAIL)

หรือ

(*F)

ด้วย PCRE และ PERL คุณสามารถใช้คำกริยาควบคุมการย้อนรอยที่บังคับให้รูปแบบล้มเหลวในทันที

หลังจากได้เห็นคำตอบที่ยอดเยี่ยมเหล่านี้ความคิดเห็นของ @ arantius (เกี่ยวกับเวลา$xเทียบx^กับ vs (?!x)x) ในคำตอบที่ยอมรับในปัจจุบันทำให้ฉันต้องการเวลาบางส่วนของคำตอบที่ให้ไว้

ด้วยการใช้มาตรฐาน 275k ของ @ arantius ฉันทำการทดสอบต่อไปนี้ใน Python (v3.5.2, IPython 6.2.1)

TL; DR: 'x^'และ'x\by'เร็วที่สุดโดยปัจจัยอย่างน้อย ~ 16 และตรงกันข้ามกับการค้นพบของ @ arantius (?!x)xอยู่ในกลุ่มที่ช้าที่สุด (ช้ากว่า ~ 37 เท่า) ดังนั้นคำถามเกี่ยวกับความเร็วจึงขึ้นอยู่กับการใช้งานอย่างแน่นอน ทดสอบด้วยตัวคุณเองในระบบที่คุณต้องการก่อนตัดสินใจว่าความเร็วมีความสำคัญสำหรับคุณหรือไม่

UPDATE:มีความแตกต่างที่เห็นได้ชัดขนาดใหญ่ระหว่างระยะเวลาและ'x^' 'a^'โปรดดูคำถามนี้สำหรับข้อมูลเพิ่มเติมและแก้ไขก่อนหน้านี้สำหรับการกำหนดเวลาช้าลงด้วยแทนax

In [1]: import re

In [2]: with open('/tmp/longfile.txt') as f:
   ...:     longfile = f.read()
   ...:     

In [3]: len(re.findall('\n',longfile))
Out[3]: 275000

In [4]: len(longfile)
Out[4]: 24733175

In [5]: for regex in ('x^','.^','$x','$.','$x^','$.^','$^','(?!x)x','(?!)','(?=x)y','(?=x)(?!x)',r'x\by',r'x\bx',r'^\b$'
    ...: ,r'\B\b',r'\ZNEVERMATCH\A',r'\Z\A'):
    ...:     print('-'*72)
    ...:     print(regex)
    ...:     %timeit re.search(regex,longfile)
    ...:     
------------------------------------------------------------------------
x^
6.98 ms ± 58.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
------------------------------------------------------------------------
.^
155 ms ± 960 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
------------------------------------------------------------------------
$x
111 ms ± 2.12 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
------------------------------------------------------------------------
$.
111 ms ± 1.76 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
------------------------------------------------------------------------
$x^
112 ms ± 1.14 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
------------------------------------------------------------------------
$.^
113 ms ± 1.44 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
------------------------------------------------------------------------
$^
111 ms ± 839 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
------------------------------------------------------------------------
(?!x)x
257 ms ± 5.03 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
------------------------------------------------------------------------
(?!)
203 ms ± 1.56 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
------------------------------------------------------------------------
(?=x)y
204 ms ± 4.84 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
------------------------------------------------------------------------
(?=x)(?!x)
210 ms ± 1.66 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
------------------------------------------------------------------------
x\by
7.41 ms ± 122 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
------------------------------------------------------------------------
x\bx
7.42 ms ± 110 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
------------------------------------------------------------------------
^\b$
108 ms ± 1.05 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
------------------------------------------------------------------------
\B\b
387 ms ± 5.77 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
------------------------------------------------------------------------
\ZNEVERMATCH\A
112 ms ± 1.52 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
------------------------------------------------------------------------
\Z\A
112 ms ± 1.38 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

ครั้งแรกที่ฉันเรียกใช้สิ่งนี้ฉันลืมที่จะraw 3 นิพจน์สุดท้ายดังนั้นจึง'\b'ถูกตีความว่าเป็น'\x08'อักขระ backspace อย่างไรก็ตามสิ่งที่ฉันประหลาดใจ'a\x08c'คือเร็วกว่าผลลัพธ์ที่เร็วที่สุดก่อนหน้านี้! เพื่อความเป็นธรรมมันจะยังคงตรงกับข้อความนั้น แต่ฉันคิดว่ามันยังน่าสังเกตเพราะฉันไม่แน่ใจว่าทำไมมันเร็วกว่า

In [6]: for regex in ('x\by','x\bx','^\b$','\B\b'):
    ...:     print('-'*72)
    ...:     print(regex, repr(regex))
    ...:     %timeit re.search(regex,longfile)
    ...:     print(re.search(regex,longfile))
    ...:     
------------------------------------------------------------------------
y 'x\x08y'
5.32 ms ± 46.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
None
------------------------------------------------------------------------
x 'x\x08x'
5.34 ms ± 66.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
None
------------------------------------------------------------------------
$ '^\x08$'
122 ms ± 1.05 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
None
------------------------------------------------------------------------
\ '\\B\x08'
300 ms ± 4.11 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
None

ไฟล์ทดสอบของฉันสร้างขึ้นโดยใช้สูตรสำหรับ"... เนื้อหาที่อ่านได้และไม่มีเส้นซ้ำ" (บน Ubuntu 16.04):

$ ruby -e 'a=STDIN.readlines;275000.times do;b=[];rand(20).times do; b << a[rand(a.size)].chomp end; puts b.join(" "); end' < /usr/share/dict/words > /tmp/longfile.txt

$ head -n5 /tmp/longfile.txt 
unavailable speedometer's garbling Zambia subcontracted fullbacks Belmont mantra's
pizzicatos carotids bitch Hernandez renovate leopard Knuth coarsen
Ramada flu occupies drippings peaces siroccos Bartók upside twiggier configurable perpetuates tapering pint paralyzed
vibraphone stoppered weirdest dispute clergy's getup perusal fork
nighties resurgence chafe

regex ว่างเปล่า

regex ที่ดีที่สุดที่จะไม่จับคู่อะไรเลยคือ regex ที่ว่างเปล่า แต่ฉันไม่แน่ใจว่าเอนจิ้น regex ทั้งหมดจะยอมรับสิ่งนั้น

regex ที่เป็นไปไม่ได้

อีกวิธีหนึ่งคือการสร้างนิพจน์ทั่วไปที่เป็นไปไม่ได้ ฉันพบว่า$-^ใช้เวลาเพียงสองขั้นตอนในการคำนวณโดยไม่คำนึงถึงขนาดของข้อความของคุณ ( https://regex101.com/r/yjcs1Z/1 )

สำหรับการอ้างอิง:

• $^และ$.ทำ 36 ขั้นตอนในการคำนวณ -> O (1)
• \b\B ใช้เวลา 1507 ขั้นตอนในตัวอย่างของฉันและเพิ่มขึ้นตามจำนวนอักขระในสตริงของคุณ -> O (n)

กระทู้ยอดนิยมเพิ่มเติมเกี่ยวกับคำถามนี้:

• Regex ถึง * not * ตรงกับอักขระใด ๆ

อาจจะเป็นแบบนี้?

/$.+^/

'[^0-9a-zA-Z...]*'

และแทนที่ ... ด้วยสัญลักษณ์ที่พิมพ์ได้ทั้งหมด;) สำหรับไฟล์ข้อความ

แล้วแทนที่จะใช้ regex ให้ใช้คำสั่ง if ที่เป็นเท็จเสมอ? ในจาวาสคริปต์:

var willAlwaysFalse=false;
if(willAlwaysFalse)
{
}
else
{
}

โซลูชันแบบพกพาที่ไม่ขึ้นอยู่กับการใช้งาน regexp คือเพียงใช้สตริงคงที่ซึ่งคุณมั่นใจว่าจะไม่ปรากฏในข้อความบันทึก ตัวอย่างเช่นสร้างสตริงตามสิ่งต่อไปนี้:

cat /dev/urandom | hexdump | head -20
0000000 5d5d 3607 40d8 d7ab ce72 aae1 4eb3 ae47
0000010 c5e2 b9e8 910d a2d9 2eb3 fdff 6301 c85f
0000020 35d4 c282 e439 33d8 1c73 ca78 1e4d a569
0000030 8aca eb3c cbe4 aff7 d079 ca38 8831 15a5
0000040 818b 323f 0b02 caec f17f 387b 3995 88da
0000050 7b02 c80b 2d42 8087 9758 f56f b71f 0053
0000060 1501 35c9 0965 2c6e 03fe 7c6d f0ca e547
0000070 aba0 d5b6 c1d9 9bb2 fcd1 5ec7 ee9d 9963
0000080 6f0a 2c91 39c2 3587 c060 faa7 4ea4 1efd
0000090 6738 1a4c 3037 ed28 f62f 20fa 3d57 3cc0
00000a0 34f0 4bc2 3067 a1f7 9a87 086b 2876 1072
00000b0 d9e1 6b8f 5432 a60e f0f5 00b5 d9ef ed6f
00000c0 4a85 70ee 5ec4 a378 7786 927f f126 2ec2
00000d0 18c5 46fe b167 1ae6 c87c 1497 48c9 3c09
00000e0 8d09 e945 13ce 7da2 08af 1a96 c24c c022
00000f0 b051 98b3 2bf5 4d7d 5ec4 e016 a50d 355b
0000100 0e89 d9dd b153 9f0e 9a42 a51f 2d46 2435
0000110 ef35 17c2 d2aa 3cc7 e2c3 e711 d229 f108
0000120 324e 5d6a 650a d151 bc55 963f 41d3 66ee
0000130 1d8c 1fb1 1137 29b2 abf7 3af7 51fe 3cf4

แน่นอนว่านี้ไม่ได้เป็นความท้าทายทางปัญญา แต่มากขึ้นเช่นการเขียนโปรแกรมเทปพันสายไฟ

new Regex(Guid.NewGuid().ToString())

สร้างรูปแบบที่มีเฉพาะตัวอักษรและตัวเลขคละกันและ ' -' (ไม่มีอักขระใดเป็นอักขระพิเศษ regex) แต่เป็นไปไม่ได้ทางสถิติที่สตริงเดียวกันจะปรากฏที่ใดก็ได้ก่อนหน้านี้ (เพราะนั่นคือจุดรวมของ GUID)