Find the longest word in the dictionary

I took the idea to solve the problem from this post: Successive adding of char to get the longest word in the dictionary

Basically, it iterates over each word in a dictionary and generates path by removing characters from the string recursively until new word is not in a dictionary or size 1. If last word is a target character, I found possible maximum path. Assuming dictionary is given as a hash-map, the runtime is O(n*k^2) where n is the number of words in a dictionary and k is the length of the biggest string (worst case). I believe it can be optimized by pruning some words, for ex. words that do not contain target character.

It returns set of strings (to simplify coding). For ex. if target character is ‘a’, this function returns:
[tamped, stamped, ta, a, tape, tap, taped, stampedes, stampede]

I would appreciate any thoughts on this solution.

    public static Set<String> findLongestPath(char targetChar, 
Set<String> dictionary) {

        Set<String> maxPath = new HashSet<String>();

        for (String word: dictionary) {
            Set<String> currentPath = findPath(word, dictionary, targetChar);
            if (maxPath.size() < currentPath.size()) {
                maxPath = currentPath;
            }
        }
        return maxPath;
    }

    public static Set<String> findPath(String word, Set<String> dictionary, char targetChar) {
        String targetCharStr = "" + targetChar;
        Set<String> path = new HashSet<String>();

        if (word.length() == 1) {
            path.add(word);
        } else if (dictionary.contains(word)) {
            for (int i = 0; i < word.length(); i++) {
                //remove one character from a word and try to find path for it
                String subWord = word.substring(0, i) + word.substring(i + 1);
                Set<String> deepPath = findPath(subWord, dictionary, targetChar);
                //stop if path contains word with a single character wich is a target character
                if (deepPath.contains(targetCharStr)) {
                    path.add(word);
                    path.addAll(deepPath);
                    break;
                }
            }
        }
        return path;
    }

And here is small driver:

    public static void main(String[] args) throws Exception {

        char targetChar = 'a';
        Set<String> dictionary = new HashSet<String>();
        BufferedReader dictionaryFile = new BufferedReader(new FileReader("/usr/share/dict/words"));
        String line;
        while ((line = dictionaryFile.readLine()) != null) {
            if (line.contains("'")) { continue; }
            dictionary.add(line.toLowerCase().trim());
        }
        dictionaryFile.close();

        System.out.println(findLongestPath(targetChar, dictionary));    
    }

A directory

What is the difference between the front end without tossing and salted fish

Two foreword

• Difficulty:simple

• Involve knowledge: Dictionary tree, hash table

• Subject address：https://leetcode-cn.com/problems/longest-word-in-dictionary/

• Subject content：

Give an English dictionary composed of a string array words.

 Find the longest word from it,
 This word is formed by gradually adding a letter to other words in the words dictionary.

 If there are multiple feasible answers, the word with the smallest lexicographic order in the answer is returned.

 If there is no answer, an empty string is returned.

 Example 1:

 Input:
words = ["w","wo","wor","worl", "world"]
 Output: "world"
 Explanation: 
 The word "world" can be composed of "w", "wo", "wor", and "worl" plus one letter.

 Example 2:

 Input:
words = ["a", "banana", "app", "appl", "ap", "apply", "apple"]
 Output: "apple"
 Explanation: 
 Both "apply" and "apple" can be composed of words in the dictionary.
 But "apple" has a lexicographical order less than "apply".

 Note:

 All input strings contain only lowercase letters.
 The length range of words array is [1,1000].
 The length range of words[i] is [1,30].

Three problem solving and testing

Friends can try to solve the problem locally, then come back and take a lookjsliang Problem-solving ideas.

• LeetCode given function body：

/**
 * @param {string[]} words
 * @return {string}
 */
var longestWord = function(words) {
    
};

According to the above known function, try to solve this problem~

After confirming your own answer, look at the following code~

index.js

/**
   * @name The longest word in the dictionary
 * @param {string[]} words
 * @return {string}
 */
