Wie kann ich die längsten Wörter in der Zeichenfolge finden und diese (ohne Duplikate) zusammen mit der maximalen Länge zurückgeben?

8

Ich weiß, wie ich das längste Wort in einer Zeichenfolge finden kann. Zum Beispiel diesen Code hier. Aber hier ist das Problem, dass das Wort "bbbbbb" gefunden wird, weil er das ERSTE LÄNGSTE WORT IN DER Zeichenfolge ist. Danach haben wir mit 6 Zeichen auch das Wort "gesprungen". Meine Frage ist, wie kann ich in diesem Fall und das Wort "gesprungen" finden, also alle nicht nur das erste.

UPDATE: Ich möchte eine eindeutige Liste, also nur eines von jedem Wort

function longestWord(sentence) {
  sentence = sentence.split(' ');

  let theWord = sentence[0];
  var longest = 0;
  for (let i = 0; i < sentence.length; i++) {
    if (sentence[i] != "") {
      if (sentence[i].length > theWord.length) {
        longest = sentence[i].length;
        theWord = sentence[i];
      }
    }
  }
  return {
    length: longest,
    actuallWord: theWord
  }
}
console.log(longestWord("The quick brown as bbbbbb fox jumped over the bbbbbb lazy dog"));

Erweitern Sie das Snippet

javascript arrays string

— Trajce12
quelle

Versuchen Sie sentence.filter(w => w.length === longest), eine Reihe von Wörtern mit dieser Länge zu erhalten.

— Rafi

Sie können versuchen, ein Array zu erstellen, das die längsten Wörter enthält, die Sie hinzufügen. Anschließend können Sie filter () oder map () verwenden, um die Länge zu bewerten und dem Array hinzuzufügen.

— CoderLee

Sie haben jetzt zwei Antworten mit eindeutigen Worten: Yevhen's und FZs

— mplungjan

9

function longestWord(sentence) {
  // First we divide the sentence into words
  var words = sentence.split(' ');
  
  // We then get the length by getting the maximun value of the length of each word
  var length = Math.max(...words.map(a=>a.length));
  return {
    length: length,
    // Finally we filter our words array returning only those of with the same length we previously calculated
    words: words.filter(i => i.length == length)
  }
}
console.log(longestWord("The quick brown as bbbbbb fox jumped over the lazy dog"));

Erweitern Sie das Snippet

— Luis felipe De jesus Munoz
quelle

Schön, um die Länge in einer Aussage zu bekommen. Ich brauche mehr, weil .sort das Array nicht

— zurückgibt

3

@LuisfelipeDejesusMunoz Warum nicht trotzdem eine Erklärung hinzufügen? Es ist gut für andere Leser, die diese Antwort finden. Neben dem OP.

— CoderLee

@YevgenGorbunkov Ihre Lösung ist auch großartig. Danke Kumpel

— Trajce12

Die obige Lösung überspringt keine doppelten Wörter und der implementierte Algorithmus ist nicht optimal, da unnötigerweise 2 Durchgänge durch das Array erforderlich sind, während der Single-Pass-Ansatz selbst für eine so kurze Testzeichenfolge eine um etwa 15% bessere Leistung erzielen kann .

— Jewgen Gorbunkow

@YevgenGorbunkov Sie haben Recht mit der Leistung, aber ich bin nicht sicher, ob das OP eindeutige Wörter erhalten wollte (dieser Teil wurde in der Frage von anderen bearbeitet )

— FZs

2

Sie können einen Einzelschleifenansatz wählen und die Länge jedes Wortes mit der Akkumulatorlänge des ersten Elements überprüfen.

function longestWords(words) {
    return words
        .split(/\s+/)
        .reduce((accu, word) => {
            if (!accu[0] || accu[0].length < word.length) return [word];
            if (accu[0].length === word.length) accu.push(word);
            return accu;
        }, []);
}

console.log(longestWords("The quick brown as bbbbbb fox jumped over the lazy dog"));

Erweitern Sie das Snippet

— Nina Scholz
quelle

@mplungjan: Interessant, wie unterschiedliche Stile unterschiedliche Menschen ansprechen. Ich finde diese Antwort leichter zu lesen. Natürlich liegt das vielleicht daran, dass es der Antwort ähnelt, die ich geschrieben habe ... aber nicht veröffentlicht hat, weil Nina mich geschlagen hat.

— Scott Sauyet

2

Sie können dies mit Array.prototype.reduce()einem einzigen Durchgang durch das Array tun (ohne zusätzliche Schleife zur Berechnung der maximalen Länge).

Die Idee ist, das resultierende Array mit einem einzelnen Wort zurückzusetzen, sobald seine Länge die zuvor eingefügten überschreitet oder anhängt, wenn das aktuelle Wort zufällig dieselbe Länge hat, oder einfach auf andere Weise vorbeizukommen:

