I would call those language-specific. While they are useful in more than one language, they are also replaced by language features in many languages.

• Builder pattern can be simplified with kwargs (Python, C#) or argument objects (JS, C++).
• Factory pattern can be simplified with first-class types (Lisp, Haskell).
• Visitor pattern is similarly simplified by first-class functions (supported by most languages nowadays).
• Dependency injection of concept X is generally simplified by first-class X. I think the least widely supported is dependency injection of effects (Koka).

Design patterns are typically just workarounds for the limitations of the chosen programming language. What you might consider a pattern in C might just be a simple language feature in C++, and the patterns in C++ (as popularized by GoF) might just be language features in Lisp/Rust/whatever.

So rather than thinking about patterns, you should first choose the right language for the task. If you're working on a parser, you might prefer Haskell. If you need formal verification, there's C and Idris and little inbetween. If you need to hire lots of developers, something widely-known like JS might be the choice.

After you've chosen a language, you can identify the things that the language is bad at and apply the appropriate design patterns. Sometimes the patterns can be found in books (C++, Java) and sometimes it's just tribal knowledge (D).

Regular expressions are great and can always be matched in linear time with respect to the input string length.

The problem is that JS standard library RegExps aren't actually regular expressions, but rather a much broader language, which is impossible to implement efficiently. If RegExp switched to proper regular expressions, they would match much faster but supporting backreferences like /(.*)x\1/ would be impossible.

Very nice. I remember looking up some of these details from StackOverflow years ago, but this blows those answers away.

It would be much easier to read if it was actually table, i.e., if hex codes and the characters were separated into their own columns.