const longestWord = (words) => {
  const map = [[]];
  for (let i = 0; i < words.length; i++) {
    if (map[words[i].length]) {
      map[words[i].length].push(words[i]);
    } else {
      map[words[i].length] = [words[i]];
    }
  }
  let route = [...map[1]];
  for (let i = 2; i < map.length; i++) {
    let tempRoute = [];
    for (let j = 0; j < map[i].length; j++) {
      const index = route.findIndex(item => map[i][j].slice(0, map[i][j].length - 1) === item);
      if (index > -1) {
        tempRoute.push(map[i][j]);
      }
    }
    if (tempRoute.length) {
      route = tempRoute;
    }
  }
  return route.sort((a, b) => a.localeCompare(b))[0] || '';
};

console.log(longestWord(['w', 'wo', 'wor', 'worl', 'world'])); // world
console.log(longestWord(['a', 'banana', 'app', 'appl', 'ap', 'apply', 'apple'])); // apple
console.log(longestWord(['m', 'mo', 'moc', 'moch', 'mocha', 'l', 'la', 'lat', 'latt', 'latte', 'c', 'ca', 'cat'])); // latte
console.log(longestWord(['yo', 'ew', 'fc', 'zrc', 'yodn', 'fcm', 'qm', 'qmo', 'fcmz', 'z', 'ewq', 'yod', 'ewqz', 'y'])); // yodn
console.log(longestWord(['rac', 'rs', 'ra', 'on', 'r', 'otif', 'o', 'onpdu', 'rsf', 'rs', 'ot', 'oti', 'racy', 'onpd'])); // otif
console.log(longestWord(['ogz','eyj','e','ey','hmn','v','hm','ogznkb','ogzn','hmnm','eyjuo','vuq','ogznk','og','eyjuoi','d'])); // eyj

node index.js return:

world
apple
latte
yodn
otif
eyj

Four LeetCode Submit

Accepted
* 57/57 cases passed (164 ms)
* Your runtime beats 35.59 % of javascript submissions
* Your memory usage beats 42.86 % of javascript submissions (41.3 MB)

Five problem-solving ideas

First of all, Get the title, start to analyze:

1. get on sort Sort by length, so that words are sorted from smallest to largest in length.

2. get on for Traverse, if the next length wraps the previous length, it means it has «evolved».

First try

const longestWord = (words) => {
     // Sort by length
  words.sort((a, b) => a.length - b.length);
     // find
  let prevMark = '';
  let nowMark = '';
  for (let i = 0; i < words.length; i++) {
    if (words[i].includes(nowMark)) {
      prevMark = nowMark;
      nowMark = words[i];
    } else if (words[i].includes(prevMark) && words[i] < nowMark) {
      nowMark = words[i];
    }
  }
  return nowMark;
};

However, I know something will happen this way, although both of my examples pass:

console.log(longestWord(['w', 'wo', 'wor', 'worl', 'world']));
// world
console.log(longestWord(['a', 'banana', 'app', 'appl', 'ap', 'apply', 'apple']));
// apple

Why, because if it is a dictionary, when there is more than one line, you don’t know which is the basis:

Wrong Answer
20/57 cases passed (N/A)

Testcase
["m","mo","moc","moch","mocha","l","la","lat","latt","latte","c","ca","cat"]

Answer
"cat"

Expected Answer
"latte"

To put it bluntly, it doesn’t want you to pass it as easily~

There are now three baselines:

• m, mo, moc, moch, mocha

• l, la, lat, latt, latte

• c, ca, cat

Think of a way to do multi-line operations:

Second attempt

