Merge branch 'master' of C:/Users/osvaldo/Documents/GitHub/copy/en.javascript.info into fix-data-types

Author: odsantos

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

@@ -0,0 +1,3 @@
+function unique(arr) {
+  return Array.from(new Set(arr));
+}

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

@@ -0,0 +1,15 @@
+describe("unique", function() {
+  it("removes non-unique elements", 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() {
+    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/solution.md

@@ -0,0 +1,27 @@
+importance: 5
+
+---
+
+# Filter unique array members
+
+Let `arr` be an array.
+
+Create a function `unique(arr)` that should return an array with unique items of `arr`.
+
+For instance:
+
+```js
+function unique(arr) {
+  /* your code */
+}
+
+let values = ["Hare", "Krishna", "Hare", "Krishna",
+  "Krishna", "Krishna", "Hare", "Hare", ":-O"
+];
+
+alert( unique(values) ); // Hare, Krishna, :-O
+```
+
+P.S. Here strings are used, but can be values of any type.
+
+P.P.S. Use `Set` to store unique values.

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

@@ -0,0 +1,11 @@
+
+function aclean(arr) {
+  let map = new Map();
+
+  for(let word of arr) {
+    let sorted = word.toLowerCase().split("").sort().join("");
+    map.set(sorted, word);
+  }
+
+  return Array.from(map.values());
+}

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

@@ -0,0 +1,24 @@
+function intersection(arr1, arr2) {
+  return arr1.filter(item => arr2.includes(item));
+}
+
+describe("aclean", function() {
+
+  it("returns exactly 1 word from each anagram set", function() {
+    let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
+
+    let result = aclean(arr);
+    assert.equal(result.length, 3);
+
+    assert.equal(intersection(result, ["nap", "PAN"]).length, 1);
+    assert.equal(intersection(result, ["teachers", "cheaters", "hectares"]).length, 1);
+    assert.equal(intersection(result, ["ear", "era"]).length, 1);
+
+  });
+
+  it("is case-insensitive", function() {
+    let arr = ["era", "EAR"];
+    assert.equal(aclean(arr).length, 1);
+  });
+
+});

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

@@ -0,0 +1,77 @@
+To find all anagrams, let's split every word to letters and sort them. When letter-sorted, all anagrams are same.
+
+For instance:
+
+```
+nap, pan -> anp
+ear, era, are -> aer
+cheaters, hectares, teachers -> aceehrst
+...
+```
+
+We'll use the letter-sorted variants as map keys to store only one value per each key:
+
+```js run
+function aclean(arr) {
+  let map = new Map();
+
+  for (let word of arr) {
+    // split the word by letters, sort them and join back
+*!*
+    let sorted = word.toLowerCase().split('').sort().join(''); // (*)
+*/!*
+    map.set(sorted, word);
+  }
+
+  return Array.from(map.values());
+}
+
+let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
+
+alert( aclean(arr) );
+```
+
+Letter-sorting is done by the chain of calls in the line `(*)`.
+
+For convenience let's split it into multiple lines:
+
+```js
+let sorted = word // PAN
+  .toLowerCase() // pan
+  .split('') // ['p','a','n']
+  .sort() // ['a','n','p']
+  .join(''); // anp
+```
+
+Two different words `'PAN'` and `'nap'` receive the same letter-sorted form `'anp'`.
+
+The next line put the word into the map:
+
+```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.
+
+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.
+
+Here we could also use a plain object instead of the `Map`, because keys are strings.
+
+That's how the solution can look:
+
+```js run demo
+function aclean(arr) {
+  let obj = {};
+
+  for (let i = 0; i < arr.length; i++) {
+    let sorted = arr[i].toLowerCase().split("").sort().join("");
+    obj[sorted] = arr[i];
+  }
+
+  return Object.values(obj);
+}
+
+let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
+
+alert( aclean(arr) );
+```

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

@@ -0,0 +1,28 @@
+importance: 4
+
+---
+
+# Filter anagrams
+
+[Anagrams](https://en.wikipedia.org/wiki/Anagram) are words that have the same number of same letters, but in different order.
+
+For instance:
+
+```
+nap - pan
+ear - are - era
+cheaters - hectares - teachers
+```
+
+Write a function `aclean(arr)` that returns an array cleaned from anagrams.
+
+For instance:
+
+```js
+let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
+
+alert( aclean(arr) ); // "nap,teachers,ear" or "PAN,cheaters,era"
+```
+
+From every anagram group should remain only one word, no matter which one.
+

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

@@ -0,0 +1,19 @@
+
+That's because `map.keys()` returns an iterable, but not an array.
+
+We can convert it into an array using `Array.from`:
+
+
+```js run
+let map = new Map();
+
+map.set("name", "John");
+
+*!*
+let keys = Array.from(map.keys());
+*/!*
+
+keys.push("more");
+
+alert(keys); // name, more
+```

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

@@ -0,0 +1,24 @@
+importance: 5
+
+---
+
+# Iterable keys
+
+We'd like to get an array of `map.keys()` in a variable and then do apply array-specific methods to it, e.g. `.push`.
+
+But that doesn't work:
+
+```js run
+let map = new Map();
+
+map.set("name", "John");
+
+let keys = map.keys();
+
+*!*
+// Error: keys.push is not a function
+keys.push("more");
+*/!*
+```
+
+Why? How can we fix the code to make `keys.push` work?