La tua missione è scrivere l'espressione regolare valida più breve che nessuna stringa può eguagliare, stringa vuota inclusa.

Le presentazioni devono avere questo modulo ("notazione letterale"):

/pattern/optional-flags

Vince regexp più breve. La dimensione di regexp è contata in caratteri. (compresi barre e flag)

Spiega come funziona il tuo regexp (se non è banale)

Grazie e buon divertimento!

6 caratteri

Seguendo le risposte di primo e Peter Taylor, e un suggerimento da man perlre:

/(?!)/

Questa regex compatibile perl corrisponde a una stringa vuota che non è seguita da un'altra stringa vuota.

8 caratteri

/(?=a)b/

Abbiamo bisogno di una stringa contenente un carattere che sia entrambi ae b, che è ovviamente impossibile.

5 caratteri

A differenza di tutti coloro che abusano $e ^... questo in realtà funziona in Perl:

/V\A/

\A corrisponde all'inizio della stringa.

6 caratteri

/x\by/

Basato sulla risposta di Sven Hohenstein .

8 caratteri

/\w\b\w/

Un limite di parole ( \b) circondato da caratteri 'word' ( \w- uno di [_a-zA-Z0-9]). È ineguagliabile poiché uno dei caratteri che precedono o seguono un limite di parole deve essere un carattere non "parola".

A proposito: questo è simile all'espressione ineguagliabile

/\W\b\W/

dove \Wsignifica carattere non "parola".

4 caratteri

/$a/

cerca una "a" dopo la fine della stringa.

o

/a^/

cerca a prima dell'inizio della stringa.

5 caratteri

/$.^/

/$^/ corrisponderà a una stringa vuota, mentre non è richiesto un carattere in mezzo.

9 caratteri

Non sono sicuro, ma /[^\S\s]/dovrebbe essere ineguagliabile poiché non significa alcun personaggio, ma almeno uno di loro.

6 caratteri

Penso che questa regex che ho creato funzionerà:

/\b\B/

Corrisponde a una parola limite ( \b) che non è una parola limite ( \B). Quali sono le impos: devo davvero spiegartelo?

4 caratteri

(Solo sapore ECMAScript)

/[]/

In altri gusti questa non è una classe di caratteri valida ( ]sarebbe considerata un carattere nella classe, quindi l'espressione non è valida, perché la classe non è mai chiusa), ma lo standard ECMAScript accetta classi di caratteri vuote. Dal momento che è una classe deve corrispondere a un personaggio (quindi le stringhe vuote non corrispondono), ma poiché non è incluso un singolo carattere, neanche un personaggio reale corrisponderà.

6 caratteri

/b++b/

Il quantificatore possessivo cerca quante più b possibili, quindi 1 in più. 6 caratteri ma punti per la simmetria?

6 caratteri

/(\1)/

Non un vincitore, ma ho pensato che fosse divertente. grep e Python sono entrambi contrari a questo, ma Perl sembra a posto.

Sembra essere molto dipendente dall'implementazione (il che non sorprende, data la sua stranezza). Bob riporta di seguito che corrisponde a qualsiasi cosa nel motore regex di JavaScript.

Forse un po 'di barare, ma ...

\0

... è ineguagliabile in regex POSIX praticamente in tutte le implementazioni, se non in tutte. BASIC RE e EXTENDED RE, pari.

E POSIX RE non ha bisogno di quelle fastidiose barre e bandiere di PCRE.

5 caratteri

/^.^/

Trova la stringa che inizia con un singolo carattere prima dell'inizio della stringa.

4 caratteri:

/.^/

Funziona con GNU grep 2.5.1 ed egrep.

Perl 6 (5 caratteri)

/<!>/

Abuso della regola di Sorta (perché le regex di Perl 6 sono diverse e incompatibili con le regex stardard in base alla progettazione), ma non mi interessa. <!>regola informa Perl 6 che la regex non corrisponde.

6 byte

/(*F)/

Abbreviazione di (*FAIL), supportata da motori regex compatibili perl. Grazie a @HamZa per averlo segnalato.

9 byte

/(*FAIL)/

Dovrebbe funzionare con qualsiasi motore regex che supporti i verbi. Non sono convinto che questo debba davvero essere ulteriormente giocato a golf.

4 caratteri

/$./

Ha bisogno di qualsiasi carattere dopo la fine della stringa

4 caratteri con barre 2 senza

Nel motore regex del linguaggio TXR, una classe di caratteri vuota []non corrisponde a nessun carattere e quindi nessuna stringa. Si comporta in questo modo perché la classe di caratteri richiede una corrispondenza di carattere e quando è vuota specifica che nessun personaggio può soddisfarla.

Un altro modo è quello di invertire il "insieme di tutte le stringhe tra vuoto" regex /.*/utilizzando l'operatore di complemento: /~.*/. Il complemento di quell'insieme non contiene affatto stringhe, quindi non può eguagliare nulla.

Tutto questo è documentato nella pagina man:

   nomatch
          The  nomatch  regular  expression  represents  the empty set: it
          matches no strings at all, not even the empty string.  There  is
          no  dedicated  syntax  to  directly express nomatch in the regex
          language.  However, the empty character class []  is  equivalent
          to nomatch, and may be considered to be a notation for it. Other
          representations of nomatch are possible: for instance, the regex
          ~.* which is the complement of the regex that denotes the set of
          all possible strings, and thus denotes the empty set. A  nomatch
          has  uses;  for instance, it can be used to temporarily "comment
          out" regular expressions. The regex ([]abc|xyz) is equivalent to
          (xyz), since the []abc branch cannot match anything. Using [] to
          "block" a subexpression allows you to leave it  in  place,  then
          enable it later by removing the "block".

Le barre non fanno parte della sintassi regex di per sé; sono solo punteggiatura che delimita le regex nella notazione dell'espressione S. Testimone:

# match line of input with x variable, and then parse that as a regex
#
$ txr -c '@x
@(do (print (regex-parse x)) (put-char #\newline))' -
ab.*c                               <- input from tty: no slashes.
(compound #\a #\b (0+ wild) #\c)    <- output: AST of regex

6 caratteri

(o 4, a seconda di come lo guardi)

/{,0}/

Questo è un regex a 5 caratteri.

/[]+/

Corrisponde a un gruppo vuoto 1 o più volte.

MODIFICARE:

Rimossa la mia risposta per altri gusti:

/.{-1}/

Tutto ciò che non è un numero all'interno di {} corrisponderà al testo.

Questo corrisponderà a ". {- 1}"

5 caratteri

Spero che questo non sembri stupido: /[]+/

/$^/

Una cosa che finisce prima che abbia inizio ...