const longestWord = (words) => {
  // Sort by length
  words.sort((a, b) => a.length - b.length);
     // find
  const map = [];
  for (let i = 0; i < words.length; i++) {
    if (words[i].length === 1) {
      map.push({
        prevValue: words[i],
        nextValue: words[i],
      })
    } else {
      for (let j = 0; j < map.length; j++) {
        if (
          words[i][0] === map[j].nextValue[0]
          && words[i].includes(map[j].nextValue)
        ) {
          map[j].prevValue = map[j].nextValue;
          map[j].nextValue = words[i];
          break;
        } else if (words[i].includes(map[j].prevValue) && words[i] < map[j].nextValue) {
          map[j].nextValue = words[i];
          break;
        }
      }
    }
  }
  map.sort((a, b) => b.nextValue.length - a.nextValue.length);
  const length = map[0].nextValue.length;
  let result = map[0].nextValue;
  for (let i = 0; i < map.length; i++) {
    if (map[i].nextValue.length === length) {
      result = result < map[i].nextValue ? result : map[i].nextValue;
    } else {
      break;
    }
  }
  return result;
};

Lorry wrote a long list, and then can accurately sort the existing 3 cases:

console.log(longestWord(['w', 'wo', 'wor', 'worl', 'world']));
// world
console.log(longestWord(['a', 'banana', 'app', 'appl', 'ap', 'apply', 'apple']));
// apple
console.log(longestWord(['m','mo','moc','moch','mocha','l','la','lat','latt','latte','c','ca','cat']));
// latte

However, I don’t want to analyze the code I wrote and optimize it, because I saw an incredible scene:

Wrong Answer
29/57 cases passed (N/A)

Testcase
["yo","ew","fc","zrc","yodn","fcm","qm","qmo","fcmz","z","ewq","yod","ewqz","y"]

Answer
"ewqz"

Expected Answer
"yodn"

Then I tried to print:

console.log('ewqz' < 'yodn');

The result returned istrue, If it is sorted by dictionary, thenewqz Should also beyodn Before, what is the reason? I can only read the answer!

Six further thinking

After reading the answer, I directly doubted life:

JavaScript answers

const longestWord = (words) => {
     // Sort by length, if the length is the same, sort in descending lexicographical order,
  let map = new Map();
  words.sort((a, b) => {
    if (!map.has(a)) map.set(a, 1);
    if (!map.has(b)) map.set(b, 1);
    if (a.length === b.length) {
      for (let i = 0; i < a.length; i++) {
        if (a[i] !== b[i]) {
          return b[i].charCodeAt() - a[i].charCodeAt();
        }
      }
    } else {
      return a.length - b.length;
    }
  });
     // The descending order of the lexicographic order ensures that the first one satisfying the condition under the same length must be the smallest lexicographical order
  for (let i = words.length - 1; i >= 0; --i) {
    let flag = true;
         // If a character of length is reached, it must be true
    for (let j = 0; j < words[i].length - 1; ++j) {
      let temp = words[i].substr(0, j + 1);
      if (!map.has(temp)) {
        flag = false;
      }
    }
    if (flag) {
      return words[i];
    }
  }
  return '';
};

…Too long, don’t watch! I don’t believe I can’t crack it:

jsliang solution

const longestWord = (words) => {
  const map = [[]];
  for (let i = 0; i < words.length; i++) {
    if (map[words[i].length]) {
      map[words[i].length].push(words[i]);
    } else {
      map[words[i].length] = [words[i]];
    }
  }
  let route = [...map[1]];
  for (let i = 2; i < map.length; i++) {
    let tempRoute = [];
    for (let j = 0; j < map[i].length; j++) {
      const index = route.findIndex(item => map[i][j].slice(0, map[i][j].length - 1) === item);
      if (index > -1) {
        tempRoute.push(map[i][j]);
      }
    }
    if (tempRoute.length) {
      route = tempRoute;
    }
  }
  return route.sort((a, b) => a.localeCompare(b))[0] || '';
};

The idea is very simple, with['m', 'mo', 'moc', 'moch', 'mocha', 'l', 'la', 'lat', 'latt', 'latte', 'c', 'ca', 'cat'] For example:

First of all, Traversewords Array, by settingmap This two-dimensional array to reorganize the data:

