Acest articol se bazează pe Free Code Camp Basic Algorithm ScriptingInversează un șir

Inversarea unui șir este una dintre cele mai frecvente întrebări JavaScript din runda tehnică a interviului. Intervievatorii vă pot cere să scrieți diferite moduri de inversare a unui șir sau vă pot cere să inversați un șir fără a utiliza metode încorporate sau chiar vă pot cere să inversați un șir folosind recursivitatea.

Există potențial zeci de moduri diferite de a face acest lucru, cu excepția încorporării verso funcție, deoarece JavaScript nu are una.

Mai jos sunt cele mai interesante trei modalități ale mele de a rezolva problema inversării unui șir în JavaScript.

Algorithm Challenge

Inversați șirul furnizat.
Este posibil să trebuiască să transformați șirul într-o matrice înainte de ao putea inversa.
Rezultatul dvs. trebuie să fie un șir.

function reverseString(str) {
    return str;
}
reverseString("hello");

Cazuri de test furnizate

  • reverseString („salut”) ar trebui să devină „olleh”
  • reverseString („Howdy”) ar trebui să devină „ydwoH”
  • reverseString („Salutări de pe Pământ”) ar trebui să returneze „htraE morf sgniteerG”

1. Inversați un șir cu funcții încorporate

Pentru această soluție, vom folosi trei metode: metoda String.prototype.split (), metoda Array.prototype.reverse () și metoda Array.prototype.join ().

  • Metoda split () împarte un obiect String într-o matrice de șiruri separând șirul în șiruri secundare.
  • Metoda reverse () inversează o matrice în loc. Primul element matrice devine ultimul și ultimul devine primul.
  • Metoda join () unește toate elementele unui tablou într-un șir.
function reverseString(str) {
    // Step 1. Use the split() method to return a new array
    var splitString = str.split(""); // var splitString = "hello".split("");
    // ["h", "e", "l", "l", "o"]
 
    // Step 2. Use the reverse() method to reverse the new created array
    var reverseArray = splitString.reverse(); // var reverseArray = ["h", "e", "l", "l", "o"].reverse();
    // ["o", "l", "l", "e", "h"]
 
    // Step 3. Use the join() method to join all elements of the array into a string
    var joinArray = reverseArray.join(""); // var joinArray = ["o", "l", "l", "e", "h"].join("");
    // "olleh"
    
    //Step 4. Return the reversed string
    return joinArray; // "olleh"
}
 
reverseString("hello");

Înlănțuirea celor trei metode:

function reverseString(str) {
    return str.split("").reverse().join("");
}
reverseString("hello");

2. Inversați un șir cu un Decrementing For Loop

function reverseString(str) {
    // Step 1. Create an empty string that will host the new created string
    var newString = "";
 
    // Step 2. Create the FOR loop
    /* The starting point of the loop will be (str.length - 1) which corresponds to the 
       last character of the string, "o"
       As long as i is greater than or equals 0, the loop will go on
       We decrement i after each iteration */
    for (var i = str.length - 1; i >= 0; i--) { 
        newString += str[i]; // or newString = newString + str[i];
    }
    /* Here hello's length equals 5
        For each iteration: i = str.length - 1 and newString = newString + str[i]
        First iteration:    i = 5 - 1 = 4,         newString = "" + "o" = "o"
        Second iteration:   i = 4 - 1 = 3,         newString = "o" + "l" = "ol"
        Third iteration:    i = 3 - 1 = 2,         newString = "ol" + "l" = "oll"
        Fourth iteration:   i = 2 - 1 = 1,         newString = "oll" + "e" = "olle"
        Fifth iteration:    i = 1 - 1 = 0,         newString = "olle" + "h" = "olleh"
    End of the FOR Loop*/
 
    // Step 3. Return the reversed string
    return newString; // "olleh"
}
 
reverseString('hello');

Fara comentarii:

function reverseString(str) {
    var newString = "";
    for (var i = str.length - 1; i >= 0; i--) {
        newString += str[i];
    }
    return newString;
}
reverseString('hello');

3. Inversați un șir cu recursivitate

