In order to allow short circuiting if the duplicate exists early in the list, you can add a [`HashSet<T>`][HashSet] and check the return value of its `.Add` method. 

By using `.Any` you can short circuit the enumeration as soon as you find a duplicate.

Here's a LINQ extension method in both C# and VB: 

### CSharp:



 public static bool ContainsDuplicates<T>(this IEnumerable<T> enumerable)
 {
 var knownKeys = new HashSet<T>();
 return enumerable.Any(item => !knownKeys.Add(item));
 }

### Visual Basic:



 <Extension>
 Public Function ContainsDuplicates(Of T)(ByVal enumerable As IEnumerable(Of T)) As Boolean
 Dim knownKeys As New HashSet(Of T)
 Return enumerable.Any(Function(item) Not knownKeys.Add(item))
 End Function

**Note**: to check if there are *no* duplicates, just change `Any` to `All`

[HashSet]: http://msdn.microsoft.com/en-us/library/bb359438(v=vs.110).aspx

Requirement: In an unsorted List, determine if a duplicate exists.  The typical way I would do this is an n-squared nested loop.  I'm wondering how others solve this.  Is there an elegant, high performance method in Linq?  Something generic that takes a lambda or a comparer would be nice. 

C# Determine Duplicate in List

### Consider using [*mark.js*][1]

Replacing nodes in the DOM can be tricky and lead to unintended consequences as elements shift and fire events. Although it adds a third party dependency, it has a pretty clean API and abstracts away the logic so you don't have to own it.

[1]: https://markjs.io/





 var instance = new Mark(".mark-context");
 instance.mark("100 bruss");



 <script src="https://cdnjs.cloudflare.com/ajax/libs/mark.js/8.11.1/mark.min.js"></script>

 
 1000, Brussels, Belgium

I have an algorithm which calculates the characters to highlight in text based on query.

For example, if I pass to the algorithm text "1000, Brussels, Belgium" and
query "1000 bruss" it will return me `[[0, 4], [6, 11]]`. But now, I need to write an algorithm which will wrap the characters with ``, so the result should be `1000, Brussels, Belgium`.
I wrote the algorithm, but i have a feeling it might be better or it might be solved more elegant.

```javascript
const highlight = (content, query, matches) => {
 if (!query) {
 return content;
 }

 const openTag = "";
 const closeTag = "";

 let result = content;
 let shift = 0;

 matches.forEach(([startIndex, endIndex]) => {
 const s =
 openTag +
 result.slice(startIndex + shift, endIndex + shift) +
 closeTag +
 result.slice(endIndex + shift);

 if (shift) {
 result = result.slice(0, startIndex + shift) + s;
 } else {
 result = s;
 }

 shift += openTag.length + closeTag.length;
 });

 return result;
};
```

Is there any better way to solve the problem?

Another example:

- Text: 'Amsterdam, North-Holland, Netherlands'
- Query: 'amst'
- Matches: `[0, 4]`