Regex which ensures no character is repeated

Question

Hi, I need to ensure that a input string follows these rules:

• It should contain upper case characters only.
• NO character should be repeated in the string. eg. ABCA is not valid because 'A' is being repeated.

For the upper case thing, [A-Z] should be fine. But i am lost at how to ensure no repeating characters.

Can someone suggest some method using regular expressions ?

Answer 1

This cannot be done via regular expressions, because they are context-free. You need at least context-sensitive grammar language, so only way how to achieve this is by writing the function by hand.

See formal grammar for background theory.

Answer 2

Why not check for a character which is repeated or not in uppercase instead ? With something like ([A-Z])?.*?([^A-Z]|\1)

Answer 3

You can do this with .NET regular expressions although I would advise against it:

string s = "ABCD";
bool result = Regex.IsMatch(s, @"^(?:([A-Z])(?!.*\1))*$");

Instead I'd advise checking that the length of the string is the same as the number of distinct characters, and checking the A-Z requirement separately:

bool result = s.Cast<char>().Distinct().Count() == s.Length;

Alteranatively, if performance is a critical issue, iterate over the characters one by one and keep a record of which you have seen.

Answer 4

Use negative lookahead and backreference.

  string pattern = @"^(?!.*(.).*\1)[A-Z]+$";
  string s1 = "ABCDEF";
  string s2 = "ABCDAEF";
  string s3 = "ABCDEBF";
  Console.WriteLine(Regex.IsMatch(s1, pattern));//True
  Console.WriteLine(Regex.IsMatch(s2, pattern));//False
  Console.WriteLine(Regex.IsMatch(s3, pattern));//False

\1 matches the first captured group. Thus the negative lookahead fails if any character is repeated.

Answer 5

This isn't regex, and would be slow, but You could create an array of the contents of the string, and then iterate through the array comparing n to n++

=Waldo

Answer 6

It can be done using what is call backreference.

I am a Java program so I will show you how it is done in Java (for C#, see here).

final Pattern aPattern = Pattern.compile("([A-Z]).*\\1");
final Matcher aMatcher1 = aPattern.matcher("ABCDA");
System.out.println(aMatcher1.find());
final Matcher aMatcher2 = aPattern.matcher("ABCDA");
System.out.println(aMatcher2.find());

The regular express is ([A-Z]).*\\1 which translate to anything between 'A' to 'Z' as group 1 ('([A-Z])') anything else (.*) and group 1.

Use $1 for C#.

Hope this helps.