console.log(map);
[
  [],
  [ 'm', 'l', 'c' ],
  [ 'mo', 'la', 'ca' ],
  [ 'moc', 'lat', 'cat' ],
  [ 'moch', 'latt' ],
  [ 'mocha', 'latte' ],
]

then, We assume that this array has an evolutionary route, for example:l -> la -> lat。

Then, by initializing the settingsroute Is a letter of only one length:['m', 'l', 'c']。

then, Doublefor Traverse this two-dimensional array to see if each item isroute A letter is added to the elements in:

console.log(tempRoute);
[ 'mo', 'la', 'ca' ]
[ 'moc', 'lat', 'cat' ]
[ 'moch', 'latt' ]
[ 'mocha', 'latte' ]

It can be seen that it actually follows the evolutionary route we have given, and the final evolutionary routeroute for:

• [ 'mocha', 'latte' ]

At last, All we need to do is to sort this array and output the first element of the final result:route.sort((a, b) => a.localeCompare(b))[0] || ''

Submit Submit:

Accepted
* 57/57 cases passed (164 ms)
* Your runtime beats 35.59 % of javascript submissions
* Your memory usage beats 42.86 % of javascript submissions (41.3 MB)

In this way, we have completed the cracking of this problem! ! !

If you have a better way of thinking, please comment or leave a private chatjsliang~

What is the difference between the front end without tossing and salted fish!

jsliang Will update a LeetCode problem solution every day, so as to help friends to lay a solid foundation of native JS, understand and learn algorithms and data structures.

Prodigal Son The interview questions will be updated every day, driven by the interview questions to drive everyone to learn, insist on learning and thinking every day, and make a little progress every day!

Scan the QR code above and followjsliang Public account (left) andProdigal Son Public account (right), let us toss together!

jsliang’s document library It is licensed by Liang Junrong using the Creative Commons Attribution-Non-Commercial Use-Share the Same Method 4.0 International License Agreement.
Based on the works on https://github.com/LiangJunrong/document-library.
Use rights not authorized by this license agreement can be obtained from https://creativecommons.org/licenses/by-nc-sa/2.5/cn/.

It should come as no surprise that we are word lovers. In fact, we are big word lovers in that we love really big words. To express our love, we looked around for some of the biggest, most ludicrously long words in the English language. In addition to pure length, we also tried to find: 

• the longest word without vowels
• the longest one-syllable word
• and other uniquely long words.

Figuring out which word is the longest of them all isn’t as simple as just counting letters, though. Should you count scientific words? Should obscure, rarely used words be included, or should we give the honor to a word people actually use? In the interest of fairness, our list includes scientific words, obscure words, and all of the absurdly long words stuck in between.  

methionylthreonylthreonylglutaminylarginyl… 

At over 180,000 letters long, the chemical name of the protein titin is often said to technically be the longest English word. If spoken out loud, this word takes over three hours to say! Its absurd length is due to the fact that proteins get their scientific names by combining the names of all of their joined amino acids together, and titin has quite a lot of them. For obvious reasons, titin’s official name has never actually appeared in a dictionary or scientific text. Because it is a scientific term, many would disqualify the Big M from actually taking the crown as English’s longest word. 

pneumonoultramicroscopicsilicovolcanoconiosis

Pneumonoultramicroscopicsilicovolcanoconiosis, coming in at 45 letters long, is typically the biggest word you will find that actually appears in an English dictionary. According to many sources, it was coined around 1935 by Everett Smith, who at the time was the president of the National Puzzlers’ League. The word, which was basically engineered for its length, refers to a lung disease caused by inhaling silica dust. 

sesquipedalianism

Let’s look at a word related to the business of “longest words.” Sesquipedalianism is the tendency to use long words. Do you have sesquipedalian tendencies? (We do.)

