Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Map and Set#157

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to ourterms of service andprivacy statement. We’ll occasionally send you account related emails.

Already on GitHub?Sign in to your account

Merged
otmon76 merged 1 commit intojavascript-tutorial:masterfromotmon76:1.5.7
Jun 3, 2025
Merged
Show file tree
Hide file tree
Changes fromall commits
Commits
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
View file
Open in desktop
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,3 @@
functionunique(arr) {
return Array.from(new Set(arr));
functionunikát(pole) {
return Array.from(new Set(pole));
}
View file
Open in desktop
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,15 @@
describe("unique", function() {
it("removes non-unique elements", function() {
letstrings = ["Hare", "Krishna", "Hare", "Krishna",
"Krishna", "Krishna", "Hare", "Hare", ":-O"
describe("unikát", function() {
it("odstraní neunikátní prvky", function() {
letřetězce = ["Haré", "Kršna", "Haré", "Kršna",
"Kršna", "Kršna", "Haré", "Haré", ":-O"
];

assert.deepEqual(unique(strings), ["Hare", "Krishna", ":-O"]);
assert.deepEqual(unikát(řetězce), ["Haré", "Kršna", ":-O"]);
});

it("does not change the source array", function() {
letstrings = ["Krishna", "Krishna", "Hare", "Hare"];
unique(strings);
assert.deepEqual(strings, ["Krishna", "Krishna", "Hare", "Hare"]);
it("nemění zdrojové pole", function() {
letřetězce = ["Kršna", "Kršna", "Haré", "Haré"];
unikát(řetězce);
assert.deepEqual(řetězce, ["Kršna", "Kršna", "Haré", "Haré"]);
});
});
22 changes: 11 additions & 11 deletions1-js/05-data-types/07-map-set/01-array-unique-map/task.md
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -2,26 +2,26 @@ importance: 5

---

#Filter unique array members
#Filtrace unikátních prvků pole

Let `arr` be an array.
Nechť `pole` je nějaké pole.

Create a function `unique(arr)` that should return an array with unique items of `arr`.
Vytvořte funkci `unikát(pole)`, která vrátí pole obsahující všechny různé prvky `pole`.

For instance:
Příklad:

```js
functionunique(arr) {
/*your code */
functionunikát(pole) {
/*váš kód */
}

letvalues = ["Hare", "Krishna", "Hare", "Krishna",
"Krishna", "Krishna", "Hare", "Hare", ":-O"
letřetězce = ["Haré", "Kršna", "Haré", "Kršna",
"Kršna", "Kršna", "Haré", "Haré", ":-O"
];

alert(unique(values) ); //Hare, Krishna, :-O
alert(unikát(řetězce) ); //Haré, Kršna, :-O
```

P.S.Here strings are used, but can be values of any type.
P.S.Zde jsou použity řetězce, ale mohou to být hodnoty libovolného typu.

P.P.S.Use `Set` to store unique values.
P.P.S.K uložení unikátních hodnot použijte `Set`.
View file
Open in desktop
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,11 @@

functionaclean(arr) {
letmap = new Map();
functionodstraňAnagramy(pole) {
letmapa = new Map();

for(letword ofarr) {
letsorted =word.toLowerCase().split("").sort().join("");
map.set(sorted, word);
for(letslovo ofpole) {
letseřazené =slovo.toLowerCase().split("").sort().join("");
mapa.set(seřazené, slovo);
}

return Array.from(map.values());
return Array.from(mapa.values());
}
View file
Open in desktop
Original file line numberDiff line numberDiff line change
@@ -1,24 +1,24 @@
functionintersection(arr1, arr2) {
return arr1.filter(item => arr2.includes(item));
functionprůnik(arr1, arr2) {
return arr1.filter(prvek => arr2.includes(prvek));
}

describe("aclean", function() {
describe("odstraňAnagramy", function() {

it("returns exactly 1 word from each anagram set", function() {
letarr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
it("z každé sady anagramů vrátí právě 1 slovo", function() {
letpole = ["rak", "reklama", "makrela", "KRA", "kostel", "stolek", "karamel"];

letresult =aclean(arr);
assert.equal(result.length, 3);
letvýsledek =odstraňAnagramy(pole);
assert.equal(výsledek.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);
assert.equal(intersection(výsledek, ["rak", "KRA"]).length, 1);
assert.equal(intersection(výsledek, ["reklama", "makrela", "karamel"]).length, 1);
assert.equal(intersection(výsledek, ["kostel", "stolek"]).length, 1);

});

it("is case-insensitive", function() {
letarr = ["era", "EAR"];
assert.equal(aclean(arr).length, 1);
it("nerozlišuje malá a velká písmena", function() {
letpole = ["rak", "KRA"];
assert.equal(odstraňAnagramy(pole).length, 1);
});

});
70 changes: 35 additions & 35 deletions1-js/05-data-types/07-map-set/02-filter-anagrams/solution.md
View file
Open in desktop
Original file line numberDiff line numberDiff line change
@@ -1,77 +1,77 @@
To find all anagrams, let's split every word to letters and sort them. When letter-sorted, all anagrams are same.
Pro nalezení anagramů rozdělíme každé slovo na písmena a ta seřadíme podle abecedy. Po seřazení písmen budou všechny anagramy stejné.

For instance:
Příklad:

```
nap, pan ->anp
ear, era, are->aer
cheaters, hectares, teachers ->aceehrst
rak, kra ->akr
kostel, stolek->eklost
reklama, makrela, karamel ->aaeklmr
...
```

We'll use the letter-sorted variants as map keys to store only one value per each key:
Varianty slov se seřazenými písmeny použijeme jako klíče mapy, abychom uložili pro každý klíč jen jednu hodnotu:

```js run
functionaclean(arr) {
letmap = new Map();
functionodstraňAnagramy(pole) {
letmapa = new Map();

for (letword ofarr) {
//split the word by letters, sort them and join back
for (letslovo ofpole) {
//rozdělíme slovo na písmena, seřadíme je a znovu spojíme
*!*
letsorted =word.toLowerCase().split('').sort().join(''); // (*)
letseřazené =slovo.toLowerCase().split('').sort().join(''); // (*)
*/!*
map.set(sorted, word);
mapa.set(seřazené, slovo);
}

return Array.from(map.values());
return Array.from(mapa.values());
}

letarr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
letpole = ["rak", "reklama", "makrela", "KRA", "kostel", "stolek", "karamel"];

alert(aclean(arr) );
alert(odstraňAnagramy(pole) );
```

Letter-sorting is done by the chain of calls in the line `(*)`.
Seřazení písmen se děje ve zřetězeném volání na řádku `(*)`.

For convenience let's split it into multiple lines:
Pro přehlednost jej rozdělme na několik řádků:

```js
letsorted =word //PAN
.toLowerCase() //pan
.split('') // ['p','a','n']
.sort() // ['a','n','p']
.join(''); //anp
letseřazené =slovo //KRA
.toLowerCase() //kra
.split('') // ['k','r','a']
.sort() // ['a','k','r']
.join(''); //akr
```

Two different words `'PAN'`and `'nap'`receive the same letter-sorted form `'anp'`.
Dvě různá slova `'KRA'`a `'rak'`budou seřazena stejně na `'akr'`.

The next line put the word into the map:
Další řádek vloží slovo do mapy:

```js
map.set(sorted, word);
mapa.set(seřazené, slovo);
```

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.
Jestliže příště přijde slovo se stejným seřazením písmen, přepíše v mapě předchozí hodnotu se stejným klíčem. Vždy tedy budeme mít pro každou seřazenou skupinu písmen nejvýše jedno slovo.

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.
Nakonec`Array.from(mapa.values())`vezme iterovatelný objekt nad hodnotami mapy (klíče ve výsledku nepotřebujeme), vytvoří z těchto hodnot pole a vrátí je.

Here we could also use a plain object instead of the `Map`, because keys are strings.
Zde bychom mohli místo `Map` použít i planý objekt, neboť klíče jsou řetězce.

That's how the solution can look:
Řešení by pak mohlo vypadat následovně:

```js run demo
functionaclean(arr) {
functionodstraňAnagramy(pole) {
let obj = {};

for (let i = 0; i <arr.length; i++) {
letsorted =arr[i].toLowerCase().split("").sort().join("");
obj[sorted] =arr[i];
for (let i = 0; i <pole.length; i++) {
letseřazené =pole[i].toLowerCase().split("").sort().join("");
obj[seřazené] =pole[i];
}

return Object.values(obj);
}

letarr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
letpole = ["rak", "reklama", "makrela", "KRA", "kostel", "stolek", "karamel"];

alert(aclean(arr) );
alert(odstraňAnagramy(pole) );
```
23 changes: 11 additions & 12 deletions1-js/05-data-types/07-map-set/02-filter-anagrams/task.md
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -2,27 +2,26 @@ importance: 4

---

#Filter anagrams
#Filtrace anagramů

[Anagrams](https://en.wikipedia.org/wiki/Anagram)are words that have the same number of same letters, but in different order.
[Anagramy](https://cs.wikipedia.org/wiki/Anagram)neboli přesmyčky jsou slova, která obsahují stejné počty stejných písmen, ale v jiném pořadí.

For instance:
Příklad:

```
nap -pan
ear -are - era
cheaters -hectares -teachers
rak -kra
kostel -stolek
reklama -makrela -karamel
```

Write a function `aclean(arr)` that returns an array cleaned from anagrams.
Napište funkci `odstraňAnagramy(pole)`, která vrátí pole zbavené anagramů.

For instance:
Příklad:

```js
letarr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
letpole = ["rak", "reklama", "makrela", "KRA", "kostel", "stolek", "karamel"];

alert(aclean(arr) ); // "nap,teachers,ear" or "PAN,cheaters,era"
alert(odstraňAnagramy(pole) ); // "rak,karamel,kostel" nebo "KRA,makrela,stolek"
```

From every anagram group should remain only one word, no matter which one.

Z každé skupiny přesmyček by mělo zbýt pouze jedno slovo. Nezáleží na tom, které.
14 changes: 7 additions & 7 deletions1-js/05-data-types/07-map-set/03-iterable-keys/solution.md
View file
Open in desktop
Original file line numberDiff line numberDiff line change
@@ -1,19 +1,19 @@

That's because `map.keys()`returns an iterable, but not an array.
Je to proto, že `mapa.keys()`vrací iterovatelný objekt, ale ne pole.

We can convert it into an array using `Array.from`:
Můžeme jej převést na pole pomocí `Array.from`:


```js run
letmap = new Map();
letmapa = new Map();

map.set("name", "John");
mapa.set("jméno", "Jan");

*!*
letkeys = Array.from(map.keys());
letklíče = Array.from(mapa.keys());
*/!*

keys.push("more");
klíče.push("další");

alert(keys); //name, more
alert(klíče); //jméno,další
```
18 changes: 9 additions & 9 deletions1-js/05-data-types/07-map-set/03-iterable-keys/task.md
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -2,23 +2,23 @@ importance: 5

---

#Iterable keys
#Iterovatelné klíče

We'd like to get an array of `map.keys()`in a variable and then apply array-specific methods to it, e.g. `.push`.
Chtěli bychom uložit pole klíčů mapy `mapa.keys()`do proměnné a pak na ní volat metody specifické pro pole, např. `.push`.

But that doesn't work:
Tohle však nefunguje:

```js run
letmap = new Map();
letmapa = new Map();

map.set("name", "John");
mapa.set("jméno", "Jan");

letkeys =map.keys();
letklíče =mapa.keys();

*!*
//Error: keys.pushis not a function
keys.push("more");
//Chyba: klíče.pushnení funkce
klíče.push("další");
*/!*
```

Why? How can we fix the code to make `keys.push`work?
Proč? Jak můžeme opravit kód, aby `klíče.push`fungovalo?
Loading
[8]ページ先頭
©2009-2025 Movatter.jp