În acest articol, voi explica cum să rezolvați Routech’s „Repetați un șir repetați un șir” provocare. Aceasta implică repetarea unui șir de un anumit număr de ori.

Există cele trei abordări pe care le voi aborda:

  1. folosind o buclă while
  2. folosind recursivitatea
  3. folosind metoda ES6 repeat ()

Descrierea provocării algoritmice

Repetați un șir dat (primul argument) num ori (al doilea argument). Returnează un șir gol dacă num nu este un număr pozitiv.

function repeatStringNumTimes(str, num) {
  return str;
}
repeatStringNumTimes("abc", 3);

Cazuri de test furnizate

repeatStringNumTimes("*", 3) should return "***".

repeatStringNumTimes("abc", 3) should return "abcabcabc".

repeatStringNumTimes("abc", 4) should return "abcabcabcabc".

repeatStringNumTimes("abc", 1) should return "abc".

repeatStringNumTimes("*", 8) should return "********".

repeatStringNumTimes("abc", -2) should return "".

Abordarea nr. 1: Repetați un șir cu un buclă While

O instrucțiune while își execută instrucțiunea atâta timp cât o condiție specificată este evaluată ca fiind adevărată.

O declarație while arată astfel:

while (condition)
  statement

cu o condiție care este evaluată înainte de fiecare trecere prin buclă. Dacă condiția este adevărată, instrucțiunea este executată. Dacă condiția este falsă, execuția continuă cu orice instrucțiune după bucla while.

Instrucțiunea este executată atâta timp cât condiția este adevărată. Iată soluția:


function repeatStringNumTimes(string, times) {
  // Step 1. Create an empty string that will host the repeated string
  var repeatedString = "";

  // Step 2. Set the While loop with (times > 0) as the condition to check
  while (times > 0) { // As long as times is greater than 0, the statement is executed
    // The statement
    repeatedString += string; // Same as repeatedString = repeatedString + string;
    times--; // Same as times = times - 1;
  }
  /* While loop logic
                      Condition       T/F       repeatedString += string      repeatedString        times
    First iteration    (3 > 0)        true            "" + "abc"                  "abc"               2
    Second iteration   (2 > 0)        true           "abc" + "abc"               "abcabc"             1
    Third iteration    (1 > 0)        true          "abcabc" + "abc"            "abcabcabc"           0
    Fourth iteration   (0 > 0)        false
    }
  */
  
  // Step 3. Return the repeated string
  return repeatedString; // "abcabcabc"
}

repeatStringNumTimes("abc", 3);

Și din nou, fără comentarii:

function repeatStringNumTimes(string, times) {
  var repeatedString = "";
  while (times > 0) {
    repeatedString += string;
    times--;
  }
  return repeatedString;
}
repeatStringNumTimes("abc", 3);

Abordarea nr. 2: Repetați un șir folosind o condițională și recursivă

Recursivitatea este o tehnică pentru iterarea unei operații prin apelarea unei funcții în mod repetat până când ajunge la un rezultat. Există câteva caracteristici cheie ale recursivității care trebuie incluse pentru a funcționa corect.

  • Primul este un caz de baza: aceasta este o afirmație, de obicei în cadrul unei clauze condiționale precum if, care oprește recursiunea.
  • Al doilea este un caz recursiv: aceasta este afirmația în care funcția recursivă este apelată la ea însăși.

Iată soluția:

function repeatStringNumTimes(string, times) {
  // Step 1. Check if times is negative and return an empty string if true
  if (times < 0) {
    return "";
  }
  
  // Step 2. Check if times equals to 1 and return the string itself if it's the case.
  if (times === 1) {
    return string;
  }
  
  // Step 3. Use recursion
  else {
    return string + repeatStringNumTimes(string, times - 1); // return "abcabcabc";
  }
  /* 
    First Part of the recursion method
    You need to remember that you won’t have just one call, you’ll have several nested calls
                     times       string + repeatStringNumTimes(string, times - 1)
      1st call         3                 "abc" + ("abc", 3 - 1)
      2nd call         2                 "abc" + ("abc", 2 - 1)
      3rd call         1                 "abc" => if (times === 1) return string;
      4th call         0                  ""   => if (times <= 0) return "";
    Second part of the recursion method
      4th call will return      ""
      3rd call will return     "abc"
      2nd call will return     "abc"
      1st call will return     "abc"
    The final call is a concatenation of all the strings
    return "abc" + "abc" + "abc"; // return "abcabcabc";
  */
}
repeatStringNumTimes("abc", 3);

Și din nou, fără comentarii:

function repeatStringNumTimes(string, times) {
  if(times < 0) 
    return "";
  if(times === 1) 
    return string;
  else 
    return string + repeatStringNumTimes(string, times - 1);
}
repeatStringNumTimes("abc", 3);

Abordarea # 3: Repetați un șir folosind metoda ES6 repeat ()

Pentru această soluție, veți utiliza metoda String.prototype.repeat ():

  • repeat() metoda construiește și returnează un șir nou care conține numărul specificat de copii ale șirului pe care a fost apelat, concatenate împreună.

Iată soluția:


function repeatStringNumTimes(string, times) {
  //Step 1. If times is positive, return the repeated string
  if (times > 0) { // (3 > 0) => true
    return string.repeat(times); // return "abc".repeat(3); => return "abcabcabc";
  }
  
  //Step 2. Else if times is negative, return an empty string if true
  else {
    return "";
  }
}

repeatStringNumTimes("abc", 3);

Și din nou, fără comentarii:

function repeatStringNumTimes(string, times) {
  if (times > 0)
    return string.repeat(times);
  else
    return "";
}
repeatStringNumTimes("abc", 3);

Puteți utiliza un operator ternar ca o comandă rapidă pentru instrucțiunea if / else, astfel:

times > 0 ? string.repeat(times) : "";

Acest lucru poate fi citit ca:

if (times > 0) {    
    return string.repeat(times);
} else {
    return "";
}

Apoi puteți returna operatorul ternar în funcția dvs.:

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 Routech Algorithm, unde propun mai multe soluții și explic pas cu pas ce se întâmplă sub capotă.

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 inversa un șir în JavaScript
Acest articol se bazează pe Free Code Camp Basic Algorithm Scripting „Reverse a String”

Trei moduri de a factorializa un număr în JavaScript
Acest articol se bazează pe algoritmul de bază Free Code Camp Scripting „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 algoritmul de bază Free Code Camp 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 aditionale