Map and Set

1-js/05-data-types/07-map-set/01-array-unique-map/_js.view/test.js

@@ -1,13 +1,13 @@
-describe("unique", function() {
-  it("removes non-unique elements", function() {
+describe("unic", function() {
+  it("elimină elementele neunice", function() {
     let strings = ["Hare", "Krishna", "Hare", "Krishna",
       "Krishna", "Krishna", "Hare", "Hare", ":-O"
     ];
 
     assert.deepEqual(unique(strings), ["Hare", "Krishna", ":-O"]);
   });
 
-  it("does not change the source array", function() {
+  it("nu schuimbă matricea sursă", function() {
     let strings = ["Krishna", "Krishna", "Hare", "Hare"];
     unique(strings);
     assert.deepEqual(strings, ["Krishna", "Krishna", "Hare", "Hare"]);

1-js/05-data-types/07-map-set/01-array-unique-map/task.md

@@ -2,17 +2,17 @@ importance: 5
 
 ---
 
-# Filter unique array members
+# Filtrează membrii unici ai matricei
 
-Let `arr` be an array.
+Let `arr` să fie o matrice.
 
-Create a function `unique(arr)` that should return an array with unique items of `arr`.
+Creați o funcție `unique(arr)` care ar trebui să returneze o matrice cu elemente unice ale lui `arr`.
 
-For instance:
+De exemplu:
 
 ```js
 function unique(arr) {
-  /* your code */
+  /* codul dumneavoastră */
 }
 
 let values = ["Hare", "Krishna", "Hare", "Krishna",
@@ -22,6 +22,6 @@ let values = ["Hare", "Krishna", "Hare", "Krishna",
 alert( unique(values) ); // Hare, Krishna, :-O
 ```
 
-P.S. Here strings are used, but can be values of any type.
+P.S. Aici se folosesc șiruri de caractere, dar pot fi valori de orice tip.
 
-P.P.S. Use `Set` to store unique values.
+P.P.S. Utilizați `Set` pentru a stoca valori unice.

1-js/05-data-types/07-map-set/02-filter-anagrams/_js.view/test.js

@@ -4,7 +4,7 @@ function intersection(arr1, arr2) {
 
 describe("aclean", function() {
 
-  it("returns exactly 1 word from each anagram set", function() {
+  it("returnează exact 1 cuvânt din fiecare set de anagrame", function() {
     let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 
     let result = aclean(arr);
@@ -16,7 +16,7 @@ describe("aclean", function() {
 
   });
 
-  it("is case-insensitive", function() {
+  it("este case-insensitive", function() {
     let arr = ["era", "EAR"];
     assert.equal(aclean(arr).length, 1);
   });

1-js/05-data-types/07-map-set/02-filter-anagrams/solution.md

@@ -1,6 +1,6 @@
-To find all anagrams, let's split every word to letters and sort them. When letter-sorted, all anagrams are same.
+Pentru a găsi toate anagramele, să împărțim fiecare cuvânt în litere și să le sortăm. Atunci când sunt ordonate pe litere, toate anagramele sunt identice.
 
-For instance:
+De exemplu:
 
 ```
 nap, pan -> anp
@@ -9,14 +9,14 @@ cheaters, hectares, teachers -> aceehrst
 ...
 ```
 
-We'll use the letter-sorted variants as map keys to store only one value per each key:
+Vom folosi variantele sortate pe litere ca chei de map pentru a stoca doar o singură valoare pentru fiecare cheie:
 
 ```js run
 function aclean(arr) {
   let map = new Map();
 
   for (let word of arr) {
-    // split the word by letters, sort them and join back
+    // desparte cuvântul după litere, le sortează și le reunește înapoi
 *!*
     let sorted = word.toLowerCase().split('').sort().join(''); // (*)
 */!*
@@ -31,9 +31,9 @@ let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 alert( aclean(arr) );
 ```
 
-Letter-sorting is done by the chain of calls in the line `(*)`.
+Sortarea literelor se face prin lanțul de apeluri din linia `(*)`.
 
-For convenience let's split it into multiple lines:
+Pentru conveniență să o împărțim în mai multe linii:
 
 ```js
 let sorted = word // PAN
@@ -43,21 +43,21 @@ let sorted = word // PAN
   .join(''); // anp
 ```
 
-Two different words `'PAN'` and `'nap'` receive the same letter-sorted form `'anp'`.
+Două cuvinte diferite `'PAN'` și `'nap'` primesc aceeași formă sortată pe litere `'anp'`.
 
-The next line put the word into the map:
+Următoarea linie a pus cuvântul în hartă:
 
 ```js
 map.set(sorted, word);
 ```
 
-If we ever meet a word the same letter-sorted form again, then it would overwrite the previous value with the same key in the map. So we'll always have at maximum one word per letter-form.
+Dacă vom mai întâlni vreodată un cuvânt cu aceeași formă sortată pe litere, atunci va suprascrie valoarea anterioară cu aceeași cheie din map. Astfel vom avea întotdeauna maxim un cuvânt per formă de literă.
 
-At the end `Array.from(map.values())` takes an iterable over map values (we don't need keys in the result) and returns an array of them.
+La final `Array.from(map.values())` ia o iterabilă peste valorile din hartă (nu avem nevoie de chei în rezultat) și returnează un array din acestea.
 
-Here we could also use a plain object instead of the `Map`, because keys are strings.
+Aici am putea folosi și un obiect simplu în loc de `Map`, deoarece cheile sunt șiruri de caractere.
 
-That's how the solution can look:
+Iată cum poate arăta soluția:
 
 ```js run demo
 function aclean(arr) {

1-js/05-data-types/07-map-set/02-filter-anagrams/task.md

@@ -2,27 +2,27 @@ importance: 4
 
 ---
 
-# Filter anagrams
+# Filtrează anagramele
 
-[Anagrams](https://en.wikipedia.org/wiki/Anagram) are words that have the same number of same letters, but in different order.
+[Anagrame](https://en.wikipedia.org/wiki/Anagram) sunt cuvinte care au același număr de litere identice, dar în ordine diferită.
 
-For instance:
+De exemplu:
 
 ```
 nap - pan
 ear - are - era
 cheaters - hectares - teachers
 ```
 
-Write a function `aclean(arr)` that returns an array cleaned from anagrams.
+Scrieți o funcție `aclean(arr)` care să returneze un tablou curățat de anagrame.
 
-For instance:
+De exemplu:
 
 ```js
 let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 
-alert( aclean(arr) ); // "nap,teachers,ear" or "PAN,cheaters,era"
+alert( aclean(arr) ); // "nap,teachers,ear" sau "PAN,cheaters,era"
 ```
 
-From every anagram group should remain only one word, no matter which one.
+Din fiecare grup de anagrame trebuie să rămână un singur cuvânt, indiferent care.
 

1-js/05-data-types/07-map-set/03-iterable-keys/solution.md

@@ -1,7 +1,7 @@
 
-That's because `map.keys()` returns an iterable, but not an array.
+Acest lucru se datorează faptului că `map.keys()` returnează un iterabil, dar nu o matrice.
 
-We can convert it into an array using `Array.from`:
+Îl putem converti într-un array folosind `Array.from`:
 
 
 ```js run

1-js/05-data-types/07-map-set/03-iterable-keys/task.md

@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Iterable keys
+# Chei iterabile
 
-We'd like to get an array of `map.keys()` in a variable and then apply array-specific methods to it, e.g. `.push`.
+Am dori să obținem o matrice de `map.keys()` într-o variabilă și apoi să aplicăm metode specifice matricei, e.g. `.push`.
 
-But that doesn't work:
+Dar acest lucru nu funcționează:
 
 ```js run
 let map = new Map();
@@ -16,9 +16,9 @@ map.set("name", "John");
 let keys = map.keys();
 
 *!*
-// Error: keys.push is not a function
+// Eroare: keys.push nu este o funcție
 keys.push("more");
 */!*
 ```
 
-Why? How can we fix the code to make `keys.push` work?
+De ce? Cum putem corecta codul să facem ca `keys.push` să funcționeze?