Meistern des JavaScript | Teil 1: Zeichenfolgen und Arrays | Arnav Aggarwal | Skillshare
Drawer
Suchen

Playback-Geschwindigkeit


  • 0.5x
  • 1x (normal)
  • 1.25x
  • 1.5x
  • 2x

Meistern des JavaScript | Teil 1: Zeichenfolgen und Arrays

teacher avatar Arnav Aggarwal, Full-Stack Engineer & Instructor

Schau dir diesen Kurs und Tausende anderer Kurse an

Erhalte unbegrenzten Zugang zu allen Kursen
Lerne von Branchenführern, Ikonen und erfahrenen Experten
Wähle aus einer Vielzahl von Themen, wie Illustration, Design, Fotografie, Animation und mehr

Schau dir diesen Kurs und Tausende anderer Kurse an

Erhalte unbegrenzten Zugang zu allen Kursen
Lerne von Branchenführern, Ikonen und erfahrenen Experten
Wähle aus einer Vielzahl von Themen, wie Illustration, Design, Fotografie, Animation und mehr

Einheiten dieses Kurses

    • 1.

      Einführung

      2:52

    • 2.

      Einzigartige Charaktere

      9:43

    • 3.

      Schnelle String

      5:25

    • 4.

      Einzigartige Zeichen: ultimative Einfachheit

      5:28

    • 5.

      Abflachende Nestete Arrays

      7:28

    • 6.

      Flachende Arrays Diskussion

      2:07

    • 7.

      Duplikate entfernen

      4:51

    • 8.

      Dupes entfernen: ultimative Einfachheit

      2:55

    • 9.

      Höchste Frequenz

      8:13

    • 10.

      String Rotation

      8:39

  • --
  • Anfänger-Niveau
  • Fortgeschrittenes Niveau
  • Fortgeschrittenes Niveau
  • Jedes Niveau

Von der Community generiert

Das Niveau wird anhand der mehrheitlichen Meinung der Teilnehmer:innen bestimmt, die diesen Kurs bewertet haben. Bis das Feedback von mindestens 5 Teilnehmer:innen eingegangen ist, wird die Empfehlung der Kursleiter:innen angezeigt.

285

Teilnehmer:innen

2

Projekte

Über diesen Kurs

Begleiten Sie den software Arnav Aggarwal für einen detaillierten 55-minütigen Kurs darüber, wie du verschiedene Arten von 55-minute handle

Dies ist Teil 1 einer 4-teiligen Serie.

Beherrsche das JavaScript indem du diese Reihe von sorgfältig kuratierten Interviewfragen und -lösungen durchführst. Diese Probleme stellen die Werkzeuge zur Verfügung, die du brauchst, um jede Frage in einem Interview zu begegnen.

Wir werden besprechen, wie du Algorithmen verfeinern kannst. Wir gehen über clevere, fortgeschrittene Möglichkeiten der Datenmanipulation, nach denen Interviewer suchen. Du wirst in deinem Problem die Lösung und das Interviewen von Fähigkeiten mehr erfahren und sicherer machen.

Teile 2 - 4 werden in den nächsten Wochen veröffentlicht!

Für ein Verständnis der Zeit- und space stehen die folgenden Seiten zur Verfügung:

Große O Notation

Was ist eine deutliche Erklärung der „Big O”

Triff deine:n Kursleiter:in

Teacher Profile Image

Arnav Aggarwal

Full-Stack Engineer & Instructor

Kursleiter:in

Arnav is a full-stack developer from San Diego, CA. He started his journey by attending a coding boot camp and has been working professionally for years since. Arnav has taught at a coding boot camp and tutored web development as well,  giving him a deep understanding of how developers learn to code. He's passionate about all things JavaScript and sharing the knowledge he's collected.

Vollständiges Profil ansehen

Level: All Levels

Kursbewertung

Erwartungen erfüllt?
    Voll und ganz!
  • 0%
  • Ja
  • 0%
  • Teils teils
  • 0%
  • Eher nicht
  • 0%

Warum lohnt sich eine Mitgliedschaft bei Skillshare?

Nimm an prämierten Skillshare Original-Kursen teil

Jeder Kurs setzt sich aus kurzen Einheiten und praktischen Übungsprojekten zusammen

Mit deiner Mitgliedschaft unterstützt du die Kursleiter:innen auf Skillshare

Lerne von überall aus

Ob auf dem Weg zur Arbeit, zur Uni oder im Flieger - streame oder lade Kurse herunter mit der Skillshare-App und lerne, wo auch immer du möchtest.

Transkripte

