For all types of searches except RegEx, the following are special characters. Either variation can be used:
| ? or . | matches exactly one character |
| * or @ | matches 0 or more characters |
| [ABC] or (ABC) | matches one of the characters inside the brackets |
Finds all words that can be created by rearranging all of the letters in the provided pattern. You can use ? and [abc] to use multiple letters. You can use * to allow an unlimited number of extra letters to be added. For fairly obvious reasons, using more that one * has no additional effect. The order of the letters in the pattern is always irrelevant, so the "reverse pattern" check box is not available. Unless the * is used, the number of letters in the pattern is the number of letters in the result, so the word length restriction boxes are only useful if a * is used.
Examples:
ARECNIOT ==> CREATION, REACTION
NART? ==> GRANT, RANTS, TARNS, TRAIN
AL[BDM]I ==> BAIL, DIAL, LAID, MAIL
UZI* (max length 6) ==> QUIZ, UNZIP, UNZIPS, FUZING
Find all words that match the letters in a pattern, in the order provided. Since order is significant, this type of search is only useful if you use one or more of the wild-card options: ? to match any letter, [ABC] to match one of a letter, or * to match zero or more letters. The pattern can be reversed if the "reverse pattern" check-box is used. This type of search is very useful for crossword-type puzzles where some of the letters are known.
Examples:
?A?T?G ==> RAGTAG
S???[^AEIOU]B ==> SUBURB, SUPERB
TES*ED ==> TESSELLATED, TESTED, TESTIFIED
Finds all words that can be created using some (or all) of the letters in the pattern, in any order. Build differs from Anagram in that not all of the letter need to be used. Thus, a Build query will find all the words that an Anagram query will, but may also find shorter words. ? and [ABC] type wild-cards can be used in a Build, but the * character does not make any sense. A Build will not use the same letter more than once, unless it is repeated in the pattern. Setting a minimum length is often useful in a Build, since a large number of two and three letter words are typically found.
Examples:
UGPCOE (min length 4) ==> COPE, COUP, COUPE, PUCE
CAULFRM (min length 6) ==> CANFUL, CARFUL, FULCRA
CCAAUULLFFRRMM (min length 6) ==> ACCRUAL, ALARUM, ALULAR, ALUMNA, ... (55
total)
?VWXYZ (min length 4) ==> WAVY, WAXY
Finds all words that are formed from a contiguous run of letters within the given pattern. This can be useful in finding words that may be hidden in a longer sentence, only some of which are known. As with Build queries, a minimum length restriction is useful to filter out small words.
Examples:
CHEMOTHERAPY (length 4-10) ==> CHEMO, MOTH, MOTHER, OTHER, THERAPY
F?LA?ACR??Y?RPO (min length 7) ==> ACRONYM, ALACRITY
Finds all words that contain the pattern as a continuous run of letters within the word. This is most useful when a small number of somewhat rare letters are known. Wildcards ? and [ABC] are allowed. The * wildcard is permitted, but is not often that useful. Note that a Superword query is equivalent to a Pattern query with * added to the front and back of the pattern.
Examples:
ZVA ==> MITZVAH, MITZVAHS
[AEO]G[TC]?[MRS] ==> DOGCART, DOGCARTS, RAGTIME, RAGTIMES
Finds all words that the pattern can be encoded to by a simple substitution cipher. A letter can be substituted for itself, but two different letters in the pattern may not map to the same letter. The * and ? wildcards are permitted. The "mistakes" option is not allowed. This is most useful when a word in a cryptogram has an number of repeated letters, or when the word list used is fairly small.
Examples:
XAZXAXG ==> BAOBABS, CONCOCT, REARERS
ABCABC ==> TSETSE, BONBON, ... (but not BOOBOO)
*BB*AA*BB* ==> MILLENNIALLY, MISSHAPENNESS, ...
Finds all words that can be created by inserting one or more consecutive letters somewhere inside the given pattern. The *, ?, and [ABC] wildcards are permitted. This query type is useful for solving cryptic crossword clues with insertions.
Examples:
STEAM ==> STREAM, STEREOGRAM, STEADICAM
A RegEx query finds all words that match a JavaScript regular expression pattern. Although the other query types are the most useful, there are occasional problems that can be solved using regular expression that the other query types cannot do.
For example, to find all words that start and end with the same digraph
(two-letter pair), separated by one or more vowels:
(..)[AEIOU]+\1 ==> CAECA, MIAMI, ONION, SEISE, SHEESH,
SHUSH