The word is traced to the ancient Roman poet Horace, who in a treatise on the art of poetry wrote that in certain circumstances, poets must avoid sesquipedalia verba, a Latin phrase meaning “words [verba] a foot and a half long [sesquipedalia].” Horace clearly had a sense of humor.

pseudopseudohypoparathyroidism

We include pseudopseudohypoparathyroidism, another medical term, because this is one of the longest words to appear in major dictionaries that wasn’t created with length in mind. Pseudo- is a combining form meaning “false, pretended, unreal.”

You might notice the appearance of pseudo- twice. That’s because this disorder simulates the symptoms of pseudohypoparathyroidism, in which the body doesn’t respond to the parathyroid hormone. So, there are two levels of “faking it” going on here.

English isn’t the only language with lengthy elements of its lexicon. Get to know some of the world’s longest words!

antidisestablishmentarianism

Often, people will bust out antidisestablishmentarianism as the longest word they know and are actually able to say. This word has rarely been used and is only mentioned due to its ridiculous length. This word refers to opposition to withdrawing support from the Anglican Church as the state church of 19th-century England. 

supercalifragilisticexpialidocious

Even though the sound if it is something quite atrocious, we do really like the word supercalifragilisticexpialidocious. This nonsensical word with no real meaning was popularized by the 1964 Disney film Mary Poppins and is often used by children as an example of a humorously long word. Songwriters Richard and Robert Sherman take credit for this exact spelling of the word, but the word itself existed even before Mary Poppins made it popular. 

floccinaucinihilipilification

Here’s one that is also very meta: floccinaucinihilipilification is a rarely used word that means “the estimation of something as valueless.” It is usually used in reference to itself! Dating back to the 1700s, the word contains four Latin roots that all mean “of little value” or “trifling”: floccī, naucī, nihilī, and pilī.

honorificabilitudinitatibus

The word honorificabilitudinitatibus, which is said to mean “capable of receiving honor,” has two major honors to its name. Firstly, it is the longest word to ever appear in the works of William Shakespeare. Billy the Bard only ever used it once, in his play Love’s Labour’s Lost (1590s). Secondly, honorificabilitudinitatibus is the longest English word wherein the consonants and vowels alternate back and forth. Check it again if you didn’t notice! 

uncharacteristically

Uncharacteristically for most of the really long words you’ve seen so far, the word uncharacteristically is often said to be the longest word that the average English speaker will commonly see or actually use in everyday life. As you may already know, uncharacteristically is an adverb that describes something as not being typical or acting in a characteristic manner. 

incomprehensibilities

At 21 characters, another one of the longest words you might actually use yourself is incomprehensibilities. We define incomprehensible as “impossible to comprehend or understand,” so incomprehensibilities are “things you can’t comprehend.” ¿Comprendes?

uncopyrightables 

If you look closely at the spelling, you’ll notice a peculiar thing about this word with 16 letters. It does not repeat any letter; each character is used only once. This word is sometimes called an isogram among lovers of words and word games.

One of the longest isograms is subdermatoglyphic, at 17 characters. But, since subdermatoglyphic (dermatoglyphics studies the patterns of skin markings on the hands and feet) is a bit scientific and certainly not one that is used often, we’re spotlighting uncopyrightables instead because it’s one we can all remember. It means, of course, “items that are unable to be copyrighted.”

rhythms 

The word rhythms may not look like much at only seven letters long, but it is said to be the longest English word without one of the five main vowels in it. The letter Y, that wishy-washy “sometimes vowel,” is filling in while A, E, I, O, and U are taking a break. As we all know, the word rhythms means “movements or procedures with uniform or patterned recurrence of a beat, accent, or the like.” 

Are there really words without vowels? Depending on the definition, the answer might elicit a hmm.

strengths 

Strengths is another smaller word with a big achievement under its belt. It is the longest English word with only a single vowel in it. Considering it is only eight letters long, that really shows you how much we value our vowels. The plural strengths is most often used to mean “positive or valuable attributes or qualities.”  

squirrelled 