const src = 'The quick brown as bbbbbb fox jumped over the jumped lazy dog',

      result = src.split(' ')
                  .reduce((res, word, idx) => {
                    if(!idx || word.length > res.length)
                        res = {length: word.length, words:new Set([word])}
                    else if(word.length == res.length)
                        res.words.add(word)
                    return res
                  }, {})

console.log({result: result.length, words: [...result.words]})

.as-console-wrapper {min-height:100%}

Erweitern Sie das Snippet

— Jewgen Gorbunkow
quelle

Es ist eine Tugend, einem Noob zu erlauben, zu verstehen, was auch los ist :)

— mplungjan

Ich würde sagen, dass diese stackoverflow.com/a/60153437/295783 besser lesbar ist. Irgendwelche Kommentare?

— Mplungjan

3

Verschachtelte Ternäre sind abscheulich und gefährlich. Ihre Suche nach einzeiligen Lösungen wird den Codierer dazu bringen, nachdem Sie Sie sehr gehasst haben :)

— mplungjan

Ich finde, dass Reduzieren nicht zu groß ist, um mehrere Werte zusammen zu aktualisieren (in diesem Fall lengthund words).

— Gershom

1

Sie können dies tun, indem Sie das sentenceArray reduzieren .

Der Vorteil dieses Ansatzes besteht darin, dass das Array nur einmal durchlaufen wird:

function longestWords(sentence) {
  return sentence.split(' ').reduce((output, word) => {
    if (word.length > output.length) {
      output.words = [word]
      output.length = word.length
    } else if (word.length === output.length) {
      output.words.push(word)
    }
    return output
  }, { length: 0, words: [] })
}
console.log(longestWords("The quick brown as bbbbbb fox jumped over the lazy dog"));

Erweitern Sie das Snippet

Wenn Sie doppelte Wörter herausfiltern möchten, können Sie Setstattdessen Folgendes zurückgeben:

function longestWords(sentence) {
  return sentence.split(' ').reduce((output, word) => {
    if (word.length > output.length) {
      output.words.clear()
      output.length = word.length
    } 
    if (word.length >= output.length) {
      output.words.add(word)
    }
    return output
  }, { length: 0, words: new Set })
}
const words = longestWords("The quick brown as bbbbbb fox jumped over the jumped lazy dog")
console.log(words.length);
console.log(Array.from(words.words)) //Just to make StackSnippets console show the Set's entries

Erweitern Sie das Snippet

— FZs
quelle

Dies ist die am besten lesbare Reduzierung, die bisher veröffentlicht wurde

— mplungjan

Kann nur einmal upvoten. Tolle Beispiele

— mplungjan

0

Sie können überprüfen, ob die Länge des Wortes größer oder gleich der Länge des ersten Elements des Arrays ist (alle Elemente im Array sollten dieselbe Länge haben).

Wenn ja, prüfen Sie, ob es größer ist. Wenn dies zutrifft, setzen Sie das Array auf dieses Wort, da Sie ein Wort gefunden haben, das größer als die Wörter im Array war. Andernfalls fügen Sie es dem Array der Wörter mit der größten Länge hinzu.

function longestWord(sentence) {
  sentence = sentence.split(' ');
  let theWord = sentence[0];
  var longest = 0;
  for (let i = 0; i < sentence.length; i++) {
    if (sentence[i] != "") {
      if (sentence[i].length >= theWord[0].length) {
        if (sentence[i].length > theWord[0].length) {
          longest = sentence[i].length;
          theWord = [sentence[i]];
        } else {
          theWord.push(sentence[i])
        }
      }
    }
  }
  return {
    length: longest,
    actuallWord: theWord
  }
}
console.log(longestWord("The quick brown as bbbbbb fox jumped over the lazy dog"));

Erweitern Sie das Snippet

— JSScratchDouble
quelle

0

Es kann auch in Einzelreduzierung erfolgen.
Mit dem Objekt initiiert.

function longestWord(words) {
  return words
    .split(/\s+/)
    .reduce((acc, word) => {
  	if(word.length > acc.length) {
  		acc.length = word.length;
  		acc.words = [word];
  	}
  	else if (word.length === acc.length) {
  		acc.words.push(word);
  	}
  	return acc;
  }, {length:0, words:[]});
}

console.log(longestWord("The quick brown as bbbbbb fox jumped over the lazy dog"));

Erweitern Sie das Snippet

— LukStorms
quelle

0

Dieser Ansatz hat keine bessere Zeitkomplexität als die besten Antworten hier, aber bessere Koeffizienten. (Es durchläuft das Array von Wörtern nur einmal, keine Funktionsaufrufe außer Array.prototype.push).

let allLongestItems = items => {
  let longest = [];
  let length = 0;
  for (let item of items) {
    let len = item.length;
    if (len === length) longest.push(item)
    else if (len > length) { longest = [ item ]; length = len; }
  }
  return { items: longest, length };
};

let str = 'The quick brown as bbbbbb fox jumped over the lazy dog';
console.log(allLongestItems(str.split(' ')));

Erweitern Sie das Snippet

— Gershom
quelle