1. Einführung: Mein Name ist Sarnoff und ich bin ein kompletter Software-Ingenieur und Engineering-Instruktor. Ich habe Software Engineering in einem Coding Boot Camp erzählt, und etwas, das ich immer wieder bemerkt habe, war, dass Studenten, obwohl extrem hell und in der Lage, leistungsstarke, dynamische Websites zu bauen , waren nicht bereit für die Arten von Fragen, die sie in ihren Interviews gesehen. Nachdem ich beobachtet hatte, wie diese Schüler mit typischen Interviewfragen kämpfen, beschloss ich, Fragen zu erstellen und zu sammeln, die die Schüler in ihren Interviews sehen könnten. Und ich habe sie ausgehändigt. Es war zusätzliche Übung für die Schüler zu versuchen. Sie erzählten mir immer wieder, wie sehr die Probleme ihnen geholfen haben, die Löcher in ihrem Wissen zu sehen und sie mit den Fähigkeiten, die sie brauchten, fielen. Dieser Kurs ist der Höhepunkt dieser Fragen. Fast alle diese Probleme sind Variationen von Fragen, die mir selbst gestellt wurden oder die andere, die ich kenne, in Interviews gestellt wurden. Nun, Sie werden diese genauen Fragen nicht in Ihren Interviews sehen. Die Strategien, die Sie lernen, indem Sie unsere Öffentlichkeit lösen, sind für fast jedes Problem anwendbar , das Sie gegeben werden. Hier ist die allgemeine Struktur des Kurses wird typischerweise mit der Erstellung eines Brute-Force-Algorithmus beginnen , der das Problem gut löst, dann verfeinern, bis wir Zeit oder Raum Komplexität oder beides optimieren können. Am Ende des Kurses haben Sie mehrere algorithmische Strategien gemeistert, die Sie auf eine Vielzahl von Problemen anwenden können . Wir lernen Wege, die Algorithmen, die wir entwickeln, kritisch zu analysieren und zu finden, drehen Sie sie, um die Zeit zu reduzieren, die sie benötigen. Das ist genau das, wonach ein Interviewer gesucht hat. Es gibt ein paar Voraussetzungen für diesen Kurs. Ähm, zuerst sollten Sie grundlegende Kenntnisse über JavaScript und die Fähigkeit haben, sinnvollen Code damit zu schreiben . Sie sollten auch mit Basic ES 2015-Konzepten, solchen Null-Funktionen und den Schlüsselwörtern Let und Const vertraut sein. Sie sollten eine Vorstellung davon haben, was die Begriffe, Zeit und Raumkomplexität bedeuten. Es ist in Ordnung, wenn Sie nicht genau wissen, was sie sind, da wir sie für jede Lösung detailliert finden werden. Der Code-Editor, den ich in meinen Videos verwende, ist Ripple. Uh, Sie können dorthin gelangen, indem Sie den Rebel Punkt i t Slash Sprachen Slash Javascript, und der Grund, warum ich das benutze, ist, weil es einfach und funktional ist, und lassen Sie uns auf Ihren Code konzentrieren, aber Sie sind natürlich, frei, jeden Code-Editor zu verwenden, den Sie mögen. Das Projekt für diesen Kurs besteht darin, eines der Probleme auszuwählen, die in der Klasse behandelt werden. Es gibt insgesamt fünf hier aufgelistet und teilen Sie Ihre eigene Lösung. Es gibt 1000 Möglichkeiten, eines dieser Probleme zu lösen, und die Klasse wird davon profitieren, Ihre Version zu sehen . Willkommen auf dem Kurs. Ich freue mich, Ihnen beizubringen, was ich weiß und Ihnen dabei helfen zu können, Ihre Interviews zu unterstützen. Wann immer du bereit bist, sehe ich dich beim ersten Problem. 2. Einzigartige Figuren: willkommen zu ihrem ersten Problem ist einzigartig. Das Ziel hier ist es, eine Funktion zu schreiben, die eine Zeichenfolge annimmt und zu bestimmen, ob jedes Zeichen in dieser Zeichenfolge nur einmal angezeigt wird. Im Wesentlichen versuchen wir zu sehen, ob jedes Zeichen in der Zeichenfolge in dieser Stärke einzigartig ist. Wir wollten Groß- und Kleinschreibung beachten, was bedeutet, dass sowohl Kleinbuchstaben als auch Großbuchstaben eines Buchstabens in derselben Zeichenfolge als eindeutig angesehen werden . Hier sind einige Beispiele. Wir erhalten eine normale Zeichenfolge A, B, C, D E f, und alles ist einzigartig, also wollen wir, dass die Funktion zurückkehrt. Wahr. Dieses nächste Beispiel zeigt nur, dass wir möchten, dass unsere Funktion in der Lage ist, eine Zeichenfolge mit jeder Art von Zeichen zu akzeptieren , nicht nur Buchstaben. Wieder. Sie sind alle einzigartig. Also werden wir wahr. Dieses dritte Beispiel zeigt wieder, dass ein Kleinbuchstaben A in einem Großbuchstaben A in der gleichen Zeichenfolge immer noch möchten wir unsere Funktion zurückgeben. True für diese Eingabe zeigt die 4. 1 eine doppelte Kleinschreibung acht und ihre Funktion würde false zurückgeben. Lassen Sie uns einfach voran und beginnen Sie sofort, diese Funktion zu schreiben. Um sicherzustellen, dass jedes Zeichen in unserer Zeichenfolge einzigartig ist, müssen wir jedes Zeichen in der Zeichenfolge verarbeiten, damit wir wissen, dass wir eine Schleife machen müssen. Gehen wir voran und fangen dort an. Was wollen wir in dieser Schleife tun? Nun, eine Strategie, die wir anwenden können, ist die folgende. Unsere Schleife hier wird durch eine Zeichenfolge von links nach rechts gehen. Also, wenn wir dies als Beispiel nehmen, werden wir bei einem beginnen. Was wir tun können, ist, dass wir eine andere Schleife von rechts nach links auf der Suche nach dem gleichen Zeichen haben können . Also, während unsere äußere Schleife auf einem ist, können wir eine innere Schleife haben, die von rechts nach links geht. Suchen Sie auch nach einem, wenn es es findet und es nicht in der gleichen Position ist, an der sich die äußere Schleife befindet , wir wissen, dass wir ein Duplikat haben und wir sofort false zurückgeben können. Wenn es kein Duplikat gibt, läuft das bis zum A hier drüben, und wir wissen, dass es einzigartig auf der Straße ist. Wir können dies wiederholen, indem wir von links nach rechts gehen, während unsere zweite Schleife rechts Zehe nach links geht. Für jeden einzelnen Fall mag dies kompliziert erscheinen, aber es gibt eine kleine Methode, die uns sehr einfach für uns macht. Schreib es uns aus und bespreche es gleich nach dem letzten Index. Das wird genau das tun, was ich gerade beschrieben habe. Es wird durch die Zeichenfolge rechts Zehe links gehen und nach dem Charakter suchen, den wir in diesem Fall zur Verfügung stellen, was auch immer Zeichen, auf dem ich gerade bin. Also wieder, wir geben es in diesem Fall für die allererste Runde, und es wird nach links gehen, um nach einem Also, was wir tun, ist sicherzustellen , dass der letzte Index von A der gleiche ist wie der aktuelle Index, der waren, die auf waren. Dies zeigt, dass die, dass das Zeichen nicht in der Zeichenfolge dupliziert wird. Wenn jedoch jedoch der letzte Index von A nicht der gleiche wie der erste Index eines ist, dann können wir sofort false Um zurückgeben, das ist wirklich die gesamte Logik, die wir am Ende der Funktion benötigen, können wir Es stimmt, es kommt erst her, nachdem es jeden Charakter hier verarbeitet hat und dafür gesorgt hat, dass es keine Duplikate, dysfunktionale Arbeit gibt. Lassen Sie uns voran gehen und Läufercode hier, und wir erwarten, wahr, wahr, falsch zu sehen wahr, , und das ist genau das, was wir sehen erscheinen, so dass unsere Funktion korrekt funktioniert. Lassen Sie uns durch die Zeitkomplexität dieser Funktion gehen, damit wir sehen können, dass wir eine for-Schleife haben und das unsere Zeitkomplexität sofort zu O von n bringt, weil jedes einzelne Zeichen genau hier verarbeitet wird . Wir haben tatsächlich eine andere Schleife in Form des letzten Index von Well, es ist keine Schleife, die wir geschrieben haben. Es ist eine Schleife, die durch die Zeichenfolge von rechts nach links geht. Also das ist eigentlich ein weiteres O des Endes. Da dies innerhalb der äußeren Schleife verschachtelt ist, müssen wir diese Zeitkomplexitäten multiplizieren, um eine endgültige Zeitkomplexität von O von n mal n oh von n quadriert zu geben . Wie hoch ist die Raumkomplexität? Nun, lasst uns darüber nachdenken. Egal wie lang die Zeichenfolge ist, ob es drei Zeichen oder 30 oder 300 sind, wir verwenden immer nur eine Variable in unserer gesamten Funktion. Und das heißt, ich habe nur einen Charakter auf einmal gespeichert. Egal wie größer die Eingabe ist, unsere Funktion nimmt die gleiche winzige Menge an Speicherplatz ein. Also sagen wir, dass es konstanten Raum verwendet, oder O von einem. Das war's für diese Version. Die Lösung. Können wir die Zeitkomplexität ein wenig verbessern? Ja, das können wir. Lasst uns das versuchen. Es gibt etwas, das wir tun können, bevor wir durch unsere Zeichenfolge gehen, um es ein wenig einfacher zu machen , wir können unsere Zeichenfolge sortieren. Also lasst uns weitermachen und das versuchen. Was ich hier bisher getan habe, ist, dass ich die Zeichenfolge nehme und sie in ein Array aufteile. Das ist, was diese Methode dot split mit einer leeren Zeichenfolge genau hier macht. Also an diesem Punkt wären Autos nur gleich einer Reihe von einzelnen Zeichen in der gleichen Zeile, in der wir sie einordnen . Die Zeichen werden nun alle von links nach rechts sortiert. Wenn wir also etwas wie D B A C erhalten würden, würde es aussehen, als hätte es ein Array. Es wäre jetzt ein Array von A, B, B, C und D. Einfach ist, dass was können wir jetzt tun, wo unsere Zeichen sortiert sind? Nun, es gibt eine andere Logik, die wir anwenden können, um das viel einfacher zu machen. Wir werden den Standard for-Schleife wieder brauchen. Eigentlich wollte ich bei einem für diesen einen anfangen, und wir erklären, warum jetzt in einer Sekunde. Aber ich weiß nicht, was die Charaktere einzeln sortiert sind. Wenn es Duplikate gibt, werden sie wieder direkt nebeneinander platziert. Angenommen, wir haben D B A. C A. Dies wird jetzt zu einem B C D Die beiden Duplikate erscheinen direkt nebeneinander. Also, was wir tun wollen, ist für diese Zeichenfolge, oder besser gesagt, dieses Array von Zeichen. Wir wollen mit dem zweiten Zeichen beginnen, und was wir tun wollen, ist es mit dem Zeichen davor zu vergleichen. Wenn sie gleich sind, ist es ein Duplikat, und wir können sofort falsch zurückgeben. Lassen Sie uns das ausprogrammieren. Das war's. Diese Funktion funktioniert auch perfekt. Lassen Sie es uns ausführen, nur um sicherzustellen, dass wir True, True, True, True, Falsch erwarten True, True, . Und genau das bekommen wir. Lass uns das ein bisschen aufräumen. Und wieder, lassen Sie uns über Zeit und Raum Komplexität sprechen. Also in diesem Fall beginnen wir mit einem Laden hier. Nun haben verschiedene Sortieralgorithmen unterschiedliche Zeitkomplexitäten, aber im Allgemeinen, wenn wir über ein Schwert sprechen, können wir die zeitliche Komplexität von O der Endzeiten annehmen. Protokoll von n Dies ist hier eine Standardschleife. Es wird nur Oh, von N sein, weil diese Dinge sequentiell passieren und wir keine Schleife innerhalb einer Schleife haben. Wir können diese einfach hinzufügen. Also fangen wir mit O von M Times an. Ein Log von Ende plus o von N, das sich in oh von N plus n mal entlang von End und N verwandelt, ist ein Begriff niedrigerer Ordnung als dieser hier. Lassen Sie uns dies weiter vereinfachen, um genau zu zeigen, was das bedeutet, wenn wir über Zeit sprechen, Komplexität schwächen. Beseitigen Sie einfach die Bedingungen der niedrigeren Ordnung, damit wir dieses Plus loswerden können und unsere endgültige Zeitkomplexität endet genau das. Oh, von Endzeiten lange von ihnen und dass ihre Zeitkomplexität für diese Lösung. Was ist mit dem Raum? Früher war es über eins, aber jetzt nehmen wir jeden Charakter und wir speichern ihn in Eile. Das ist es, was hier passiert. Also speichern wir jedes Zeichen, was bedeutet, dass wir die gleiche Menge an Speicherplatz wie die Größe der Eingabe. Also wird es sein, oh von, und wir werden über zwei weitere Lösungen im nächsten Video sprechen. Wir sehen uns dort 3. Schnelle String: Willkommen zurück zu seinem einzigartigen. Wir haben jetzt zwei Lösungen durchlaufen und es ist uns gelungen, die Zeitkomplexität von O und Quadrat Thio der Endzeiten zu verbessern. Log des Endes. Wir erreichen dies, indem wir die Zeichenfolge sortieren, die wir als Eingabe erhalten. Wir können unsere Zeitkomplexität sogar noch verbessern. Und das wird eine andere Strategie erfordern. Lasst uns das alles löschen und von vorne anfangen. Also das letzte Mal hatten wir die Saite sortiert. Sie möchten etwas anderes machen Diesmal werden wir ein Objekt erstellen, um Charaktere zu speichern, während wir wieder auf sie stoßen. Wir brauchen eine Schleife, die durch unsere Schnur geht, und sie mag etwas nicht. 04 Schlaufe. Was wir also tun wollen, ist zu überprüfen, ob unser Objekt bereits eine Kopie der momentan verarbeiteten Charakterarbeit enthält . Das war's. Das ist eigentlich das ganze Problem ist nur das. Führen Sie erneut aus und stellen Sie sicher, dass es einwandfrei funktioniert. Und es funktioniert nicht gut. Was ist los? Uh, habe False hier unten zurückgegeben. Das muss wahr sein. Da gehen wir hin. Ich entschuldige mich. Lassen Sie uns also noch einmal durch das gehen, was hier passiert, während wir durch jedes Zeichen gehen, zum Beispiel, Nehmen wir diese Zeichenfolge direkt hier. ABC A e f. Wir werden jeden Artikel einzeln verarbeiten. Also, das erste Mal, wenn wir durch diese Schleife gehen, wird dieses Auto ein Wir werden überprüfen, ob unser Objekt es bereits enthält. Und wenn es so ist, wollen wir Stürze zurückkehren. Unser Objekt ist am Anfang leer. Also geht dieser Scheck vorbei und wir gehen weiter hierher. Wir werden ein in unserem Objekt speichern. Wir werden nur seinen Wert gleich true setzen. So wird unser Objekt jeden Charakter enthalten, den wir bisher bereits bearbeitet haben. Wie wir durch die Schnur gehen, werden wir in ein und dann B hinzufügen und dann sehen, wenn wir zum nächsten ein wieder gehen um zu überprüfen, ob Autos hat den Charakter A Und wenn dieser Adler wahr, da es tut, weil wir bereits gesehen und wir haben es bereits in unser Objekt eingefügt. Wir wissen, dass es ein Duplikat ist und wir können sofort falsch zurückgeben. Wenn wir diese gesamte Schleife durchlaufen, wissen wir, dass es keine Duplikate und die Zeichenfolge gibt, und wir können true zurückgeben. Das war's. Lassen Sie uns über die Zeitkomplexität in dieser Version dieser Funktion sprechen. Wir haben nur eine Schleife. Wir gehen durch jeden Charakter und während wir durch jeden Charakter gehen, die Dinge, die wir hier tun, sind konstante Zeit. Es gibt keine Loops mehr oder irgendetwas von dieser Natur. Also haben wir eine einzige Schleife, die uns eine Tom-Komplexität von o von N gibt. Was ist mit Raum? Nun, jeder Charakter wird in unserem Objekt gespeichert. Also wird Raum auch eine Liebe N sein, weil er proportional zur Größe der Eingabe ist. Es gibt einen Weg, dass wir das etwas ändern können. Anstelle eines Objekts werden wir ein E S 2015-Konstrukt verwenden, das eine Menge genannt wird, jetzt eine Menge ähnlich wie ein Objekt. Außer, dass es für diese genaue Aufgabe besser geeignet ist, plötzlich als eine Datenstruktur, die eindeutige Elemente enthalten soll. Lassen Sie uns eigentlich voran und schauen Sie sich das Indian Page 4 Set an, wie wir sehen können, ein Set, ist ein Objekt, mit dem Sie eindeutige Werte jeder Art speichern können, uh, in einem Satz. Daher kann ein Wert in einer Einstellung nur einmal auftreten, und er ist in der sets-Auflistung eindeutig. Dies ist also eine speziell angefertigte Datenstruktur. Im Wesentlichen für dieses Problem müssen wir für dieses Problemnur ein paar Dinge ändern. Zum Beispiel, Stattdessen müssen wir eine eingebaute Methode und dasselbe hier anstelle der Einstellung verwenden. Anstatt unseren Artikel auf true zu setzen, fügen wir ihn einfach in das Set ein. Das brauchen wir nicht. Und das brauchen wir nicht. Und noch einmal, um sicherzustellen, dass das funktioniert. Es gibt uns in der Tat, was wir wollen. Wahr, wahr, wahr, falsch. Auch hier, Dies ist sehr ähnlich wie ein off zu der Methode, die wir zuvor mit einem Objekt hatten. Der einzige Unterschied ist, dass wir ausgetauscht oder Datenstruktur. Und es gibt einen sehr guten Grund, warum wir das getan haben. Es wird uns erlauben, unsere Lösung auf eine neue und noch einfachere Art und Weise zu schreiben. Und das werden wir im nächsten Video besprechen. Siehst du, da 4. Einzigartige Charaktere: Ultimative Einfachheit: Willkommen zurück zu seinem einzigartigen. Wir haben nun drei verschiedene Möglichkeiten zur Lösung dieses Problems behandelt. Für die letzte Methode haben wir gezeigt, wie man es sowohl mit einem Objekt als auch mit einem Satz macht. Jetzt fragst du dich vielleicht, warum ich dir dieses Set gezeigt habe. Es tut das gleiche wie ein Objekt, und es bietet nicht wirklich etwas Neues. Es ist nur eine andere Sache für uns, zu lernen und sich daran zu gewöhnen. Nun, ich möchte Ihnen die wahre Macht hinter einem Set zeigen, und ich möchte Ihnen einen Weg zeigen, wie es unsere Lösung viel, viel einfacher machen kann . Also, bevor wir etwas tun, lasst uns in einige der Eigenschaften eines Satzes eintauchen. Lassen Sie uns einfach ein neues hier erstellen und werfen wir ein paar Elemente ein, damit wir ihm ein Array mit den Zahlen eins bis fünf geben , und lassen Sie uns das raus. Wie Sie sehen können, wenn wir uns ein Array setzen, wird es jedes einzelne Element im Array nehmen. Ein hinzugefügt in das Set. Was war un intuitiv, zumindest für mich, war, was passiert, wenn wir ihm stattdessen eine Zeichenfolge geben? Hoffnungen, so lasst uns voran gehen und loswerden, und stattdessen geben Sie ihm die Zeichenfolge A B C D e. Wie Sie sehen können, was passiert ist, ist jedes einzelne Zeichen in der Zeichenfolge wurde in den Satz eingefügt. Einer nach dem anderen wurde die Saite im Wesentlichen auseinander gespalten. Für uns ist das sehr wichtig. Es gibt noch eine Sache, die ich darauf hinweisen möchte, und das ist die Größeneigenschaft. Eine Zeichenfolge hat also eine length Eigenschaft, die Ihnen die Anzahl der Zeichen in der Zeichenfolge angibt. Ein Satz hat eine Größeneigenschaft, die Ihnen nur die Anzahl der Elemente in der Menge mitteilt. Also, wie erwartet, es fünf, weil wir fünf verschiedene Gegenstände im Set haben. Ich möchte Ihnen noch eine Sache zeigen, was passiert, wenn wir Duplikate hinzufügen. Lassen Sie mich voran und fügen Sie ABC wieder hinzu und wir führen es aus und wir sehen, dass die Ausgabe hier genau die gleiche ist , weil wieder Satz kann nur einzigartige Elemente enthalten. Und die Charaktere A, B und C sind schon da drin. Also ignoriert es die drei völlig. Und das Set enthält fünf Gegenstände, wie wir hier sehen können. Gehen wir weiter und gehen zurück zu unserem Problem. Ich werde das alles löschen und ich werde eine Codezeile schreiben und wir werden gleich danach darüber reden . Das ist eigentlich die gesamte Lösung. Und lassen Sie mich das nur ausführen, um zu zeigen, dass es funktioniert. Und das tut es auch. Gehen Sie vor und testen Sie es auf eigene Faust, wenn Sie möchten. Es wird jedes Mal funktionieren. Lassen Sie uns besprechen, warum das hier oben gezeigt ist. Wenn wir Duplikate in den Satz sind, werden sie vollständig ignoriert. Das ist es, was hier passiert. Wir fügen eine Zeichenfolge in die Menge, und jedes einzelne Zeichen wird in die Menge eingefügt wurden dann überprüft, um zu sehen, ob die Größe des Satzes die gleiche wie die Länge der ursprünglichen Zeichenfolge ist. Wenn es keine Duplikate als die Größe des Satzes, sollte genau die gleiche wie die Länge der Zeichenfolge sein. jedoch Wenn esjedochDuplikate auf der Abrechnung gab, seien Sie etwas kleiner. Indem wir diesen Vergleich direkt zurückgeben, haben wir das ganze Problem gelöst, wenn ihre Einzigartigkeit diese Gleichheit des Wahren und des Funktionalen wahr ist. Wenn doppelte Zeichen vorhanden sind, wird diese Gleichheit nicht gehalten und die Funktion gibt erneut false zurück. Lassen Sie uns durch die Zeit- und Raumkomplexität für diese Funktion gehen. Wir nehmen eine Zeichenfolge und wir fügen sie in die Menge Zeichen für Zeichen. Das ist eine lineare Operation. Also ist es O des Endraums, der wieder jedes einzelne Zeichen in die Menge hinzufügte, also wird es proportional zur Größe der Zeichenfolge sein. Also noch einmal, oh, von n lasst uns schnell einschließen, indem wir über alles reden, was wir bisher abgedeckt haben. Die erste Lösung, die wir entwickelt haben, war die Brute-Force-Lösung, die einen Eid und quadrierte Zeitkomplexität hatte ihre einfache, unkomplizierte. Und es ist die erste Lösung, die die meisten Leute finden. Wenn Sie die Zeitkomplexität identifizieren und dann daran arbeiten können, sie zu verbessern, stellen Sie sich dieser Frage in einem Interview. Die zweite Lösung bestand darin, die Zeichenfolge zu sortieren. Erstens war es in Bezug auf Zeit und Komplexität besser, Komplexität besser, aber wir mussten die Platzkomplexität für diese Lösung erhöhen. Die dritte und vierte Lösung ist ideal. Wir haben die geringste Zeitkomplexität, und wir reduzieren sie auf O von Ende, was eine sehr signifikante Verbesserung ist. Die 4. 1 hier ist klug, aber die 3. 1 wäre mehr als ausreichend gewesen. In einem Interview erreichten sie beide die bestmögliche zeitliche Komplexität. Die Hauptidee ist, davon zu nehmen ist, dass die Anwendung verschiedener Techniken auf ein Problem, Consignia effizient verbessern Zeit oder Raum Komplexität. Durch das Sortieren unserer Daten wurde es gesenkt , unsere Zeitkomplexität gesenkt und dann, mit einer geeigneten Datenstruktur, entweder ein Objekt oder ein Set, verbessert es erneut. Wir werden sehen, dass dies in den zukünftigen Problemen immer wieder auftaucht. Versuchen Sie, einen Objekt-Arraysatz zu verwenden. Stapeln Sie unser Cue oder eine andere Datenstruktur und sehen Sie, ob das neue Wege für Ihre Lösung eröffnet . Ich sehe dich im nächsten Problem im nächsten Video. 5. Flattening Anliegen: Willkommen zu unserem zweiten Problem flachen Array. In diesem Problem werden Eingaben ein Array von verschachtelten Arrays sein, manchmal tief verschachtelte Arrays. Und unser Ziel ist es, eine Funktion zu schreiben, die jedes einzelne Element im Array nimmt und in ein neues flaches Array extrahiert. Hier ist ein Beispiel. Wir erhalten ein Array, das mehrere oder erhöhen darin, plus andere Elemente. Das Ziel ist es, diese Elemente aus ihren tief verschachtelten Arrays in ein einzelnes flaches Array zu bekommen während die Reihenfolge beibehalten wird. Die Eingaben können Zahlen sein, oder sie können Zeichenfolgen sein, oder sie könnten Objekte sein, die wirklich alles sein können. Unser Ziel ist es, sie zu nehmen, was immer sie sind, und ihn in eine flache neue Anordnung zu bringen, während die Ordnung bewahrt wird. Dieses Problem hat einige praktische Verwendungen in einer Entwicklerkarriere. Ich musste viele Male mit verschachtelten Datenquellen umgehen, und die Lösung dieses Problems gibt Ihnen einige Einblicke, wie Sie ähnliche Probleme lösen können, die in der Zukunft auftreten. Im Gegensatz zu dem letzten Problem, bei dem ich Lösungen zeigte und sie dann diskutiert habe, denke ich, dass es in diesem Fall lehrreicher sein wird, die Lösung zu durchlaufen. Also lasst uns weitermachen und loslegen. Ich ermutige Sie, das Video anzuhalten und es zuerst selbst auszuprobieren. Gehen wir weiter. Also müssen wir ein neues Array erstellen. Lasst uns zuerst weitermachen und das tun. Okay? Wir müssen jedes Element in unserem Gedächtnis durchlaufen und sie einzeln verarbeiten. Also brauchen wir eine Schleife. Okay? Ich werde nur den aktuellen Artikel in einer neuen Variablen speichern. Und was wollen wir hier drinnen machen? Nun, wir werden etwas tun wollen. Wenn dieser Artikel hier ein Array ist und wir etwas anderes tun wollen, wenn es nicht in Eile ist , Wenn es kein Array ist, dann können wir es sofort in unser neues Array schieben. Aber wenn es so ist, müssen wir durch jedes Individuum gehen, den Schulkopf auftragen und anfangen, das auszustreichen. Also zuerst, was wir tun wollen, ist zu überprüfen, ob dieses Element ein Array ist. Wenn dieses Element also kein Array ist, wissen wir, dass es nicht weiter verschachtelt ist, und wir können es direkt in unser neues Array schieben. jedoch Wenn es sichjedochum ein Array handelt, was wir tun wollen, ist jedes einzelne Element innerhalb der Batterie zu nehmen und diese einzeln in ein neues Array zu schieben . Also werden wir tatsächlich eine weitere Schleife hier brauchen, und am Ende wollen wir unser neues Array zurückgeben. Okay, also wird diese Funktion hier funktionieren, wenn wir ein Array haben, das eine Ebene tief verschachtelt ist, zum Beispiel, sagen Sie, dies ist unsere Eingabe. Unsere Funktion funktioniert korrekt für dieses Array, und es wird es in ein Array verwandeln, das nicht verschachtelt ist. Das sieht einfach so aus. Nur um sicherzustellen, dass es funktioniert. Lass uns voran gehen und es ausprobieren. Und es funktioniert. Lass uns durchgehen, warum das funktioniert. Also sind wir innen für Schleife, und dieser Gegenstand, das erste Mal, wird die Nummer eins sein. Es ist kein Array, das so ruiniert ist, direkt in ein neues Array zu schieben, das jetzt nur eins darin hat. Das nächste Mal wird dieser Artikel auch sein, auch sein, und wir werden das gleiche tun und wieder dasselbe für drei. Schließlich kommen wir zu diesem Array, das fremde fünf darin hat, und wir werden in diesen Teil der if-Anweisung gehen, die wir durch jedes Element hier gehen und jedes Element drücken, das fremde fünf ist individuell in. So wird es einfach voran gehen und fügen Sie sie auf neue arrangieren wieder mit sechs. Wir gehen hier rein und schieben es direkt rein. Und deshalb funktioniert diese Funktion so, wie sie jetzt funktioniert. Was passiert, wenn wir mehr Notwendigkeiten haben? Zum Beispiel, Wenn wir so etwas haben wie, Entschuldigung, so etwas, es wird nicht funktionieren, weil wir nur eine Ebene tief gehen. Anstatt in das zu gehen und sieben zu drücken, wird es dieses gesamte Array in unser neues Array schieben. Also, wie beheben wir das? Nun, der Schlüssel ist eigentlich hier, also wissen wir nicht, wie viele Ebenen tief wir gehen müssen. Zum Beispiel könnten die Sieben ein weiteres Array tief sein. Es könnte sogar noch weiter gehen, und es könnte einfach weitergehen. Das ist das Problem, das wir lösen wollen. Wir wissen also nicht wirklich, wie oft, und wir müssen gehen, weil wir nicht wissen, wie tief verschachtelt diese Gegenstände sein können. Wollte der Schauspieler das in eine rekursive Funktion verwandeln müssen, und hier ist, wie wir das machen. Das wird funktionieren. Lassen Sie uns voran und testen Sie es, nur um sicherzugehen. Und es funktioniert genau so, wie wir es erwarten. Was haben wir hier gemacht? Nun, wir sagen, dass, wenn wir auf ein verschachteltes Array stoßen, wir werden einfach die gesamte abgeflachte Funktion erneut aufrufen, die notwendig ist. Lass uns darüber nachdenken. Mal sehen. Wir kommen zu diesem Element, das ein Array verschachtelt ist. Sieht aus wie drei Ebenen tief. Wenn das passiert, gehen wir einfach durch. Abflachen noch einmal, so abgeflacht das nächste Mal um niedrig erhalten ein Array, verschachtelt zwei Ebenen tief. Wieder, wir werden es übergeben. Es wird dieses erhalten, und wieder wird es durchgehen und dieses erhalten. Schließlich wird es nur zu den sieben kommen, und es wird das brauchen und es wird es in ein neues Array schieben. Dies funktioniert unabhängig davon, wie tief verschachtelt sind. Array ist 6. Flattening Diskussion: Willkommen zurück zu glätten. Rickerson ist ein schwieriges Konzept, daher ermutige ich Sie, ein paar verschiedene Eingaben zu nehmen und die Funktion mehrmals auf eigene Faust zu durchlaufen . Stellen Sie sicher, dass Sie sich davon überzeugt haben, dass die Lösung so funktioniert, wie Sie denken, dass sie funktioniert . Lassen Sie uns über die Zeitkomplexität dieser Funktion sprechen. Wir haben hier eine Vier-Schleife, und wir haben einen rekursiven Anruf und sogar eine weitere vier Schleife hier unten. Auf der Oberfläche sieht es so aus, als würde die Zeitkomplexität ziemlich verrückt sein, aber es ist eigentlich ziemlich einfach. Lassen Sie uns die Funktion für jetzt ignorieren und denken Sie einfach darüber nach, was sie mit einer Eingabe macht. Wieder. Nehmen wir das hier. Während wir die Funktion durchlaufen, wird jedes Element eins nach dem anderen in unser neues Array geschoben. Also wird unsere Schleife hier gehen und es wird eine verarbeiten und es anders ausdrücken, wenig Prozess zu unserem neuen Array und es wird dasselbe mit drei tun. Sobald er zu diesem Array kommt, taucht es hinein und es wird vier und dann fünf und dann sechs verarbeiten. Und wenn es hier rüber kommt, taucht es einfach tief in die Tiefe, verarbeitet die Sieben und geht dann den ganzen Weg zurück. Wie Sie sehen können, wird jedes Element nur einmal verarbeitet. Wir haben all diese Schleifen und wir haben sogar einen rekursiven Aufruf. Aber am Ende wird jedes Element hier verarbeitet. Einmal Das gibt uns eine lineare Zeit, Komplexität oder oh, des Endes. Und was ist mit dem Weltraum? Nun, jedes einzelne Element wird in ihrem neuen Array gespeichert, also ist es wieder proportional zur Größe der Eingabe, Linear. Das ist es wirklich für dieses Problem. Was Sie davon nehmen können, ist, dass Rikers in ist ein leistungsfähiges Werkzeug. Jedes Mal, wenn Sie sehen können, dass Sie in diesem Fall etwas wiederholen werden tauchen in ein Array und Sie wissen nicht, wie oft Sie es tun müssen, werden Sie wahrscheinlich Rickerson brauchen. Vielen Dank. Und wir sehen uns im nächsten Video. 7. Duplizierte Zeichen entfernen: Willkommen bei Problem Nummer drei. Entfernen Sie Dupes. Das Ziel hier ist es, eine Funktion zu schreiben, die eine Zeichenfolge aufnehmen wird. Die Funktion sollte eine neue Zeichenfolge mit den gleichen Zeichen wie die ursprüngliche Zeichenfolge zurückgeben, jedoch mit doppelten Zeichen entfernt. Wenn unsere Funktion also eine Zeichenfolge mit eindeutigen Zeichen gegeben wird, möchten wir diese genaue Zeichenfolge zurückgeben. Wenn es irgendwelche Duplikate gibt, möchten wir sie entfernen, während die Reihenfolge der Zeichen beibehalten wird. Das ist, was diese beiden Beispiele hier Luft tun. Lassen Sie uns voran und beginnen Sie, diese Funktion erneut zu schreiben. Ich empfehle Ihnen, es zu pausieren und sicher auf sich selbst zu kommen und dann zu diesem Video zurückzukommen. Wir müssen diese Funktion starten, indem wir ein Array erstellen, um die eindeutigen Zeichen in unserer Zeichenfolge zu speichern . Lass uns weitermachen und das tun. Wir werden eine Schleife benötigen, um jedes einzelne Zeichen zu verarbeiten. Also lassen Sie uns richtig, dass wir innerhalb dieser Schleife zuerst überprüfen möchten, ob das aktuelle Zeichen verarbeitet wurde, bereits in unserem Array existiert. Wenn es bereits in unserem Array ist, bedeutet das, dass wir es vorher gesehen haben und wir es nicht wieder einfügen wollen, also wollen wir einfach weitermachen. Wenn es jedoch das erste Mal ist, dass wir es sehen, wollen wir es in unser Array schieben. Unser einzigartiges Cars-Array enthält jetzt nur einzigartige Charaktere. Was wir tun möchten, ist dies in eine Zeichenfolge zu verwandeln und diese Zeichenfolge zurückzugeben, und das ist die Lösung. Lassen Sie uns es laufen und stellen Sie sicher, dass es funktioniert. Und das tut es. In der Tat sehen wir, dass ein B. C D dreimal genau das erscheint, was wir wollen. Lassen Sie uns durch die Zeit und die Raumkomplexität gehen, für die Zeit, die wir hier nicht außen für Schleife haben. Das bringt uns sofort zu O von N Lord linear, weil wir jeden Charakter in dieser for-Schleife verarbeiten , die wir verwenden, umfasst dies selbst ist eine Schleife, weil es durch dieses einzigartige Autos Array geht und nach diesem Auto sucht. Und um dies zu tun, muss es individuell alles im Array durchlaufen. Es muss also das Array von links nach rechts durchlaufen, und das wird aufhören, wenn ein anderer das Element findet oder zum Ende kommt. Aber es ist in der Tat eine Schleife, und weil wir eine Schleife in einer Schleife haben, werden wir oh von Endzeiten Ende haben. Da Sie ihre Zeit Komplexität multiplizieren, was uns toe of n Square führt und das ist unsere Zeitkomplexität. Was ist mit Weltraum? Nun, wir müssen die Zeichenfolge nehmen und jedes einzigartige Zeichen in unser Array einfügen. Also müssen wir im Wesentlichen die gesamte Saite wieder speichern, zumindest fast die ganze Saite . Das wird also Oh, von N sein, weil die Menge der Daten, die wir verwenden, proportional zur Größe der Eingabe sein wird . Es gibt einen Weg, wie wir diese Zeitkomplexität nach einer ganzen Menge besser machen können . Lasst uns das durchmachen. Also füge ich ein Objekt zu unserem Array hinzu, genau hier. Immer wenn wir einen Charakter in unser Array schieben, wollen wir ihn auch zu unserem Objekt hinzufügen. Anstatt das Array zu überprüfen, um zu sehen, ob es unseren Charakter enthält, wollen wir nun das Objekt überprüfen. Also werden wir das hier ersetzen. Dies ist nicht mehr ein O einer Operation. Dies ist eine konstante Zeitüberprüfung. Wenn ein Objekt ein Element enthält, ist eine konstante Zeitoperation. Es passiert so ziemlich sofort, im Gegensatz zu einem Array, das von Anfang bis Ende durchsucht werden muss. Da wir keine Schleife mehr innerhalb einer Schleife haben, haben wir nur eine einzige Schleife, die unsere Zeitkomplexität Toe insgesamt ausmacht. Oh, und es gibt einen Weg, dass wir das etwas einfacher machen können. Es wird nicht viel für eine Zeit oder Raum Komplexität tun, aber es wird das Problem viel eleganter und viel einfacher zu verstehen. Und das werden wir im nächsten Video durchmachen. Wir sehen uns dort. 8. Dupes: Ultimative Einfachheit: Willkommen zurück, um Dupes zu entfernen. Was wir bisher getan haben, ist dieses Problem gelöst und dann die Zeitkomplexität zu reduzieren. Wir begannen bei über und quadriert, und indem wir ein Objekt hinzufügen, schafften wir es auf O des Endes zu reduzieren. Es gibt eine andere Möglichkeit, dieses Problem zu lösen, was Ihre Zeit- oder Raumkomplexität nicht verändert. Das macht das Problem ganz einfacher, darüber nachzudenken. Ich schreibe die Lösung einfach aus und dann können wir sie später besprechen. wir sicher, dass es funktioniert und es tut. Wir bekommen, was wir erwarten. Dies ist die Lösung, und lassen Sie uns erklären, was passiert. Wir benutzen noch einmal ein Set. Also, wenn wir eine Zeichenfolge in einen Satz einfügen, wird jedes einzelne Zeichen in einen Satz nur eindeutige Werte Luft gespeichert eingefügt. Alle Duplikate werden also ignoriert und verworfen, nachdem der Satz erstellt wurde. Wir verwenden diese Methode als Strahlenpunkt von jetzt an, was der Überfall aus tut, ist es in einem epiduralen, einem entzückenden, und JavaScript ist eine Datenstruktur, die unsere behält den Überblick über die Reihenfolge, in der Daten eingefügt und ein Satz tut genau das. Ein Satz wird den Überblick über die Zeichen in der Reihenfolge behalten, in der sie eingefügt wurden, was genau das ist, was wir brauchen, weil es tut, dass wir sagen können, dass, wenn Satz ein ehrenhafter ist und es wird mit dieser Methode arbeiten , aus der buchstäblich angeordnete verwandelte es in ein Array. Diese Aussage hier ist also gleich einem Array, das die eindeutigen Zeichen und die Stärke mit ihrer Reihenfolge enthält. Alles, was wir danach tun, ist die Verwendung von Join, um sie in eine Zeichenfolge zu verwandeln. Die Zeitkomplexität ist hier genau die gleiche. Wir nehmen jedes Zeichen und setzen eins nach dem anderen in den Satz ein. Das ist also die Schleife. Wir geben uns oh, von Ende. Es tut uns leid, es in ein Array zu integrieren. Es in ein Array zu verwandeln ist auch dann alt und dann, es als oh, von n wieder zu verbinden . Also haben wir drei n und wenn wir die Konstante fallen lassen, bleiben wir bei O von n für Raumkomplexität. Wir setzen jedes Zeichen in einen Satz und dann in ein Array. Also haben wir oh von zwei n, die wieder O von n. Hoffentlich zeigt Ihnen das, wie mächtig ein Satz ist und wie viel Mastering Datenstrukturen Ihnen bei diesen Problemen helfen können. Je mehr Sie wissen, desto mehr werden Sie in der Lage sein, diese Dinge und zukünftige Probleme anzuwenden. Wir drehten uns um, was über eine 15-Zeilenfunktion war. Wenn die beiden Zeilen, es ist viel einfacher zu lesen, verstehen und richtig, Ich werde Sie im nächsten Video sehen. 9. Höchste Frequenz: Willkommen zum nächsten Problem. Höchste Frequenz. Das Ziel hier ist es, eine Funktion zu schreiben, die ein Array von Strings aufnehmen und zurückgeben wird. Die Zeichenfolge, die am häufigsten in diesem Problem implizit auftritt, ist, dass Theorie, die Sie erhalten einige doppelte Strings haben könnte, einige darin mehrmals, und wir wollen die eine, die am häufigsten erscheint. Wenn es mehrere Strings mit der gleichen hohen Frequenz gibt, möchten wir diejenige zurückgeben, die zuerst angezeigt wird. Hier sind ein paar Beispiele in der 1. 1 C ist die einzige Zeichenfolge, die mehr als einmal erscheint, also das ist, was wir in der nächsten zurückgeben wollen. ABC erscheint dreimal und D E F zweimal, also wollen wir sehen, dass ABC in der nächsten herauskommt. Sie sind beide nur einmal Präsident. Es tut mir so leid. Und da ABC der Erste ist, wollen wir, dass eine wieder raus kommt und in den letzten GH-Augen und sie sind öfter als alle anderen. Das ist es, was wir wollen zurückkommen. Lassen Sie uns mit der Lösung beginnen, also müssen wir jede Zeichenfolge verarbeiten, die sich in unserem Array befindet, um die Frequenzen im Auge zu behalten . Also müssen wir wie gewohnt mit einer Schleife beginnen, wenn wir zu jeder Saite kommen oder irgendwie Überblick behalten müssen, wie oft wir sie gesehen haben. Lassen Sie uns voran und verwenden Sie ein Objekt, um diese Strings und in der Schleife zu verfolgen. Wenn wir jede Zeichenfolge verarbeiten, können wir fortfahren und unser Objekt aktualisieren. Denken wir also an die erste Saite. Lassen Sie uns voran und konzentrieren Sie sich auf dieses Beispiel für jetzt, bei I gleich Null ist, wird der erste Punkt ABC sein. Lassen Sie uns voran und erstellen Sie eine Variable dafür. Also wird diese Zeichenfolge A B, C und R Objekt ist leer. Wir werden es in die Frequenzen hinzufügen wollen. Objekt. Okay, so weit, so gut. Gehen wir weiter und sehen, was passiert, wenn wir wieder zur nächsten Saite gehen. ABC, wir werden hier drin sein, und diese Saite wird wieder ABC sein. Aber jetzt tut diese Codezeile nicht das, was wir wollen. Es setzt den Wert auf einen zurück, der nichts für uns tut. Wir werden einen Weg brauchen, um zu überprüfen, ob es das erste Mal ist, dass unser Objekt diese Zeichenfolge gesehen hat. Wenn ja, müssen wir ihm den Wert eines geben. Sonst müssen wir irgendwie den Wert nehmen und ihn um eins erhöhen. Lassen Sie uns damit beginnen, zu überprüfen, ob es das erste Mal ist, dass wir diese Zeichenfolge gesehen haben. Und wenn es so ist, dann wird es im Objekt noch nicht anwesend sein. Wenn es also noch nicht im Objekt existiert, sollte die Überprüfung darauf undefiniert sein. Und wenn es nicht definiert ist, müssen wir ihm den Wert eins geben. Wer ist das erste Mal, dass wir die Saite gesehen haben? Wenn jedoch bereits existiert, es jedoch bereits existiert, was bedeutet, dass es Ihren Wert 123 bereits zementiert hat oder was auch immer wir brauchen, um diesen um eins zu erhöhen . Das sieht so aus, als wäre es für mich sinnvoll. Lasst uns weitermachen und unser Frequenz-Array auslangen. Sorry Objekt nur um sicherzustellen, dass wir das richtig machen. Und ich werde vorerst diese drei loswerden und einfach mit diesem Beispiel arbeiten damit wir sehen, was wir erwarten. A. B C ist hier zweimal D E f. Dreimal und G h I viermal drinnen. Unser Objekt spiegelt das richtig wider. Was müssen wir jetzt tun? Nun, wir müssen irgendwie herausfinden, welcher dieser Werte der höchste ist. Wir müssen wissen, dass vier hier der höchste Wert ist und dass die Zeichenfolge, die diesem entspricht , G H I ist. Wir könnten einige Verarbeitung hier unten durchführen. Wir könnten jeden einzelnen Wert im Objekt nehmen und dann die höchste Zahl verfolgen . Aber wir haben bereits eine for-Schleife. Wir können das nur tun, indem wir eine Variable während der gesamten Schleife aktualisieren. Lassen Sie uns voran und erstellen Sie eine Variable, um die höchste freie Konzept zu speichern, auf die wir bisher gestoßen sind . Und wir werden es auf Null initialisieren. Und es ist auch kreative Variable für die häufigste Zeichenfolge, und wir initialisieren es auf das erste Element in unseren Strings sind ein in unserer Schleife. Lassen Sie uns voran und aktualisieren Sie diese jedes Mal, wenn wir durch unsere Schleife gehen. Also müssen sie nur aktualisiert werden, wenn wir eine neue maximale Frequenz haben. Lassen Sie uns überprüfen, ob wir diese Überprüfung genau hier überprüft, ob unsere neue Frequenz bedeutet, dass der Wert, den wir gerade aktualisiert haben, höher ist als die vorherige Max Frequenz, die wir hatten. Wenn ja, wollen wir diese Frequenznummer aktualisieren Wir wollen auch die häufigste Zeichenfolge aktualisieren weil das bedeutet, dass sie einmal geändert wird, während wir durch diese Schleife gehen Diese beiden Variablen werden wiederholt aktualisiert, da sie Teoh benötigen. Am Ende werden die häufigsten Strings Variable hier die häufigste Straße enthalten. Also können wir einfach weitermachen und das zurückgeben. Fügen wir diese wieder hinzu und stellen sicher, dass alles so funktioniert, wie wir es erwarten Wenn es also ist, erwarten wir, dass wir ABC, ABC und G H Isehen ABC und G H I Und das ist, was wir bekommen. Es scheint richtig zu funktionieren. Lassen Sie uns über die zeitliche Komplexität dieser Lösung sprechen. Wir haben hier sofort eine Schleife. Bringen Sie uns 20 von Ende in die Schleife. Alles, was wir tun, ist ein paar Prüfungen durchzuführen und bei Bedarf ein paar Variablen zu aktualisieren. Das sind keine Schleifen an sich, also werden sie unsere Zeitkomplexität nicht ändern. Also wird unsere letzte Komplexität der Zeit von jedem sein und was ist mit dem Raum? Nun, wir speichern jede Zeichenfolge, die wir finden, in unserem Frequenzobjekt. Wenn unser Strings-Array nur eindeutige Strings enthält, dann wird dieses Frequenzobjekt alle von ihnen enthalten. Also ist es im Wesentlichen proportional zur Größe unserer Saiten sind eine Bedeutung. Es wird auch oh, vom Ende sein . Was können wir diesem Problem wegnehmen? Nun, dieses Problem zwingt uns im Wesentlichen, Aktualisierungsdaten zu speichern, während wir unsere Schleife durchlaufen. Dies ist eine gute Technik im Auge zu behalten. Probleme erfordern dies oft nicht, und eine Lösung kann erreicht werden, ohne den Überblick zu behalten. In der Tat, selbst hier mussten wir das nicht tun. Wir könnten das einfach auskommentieren und dies auskommentieren, und wir könnten hier unten einige Nachbearbeitung ausführen. Wir könnten ein wenig mehr Code hinzufügen, um dann herauszufinden, welcher Wert der höchste ist und welcher String dann entspricht. Aber stattdessen behalten wir alles im Auge, während wir unsere Schleife durchlaufen, also brauchen wir danach nichts zu tun. im Allgemeinen, Versuchen Sieim Allgemeinen,zu sehen. Wenn das Speichern von Daten und ein kreativer Weg einen Algorithmus einfacher machen kann, kann dies die Zeitkomplexität verringern. Aber wenn nicht, kann es zumindest den Code einfacher machen. Wir werden im nächsten Video sehen 10. String: Willkommen zum nächsten Problem. Zeichenfolgen-Rotation. Das Ziel hier ist es, eine Funktion zu schreiben, die in zwei Strings nimmt und festzustellen, ob ihre Rotationen voneinander. Was ist nun die Rotation? Dies sind Beispiele für Rotationen, so haben wir die Zeichenfolge 1234 Um es zu drehen, können wir ein Zeichen vom Anfang nehmen und es am Ende platzieren. Das gibt uns 2341 Wir können das wieder tun und die beiden nehmen und bis zum Ende bewegen, und wir bekommen 3412 und das noch einmal tun. Eine Drei bis ans Ende zu bewegen, bekommt seine 4123 Das ist eine Drehung hier. Ein paar weitere Beispiele. Lassen Sie uns voran und beginnen Sie mit dem Schreiben dieser Funktion, so dass der allererste Weg, wie wir herausfinden können, ob sie sicherlich keine Rotationen sind, ist, ob die Saiten unterschiedliche Längen für zwei Saiten drei Rotationen voneinander haben. Sie müssen exakt die gleiche Länge haben. Also lasst uns voran gehen und das überprüfen. Ok, fertig damit? Nein. Eine Möglichkeit, dieses Problem zu lösen, wäre, unsere erste Saite zu nehmen und jede mögliche Rotation davon zu erzeugen , während wir das tun. Wir prüfen, ob diese Rotationen der zweiten Zeichenfolge entsprechen. Wenn sie das tun, können wir wahr zurückkehren. Und wenn wir alle Rotationen durchlaufen und es keine Übereinstimmungen gibt, als wir false zurückgeben können , lassen Sie uns voran und schreiben eine Schleife, um das für uns zu tun, und dazu werden wir die String-Punkt-Methode verwenden. Dies ist eine Methode, die Text aus einer Zeichenfolge extrahiert. Der Weg, es zu verwenden, ist, dass wir es Parametern den Start- und End-Index geben, den wir ausschneiden möchten , und es wird zwischen diesen beiden Indizes schneiden. Also, zum Beispiel, das bei Indizes eins und acht zu schneiden bedeutet, Index eins ist genau hier und die nächste acht ist genau hier und wir werden alles zwischen diesen beiden bekommen. Das bedeutet, dass dies die Methode verwendet wird. Mal sehen, was darin ausdruckt und lass uns voran gehen und drei davon loswerden und uns auf diesen konzentrieren. Okay, so wie ich mich von links nach rechts bewegt, bekommen wir etwas größere und größere Scheiben. Lassen Sie uns nun versuchen, andere Indizes. Versuchen wir es zu schneiden. Wir haben es von Anfang bis zum Index getan, und jetzt versuchen wir den Index auf die Länge der Strings. Und was wir hier sehen, ist eine vollkommen saubere Spaltung. Was wir tun müssen, um diese Saite tatsächlich zu drehen, ihren Platz, dies am Anfang. Und dann würden wir Rotation mit einem R am Ende bekommen. Wir machen das weiter und setzen diese Saite vor diese, und wir haben jede mögliche Rotation erzeugt. Lassen Sie mich Ihnen zeigen, was das bedeutet. Wir müssen nur die Reihenfolge der beiden ändern und wir bekommen jede einzelne Drehung eins nach dem anderen von Buchstaben. Nehmen Sie es vom Anfang ab und legen Sie es am Ende. Das ist genau das, was wir jetzt tun müssen, ist überprüfen. F Rotation Rotation ist gleich der zweiten Zeichenfolge. Wenn dies der Fall ist, können wir aus der Schleife ausbrechen und true zurückgeben. Und wenn wir bis zum Ende kommen und keiner von ihnen übereinstimmt, geben wir falsch zurück. Lasst uns weitermachen, diese loswerden und sehen, ob das funktioniert. Also erwarten wir, Waffenstillstand und zwei falsch ist, und das ist, was wir bekommen. Wir sehen gut aus. Lassen Sie uns über die Zeitkomplexität dieser Funktion sprechen. Also haben wir hier bereits eine Schleife, uns zu Ole von Ed diesmal n bringt, ist nicht die Größe der Theorie a oder die Anzahl der Argumente . Es wird tatsächlich die Länge der Strings darstellen, weil das so ziemlich das einzige ist , was sich ändert. In der Tat ist das das einzige, was sich ändert, was wir messen können. Also haben wir hier eine No-of-End-Schleife. Lassen Sie uns diese Linie ein wenig genau untersuchen. Also Scheibe, nach den Docks für Indianer, ist eigentlich eine Schleife, weil jedes Zeichen eins nach dem anderen kontaminiert werden muss. Also glauben Sie es oder nicht, Scheibe ist ein O von n Operation. Und was wir hier haben, ist eine Schleife innerhalb einer Schleife, die uns zu bringt, obwohl von n Quadrat und Raum. Wir speichern eine Rotation und diese Variable, so dass die Anzahl der Zeichen in der Zeichenfolge, die diese Variable hält, gleich der Länge der Zeichenfolge sein wird . , Mit anderen Worten, die Menge an Speicherplatz, die diese Variable verbraucht, wird äquivalent zu der Menge an Speicherplatz sein , die diese Zeichenfolge verbraucht. Das wird also linear sein. Das ist es für die Lösung. Aber es gibt noch eine, die das für uns viel einfacher macht. Ich werde den Code ausschreiben, und wir werden ihn sofort danach besprechen und lassen es uns laufen und wir sind gut zu gehen, jetzt überlegen wir uns eine Minute warum das funktioniert. Nehmen wir diese beiden und platzieren wir die Drehung neben sich selbst. Also, mit anderen Worten, wir führen diese Aktion genau hier durch. Str wana plus str eins Und wir überprüfen, ob dies, wenn diese Zeichenfolge so die erste 1 dupliziert die 2. 1 irgendwo darin hat. Also suchen wir nach der Existenz dieses irgendwo in diesem und wir können es finden. Es ist genau da. Probieren Sie es selbst aus. Aber jede einzelne Rotation, die Sie finden können, wird in dieser Zeichenfolge vorhanden sein. Das ist so ziemlich ein Gesetz hier. In Bezug auf die Funktionsweise dieser Rotationen setzen Sie eine Zeichenfolge neben sich selbst und sie enthält jede Drehung der ursprünglichen Zeichenfolge. Die Zeitkomplexität dieser Lösung ist oh, von n. Alles, was wir tun, ist, eine Zeichenfolge zu sich selbst hinzuzufügen, die linear ist und dann zu prüfen, ob es die zweite 1 enthält, die auch Lanier ist. So wurde das in oh, aus und Raum ist auch von n, weil wir diese beiden hinzufügen und die Länge genau proportional sein wird . Doppelt auf die Länge dieses hier. Das ist es für dieses Problem, das nächste zu sehen.