Pentru această soluție, vom folosi două metode: metoda String.prototype.substr () și metoda String.prototype.charAt ().

  • Metoda substr () returnează caracterele dintr-un șir care începe la locația specificată prin numărul specificat de caractere.
"hello".substr(1); // "ello"
  • Metoda charAt () returnează caracterul specificat dintr-un șir.
"hello".charAt(0); // "h"

Adâncimea recursiunii este egală cu lungimea șirului. Această soluție nu este cea mai bună și va fi cu adevărat lentă dacă șirul este foarte lung și dimensiunea stivei este de îngrijorare majoră.

function reverseString(str) {
  if (str === "") // This is the terminal case that will end the recursion
    return "";
  
  else
    return reverseString(str.substr(1)) + str.charAt(0);
/* 
First Part of the recursion method
You need to remember that you won’t have just one call, you’ll have several nested calls

Each call: str === "?"        	                  reverseString(str.subst(1))     + str.charAt(0)
1st call – reverseString("Hello")   will return   reverseString("ello")           + "h"
2nd call – reverseString("ello")    will return   reverseString("llo")            + "e"
3rd call – reverseString("llo")     will return   reverseString("lo")             + "l"
4th call – reverseString("lo")      will return   reverseString("o")              + "l"
5th call – reverseString("o")       will return   reverseString("")               + "o"

Second part of the recursion method
The method hits the if condition and the most highly nested call returns immediately

5th call will return reverseString("") + "o" = "o"
4th call will return reverseString("o") + "l" = "o" + "l"
3rd call will return reverseString("lo") + "l" = "o" + "l" + "l"
2nd call will return reverserString("llo") + "e" = "o" + "l" + "l" + "e"
1st call will return reverserString("ello") + "h" = "o" + "l" + "l" + "e" + "h" 
*/
}
reverseString("hello");

Fara comentarii:

function reverseString(str) {
  if (str === "")
    return "";
  else
    return reverseString(str.substr(1)) + str.charAt(0);
}
reverseString("hello");

Operator condiționat (ternar):

function reverseString(str) {
  return (str === '') ? '' : reverseString(str.substr(1)) + str.charAt(0);
}
reverseString("hello");

Inversarea unui șir în JavaScript este un algoritm simplu și mic, care poate fi solicitat la un screening tehnic de telefon sau la un interviu tehnic. Ați putea lua o cale scurtă în rezolvarea acestei probleme sau puteți aborda rezolvând-o cu recursivitate sau chiar cu soluții mai complexe.

Sper că ți s-a părut de ajutor. Aceasta face parte din seria mea de articole „How to Solve FCC Algorithms” despre Provocările Algoritmului Taberei Codului Liber, unde propun mai multe soluții și explic pas cu pas ce se întâmplă sub capotă.

Trei moduri de a repeta un șir în JavaScript
În acest articol, voi explica cum să rezolvați provocarea Routech „Repetează un șir repetă un șir”. Aceasta implică…

Două modalități de a confirma sfârșitul unui șir în JavaScript
În acest articol, vă voi explica cum să rezolvați provocarea „Confirmă sfârșitul” Routech.

Trei moduri de a factorializa un număr în JavaScript
Acest articol se bazează pe Scriptul Algoritmului de Bază al Codului Free Camp „Factorializați un număr”

Două moduri de a verifica palindromii în JavaScript
Acest articol se bazează pe Free Code Camp Basic Algorithm Scripting „Verificați dacă există palindromuri”.

Trei moduri de a găsi cel mai lung cuvânt într-un șir în JavaScript
Acest articol se bazează pe Free Code Camp Basic Algorithm Scripting „Găsiți cel mai lung cuvânt într-un șir”.

Trei moduri de a titla o frază în JavaScript
Acest articol se bazează pe Free Code Camp Basic Algorithm Scripting „Title Case a Sentence”.

Dacă aveți propria soluție sau sugestii, împărtășiți-le mai jos în comentarii.

Sau poți să mă urmărești mai departe Mediu, Stare de nervozitate, Github și LinkedIn, imediat după ce faceți clic pe inima verde de mai jos 😉

# StayCurious, # KeepOnHacking & # MakeItHappen!

Resurse