If you are interested in a regular expression that excludes duplicates, try this: (?([a-zA-Z0-9_\-\.]+)@([a-zA-Z0-9_\-\.]+)\.([a-zA-Z]{2,9}))(?!.*\).

It can be compared with DistinctBy:

Dim matches = Regex.Matches(Text, "your original expression...", RegexOptions.CultureInvariant Or RegexOptions.IgnoreCase Or RegexOptions.Multiline).DistinctBy(Function(m) m.Value, StringComparer.CurrentCultureIgnoreCase)

The experiments with typical data will show the fastest method.

That's easy to do with a negative lookahead assertion:

^(?!.*(.).*\1)[ABC]+$

matches exactly as you described.

Test it live on regex101.com.

Explanation:

^      # Start of the string
(?!    # Assert that it's impossible to match...
 .*    # Any number of characters (including zero)
 (.)   # followed by one character (remember this one in group 1)
 .*    # that's followed by any number of characters
 \1    # and the same character as before
)      # End of lookahead
[ABC]+ # Match one or more characters from this list
$      # until the end of the string

Yes, regex can do this.

NOT(REGEX(SomeCustomField__c, '^(?s)\\d{9}(\\s+\\d{9})$')) ||
REGEX(SomeCustomField__c, '(?s)(\\d{9}).*\\1')

The trick here is that we go in to "single line mode" (?s) to allow . to match newlines, then we check each nine-digit string (\\d{9}) with any intervening characters (.*), followed by the same group again (\\1).

How about something like

(\w+)(?!.*?\1)

Or, if you don't want "cat" matches "caterpillar" :

(\b\w+\b)(?!.*?\b\1\b)

You can use a regex like this to find the duplicates:

(.).*\1

Then you can use a replace over your main string by an empty string, so your resulting string will have all the characters non duplicated

Working demo

The substitution section contains your resulting string having the non duplicated characters:

Btw, if you just want to find the non duplicated letters you can change the regex to:

([A-Za-z]).*\1

This solution, works for consecutive characters but if you can have duplicated characters then you should use another solution. What I'd do is to split your string by characters and add them into a map, then store for each character the count for their ocurrences. So, there you have another approach without regex.

Regular-expressions.info has a page on Deleting Duplicate Lines From a File

This basically boils down to searching for this oneliner:

^(.*)(\r?\n\1)+$

... And replacing with \1.
Note: Dot must not match Newline

Explanation:

The caret will match only at the start of a line. So the regex engine will only attempt to match the remainder of the regex there. The dot and star combination simply matches an entire line, whatever its contents, if any. The parentheses store the matched line into the first backreference.

Next we will match the line separator. I put the question mark into \r?\n to make this regex work with both Windows (\r\n) and UNIX (\n) text files. So up to this point we matched a line and the following line break.

Now we need to check if this combination is followed by a duplicate of that same line. We do this simply with \1. This is the first backreference which holds the line we matched. The backreference will match that very same text.

If the backreference fails to match, the regex match and the backreference are discarded, and the regex engine tries again at the start of the next line. If the backreference succeeds, the plus symbol in the regular expression will try to match additional copies of the line. Finally, the dollar symbol forces the regex engine to check if the text matched by the backreference is a complete line. We already know the text matched by the backreference is preceded by a line break (matched by \r?\n). Therefore, we now check if it is also followed by a line break or if it is at the end of the file using the dollar sign.

The entire match becomes line\nline (or line\nline\nline etc.). Because we are doing a search and replace, the line, its duplicates, and the line breaks in between them, are all deleted from the file. Since we want to keep the original line, but not the duplicates, we use \1 as the replacement text to put the original line back in.

Assuming the regex engine used is either JS (new one ) or C#.
Both of which would allow you to use a well placed, variable length look behind.
This will allow to highlight only the first unique NASDAQ codes.

(?<=NASDAQ:)(?=(\w+))(?<!^[\s\S]*NASDAQ:\1[\s\S]*)\1

https://regex101.com/r/EeGy3E/1

 (?<= NASDAQ: )
 (?=
    ( \w+ )                       # (1)
 )
 (?<! ^ [\s\S]* NASDAQ: \1 [\s\S]* )
 \1

You can use this negative lookahead based regex to make sure to match desired word only if same word doesn't exist further in text thus matching last occurrence of the search words:

/(home|fire)(?!.*\1)/ig

Output:

["Home", "fire"]

RegEx Demo

To remove lines ending in duplicate values replace

([^\s]+\s(.*\n))([^\s]+\s\2)+

With

\2

I am assuming with this based on your example input that we can use the first space in a given line to delimit the boundary between the regex which should be checked for duplicates and the rest of the string. If this assumption is wrong you can modify the part [^\s]+\s to be any valid regex that matches the first (non duplicate) part of your string.

The first set of parentheses matches the first line which we will keep.

The second set of parentheses matches the string which we want to check as a duplicate values.

In the third set we check again for a string followed by a space followed by the same duplicate string which we captured in the 2nd set of parentheses.

The + checks for this multiple times.

\2 replaces the entire match with just the duplicated string.