We go nuts for this word. While the word squirreled usually only has one L in American English, some dictionaries accept this British English version as an alternate spelling. Some Americans pronounce the word squirrelled as a one-syllable word (rhyming with “curled”). This makes squirrelled the longest one-syllable word in the English language at 11 letters. If all of that sounds too squirrely for you, the one-syllable verb broughammed from the noun brougham, a type of carriage, is also 11 letters long. 

As an aside, some may tell you that the word schtroumpfed is actually the longest “English” word with only a single syllable. This word has been used in some translations of The Smurfs (which is Les Schtroumpfs in French) in place of the more commonly used nonsensical verb smurfed. In our opinion, claiming schtroumpfed is the longest one-syllable word is just a bunch of smurf. 

Aegilops

Aegilops sounds like the name of a mythical monster, but it is actually the name of a genus of wild grasses commonly known as goatgrass. In addition to that, Aegilops is also commonly said to be the longest English word that has all of the letters in alphabetical order.

Indulge your inner sesquipedalian and take the quiz!

Think you’re ready to ace our longest English words quiz? Or is it a long shot? It won’t be long before you find out. Remember that a little practice goes a long way!

Last Updated: Dec 30, 2019
How many words exactly are in the English language? The second edition of the current 20-volume Oxford English Dictionary contains 171,476 words in current use. That’s a lot! Which gets the mind thinking the next question, what’s the longest word in current use today?

Many of the longest words in the dictionary refer to medicine or chemistry. You’ll find a few defined in here along with other long words that you may or may not already use. Here’s how Merriam-Webster defines the ten longest words in the English language.

1. Pneumonoultramicroscopicsilicovolcanoconiosis (45 letters)

Pneumoconiosis caused by inhalation of very fine silicate or quartz dust.

2. Hippopotomonstrosesquippedaliophobia (36 letters)

Ironically, Hippopotomonstrosesquippedaliophobia is one of the longest work in the dictionary and is the name for a fear of long words! Who would have thought, right?

3. Supercalifragilisticexpialidocious (34 letters)

Perhaps the best word of all! Made popular by the film Mary Poppins, Supercalifragilisticexpialidocious is something to say when you have nothing to say.

4. Pseudopseudohypoparathyroidism (30 letters)

A relatively mild form of pseudohypoparathyroidism that is characterized by normal levels of calcium and phosphorus in the blood.

5. Floccinaucinihilipilification (29 letters)

The longest unchallenged nontechnical word that not all directories recognize, that including Merriam-Webster. According to alternative sources, floccinaucinihilipilification is the act or habit of describing or regarding something as unimportant, of having no value or being worthless. Often times, it is used in a humorous way.

Free Speed Reading Class – Click Here To Register

6. Antidisestablishmentarianism (28 letters)

A term referring to a political movement in 19th century Britain that sought to separate church and state. In this case, political movement wanted to disestablish the Church of England as the official state church of England, Ireland and Wales.

7. Honorificabilitudinitatibus (27 letters)

The longest word in Shakespeare’s works. Honorificabilitudinitatibus is the longest word in the English language featuring alternating consonants and vowels.

8. Thyroparathyroidectomized (25 letters)

A medical term that defines the excision of both the thyroid and parathyroid glands.

9. Dichlorodifluoromethane (23 letters)

A chlorofluoromethane CF2Cl2.

10. Incomprehensibilities (21 letters)

Impossible to comprehend. In the 1990’s, incomprehensibilities set the record as the longest word “in common usage.”

LONGEST ENGLISH WORD:Methionylthreonylthreonylglutaminylarginyl…isoleucine (189,819 letters)

If we’re talking chemistry, the longest chemical name is 189,819 letters long. It is the chemical name for titin, a giant filamentous protein essential to the structure, development, and elasticity of muscle. As to whether or not this is an actual word is disputed by many. It is not in the Merriam-Webster dictionary, so you shouldn’t ever have to worry about spelling it. ?