gaspersic/freeCodeCamp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

chore(i18n,curriculum): processed translations (#43390)

Browse Source
This commit is contained in:
camperbot
2021-09-07 07:47:37 -07:00
committed by GitHub
parent fa6d3f4cf2
commit ec4821a707
67 changed files with 662 additions and 654 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/set-consolidation.md
View File

@ -1,6 +1,6 @@
---
id: 5eb3e4af7d0e7b760b46cedc
title: Set consolidation
title: Definir consolidação
challengeType: 5
forumTopicId: 385319
dashedName: set-consolidation
@ -8,58 +8,58 @@ dashedName: set-consolidation
# --description--
Given two sets of items then if any item is common to any set then the result of applying *consolidation* to those sets is a set of sets whose contents is:
Dados dois conjuntos de itens, se qualquer item for comum a qualquer dos conjuntos, o resultado de aplicar a *consolidação* àqueles conjuntos é um conjunto de conjuntos, cujo conteúdo é:
<ul>
<li>The two input sets if no common item exists between the two input sets of items.</li>
<li>The single set that is the union of the two input sets if they share a common item.</li>
<li>Os dois conjuntos de entrada, se não existir nenhum item comum entre os dois conjuntos de itens de entrada.</li>
<li>O conjunto único que é a união dos dois conjuntos de entrada define se partilham um item em comum.</li>
</ul>
Given N sets of items where N > 2 then the result is the same as repeatedly replacing all combinations of two sets by their consolidation until no further consolidation between set pairs is possible. If N &lt; 2 then consolidation has no strict meaning and the input can be returned.
Dados N conjuntos de itens em que N > 2, o resultado é o mesmo que substituir repetidamente todas as combinações de dois conjuntos por sua consolidação até que nenhuma consolidação adicional entre os pares de conjuntos seja possível. Se N &lt; 2, a consolidação não terá nenhum significado estrito e a entrada pode ser retornada.
Here are some examples:
Aqui estão alguns exemplos:
**Example 1:**
**Exemplo 1:**
Given the two sets `{A,B}` and `{C,D}` then there is no common element between the sets and the result is the same as the input.
Dados os dois conjuntos `{A,B}` e `{C,D}`, não há elemento comum entre os conjuntos e o resultado é o mesmo que a entrada.
**Example 2:**
**Exemplo 2:**
Given the two sets `{A,B}` and `{B,D}` then there is a common element `B` between the sets and the result is the single set `{B,D,A}`. (Note that order of items in a set is immaterial: `{A,B,D}` is the same as `{B,D,A}` and `{D,A,B}`, etc).
Dados os dois conjuntos `{A,B}` e `{B,D}`, há um elemento comum `B` entre os conjuntos. O resultado é um conjunto único `{B,D,A}`. (Observe que a ordem dos itens em um conjunto não tem importância: `{A,B,D}` é o mesmo que `{B,D,A}`, `{D,A,B}` e assim por diante).
**Example 3:**
**Exemplo 3:**
Given the three sets `{A,B}` and `{C,D}` and `{D,B}` then there is no common element between the sets `{A,B}` and `{C,D}` but the sets `{A,B}` and `{D,B}` do share a common element that consolidates to produce the result `{B,D,A}`. On examining this result with the remaining set, `{C,D}`, they share a common element and so consolidate to the final output of the single set `{A,B,C,D}`
Dados os três conjuntos `{A,B}`, `{C,D}` e `{D,B}` não há elemento comum entre os conjuntos `{A,B}` e `{C,D}`, mas os conjuntos `{A,B}` e `{D,B}` compartilham um elemento comum que é consolidado, produzindo o resultado `{B,D,A}`. Ao analisar este resultado com o conjunto restante, `{C,D}`, eles compartilham um elemento comum e assim são consolidados na saída final do conjunto único `{A,B,C,D}`
**Example 4:**
**Exemplo 4:**
The consolidation of the five sets:
A consolidação dos cinco conjuntos:
`{H,I,K}`, `{A,B}`, `{C,D}`, `{D,B}`, and `{F,G,H}`
`{H,I,K}`, `{A,B}`, `{C,D}`, `{D,B}` e `{F,G,H}`
Is the two sets:
São os dois conjuntos:
`{A, C, B, D}`, and `{G, F, I, H, K}`
`{A, C, B, D}` e `{G, F, I, H, K}`
# --instructions--
Write a function that takes an array of strings as a parameter. Each string is represents a set with the characters representing the set elements. The function should return a 2D array containing the consolidated sets. Note: Each set should be sorted.
Escreva uma função que receba um array de strings como parâmetro. Cada string representa um conjunto com os caracteres que representam os elementos do conjunto. A função deve retornar um array 2D contendo os conjuntos consolidados. Observação: cada conjunto deve ser ordenado.
# --hints--
`setConsolidation` should be a function.
`setConsolidation` deve ser uma função.
```js
assert(typeof setConsolidation === 'function');
```
`setConsolidation(["AB", "CD"])` should return a array.
`setConsolidation(["AB", "CD"])` deve retornar um array.
```js
assert(Array.isArray(setConsolidation(['AB', 'CD'])));
```
`setConsolidation(["AB", "CD"])` should return `[["C", "D"], ["A", "B"]]`.
`setConsolidation(["AB", "CD"])` deve retornar `[["C", "D"], ["A", "B"]]`.
```js
assert.deepEqual(setConsolidation(['AB', 'CD']), [
@ -68,19 +68,19 @@ assert.deepEqual(setConsolidation(['AB', 'CD']), [
]);
```
`setConsolidation(["AB", "BD"])` should return `[["A", "B", "D"]]`.
`setConsolidation(["AB", "BD"])` deve retornar `[["A", "B", "D"]]`.
```js
assert.deepEqual(setConsolidation(['AB', 'BD']), [['A', 'B', 'D']]);
```
`setConsolidation(["AB", "CD", "DB"])` should return `[["A", "B", "C", "D"]]`.
`setConsolidation(["AB", "CD", "DB"])` deve retornar `[["A", "B", "C", "D"]]`.
```js
assert.deepEqual(setConsolidation(['AB', 'CD', 'DB']), [['A', 'B', 'C', 'D']]);
```
`setConsolidation(["HIK", "AB", "CD", "DB", "FGH"])` should return `[["F", "G", "H", "I", "K"], ["A", "B", "C", "D"]]`.
`setConsolidation(["HIK", "AB", "CD", "DB", "FGH"])` deve retornar `[["F", "G", "H", "I", "K"], ["A", "B", "C", "D"]]`.
```js
assert.deepEqual(setConsolidation(['HIK', 'AB', 'CD', 'DB', 'FGH']), [

26
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sha-1.md
View File

@ -8,59 +8,59 @@ dashedName: sha-1
# --description--
**SHA-1** or **SHA1** is a one-way hash function; it computes a 160-bit message digest.
**SHA-1** ou **SHA1** é uma função hash de mão única; ela calcula um message digest de 160-bit.
SHA-1 often appears in security protocols; for example, many HTTPS websites use RSA with SHA-1 to secure their connections.
O SHA-1 aparece frequentemente em protocolos de segurança; por exemplo, muitos sites HTTPS usam RSA com SHA-1 para proteger suas conexões.
BitTorrent uses SHA-1 to verify downloads.
O BitTorrent usa SHA-1 para verificar downloads.
Git and Mercurial use SHA-1 digests to identify commits.
O Git e o Mercurial usam SHA-1 digests para identificar commits.
A US government standard, [FIPS 180-1](https://rosettacode.org/wiki/SHA-1/FIPS-180-1), defines SHA-1.
Um padrão do governo dos EUA, [FIPS 180-1](https://rosettacode.org/wiki/SHA-1/FIPS-180-1), define o SHA-1.
# --instructions--
Write a function that returns the SHA-1 message digest for a given string.
Escreva uma função que retorne o SHA-1 message digest para uma determinada string.
# --hints--
`SHA1` should be a function.
`SHA1` deve ser uma função.
```js
assert(typeof SHA1 === 'function');
```
`SHA1("abc")` should return a string.
`SHA1("abc")` deve retornar uma string.
```js
assert(typeof SHA1('abc') === 'string');
```
`SHA1("abc")` should return `"a9993e364706816aba3e25717850c26c9cd0d89d"`.
`SHA1("abc")` deve retornar `"a9993e364706816aba3e25717850c26c9cd0d89d"`.
```js
assert.equal(SHA1('abc'), 'a9993e364706816aba3e25717850c26c9cd0d89d');
```
`SHA1("Rosetta Code")` should return `"48c98f7e5a6e736d790ab740dfc3f51a61abe2b5"`.
`SHA1("Rosetta Code")` deve retornar `"48c98f7e5a6e736d790ab740dfc3f51a61abe2b5"`.
```js
assert.equal(SHA1('Rosetta Code'), '48c98f7e5a6e736d790ab740dfc3f51a61abe2b5');
```
`SHA1("Hello world")` should return `"7b502c3a1f48c8609ae212cdfb639dee39673f5e"`.
`SHA1("Hello world")` deve retornar `"7b502c3a1f48c8609ae212cdfb639dee39673f5e"`.
```js
assert.equal(SHA1('Hello world'), '7b502c3a1f48c8609ae212cdfb639dee39673f5e');
```
`SHA1("Programming")` should return `"d1a946bf8b2f2a7292c250063ee28989d742cd4b"`.
`SHA1("Programming")` deve retornar `"d1a946bf8b2f2a7292c250063ee28989d742cd4b"`.
```js
assert.equal(SHA1('Programming'), 'd1a946bf8b2f2a7292c250063ee28989d742cd4b');
```
`SHA1("is Awesome")` should return `"6537205da59c72b57ed3881843c2d24103d683a3"`.
`SHA1("is Awesome")` deve retornar `"6537205da59c72b57ed3881843c2d24103d683a3"`.
```js
assert.equal(SHA1('is Awesome'), '6537205da59c72b57ed3881843c2d24103d683a3');

18
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sha-256.md
View File

@ -8,27 +8,27 @@ dashedName: sha-256
# --description--
The `SHA-2` family is a stronger alternative to `SHA-1`. The main difference between them is the length of the hash. Meaning `SHA-1` provides a shorter code with fewer possibilities for unique combinations. `SHA-2` or `SHA-256` creates a longer and thus more complex hash with more possibilities.
A família `SHA-2` é uma alternativa mais forte a `SHA-1`. A principal diferença entre elas é o comprimento do hash. Significa que a `SHA-1` fornece um código mais curto com menos possibilidades para combinações únicas. `SHA-2` ou `SHA-256` cria um hash mais longo e, portanto, mais complexo com mais possibilidades.
# --instructions--
Research implemenation details and write a function that takes a string as the parameter and returns a hash using `SHA-256`
Pesquise os detalhes de implementação e escreva uma função que receba uma string como parâmetro e retorna um hash usando `SHA-256`
# --hints--
`SHA256` should be a function.
`SHA256` deve ser uma função.
```js
assert(typeof SHA256 === 'function');
```
`SHA256("Rosetta code")` should return a string.
`SHA256("Rosetta code")` deve retornar uma string.
```js
assert(typeof SHA256('Rosetta code') === 'string');
```
`SHA256("Rosetta code")` should return `"764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf"`.
`SHA256("Rosetta code")` deve retornar `"764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf"`.
```js
assert.equal(
@ -37,7 +37,7 @@ assert.equal(
);
```
`SHA256("SHA-256 Hash")` should return `"bee8c0cabdcf8c7835f40217dd35a8b0dba9134520e633f1c57285f35ca7ee3e"`.
`SHA256("SHA-256 Hash")` deve retornar `"bee8c0cabdcf8c7835f40217dd35a8b0dba9134520e633f1c57285f35ca7ee3e"`.
```js
assert.equal(
@ -46,7 +46,7 @@ assert.equal(
);
```
`SHA256("implementation")` should return `"da31012c40330e7e21538e7dd57503b16e8a0839159e96137090cccc9910b171"`.
`SHA256("implementation")` deve retornar `"da31012c40330e7e21538e7dd57503b16e8a0839159e96137090cccc9910b171"`.
```js
assert.equal(
@ -55,7 +55,7 @@ assert.equal(
);
```
`SHA256("algorithm")` should return `"b1eb2ec8ac9f31ff7918231e67f96e6deda83a9ff33ed2c67443f1df81e5ed14"`.
`SHA256("algorithm")` deve retornar `"b1eb2ec8ac9f31ff7918231e67f96e6deda83a9ff33ed2c67443f1df81e5ed14"`.
```js
assert.equal(
@ -64,7 +64,7 @@ assert.equal(
);
```
`SHA256("language")` should return `"a4ef304ba42a200bafd78b046e0869af9183f6eee5524aead5dcb3a5ab5f8f3f"`.
`SHA256("language")` deve retornar `"a4ef304ba42a200bafd78b046e0869af9183f6eee5524aead5dcb3a5ab5f8f3f"`.
```js
assert.equal(

14
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sort-an-array-of-composite-structures.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc7ffe
title: Sort an array of composite structures
title: Ordenar um array de estruturas compostas
challengeType: 5
forumTopicId: 302306
dashedName: sort-an-array-of-composite-structures
@ -8,17 +8,17 @@ dashedName: sort-an-array-of-composite-structures
# --description--
Write a function that takes an array of objects as a parameter. The function should sort the array according to the 'key' attribute of the objects and return the sorted array.
Escreva uma função que receba um array de objetos como parâmetro. A função deve ordenar o array de acordo com o atributo 'key' dos objetos e retornar o array ordenado.
# --hints--
`sortByKey` should be a function.
`sortByKey` deve ser uma função.
```js
assert(typeof sortByKey == 'function');
```
`sortByKey([{key: 3, value: "foo"}, {key: 2, value: "bar"}, {key: 4, value: "baz"}, {key: 1, value: 42}, {key: 5, value: "another string"}])` should return an array.
`sortByKey([{key: 3, value: "foo"}, {key: 2, value: "bar"}, {key: 4, value: "baz"}, {key: 1, value: 42}, {key: 5, value: "another string"}])` deve retornar um array.
```js
assert(
@ -34,7 +34,7 @@ assert(
);
```
`sortByKey([{key: 3, value: "foo"}, {key: 2, value: "bar"}, {key: 4, value: "baz"}, {key: 1, value: 42}, {key: 5, value: "another string"}])` should return `[{key: 1, value: 42}, {key: 2, value: "bar"}, {key: 3, value: "foo"}, {key: 4, value: "baz"}, {key: 5, value: "another string"}]`.
`sortByKey([{key: 3, value: "foo"}, {key: 2, value: "bar"}, {key: 4, value: "baz"}, {key: 1, value: 42}, {key: 5, value: "another string"}])` deve retornar `[{key: 1, value: 42}, {key: 2, value: "bar"}, {key: 3, value: "foo"}, {key: 4, value: "baz"}, {key: 5, value: "another string"}]`.
```js
assert.deepEqual(
@ -55,7 +55,7 @@ assert.deepEqual(
);
```
`sortByKey([{key: 3, name: "Joe"}, {key: 4, name: "Bill"}, {key: 20, name: "Alice"}, {key: 5, name: "Harry"}])` should return `[{key: 3, name: "Joe"}, {key: 4, name: "Bill"}, {key: 5, name: "Harry"}, {key: 20, name: "Alice"}]`.
`sortByKey([{key: 3, name: "Joe"}, {key: 4, name: "Bill"}, {key: 20, name: "Alice"}, {key: 5, name: "Harry"}])` deve retornar `[{key: 3, name: "Joe"}, {key: 4, name: "Bill"}, {key: 5, name: "Harry"}, {key: 20, name: "Alice"}]`.
```js
assert.deepEqual(
@ -74,7 +74,7 @@ assert.deepEqual(
);
```
`sortByKey([{key: 2341, name: "Adam"}, {key: 122, name: "Bernie"}, {key: 19, name: "David"}, {key: 5531, name: "Joe"}, {key: 1234, name: "Walter"}])` should return `[{key: 19, name: "David"}, {key: 122, name: "Bernie"}, {key: 1234, name: "Walter"}, {key: 2341, name: "Adam"}, {key: 5531, name: "Joe"}]`.
`sortByKey([{key: 2341, name: "Adam"}, {key: 122, name: "Bernie"}, {key: 19, name: "David"}, {key: 5531, name: "Joe"}, {key: 1234, name: "Walter"}])` deve retornar `[{key: 19, name: "David"}, {key: 122, name: "Bernie"}, {key: 1234, name: "Walter"}, {key: 2341, name: "Adam"}, {key: 5531, name: "Joe"}]`.
```js
assert.deepEqual(

22
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sort-disjoint-sublist.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8000
title: Sort disjoint sublist
title: Ordenar sublista desarticulada
challengeType: 5
forumTopicId: 302307
dashedName: sort-disjoint-sublist
@ -8,9 +8,9 @@ dashedName: sort-disjoint-sublist
# --description--
Given a list of values and a set of integer indices into that value list, the task is to sort the values at the given indices, but preserving the values at indices outside the set of those to be sorted.
Dada uma lista de valores e um conjunto de índices inteiros nessa lista de valores a tarefa é ordenar os valores nos índices indicados, mas preservando os valores nos índices exteriores ao conjunto dos que devem ser ordenados.
Make your function work with the following list of values and set of indices:
Faça a função funcionar com a seguinte lista de valores e conjunto de índices:
<code>values: [7, <b>6</b>, 5, 4, 3, 2, <b>1</b>, <b>0</b>]</code>
@ -18,25 +18,25 @@ Make your function work with the following list of values and set of indices:
indices(0-based): {6, 1, 7}
```
Where the correct result would be:
Onde o resultado correto seria:
<code>[7, <b>0</b>, 5, 4, 3, 2, <b>1</b>, <b>6</b>]</code>.
# --hints--
`sortDisjoint` should be a function.
`sortDisjoint` deve ser uma função.
```js
assert(typeof sortDisjoint == 'function');
```
`sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7])` should return an array.
`sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7])` deve retornar um array.
```js
assert(Array.isArray(sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7])));
```
`sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7])` should return `[7, 0, 5, 4, 3, 2, 1, 6]`.
`sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7])` deve retornar `[7, 0, 5, 4, 3, 2, 1, 6]`.
```js
assert.deepEqual(sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7]), [
@ -51,7 +51,7 @@ assert.deepEqual(sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [6, 1, 7]), [
]);
```
`sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [1, 2, 5, 6])` should return `[7, 1, 2, 4, 3, 5, 6, 0]`.
`sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [1, 2, 5, 6])` deve retornar `[7, 1, 2, 4, 3, 5, 6, 0]`.
```js
assert.deepEqual(sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [1, 2, 5, 6]), [
@ -66,7 +66,7 @@ assert.deepEqual(sortDisjoint([7, 6, 5, 4, 3, 2, 1, 0], [1, 2, 5, 6]), [
]);
```
`sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [6, 1, 7])` should return `[8, 1, 6, 5, 4, 3, 2, 7]`.
`sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [6, 1, 7])` deve retornar `[8, 1, 6, 5, 4, 3, 2, 7]`.
```js
assert.deepEqual(sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [6, 1, 7]), [
@ -81,7 +81,7 @@ assert.deepEqual(sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [6, 1, 7]), [
]);
```
`sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [1, 3, 5, 6])` should return `[8, 2, 6, 3, 4, 5, 7, 1]`.
`sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [1, 3, 5, 6])` deve retornar `[8, 2, 6, 3, 4, 5, 7, 1]`.
```js
assert.deepEqual(sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [1, 3, 5, 6]), [
@ -96,7 +96,7 @@ assert.deepEqual(sortDisjoint([8, 7, 6, 5, 4, 3, 2, 1], [1, 3, 5, 6]), [
]);
```
`sortDisjoint([6, 1, 7, 1, 3, 5, 6], [6, 1, 5, 4])` should return `[6, 1, 7, 1, 3, 5, 6]`.
`sortDisjoint([6, 1, 7, 1, 3, 5, 6], [6, 1, 5, 4])` deve retornar `[6, 1, 7, 1, 3, 5, 6]`.
```js
assert.deepEqual(sortDisjoint([6, 1, 7, 1, 3, 5, 6], [6, 1, 5, 4]), [

24
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sort-stability.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8014
title: Sort stability
title: Estabilidade de ordenação
challengeType: 5
forumTopicId: 302308
dashedName: sort-stability
@ -8,9 +8,9 @@ dashedName: sort-stability
# --description--
When sorting records in a table by a particular column or field, a [stable sort](https://en.wikipedia.org/wiki/Stable_sort#Stability) will always retain the relative order of records that have the same key.
Ao ordenar registros em uma tabela por uma coluna ou campo específico, uma [ordenação estável](https://en.wikipedia.org/wiki/Stable_sort#Stability) sempre manterá a ordem relativa dos registros que têm a mesma chave.
For example, in this table of countries and cities, a stable sort on the **second** column, the cities, would keep the US Birmingham above the UK Birmingham. (Although an unstable sort *might*, in this case, place the US Birmingham above the UK Birmingham, a stable sort routine would *guarantee* it).
Por exemplo, nesta tabela de países e cidades, uma organização estável na **segunda** coluna, a das cidades, manteria US Birmingham acima de UK Birmingham. (Embora uma ordenação instável *possa*, neste caso, colocar US Birmingham acima de UK Birmingham, uma ordenação estável *garantiria* que isso ocorresse).
<pre>UK London
US New York
@ -18,21 +18,21 @@ US Birmingham
UK Birmingham
</pre>
Similarly, stable sorting on just the first column would generate "UK London" as the first item and "US Birmingham" as the last item (since the order of the elements having the same first word – "UK" or "US" – would be maintained).
Da mesma forma, uma ordenação estável na primeira coluna geraria "UK London" como o primeiro item e "US Birmingham" como o último (já que a ordem dos elementos que têm a mesma palavra – "UK" ou "US" – seria mantida).
# --instructions--
Write a function that takes a 2D array as a parameter. Each element has 2 elements similar to the above example. The function should sort the array as mentioned previously and return the sorted array.
Escreva uma função que receba um array bidimensional como parâmetro. Cada elemento tem 2 elementos semelhantes ao exemplo acima. A função deve ordenar o array conforme mencionado anteriormente e retornar o array ordenado.
# --hints--
`stableSort` should be a function.
`stableSort` deve ser uma função.
```js
assert(typeof stableSort == 'function');
```
`stableSort([["UK", "London"], ["US", "New York"], ["US", "Birmingham"], ["UK", "Birmingham"]])` should return an array.
`stableSort([["UK", "London"], ["US", "New York"], ["US", "Birmingham"], ["UK", "Birmingham"]])` deve retornar um array.
```js
assert(
@ -47,7 +47,7 @@ assert(
);
```
`stableSort([["UK", "London"], ["US", "New York"], ["US", "Birmingham"], ["UK", "Birmingham"]])` should return `[["US", "Birmingham"], ["UK", "Birmingham"], ["UK", "London"], ["US", "New York"]]`.
`stableSort([["UK", "London"], ["US", "New York"], ["US", "Birmingham"], ["UK", "Birmingham"]])` deve retornar `[["US", "Birmingham"], ["UK", "Birmingham"], ["UK", "London"], ["US", "New York"]]`.
```js
assert.deepEqual(
@ -66,7 +66,7 @@ assert.deepEqual(
);
```
`stableSort([[2, 2], [1, 2], [1, 4], [1, 5]])` should return `[[2, 2], [1, 2], [1, 4], [1, 5]]`.
`stableSort([[2, 2], [1, 2], [1, 4], [1, 5]])` deve retornar `[[2, 2], [1, 2], [1, 4], [1, 5]]`.
```js
assert.deepEqual(
@ -85,7 +85,7 @@ assert.deepEqual(
);
```
`stableSort([[11, 55], [12, 45], [11, 45], [32, 45]])` should return `[[12, 45], [11, 45], [32, 45], [11, 55]]`.
`stableSort([[11, 55], [12, 45], [11, 45], [32, 45]])` deve retornar `[[12, 45], [11, 45], [32, 45], [11, 55]]`.
```js
assert.deepEqual(
@ -104,7 +104,7 @@ assert.deepEqual(
);
```
`stableSort([[10, 22], [1, 2], [1, 4], [1, 5], [10, 9]])` should return `[[1, 2], [1, 4], [1, 5], [10, 9], [10, 22]]`.
`stableSort([[10, 22], [1, 2], [1, 4], [1, 5], [10, 9]])` deve retornar `[[1, 2], [1, 4], [1, 5], [10, 9], [10, 22]]`.
```js
assert.deepEqual(
@ -125,7 +125,7 @@ assert.deepEqual(
);
```
`stableSort([[55, 54], [12, 22], [31, 43], [31, 54], [10, 49]])` should return `[[12, 22], [31, 43], [10, 49], [55, 54], [31, 54]]`.
`stableSort([[55, 54], [12, 22], [31, 43], [31, 54], [10, 49]])` deve retornar `[[12, 22], [31, 43], [10, 49], [55, 54], [31, 54]]`.
```js
assert.deepEqual(

18
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sort-using-a-custom-comparator.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8016
title: Sort using a custom comparator
title: Ordenar usando um comparador personalizado
challengeType: 5
forumTopicId: 302309
dashedName: sort-using-a-custom-comparator
@ -8,17 +8,17 @@ dashedName: sort-using-a-custom-comparator
# --description--
Write a function to sort an array (or list) of strings in order of descending length, and in ascending lexicographic order for strings of equal length.
Escrever uma função para ordenar um array (ou lista) de strings em ordem de tamanho decrescente, e em ordem lexicográfica crescente strings de mesmo tamanho.
# --hints--
`lengthSorter` should be a function.
`lengthSorter` deve ser uma função.
```js
assert(typeof lengthSorter == 'function');
```
`lengthSorter(["Here", "are", "some", "sample", "strings", "to", "be", "sorted"])` should return an array.
`lengthSorter(["Here", "are", "some", "sample", "strings", "to", "be", "sorted"])` deve retornar um array.
```js
assert(
@ -37,7 +37,7 @@ assert(
);
```
`lengthSorter(["Here", "are", "some", "sample", "strings", "to", "be", "sorted"])` should return `["strings", "sample", "sorted", "Here", "some", "are", "be", "to"]`.
`lengthSorter(["Here", "are", "some", "sample", "strings", "to", "be", "sorted"])` deve retornar`["strings", "sample", "sorted", "Here", "some", "are", "be", "to"]`.
```js
assert.deepEqual(
@ -55,7 +55,7 @@ assert.deepEqual(
);
```
`lengthSorter(["I", "hope", "your", "day", "is", "going", "good", "?"])` should return `["going", "good", "hope", "your", "day", "is", "?","I"]`.
`lengthSorter(["I", "hope", "your", "day", "is", "going", "good", "?"])` deve retornar `["going", "good", "hope", "your", "day", "is", "?","I"]`.
```js
assert.deepEqual(
@ -64,7 +64,7 @@ assert.deepEqual(
);
```
`lengthSorter(["Mine", "is", "going", "great"])` should return `["going", "great", "Mine", "is"]`.
`lengthSorter(["Mine", "is", "going", "great"])` deve retornar `["going", "great", "Mine", "is"]`.
```js
assert.deepEqual(lengthSorter(['Mine', 'is', 'going', 'great']), [
@ -75,7 +75,7 @@ assert.deepEqual(lengthSorter(['Mine', 'is', 'going', 'great']), [
]);
```
`lengthSorter(["Have", "fun", "sorting", "!!"])` should return `["sorting", "Have", "fun", "!!"]`.
`lengthSorter(["Have", "fun", "sorting", "!!"])` deve retornar `["sorting", "Have", "fun", "!!"]`.
```js
assert.deepEqual(lengthSorter(['Have', 'fun', 'sorting', '!!']), [
@ -86,7 +86,7 @@ assert.deepEqual(lengthSorter(['Have', 'fun', 'sorting', '!!']), [
]);
```
`lengthSorter(["Everything", "is", "good", "!!"])` should return `["Everything", "good", "!!", "is"]`.
`lengthSorter(["Everything", "is", "good", "!!"])` deve retornar `["Everything", "good", "!!", "is"]`.
```js
assert.deepEqual(lengthSorter(['Everything', 'is', 'good', '!!']), [

24
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sorting-algorithms-bead-sort.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8001
title: Sorting algorithms/Bead sort
title: Ordenar algoritmos/ordenação de contas
challengeType: 5
forumTopicId: 302310
dashedName: sorting-algorithmsbead-sort
@ -8,47 +8,47 @@ dashedName: sorting-algorithmsbead-sort
# --description--
Sort an array of positive integers using the [Bead Sort Algorithm](https://en.wikipedia.org/wiki/Bead_sort).
Ordene um array de números inteiros positivos usando o [Algoritmo de ordenação de contas](https://en.wikipedia.org/wiki/Bead_sort).
A *bead sort* is also known as a *gravity sort*.
Uma *ordenação de contas* também é conhecida como *ordenação por gravidade*.
The algorithm has O(S), where S is the sum of the integers in the input set: Each bead is moved individually.
O algoritmo tem O(S), onde S é a soma dos inteiros no conjunto de entrada: cada conta é movida individualmente.
This is the case when bead sort is implemented without a mechanism to assist in finding empty spaces below the beads, such as in software implementations.
Esse é o caso quando a ordenação de contas é implementada sem um mecanismo para ajudar a encontrar espaços vazios abaixo das contas, como em implementações de software.
# --hints--
`beadSort` should be a function.
`beadSort` deve ser uma função.
```js
assert(typeof beadSort == 'function');
```
`beadSort([25, 32, 12, 7, 20])` should return an array.
`beadSort([25, 32, 12, 7, 20])` deve retornar um array.
```js
assert(Array.isArray(beadSort([25, 32, 12, 7, 20])));
```
`beadSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
`beadSort([25, 32, 12, 7, 20])` deve retornar `[7, 12, 20, 25, 32]`.
```js
assert.deepEqual(beadSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
`beadSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
`beadSort([38, 45, 35, 8, 13])` deve retornar `[8, 13, 35, 38, 45]`.
```js
assert.deepEqual(beadSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
`beadSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
`beadSort([43, 36, 20, 34, 24])` deve retornar `[20, 24, 34, 36, 43]`.
```js
assert.deepEqual(beadSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
`beadSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
`beadSort([12, 33, 26, 18, 1, 16, 38])` deve retornar `[1, 12, 16, 18, 26, 33, 38]`.
```js
assert.deepEqual(beadSort([12, 33, 26, 18, 1, 16, 38]), [
@ -62,7 +62,7 @@ assert.deepEqual(beadSort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
`beadSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
`beadSort([3, 39, 48, 16, 1, 4, 29])` deve retornar `[1, 3, 4, 16, 29, 39, 48]`.
```js
assert.deepEqual(beadSort([3, 39, 48, 16, 1, 4, 29]), [

32
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sorting-algorithms-bogosort.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8002
title: Sorting algorithms/Bogosort
title: Algoritmos de ordenação/Bogosort
challengeType: 5
forumTopicId: 302311
dashedName: sorting-algorithmsbogosort
@ -8,56 +8,56 @@ dashedName: sorting-algorithmsbogosort
# --description--
[Bogosort](https://en.wikipedia.org/wiki/Bogosort) a list of numbers.
Faça o [Bogosort](https://en.wikipedia.org/wiki/Bogosort) de uma lista de números.
Bogosort simply shuffles a collection randomly until it is sorted.
O Bogosort simplesmente embaralha uma coleção aleatoriamente até que ela fica ordenada.
"Bogosort" is a perversely inefficient algorithm only used as an in-joke.
O "Bogosort" é um algoritmo perversamente ineficaz, que só é usado como uma piada interna.
Its average run-time is O(n!) because the chance that any given shuffle of a set will end up in sorted order is about one in *n* factorial, and the worst case is infinite since there's no guarantee that a random shuffling will ever produce a sorted sequence.
Seu tempo médio de execução é O(n!), pois a probabilidade de que qualquer embaralhamento dado de um conjunto acabe ordenado é equivalente ao fatorial de *n*. No pior dos casos, o tempo é infinito, já que não há garantias de que um embaralhamento aleatório produza uma sequência ordenada.
Its best case is O(n) since a single pass through the elements may suffice to order them.
O melhor caso é O(n), uma vez que um único passo através dos elementos pode bastar para ordená-los.
Pseudocode:
Pseudocódigo:
<pre><b>while not</b> InOrder(list) <b>do</b>
Shuffle(list)
<pre><b>while not</b> NaOrdem(lista) <b>do</b>
Embaralhar(lista)
<b>done</b>
</pre>
# --hints--
`bogosort` should be a function.
`bogosort` deve ser uma função.
```js
assert(typeof bogosort == 'function');
```
`bogosort([25, 32, 12, 7, 20])` should return an array.
`bogosort([25, 32, 12, 7, 20])` deve retornar um array.
```js
assert(Array.isArray(bogosort([25, 32, 12, 7, 20])));
```
`bogosort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
`bogosort([25, 32, 12, 7, 20])` deve retornar `[7, 12, 20, 25, 32]`.
```js
assert.deepEqual(bogosort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
`bogosort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
`bogosort([38, 45, 35, 8, 13])` deve retornar `[8, 13, 35, 38, 45]`.
```js
assert.deepEqual(bogosort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
`bogosort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
`bogosort([43, 36, 20, 34, 24])` deve retornar `[20, 24, 34, 36, 43]`.
```js
assert.deepEqual(bogosort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
`bogosort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
`bogosort([12, 33, 26, 18, 1, 16, 38])` deve retornar `[1, 12, 16, 18, 26, 33, 38]`.
```js
assert.deepEqual(bogosort([12, 33, 26, 18, 1, 16, 38]), [
@ -71,7 +71,7 @@ assert.deepEqual(bogosort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
`bogosort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
`bogosort([3, 39, 48, 16, 1, 4, 29])` deve retornar `[1, 3, 4, 16, 29, 39, 48]`.
```js
assert.deepEqual(bogosort([3, 39, 48, 16, 1, 4, 29]), [

36
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sorting-algorithms-cocktail-sort.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8004
title: Sorting algorithms/Cocktail sort
title: Algoritmos de ordenação/ordenação de coquetel
challengeType: 5
forumTopicId: 302312
dashedName: sorting-algorithmscocktail-sort
@ -8,67 +8,67 @@ dashedName: sorting-algorithmscocktail-sort
# --description--
The cocktail shaker sort is an improvement on the [Bubble Sort](https://rosettacode.org/wiki/Bubble Sort). The improvement is basically that values "bubble" both directions through the array, because on each iteration the cocktail shaker sort bubble sorts once forwards and once backwards. Pseudocode for the algorithm (from [wikipedia](https://en.wikipedia.org/wiki/Cocktail sort)):
A ordenação do shaker de coquetel é uma melhoria da [Ordenação de bolha](https://rosettacode.org/wiki/Bubble Sort). A melhoria consiste basicamente no fato de que os valores são levados como "bolhas" para ambas as direções através do array, porque, em cada iteração, o shaker de coquetel classifica uma vez para frente e uma vez para trás. Pseudocódigo para o algoritmo (da [Wikipédia](https://en.wikipedia.org/wiki/Cocktail sort)):
<pre><b>function</b> <i>cocktailSort</i>( A : list of sortable items )
<pre><b>function</b> <i>cocktailSort</i>( A : lista de itens ordenáveis)
<b>do</b>
swapped := false
<b>for each</b> i <b>in</b> 0 <b>to</b> length( A ) - 2 <b>do</b>
<b>if</b> A[ i ] > A[ i+1 ] <b>then</b> <i>// test whether the two</i>
<i>// elements are in the wrong</i>
<i>// order</i>
swap( A[ i ], A[ i+1 ] ) <i>// let the two elements</i>
<i>// change places</i>
<i>// elementos na ordem</i>
<i>// incorreta</i>
swap( A[ i ], A[ i+1 ] ) <i>// permitir que os elementos</i>
<i>// troquem de lugar</i>
swapped := true;
<b>if</b> swapped = false <b>then</b>
<i>// we can exit the outer loop here if no swaps occurred.</i>
<i>// saímos do laço externo aqui se não houver trocas.</i>
<b>break do-while loop</b>;
swapped := false
<b>for each</b> i <b>in</b> length( A ) - 2 <b>down to</b> 0 <b>do</b>
<b>if</b> A[ i ] > A[ i+1 ] <b>then</b>
swap( A[ i ], A[ i+1 ] )
swapped := true;
<b>while</b> swapped; <i>// if no elements have been swapped,</i>
<i>// then the list is sorted</i>
<b>while</b> swapped; <i>// se nenhum elemento for trocado,</i>
<i>// a lista está ordenada</i>
</pre>
# --instructions--
Write a function that sorts a given array using cocktail sort.
Escreva uma função que ordene um determinado array usando uma ordenação de coquetel.
# --hints--
`cocktailSort` should be a function.
`cocktailSort` deve ser uma função.
```js
assert(typeof cocktailSort == 'function');
```
`cocktailSort([25, 32, 12, 7, 20])` should return an array.
`cocktailSort([25, 32, 12, 7, 20])` deve retornar um array.
```js
assert(Array.isArray(cocktailSort([25, 32, 12, 7, 20])));
```
`cocktailSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
`cocktailSort([25, 32, 12, 7, 20])` deve retornar `[7, 12, 20, 25, 32]`.
```js
assert.deepEqual(cocktailSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
`cocktailSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
`cocktailSort([38, 45, 35, 8, 13])` deve retornar `[8, 13, 35, 38, 45]`.
```js
assert.deepEqual(cocktailSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
`cocktailSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
`cocktailSort([43, 36, 20, 34, 24])` deve retornar `[20, 24, 34, 36, 43]`.
```js
assert.deepEqual(cocktailSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
`cocktailSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
`cocktailSort([12, 33, 26, 18, 1, 16, 38])` deve retornar `[1, 12, 16, 18, 26, 33, 38]`.
```js
assert.deepEqual(cocktailSort([12, 33, 26, 18, 1, 16, 38]), [
@ -82,7 +82,7 @@ assert.deepEqual(cocktailSort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
`cocktailSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
`cocktailSort([3, 39, 48, 16, 1, 4, 29])` deve retornar `[1, 3, 4, 16, 29, 39, 48]`.
```js
assert.deepEqual(cocktailSort([3, 39, 48, 16, 1, 4, 29]), [

56
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sorting-algorithms-comb-sort.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8005
title: Sorting algorithms/Comb sort
title: Algoritmos de ordenação/ordenação do pente
challengeType: 5
forumTopicId: 302313
dashedName: sorting-algorithmscomb-sort
@ -8,48 +8,48 @@ dashedName: sorting-algorithmscomb-sort
# --description--
Implement a *comb sort*.
Implemente uma *ordenação de pente*.
The **Comb Sort** is a variant of the [Bubble Sort](https://rosettacode.org/wiki/Bubble Sort).
A **ordenação de pente** é uma variante da [ordenação de bolha](https://rosettacode.org/wiki/Bubble Sort).
Like the [Shell sort](https://rosettacode.org/wiki/Shell sort), the Comb Sort increases the gap used in comparisons and exchanges.
Como a [ordenação de concha](https://rosettacode.org/wiki/Shell sort), a ordenação de pente aumenta o intervalo usado nas comparações e trocas.
Dividing the gap by $(1-e^{-\\varphi})^{-1} \\approx 1.247330950103979$ works best, but 1.3 may be more practical.
Dividir a diferença por $(1-e^{-\\varphi})^{-1} \\approx 1,247330950103979$ funciona melhor, mas 1,3 pode ser mais prático.
Some implementations use the insertion sort once the gap is less than a certain amount.
Algumas implementações usam a ordenação de inserção, já que a diferença é menor do que uma certa quantidade.
**Also see**
**Veja também**
<ul>
<li>the Wikipedia article: <a href='https://en.wikipedia.org/wiki/Comb sort' target='_blank'>Comb sort</a>.</li>
<li>o artigo da Wikipédia: <a href='https://pt.wikipedia.org/wiki/Comb_sort' target='_blank'>Comb sort</a>.</li>
</ul>
Variants:
Variantes:
<ul>
<li>Combsort11 makes sure the gap ends in (11, 8, 6, 4, 3, 2, 1), which is significantly faster than the other two possible endings.</li>
<li>Combsort with different endings changes to a more efficient sort when the data is almost sorted (when the gap is small). Comb sort with a low gap isn't much better than the Bubble Sort.</li>
<li>Combsort11 garante que a diferença termine em (11, 8, 6, 4, 3, 2, 1), o que é significativamente mais rápido do que as outras duas terminações possíveis.</li>
<li>A ordenação de pente com terminações diferentes muda para uma ordenação mais eficiente quando os dados estão quase ordenados (quando a diferença é pequena). A ordenação de pente com diferença baixa não é muito melhor que a ordenação de bolha.</li>
</ul>
Pseudocode:
Pseudocódigo:
<pre><b>function</b> combsort(<b>array</b> input)
gap := input<b>.size</b> <i>//initialize gap size</i>
gap := input<b>.size</b> <i>//inicialize o tamanho da diferença</i>
<b>loop until</b> gap = 1 <b>and</b> swaps = 0
<i>//update the gap value for a next comb. Below is an example</i>
<i>//atualize o valor da diferença para o próximo pente. Abaixo, vemos um exemplo</i>
gap := int(gap / 1.25)
<b>if</b> gap &#x3C; 1
<i>//minimum gap is 1</i>
<i>//a diferença mínima é 1</i>
gap := 1
<b>end if</b>
i := 0
swaps := 0 <i>//see <a href='https://rosettacode.org/wiki/Sorting_algorithms/Bubble_sort' target='_blank'>Bubble Sort</a> for an explanation</i>
<i>//a single "comb" over the input list</i>
<b>loop until</b> i + gap >= input<b>.size</b> <i>//see <a href='https://rosettacode.org/wiki/Sorting_algorithms/Shell_sort' target='_blank'>Shell sort</a> for similar idea</i>
swaps := 0 <i>//veja <a href='https://rosettacode.org/wiki/Sorting_algorithms/Bubble_sort' target='_blank'>ordenação de bolha</a> para uma explicação</i>
<i>//um único "pente" sobre a lista de entradas</i>
<b>loop until</b> i + gap >= input<b>.size</b> <i>//consulte a <a href='https://rosettacode.org/wiki/Sorting_algorithms/Shell_sort' target='_blank'>ordenação de concha</a> para ver uma ideia semelhante</i>
<b>if</b> input[i] > input[i+gap]
<b>swap</b>(input[i], input[i+gap])
swaps := 1 <i>// Flag a swap has occurred, so the</i>
<i>// list is not guaranteed sorted</i>
swaps := 1 <i>// Marque uma troca que ocorreu, para que</i>
<i>// a lista não esteja garantidamente ordenada</i>
<b>end if</b>
i := i + 1
<b>end loop</b>
@ -59,41 +59,41 @@ Pseudocode:
# --instructions--
Write a function that sorts a given array using Comb sort.
Escreva uma função que ordene um determinado array usando uma ordenação de pente.
# --hints--
`combSort` should be a function.
`combSort` deve ser uma função.
```js
assert(typeof combSort == 'function');
```
`combSort([25, 32, 12, 7, 20])` should return an array.
`combSort([25, 32, 12, 7, 20])` deve retornar um array.
```js
assert(Array.isArray(combSort([25, 32, 12, 7, 20])));
```
`combSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
`combSort([25, 32, 12, 7, 20])` deve retornar `[7, 12, 20, 25, 32]`.
```js
assert.deepEqual(combSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
`combSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
`combSort([38, 45, 35, 8, 13])` deve retornar `[8, 13, 35, 38, 45]`.
```js
assert.deepEqual(combSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
`combSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
`combSort([43, 36, 20, 34, 24])` deve retornar `[20, 24, 34, 36, 43]`.
```js
assert.deepEqual(combSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
`combSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
`combSort([12, 33, 26, 18, 1, 16, 38])` deve retornar `[1, 12, 16, 18, 26, 33, 38]`.
```js
assert.deepEqual(combSort([12, 33, 26, 18, 1, 16, 38]), [
@ -107,7 +107,7 @@ assert.deepEqual(combSort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
`combSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
`combSort([3, 39, 48, 16, 1, 4, 29])` deve retornar `[1, 3, 4, 16, 29, 39, 48]`.
```js
assert.deepEqual(combSort([3, 39, 48, 16, 1, 4, 29]), [

24
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sorting-algorithms-gnome-sort.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8007
title: Sorting algorithms/Gnome sort
title: Algoritmos de ordenação/ordenação do gnomo
challengeType: 5
forumTopicId: 302314
dashedName: sorting-algorithmsgnome-sort
@ -8,16 +8,16 @@ dashedName: sorting-algorithmsgnome-sort
# --description--
Gnome sort is a sorting algorithm which is similar to [Insertion sort](https://rosettacode.org/wiki/Insertion sort), except that moving an element to its proper place is accomplished by a series of swaps, as in [Bubble Sort](https://rosettacode.org/wiki/Bubble Sort).
A ordenação do gnomo é um algoritmo de ordenação semelhante à [ordenação de inserção](https://rosettacode.org/wiki/Insertion sort), exceto pelo fato de que mover um elemento para o lugar adequado é realizado por uma série de trocas, como na [ordenação de bolha](https://rosettacode.org/wiki/Bubble Sort).
The pseudocode for the algorithm is:
O pseudocódigo para o algoritmo é:
<pre><b>function</b> <i>gnomeSort</i>(a[0..size-1])
i := 1
j := 2
<b>while</b> i &#x3C; size <b>do</b>
<b>if</b> a[i-1] &#x3C;= a[i] <b>then</b>
<i>/// for descending sort, use >= for comparison</i>
<i>/// para a ordenação descendente, use >= para a comparação</i>
i := j
j := j + 1
<b>else</b>
@ -33,41 +33,41 @@ The pseudocode for the algorithm is:
# --instructions--
Write a function to implement the above pseudo code. The function should return the sorted array.
Escreva uma função para implementar o pseudocódigo acima. A função deve retornar o array ordenado.
# --hints--
`gnomeSort` should be a function.
`gnomeSort` deve ser uma função.
```js
assert(typeof gnomeSort == 'function');
```
`gnomeSort([25, 32, 12, 7, 20])` should return an array.
`gnomeSort([25, 32, 12, 7, 20])` deve retornar um array.
```js
assert(Array.isArray(gnomeSort([25, 32, 12, 7, 20])));
```
`gnomeSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
`gnomeSort([25, 32, 12, 7, 20])` deve retornar `[7, 12, 20, 25, 32]`.
```js
assert.deepEqual(gnomeSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
`gnomeSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
`gnomeSort([38, 45, 35, 8, 13])` deve retornar `[8, 13, 35, 38, 45]`.
```js
assert.deepEqual(gnomeSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
`gnomeSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
`gnomeSort([43, 36, 20, 34, 24])` deve retornar `[20, 24, 34, 36, 43]`.
```js
assert.deepEqual(gnomeSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
`gnomeSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
`gnomeSort([12, 33, 26, 18, 1, 16, 38])` deve retornar `[1, 12, 16, 18, 26, 33, 38]`.
```js
assert.deepEqual(gnomeSort([12, 33, 26, 18, 1, 16, 38]), [
@ -81,7 +81,7 @@ assert.deepEqual(gnomeSort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
`gnomeSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
`gnomeSort([3, 39, 48, 16, 1, 4, 29])` deve retornar `[1, 3, 4, 16, 29, 39, 48]`.
```js
assert.deepEqual(gnomeSort([3, 39, 48, 16, 1, 4, 29]), [

26
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sorting-algorithms-pancake-sort.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc800b
title: Sorting algorithms/Pancake sort
title: Algoritmos de ordenação/ordenação da panqueca
challengeType: 5
forumTopicId: 302315
dashedName: sorting-algorithmspancake-sort
@ -8,51 +8,51 @@ dashedName: sorting-algorithmspancake-sort
# --description--
Write a function to sort an array of integers (of any convenient size) into ascending order using [Pancake sorting](https://en.wikipedia.org/wiki/Pancake sorting). The function should return the sorted array.
Escreva uma função para ordenar um array de inteiros (de qualquer tamanho conveniente) em ordem ascendente usando o método de ordenação [Pancake sorting](https://en.wikipedia.org/wiki/Pancake sorting). A função deve retornar o array ordenado.
In short, instead of individual elements being sorted, the only operation allowed is to "flip" one end of the list, like so:
Em resumo, em vez de serem ordenados elementos individuais, a única operação permitida é "virar" uma extremidade da lista, assim:
<pre>Before:
<pre>Antes:
<b>6 7 8 9</b> 2 5 3 4 1<br>
After:
Depois:
<b>9 8 7 6</b> 2 5 3 4 1
</pre>
Only one end of the list can be flipped; this should be the low end, but the high end is okay if it's easier to code or works better, but it **must** be the same end for the entire solution. (The end flipped can't be arbitrarily changed.)
Apenas uma extremidade da lista pode ser invertida. Esta deve ser a extremidade inferior, mas pode ser a extremidade superior se for mais fácil codificar ou se funcionar melhor. mas **deve** ser a mesma extremidade virada para toda a solução. (A extremidade virada não pode ser alterada arbitrariamente.)
# --hints--
`pancakeSort` should be a function.
`pancakeSort` deve ser uma função.
```js
assert(typeof pancakeSort == 'function');
```
`pancakeSort([25, 32, 12, 7, 20])` should return an array.
`pancakeSort([25, 32, 12, 7, 20])` deve retornar um array.
```js
assert(Array.isArray(pancakeSort([25, 32, 12, 7, 20])));
```
`pancakeSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
`pancakeSort([25, 32, 12, 7, 20])` deve retornar `[7, 12, 20, 25, 32]`.
```js
assert.deepEqual(pancakeSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
`pancakeSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
`pancakeSort([38, 45, 35, 8, 13])` deve retornar `[8, 13, 35, 38, 45]`.
```js
assert.deepEqual(pancakeSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
`pancakeSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
`pancakeSort([43, 36, 20, 34, 24])` deve retornar `[20, 24, 34, 36, 43]`.
```js
assert.deepEqual(pancakeSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
`pancakeSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
`pancakeSort([12, 33, 26, 18, 1, 16, 38])` deve retornar `[1, 12, 16, 18, 26, 33, 38]`.
```js
assert.deepEqual(pancakeSort([12, 33, 26, 18, 1, 16, 38]), [
@ -66,7 +66,7 @@ assert.deepEqual(pancakeSort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
`pancakeSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
`pancakeSort([3, 39, 48, 16, 1, 4, 29])` deve retornar `[1, 3, 4, 16, 29, 39, 48]`.
```js
assert.deepEqual(pancakeSort([3, 39, 48, 16, 1, 4, 29]), [

24
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sorting-algorithms-permutation-sort.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc800c
title: Sorting algorithms/Permutation sort
title: Algoritmos de ordenação/ordenação de permutação
challengeType: 5
forumTopicId: 302316
dashedName: sorting-algorithmspermutation-sort
@ -8,48 +8,48 @@ dashedName: sorting-algorithmspermutation-sort
# --description--
Write a function to implement a permutation sort, which proceeds by generating the possible permutations of the input array until discovering the sorted one. The function should return the sorted array.
Escreva uma função para implementar uma ordenação de permutação, que gere as possíveis permutações do array de entrada até descobrir a forma ordenada. A função deve retornar o array ordenado.
Pseudocode:
Pseudocódigo:
<pre><b>while not</b> InOrder(list) <b>do</b>
nextPermutation(list)
<pre><b>while not</b> NaOrdem(lista) <b>do</b>
proximaPermutacao(lista)
<b>done</b>
</pre>
# --hints--
`permutationSort` should be a function.
`permutationSort` deve ser uma função.
```js
assert(typeof permutationSort == 'function');
```
`permutationSort([25, 32, 12, 7, 20])` should return an array.
`permutationSort([25, 32, 12, 7, 20])` deve retornar um array.
```js
assert(Array.isArray(permutationSort([25, 32, 12, 7, 20])));
```
`permutationSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
`permutationSort([25, 32, 12, 7, 20])` deve retornar `[7, 12, 20, 25, 32]`.
```js
assert.deepEqual(permutationSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
`permutationSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
`permutationSort([38, 45, 35, 8, 13])` deve retornar `[8, 13, 35, 38, 45]`.
```js
assert.deepEqual(permutationSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
`permutationSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
`permutationSort([43, 36, 20, 34, 24])` deve retornar `[20, 24, 34, 36, 43]`.
```js
assert.deepEqual(permutationSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
`permutationSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
`permutationSort([12, 33, 26, 18, 1, 16, 38])` deve retornar `[1, 12, 16, 18, 26, 33, 38]`.
```js
assert.deepEqual(permutationSort([12, 33, 26, 18, 1, 16, 38]), [
@ -63,7 +63,7 @@ assert.deepEqual(permutationSort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
`permutationSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
`permutationSort([3, 39, 48, 16, 1, 4, 29])` deve retornar `[1, 3, 4, 16, 29, 39, 48]`.
```js
assert.deepEqual(permutationSort([3, 39, 48, 16, 1, 4, 29]), [

28
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sorting-algorithms-shell-sort.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8010
title: Sorting algorithms/Shell sort
title: Ordenar algoritmos/ordenação de concha
challengeType: 5
forumTopicId: 302317
dashedName: sorting-algorithmsshell-sort
@ -8,51 +8,51 @@ dashedName: sorting-algorithmsshell-sort
# --description--
Write a function to sort an array of elements using the [Shell sort](https://en.wikipedia.org/wiki/Shell sort) algorithm, a diminishing increment sort. The function should return the sorted array.
Escreva uma função para classificar um array de elementos usando o algoritmo de [ordenação de concha](https://en.wikipedia.org/wiki/Shell sort), uma ordenação de incremento reduzido. A função deve retornar o array ordenado.
The Shell sort (also known as Shellsort or Shell's method) is named after its inventor, Donald Shell, who published the algorithm in 1959.
A ordenação de concha (também conhecida como método de Shell ou shellsort) recebeu o nome em homenagem ao seu inventor, Donald Shell, que publicou o algoritmo em 1959.
Shell sort is a sequence of interleaved insertion sorts based on an increment sequence. The increment size is reduced after each pass until the increment size is 1.
A ordenação de concha é uma sequência de ordenações de inserção intercaladas baseadas em sequência de incremento. O tamanho do incremento é reduzido após cada passagem até que seu tamanho seja 1.
With an increment size of 1, the sort is a basic insertion sort, but by this time the data is guaranteed to be almost sorted, which is insertion sort's "best case".
Com um tamanho de incremento de 1, a ordenação é de inserção básica, mas, desta vez, com a garantia de que os dados estarão quase classificados, o que é o "melhor caso" da ordenação de inserção.
Any sequence will sort the data as long as it ends in 1, but some work better than others.
Qualquer sequência ordenará os dados desde que termine em 1, mas algumas funcionam melhor do que outras.
Empirical studies have shown a geometric increment sequence with a ratio of about 2.2 work well in practice.
Estudos empíricos mostraram que uma sequência de incrementos geométricos com uma relação de cerca de 2,2 funcionam bem na prática.
# --hints--
`shellSort` should be a function.
`shellSort` deve ser uma função.
```js
assert(typeof shellSort == 'function');
```
`shellSort([25, 32, 12, 7, 20])` should return an array.
`shellSort([25, 32, 12, 7, 20])` deve retornar um array.
```js
assert(Array.isArray(shellSort([25, 32, 12, 7, 20])));
```
`shellSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
`shellSort([25, 32, 12, 7, 20])` deve retornar `[7, 12, 20, 25, 32]`.
```js
assert.deepEqual(shellSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
`shellSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
`shellSort([38, 45, 35, 8, 13])` deve retornar `[8, 13, 35, 38, 45]`.
```js
assert.deepEqual(shellSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
`shellSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
`shellSort([43, 36, 20, 34, 24])` deve retornar `[20, 24, 34, 36, 43]`.
```js
assert.deepEqual(shellSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
`shellSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
`shellSort([12, 33, 26, 18, 1, 16, 38])` deve retornar `[1, 12, 16, 18, 26, 33, 38]`.
```js
assert.deepEqual(shellSort([12, 33, 26, 18, 1, 16, 38]), [
@ -66,7 +66,7 @@ assert.deepEqual(shellSort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
`shellSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
`shellSort([3, 39, 48, 16, 1, 4, 29])` deve retornar `[1, 3, 4, 16, 29, 39, 48]`.
```js
assert.deepEqual(shellSort([3, 39, 48, 16, 1, 4, 29]), [

22
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sorting-algorithms-stooge-sort.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8012
title: Sorting algorithms/Stooge sort
title: Algoritmos de ordenação/ordenação fantoche
challengeType: 5
forumTopicId: 302318
dashedName: sorting-algorithmsstooge-sort
@ -8,11 +8,11 @@ dashedName: sorting-algorithmsstooge-sort
# --description--
Write a function to perform [Stooge Sort](https://en.wikipedia.org/wiki/Stooge sort) on an array of integers. The function should return a sorted array.
Escreva uma função para executar a [ordenação fantoche](https://en.wikipedia.org/wiki/Stooge sort) em um array de números inteiros. A função deve retornar o array ordenado.
The Stooge Sort algorithm is as follows:
O algoritmo de ordenação fantoche é o seguinte:
<pre><b>algorithm</b> stoogesort(<b>array</b> L, i = 0, j = <b>length</b>(L)-1)
<pre><b>Algoritmo</b> stoogesort(<b>array</b> L, i = 0, j = <b>length</b>(L)-1)
<b>if</b> L[j] &#x3C; L[i] <b>then</b>
L[i] <b>↔</b> L[j]
<b>if</b> j - i > 1 <b>then</b>
@ -25,37 +25,37 @@ The Stooge Sort algorithm is as follows:
# --hints--
`stoogeSort` should be a function.
`stoogeSort` deve ser uma função.
```js
assert(typeof stoogeSort == 'function');
```
`stoogeSort([25, 32, 12, 7, 20])` should return an array.
`stoogeSort([25, 32, 12, 7, 20])` deve retornar um array.
```js
assert(Array.isArray(stoogeSort([25, 32, 12, 7, 20])));
```
`stoogeSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
`stoogeSort([25, 32, 12, 7, 20])` deve retornar `[7, 12, 20, 25, 32]`.
```js
assert.deepEqual(stoogeSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
`stoogeSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
`stoogeSort([38, 45, 35, 8, 13])` deve retornar `[8, 13, 35, 38, 45]`.
```js
assert.deepEqual(stoogeSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
`stoogeSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
`stoogeSort([43, 36, 20, 34, 24])` deve retornar `[20, 24, 34, 36, 43]`.
```js
assert.deepEqual(stoogeSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
`stoogeSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
`stoogeSort([12, 33, 26, 18, 1, 16, 38])` deve retornar `[1, 12, 16, 18, 26, 33, 38]`.
```js
assert.deepEqual(stoogeSort([12, 33, 26, 18, 1, 16, 38]), [
@ -69,7 +69,7 @@ assert.deepEqual(stoogeSort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
`stoogeSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
`stoogeSort([3, 39, 48, 16, 1, 4, 29])` deve retornar `[1, 3, 4, 16, 29, 39, 48]`.
```js
assert.deepEqual(stoogeSort([3, 39, 48, 16, 1, 4, 29]), [

20
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sorting-algorithms-strand-sort.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8013
title: Sorting algorithms/Strand sort
title: Algoritmos de ordenação/ordenação strand
challengeType: 5
forumTopicId: 302319
dashedName: sorting-algorithmsstrand-sort
@ -8,43 +8,43 @@ dashedName: sorting-algorithmsstrand-sort
# --description--
Write a function to sort an array using the [Strand sort](https://en.wikipedia.org/wiki/Strand sort). The function should return the sorted array.
Escreva uma função para ordenar um array usando o algoritmo de ordenação [Strand sort](https://pt.wikipedia.org/wiki/Strand_sort). A função deve retornar o array ordenado.
This is a way of sorting numbers by extracting shorter sequences of already sorted numbers from an unsorted list.
Esta é uma forma de ordenar números extraindo sequências mais curtas de números já ordenados de uma lista não ordenada.
# --hints--
`strandSort` should be a function.
`strandSort` deve ser uma função.
```js
assert(typeof strandSort == 'function');
```
`strandSort([25, 32, 12, 7, 20])` should return an array.
`strandSort([25, 32, 12, 7, 20])` deve retornar um array.
```js
assert(Array.isArray(strandSort([25, 32, 12, 7, 20])));
```
`strandSort([25, 32, 12, 7, 20])` should return `[7, 12, 20, 25, 32]`.
`strandSort([25, 32, 12, 7, 20])` deve retornar `[7, 12, 20, 25, 32]`.
```js
assert.deepEqual(strandSort([25, 32, 12, 7, 20]), [7, 12, 20, 25, 32]);
```
`strandSort([38, 45, 35, 8, 13])` should return `[8, 13, 35, 38, 45]`.
`strandSort([38, 45, 35, 8, 13])` deve retornar `[8, 13, 35, 38, 45]`.
```js
assert.deepEqual(strandSort([38, 45, 35, 8, 13]), [8, 13, 35, 38, 45]);
```
`strandSort([43, 36, 20, 34, 24])` should return `[20, 24, 34, 36, 43]`.
`strandSort([43, 36, 20, 34, 24])` deve retornar `[20, 24, 34, 36, 43]`.
```js
assert.deepEqual(strandSort([43, 36, 20, 34, 24]), [20, 24, 34, 36, 43]);
```
`strandSort([12, 33, 26, 18, 1, 16, 38])` should return `[1, 12, 16, 18, 26, 33, 38]`.
`strandSort([12, 33, 26, 18, 1, 16, 38])` deve retornar `[1, 12, 16, 18, 26, 33, 38]`.
```js
assert.deepEqual(strandSort([12, 33, 26, 18, 1, 16, 38]), [
@ -58,7 +58,7 @@ assert.deepEqual(strandSort([12, 33, 26, 18, 1, 16, 38]), [
]);
```
`strandSort([3, 39, 48, 16, 1, 4, 29])` should return `[1, 3, 4, 16, 29, 39, 48]`.
`strandSort([3, 39, 48, 16, 1, 4, 29])` deve retornar `[1, 3, 4, 16, 29, 39, 48]`.
```js
assert.deepEqual(strandSort([3, 39, 48, 16, 1, 4, 29]), [

32
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/soundex.md
View File

@ -8,86 +8,86 @@ dashedName: soundex
# --description--
Soundex is an algorithm for creating indices for words based on their pronunciation. The goal is for homophones to be encoded to the same representation so that they can be matched despite minor differences in spelling (from [the WP article](https://en.wikipedia.org/wiki/soundex)). There is a major issue in many of the implementations concerning the separation of two consonants that have the same soundex code! According to the [official Rules](https://www.archives.gov/research/census/soundex.html). So check for instance if **Ashcraft** is coded to **A-261**.
Soundex é um algoritmo para criar índices para palavras com base em sua pronúncia. O objetivo é que os homófonos sejam codificados para a mesma representação, para que eles possam ser combinados apesar das pequenas diferenças na ortografia (do [artigo da Wikipédia](https://en.wikipedia.org/wiki/soundex)). Há uma questão importante em muitas das implementações relativas à separação de duas consoantes que têm o mesmo código soundex! De acordo com as [regras oficiais](https://www.archives.gov/research/census/soundex.html). Então, verifique por exemplo se **Ashcraft** é codificado para **A-261**.
<ul>
<li>If a vowel (A, E, I, O, U) separates two consonants that have the same soundex code, the consonant to the right of the vowel is coded. Tymczak is coded as T-522 (T, 5 for the M, 2 for the C, Z ignored (see "Side-by-Side" rule above), 2 for the K). Since the vowel "A" separates the Z and K, the K is coded.</li>
<li>If "H" or "W" separate two consonants that have the same soundex code, the consonant to the right of the vowel is not coded. Example: Ashcraft is coded A-261 (A, 2 for the S, C ignored, 6 for the R, 1 for the F). It is not coded A-226.</li>
<li>Se uma vogal (A, E, I, O, U) separa duas consoantes que tenham o mesmo código soundex, a consoante à direita da vogal é codificada. Tymczak é codificado como T-522 (T, 5 para M, 2 para o C, Z ignorado – veja a regra "Lado a lado" acima –, 2 para o K). Uma vez que a vogal "A" separa Z e K, o K está codificado.</li>
<li>Se "H" ou "W" separa duas consoantes que tenham o mesmo código soundex, a consoante à direita da vogal não é codificada. Exemplo: Ashcraft está codificado A-261 (A, 2 para o S, C ignorado, 6 para o R, 1 para o F). Ele não é codificado A-226.</li>
</ul>
# --instructions--
Write a function that takes a string as a parameter and returns the encoded string.
Escreva uma função que receba uma string como parâmetro e retorne a string codificada.
# --hints--
`soundex` should be a function.
`soundex` deve ser uma função.
```js
assert(typeof soundex == 'function');
```
`soundex("Soundex")` should return a string.
`soundex("Soundex")` deve retornar uma string.
```js
assert(typeof soundex('Soundex') == 'string');
```
`soundex("Soundex")` should return `"S532"`.
`soundex("Soundex")` deve retornar `"S532"`.
```js
assert.equal(soundex('Soundex'), 'S532');
```
`soundex("Example")` should return `"E251"`.
`soundex("Example")` deve retornar `"E251"`.
```js
assert.equal(soundex('Example'), 'E251');
```
`soundex("Sownteks")` should return `"S532"`.
`soundex("Sownteks")` deve retornar `"S532"`.
```js
assert.equal(soundex('Sownteks'), 'S532');
```
`soundex("Ekzampul")` should return `"E251"`.
`soundex("Ekzampul")` deve retornar `"E251"`.
```js
assert.equal(soundex('Ekzampul'), 'E251');
```
`soundex("Euler")` should return `"E460"`.
`soundex("Euler")` deve retornar `"E460"`.
```js
assert.equal(soundex('Euler'), 'E460');
```
`soundex("Gauss")` should return `"G200"`.
`soundex("Gauss")` deve retornar `"G200"`.
```js
assert.equal(soundex('Gauss'), 'G200');
```
`soundex("Hilbert")` should return `"H416"`.
`soundex("Hilbert")` deve retornar `"H416"`.
```js
assert.equal(soundex('Hilbert'), 'H416');
```
`soundex("Knuth")` should return `"K530"`.
`soundex("Knuth")` deve retornar `"K530"`.
```js
assert.equal(soundex('Knuth'), 'K530');
```
`soundex("Lloyd")` should return `"L300"`.
`soundex("Lloyd")` deve retornar `"L300"`.
```js
assert.equal(soundex('Lloyd'), 'L300');
```
`soundex("Lukasiewicz")` should return `"L222"`.
`soundex("Lukasiewicz")` deve retornar `"L222"`.
```js
assert.equal(soundex('Lukasiewicz'), 'L222');

14
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/spiral-matrix.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc801c
title: Spiral matrix
title: Matriz espiral
challengeType: 5
forumTopicId: 302321
dashedName: spiral-matrix
@ -8,7 +8,7 @@ dashedName: spiral-matrix
# --description--
Produce a spiral array. A *spiral array* is a square arrangement of the first N<sup>2</sup> natural numbers, where the numbers increase sequentially as you go around the edges of the array spiraling inwards. For example, given **5**, produce this array:
Produza um array espiral. Um *array espiral* é um arranjo quadrado dos primeiros N<sup>2</sup> números naturais, onde os números aumentam sequencialmente à medida que você vai visitando as arestas do array em uma espiral para dentro. Por exemplo, dado **5**, produza este array:
<pre>
0 1 2 3 4
@ -20,19 +20,19 @@ Produce a spiral array. A *spiral array* is a square arrangement of the first N<
# --hints--
`spiralArray` should be a function.
`spiralArray` deve ser uma função.
```js
assert(typeof spiralArray == 'function');
```
`spiralArray(3)` should return an array.
`spiralArray(3)` deve retornar um array.
```js
assert(Array.isArray(spiralArray(3)));
```
`spiralArray(3)` should return `[[0, 1, 2],[7, 8, 3],[6, 5, 4]]`.
`spiralArray(3)` deve retornar `[[0, 1, 2],[7, 8, 3],[6, 5, 4]]`.
```js
assert.deepEqual(spiralArray(3), [
@ -42,7 +42,7 @@ assert.deepEqual(spiralArray(3), [
]);
```
`spiralArray(4)` should return `[[0, 1, 2, 3],[11, 12, 13, 4],[10, 15, 14, 5],[9, 8, 7, 6]]`.
`spiralArray(4)` deve retornar `[[0, 1, 2, 3],[11, 12, 13, 4],[10, 15, 14, 5],[9, 8, 7, 6]]`.
```js
assert.deepEqual(spiralArray(4), [
@ -53,7 +53,7 @@ assert.deepEqual(spiralArray(4), [
]);
```
`spiralArray(5)` should return `[[0, 1, 2, 3, 4],[15, 16, 17, 18, 5],[14, 23, 24, 19, 6],[13, 22, 21, 20, 7],[12, 11, 10, 9, 8]]`.
`spiralArray(5)` deve retornar `[[0, 1, 2, 3, 4],[15, 16, 17, 18, 5],[14, 23, 24, 19, 6],[13, 22, 21, 20, 7],[12, 11, 10, 9, 8]]`.
```js
assert.deepEqual(spiralArray(5), [

20
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/split-a-character-string-based-on-change-of-character.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc801d
title: Split a character string based on change of character
title: Dividir a string de caracteres com base na mudança de caractere
challengeType: 5
forumTopicId: 302322
dashedName: split-a-character-string-based-on-change-of-character
@ -8,13 +8,13 @@ dashedName: split-a-character-string-based-on-change-of-character
# --description--
Split a (character) string into comma (plus a blank) delimited strings based on a change of character (left to right). Blanks should be treated as any other character (except they are problematic to display clearly). The same applies to commas. For instance, the string:
Divida uma string (de caracteres) em vírgulas (mais um espaço em branco) com base em uma mudança de caractere (da esquerda para a direita). Os espaços em branco devem ser tratados como qualquer outro caractere (exceto pelo fato de que são problemáticos para exibir claramente). O mesmo se aplica às vírgulas. Por exemplo, a string:
<pre>
"gHHH5YY++///\\"
</pre>
should be split as:
deve ser dividida como:
<pre>
["g", "HHH", "5", "YY", "++", "///", "\\" ];
@ -22,25 +22,25 @@ should be split as:
# --hints--
`split` should be a function.
`split` deve ser uma função.
```js
assert(typeof split == 'function');
```
`split("hello")` should return an array.
`split("hello")` deve retornar um array.
```js
assert(Array.isArray(split('hello')));
```
`split("hello")` should return `["h", "e", "ll", "o"]`.
`split("hello")` deve retornar `["h", "e", "ll", "o"]`.
```js
assert.deepEqual(split('hello'), ['h', 'e', 'll', 'o']);
```
`split("commission")` should return `["c", "o", "mm", "i", "ss", "i", "o", "n"]`.
`split("commission")` deve retornar `["c", "o", "mm", "i", "ss", "i", "o", "n"]`.
```js
assert.deepEqual(split('commission'), [
@ -55,7 +55,7 @@ assert.deepEqual(split('commission'), [
]);
```
`split("ssss----====llloooo")` should return `["ssss", "----", "====", "lll", "oooo"]`.
`split("ssss----====llloooo")` deve retornar `["ssss", "----", "====", "lll", "oooo"]`.
```js
assert.deepEqual(split('ssss----====llloooo'), [
@ -67,7 +67,7 @@ assert.deepEqual(split('ssss----====llloooo'), [
]);
```
`split("sssmmmaaammmaaat")` should return `["sss", "mmm", "aaa", "mmm", "aaa", "t"]`.
`split("sssmmmaaammmaaat")` deve retornar `["sss", "mmm", "aaa", "mmm", "aaa", "t"]`.
```js
assert.deepEqual(split('sssmmmaaammmaaat'), [
@ -80,7 +80,7 @@ assert.deepEqual(split('sssmmmaaammmaaat'), [
]);
```
`split("gHHH5YY++///\\")` should return `["g", "HHH", "5", "YY", "++", "///", "\\"]`.
`split("gHHH5YY++///\\")` deve retornar `["g", "HHH", "5", "YY", "++", "///", "\\"]`.
```js
assert.deepEqual(split('gHHH5YY++///\\'), [

14
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/state-name-puzzle.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8024
title: State name puzzle
title: Desafio do nome do estado
challengeType: 5
forumTopicId: 302323
dashedName: state-name-puzzle
@ -8,21 +8,21 @@ dashedName: state-name-puzzle
# --description--
This task is inspired by Mark Nelson's DDJ Column "Wordplay" and one of the weekly puzzle challenges from Will Shortz on NPR Weekend Edition [\[1\]](https://www.npr.org/templates/story/story.php?storyId=9264290) and originally attributed to David Edelheit. The challenge was to take the names of two U.S. States, mix them all together, then rearrange the letters to form the names of two *different* U.S. States (so that all four state names differ from one another). What states are these? The problem was reissued on [the Unicon Discussion Web](https://tapestry.tucson.az.us/twiki/bin/view/Main/StateNamesPuzzle) which includes several solutions with analysis. Several techniques may be helpful and you may wish to refer to [Gödel numbering](https://en.wikipedia.org/wiki/Goedel_numbering), [equivalence relations](https://en.wikipedia.org/wiki/Equivalence_relation), and [equivalence classes](https://en.wikipedia.org/wiki/Equivalence_classes). The basic merits of these were discussed in the Unicon Discussion Web. A second challenge in the form of a set of fictitious new states was also presented.
Esta tarefa é inspirada na coluna "Wordplay", de Mark Nelson no DDJ e um dos desafios semanais de Will Shortz na edição de fim de semana da NPR [\[1\]](https://www.npr.org/templates/story/story.php?storyId=9264290), sendo originalmente atribuída a David Edelheit. O desafio era pegar os nomes de dois estados dos Estados Unidos misturá-los, e, então, reorganizar as letras para formar os nomes de dois estados *diferentes* (para que os quatro nomes de estados sejam diferentes um do outro). Que estados são esses? O problema foi publicado novamente na [Unicon Discussion Web](https://tapestry.tucson.az.us/twiki/bin/view/Main/StateNamesPuzzle), que inclui diversas soluções com a análise. Várias técnicas podem ser úteis caso você queira consultar, como: [a numeração de Gödel](https://en.wikipedia.org/wiki/Goedel_numbering), [as relações de equivalência](https://en.wikipedia.org/wiki/Equivalence_relation) e [as classes de equivalência](https://en.wikipedia.org/wiki/Equivalence_classes). Os méritos básicos destas técnicas foram discutidos na Unicon Discussion Web. Foi também apresentado um segundo desafio, sob a forma de um conjunto de novos estados fictícios.
# --instructions--
Write a function to solve the challenge for the given array of names of states. The function should return an array. Each element should be an object in this form: `{"from":[],"to":[]}`. The "from" array should contain the original names and the "to" array should contain the resultant names.
Escreva uma função para resolver o desafio para o array de nomes de estados fornecido. A função deve retornar um array. Cada elemento deve ser um objeto neste formato: `{"from":[],"to":[]}`. O array "from" deve conter os nomes originais e o array "to" deve conter os nomes resultantes.
# --hints--
`solve` should be a function.
`solve` deve ser uma função.
```js
assert(typeof solve == 'function');
```
`solve(["New Mexico", "New York", "North Carolina ", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota"])` should return an array.
`solve(["New Mexico", "New York", "North Carolina ", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota"])` deve retornar um array.
```js
assert(
@ -44,7 +44,7 @@ assert(
);
```
`solve(["New Mexico", "New York", "North Carolina ", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota"])` should return `[{ from: ["North Carolina ", "South Dakota"], to: ["North Dakota", "South Carolina"] }]`.
`solve(["New Mexico", "New York", "North Carolina ", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota"])` deve retornar `[{ from: ["North Carolina ", "South Dakota"], to: ["North Dakota", "South Carolina"] }]`.
```js
assert.deepEqual(
@ -70,7 +70,7 @@ assert.deepEqual(
);
```
`solve(["New York", "New Kory", "Wen Kory", "York New", "Kory New", "New Kory"])` should return `[{ from: ["New Kory", "New York"], to: ["Wen Kory", "York New"] }, { from: ["New Kory", "New York"], to: ["Kory New", "Wen Kory"] }, { from: ["New Kory", "New York"], to: ["Kory New", "York New"] }, { from: ["New York", "Wen Kory"], to: ["New Kory", "York New"] }, { from: ["New York", "Wen Kory"], to: ["Kory New", "New Kory"] }, { from: ["New York", "Wen Kory"], to: ["Kory New", "York New"] }, { from: ["New York", "York New"], to: ["New Kory", "Wen Kory"] }, { from: ["New York", "York New"], to: ["Kory New", "New Kory"] }, { from: ["New York", "York New"], to: ["Kory New", "Wen Kory"] }, { from: ["Kory New", "New York"], to: ["New Kory", "Wen Kory"] }, { from: ["Kory New", "New York"], to: ["New Kory", "York New"] }, { from: ["Kory New", "New York"], to: ["Wen Kory", "York New"] }, { from: ["New Kory", "Wen Kory"], to: ["Kory New", "York New"] }, { from: ["New Kory", "York New"], to: ["Kory New", "Wen Kory"] }, { from: ["Kory New", "New Kory"], to: ["Wen Kory", "York New"] }]`.
`solve(["New York", "New Kory", "Wen Kory", "York New", "Kory New", "New Kory"])` deve retornar `[{ from: ["New Kory", "New York"], to: ["Wen Kory", "York New"] }, { from: ["New Kory", "New York"], to: ["Kory New", "Wen Kory"] }, { from: ["New Kory", "New York"], to: ["Kory New", "York New"] }, { from: ["New York", "Wen Kory"], to: ["New Kory", "York New"] }, { from: ["New York", "Wen Kory"], to: ["Kory New", "New Kory"] }, { from: ["New York", "Wen Kory"], to: ["Kory New", "York New"] }, { from: ["New York", "York New"], to: ["New Kory", "Wen Kory"] }, { from: ["New York", "York New"], to: ["Kory New", "New Kory"] }, { from: ["New York", "York New"], to: ["Kory New", "Wen Kory"] }, { from: ["Kory New", "New York"], to: ["New Kory", "Wen Kory"] }, { from: ["Kory New", "New York"], to: ["New Kory", "York New"] }, { from: ["Kory New", "New York"], to: ["Wen Kory", "York New"] }, { from: ["New Kory", "Wen Kory"], to: ["Kory New", "York New"] }, { from: ["New Kory", "York New"], to: ["Kory New", "Wen Kory"] }, { from: ["Kory New", "New Kory"], to: ["Wen Kory", "York New"] }]`.
```js
assert.deepEqual(

24
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/straddling-checkerboard.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8029
title: Straddling checkerboard
title: Tabuleiro de damas escarranchado
challengeType: 5
forumTopicId: 302325
dashedName: straddling-checkerboard
@ -8,17 +8,17 @@ dashedName: straddling-checkerboard
# --description--
Implement functions to encrypt and decrypt a message using the [straddling checkerboard](https://en.wikipedia.org/wiki/Straddling_checkerboard) method. The functions will take a string and an array as parameters. The array has 3 strings representing the 3 rows of the checkerboard. The output will be a series of decimal digits. Numbers should be encrypted by inserting the escape character before each digit, then including the digit unencrypted. This should be reversed for decryption.
Implemente funções para criptografar e descriptografar uma mensagem usando o método do [tabuleiro de damas escarranchado](https://en.wikipedia.org/wiki/Straddling_checkerboard). As funções receberão uma string e um array como parâmetros. O array tem 3 strings representando as 3 linhas do tabuleiro de damas. O resultado será uma série de dígitos decimais. Os números devem ser criptografados inserindo o caractere de escape antes de cada dígito e, em seguida, incluindo o dígito não criptografado. Isso deve ser revertido para descriptografia.
# --hints--
`straddle` should be a function.
`straddle` deve ser uma função.
```js
assert(typeof straddle == 'function');
```
`straddle("One night-it was on the twentieth of March, 1888-I was returning.",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` should return a string.
`straddle("One night-it was on the twentieth of March, 1888-I was returning.",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` deve retornar uma string.
```js
assert(
@ -29,7 +29,7 @@ assert(
);
```
`straddle("One night-it was on the twentieth of March, 1888-I was returning.",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` should return `"34045747525284613427502840425027537379697175891898898898584619028294547488"`.
`straddle("One night-it was on the twentieth of March, 1888-I was returning.",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` deve retornar `"34045747525284613427502840425027537379697175891898898898584619028294547488"`.
```js
assert.equal(
@ -41,7 +41,7 @@ assert.equal(
);
```
`straddle("One night-it was on the twentieth of March, 1888-I was returning",["HOL MES RT", "ABCDFGIJKN", "PQUVWXYZ./"])` should return `"139539363509369743061399059745399365901344308320791798798798367430685972839363935"`.
`straddle("One night-it was on the twentieth of March, 1888-I was returning",["HOL MES RT", "ABCDFGIJKN", "PQUVWXYZ./"])` deve retornar `"139539363509369743061399059745399365901344308320791798798798367430685972839363935"`.
```js
assert.equal(
@ -54,7 +54,7 @@ assert.equal(
);
```
`straddle("Thecheckerboardcakerecipespecifies3largeeggsand2.25cupsofflour.",["ET AON RIS", "BCDFGHJKLM", "PQ/UVWXYZ."])` should return `"125021250212707204372221327070218600960021823809623283724002424935226226962262521636094232328463769"`.
`straddle("Thecheckerboardcakerecipespecifies3largeeggsand2.25cupsofflour.",["ET AON RIS", "BCDFGHJKLM", "PQ/UVWXYZ."])` deve retornar `"125021250212707204372221327070218600960021823809623283724002424935226226962262521636094232328463769"`.
```js
assert.equal(
@ -67,13 +67,13 @@ assert.equal(
);
```
`unstraddle` should be a function.
`unstraddle` deve ser uma função.
```js
assert(typeof unstraddle == 'function');
```
`unstraddle("34045747525284613427502840425027537379697175891898898898584619028294547488",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` should return a string.
`unstraddle("34045747525284613427502840425027537379697175891898898898584619028294547488",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` deve retornar uma string.
```js
assert(
@ -84,7 +84,7 @@ assert(
);
```
`unstraddle("34045747525284613427502840425027537379697175891898898898584619028294547488",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` should return `"ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING."`.
`unstraddle("34045747525284613427502840425027537379697175891898898898584619028294547488",["ESTONIA R", "BCDFGHJKLM", "PQUVWXYZ./"])` deve retornar `"ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING."`.
```js
assert.equal(
@ -96,7 +96,7 @@ assert.equal(
);
```
`unstraddle("139539363509369743061399059745399365901344308320791798798798367430685972839363935",["HOL MES RT", "ABCDFGIJKN", "PQUVWXYZ./"])` should return `"ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING"`.
`unstraddle("139539363509369743061399059745399365901344308320791798798798367430685972839363935",["HOL MES RT", "ABCDFGIJKN", "PQUVWXYZ./"])` deve retornar `"ONENIGHTITWASONTHETWENTIETHOFMARCH1888IWASRETURNING"`.
```js
assert.equal(
@ -108,7 +108,7 @@ assert.equal(
);
```
`unstraddle("125021250212707204372221327070218600960021823809623283724002424935226226962262521636094232328463769",["ET AON RIS", "BCDFGHJKLM", "PQ/UVWXYZ."])` should return `"THECHECKERBOARDCAKERECIPESPECIFIES3LARGEEGGSAND2.25CUPSOFFLOUR."`.
`unstraddle("125021250212707204372221327070218600960021823809623283724002424935226226962262521636094232328463769",["ET AON RIS", "BCDFGHJKLM", "PQ/UVWXYZ."])` deve retornar `"THECHECKERBOARDCAKERECIPESPECIFIES3LARGEEGGSAND2.25CUPSOFFLOUR."`.
```js
assert.equal(

18
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/stream-merge.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc802a
title: Stream Merge
title: Mesclar fluxos
challengeType: 5
forumTopicId: 302326
dashedName: stream-merge
@ -8,17 +8,17 @@ dashedName: stream-merge
# --description--
Write a function that takes multiple sorted arrays of items, and returns one array of sorted items.
Escreva uma função que receba vários arrays de itens ordenados e retorne um array de itens ordenados.
# --hints--
`mergeLists` should be a function.
`mergeLists` deve ser uma função.
```js
assert(typeof mergeLists == 'function');
```
`mergeLists([[1, 3, 5, 9, 10], [2, 4, 6, 7, 8]])` should return an array.
`mergeLists([[1, 3, 5, 9, 10], [2, 4, 6, 7, 8]])` deve retornar um array.
```js
assert(
@ -31,7 +31,7 @@ assert(
);
```
`mergeLists([[1, 3, 5, 9, 10], [2, 4, 6, 7, 8]])` should return `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`.
`mergeLists([[1, 3, 5, 9, 10], [2, 4, 6, 7, 8]])` deve retornar `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`.
```js
assert.deepEqual(
@ -43,7 +43,7 @@ assert.deepEqual(
);
```
`mergeLists([[1, 4, 7, 10], [2, 5, 8, 11], [3, 6, 9, 12]])` should return `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]`.
`mergeLists([[1, 4, 7, 10], [2, 5, 8, 11], [3, 6, 9, 12]])` deve retornar `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]`.
```js
assert.deepEqual(
@ -56,7 +56,7 @@ assert.deepEqual(
);
```
`mergeLists([[1, 3, 9, 14, 15, 17, 28], [7, 8, 14, 14, 23, 26, 28, 29, 30], [9, 23, 25, 29]])` should return `[1, 3, 7, 8, 9, 9, 14, 14, 14, 15, 17, 23, 23, 25, 26, 28, 28, 29, 29, 30]`.
`mergeLists([[1, 3, 9, 14, 15, 17, 28], [7, 8, 14, 14, 23, 26, 28, 29, 30], [9, 23, 25, 29]])` deve retornar `[1, 3, 7, 8, 9, 9, 14, 14, 14, 15, 17, 23, 23, 25, 26, 28, 28, 29, 29, 30]`.
```js
assert.deepEqual(
@ -69,7 +69,7 @@ assert.deepEqual(
);
```
`mergeLists([[3, 14, 15], [2, 17, 18], [], [2, 3, 5, 7]])` should return `[2, 2, 3, 3, 5, 7, 14, 15, 17, 18]`.
`mergeLists([[3, 14, 15], [2, 17, 18], [], [2, 3, 5, 7]])` deve retornar `[2, 2, 3, 3, 5, 7, 14, 15, 17, 18]`.
```js
assert.deepEqual(mergeLists([[3, 14, 15], [2, 17, 18], [], [2, 3, 5, 7]]), [
@ -86,7 +86,7 @@ assert.deepEqual(mergeLists([[3, 14, 15], [2, 17, 18], [], [2, 3, 5, 7]]), [
]);
```
`mergeLists([[1, 19, 1999], [17, 33, 2999, 3000], [8, 500, 3999]])` should return `[1, 8, 17, 19, 33, 500, 1999, 2999, 3000, 3999]`.
`mergeLists([[1, 19, 1999], [17, 33, 2999, 3000], [8, 500, 3999]])` deve retornar `[1, 8, 17, 19, 33, 500, 1999, 2999, 3000, 3999]`.
```js
assert.deepEqual(

18
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/strip-control-codes-and-extended-characters-from-a-string.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8036
title: Strip control codes and extended characters from a string
title: Remover códigos de controle e caracteres estendidos a partir de uma string
challengeType: 5
forumTopicId: 302327
dashedName: strip-control-codes-and-extended-characters-from-a-string
@ -8,47 +8,47 @@ dashedName: strip-control-codes-and-extended-characters-from-a-string
# --description--
The task is to strip control codes and extended characters from a string. The solution should demonstrate how to achieve each of the following results: A string with control codes and extended characters stripped. In ASCII, the control codes have decimal codes 0 through to 31 and 127. On an ASCII based system, if the control codes are stripped, the resultant string would have all of its characters within the range of 32 to 126 decimal on the ASCII table. On a non-ASCII based system, we consider characters that do not have a corresponding glyph on the ASCII table (within the ASCII range of 32 to 126 decimal) to be an extended character for the purpose of this task.
A tarefa é remover códigos de controle e caracteres estendidos de uma string. A solução deve demonstrar como alcançar cada um dos seguintes resultados: uma string com códigos de controle e caracteres estendidos removidos. Em ASCII, os códigos de controle têm códigos decimais 0 até 31 e 127. Em um sistema baseado em ASCII, se os códigos de controle forem removidos, a string resultante teria todos os seus caracteres dentro do intervalo de 32 a 126 decimal na tabela ASCII. Em um sistema não ASCII, consideramos que caracteres que não têm um glifo correspondente na tabela ASCII (dentro do intervalo ASCII de 32 a 126 decimal) são um caráter alargado para efeitos desta tarefa.
# --hints--
`strip` should be a function.
`strip` deve ser uma função.
```js
assert(typeof strip == 'function');
```
`strip("abc")` should return a string.
`strip("abc")` deve retornar uma string.
```js
assert(typeof strip('abc') == 'string');
```
`strip("\ba\x00b\n\rc\fd\xc3")` should return `"abcd"`.
`strip("\ba\x00b\n\rc\fd\xc3")` deve retornar `"abcd"`.
```js
assert.equal(strip('\ba\x00b\n\rc\fd\xc3'), 'abcd');
```
`strip("\u0000\n abc\u00E9def\u007F")` should return `" abcdef"`.
`strip("\u0000\n abc\u00E9def\u007F")` deve retornar `" abcdef"`.
```js
assert.equal(strip('\u0000\n abc\u00E9def\u007F'), ' abcdef');
```
`strip("a\n\tb\u2102d\u2147f")` should return `"abdf"`.
`strip("a\n\tb\u2102d\u2147f")` deve retornar `"abdf"`.
```js
assert.equal(strip('a\n\tb\u2102d\u2147f'), 'abdf');
```
`strip("Français.")` should return `"Franais."`.
`strip("Français.")` deve retornar `"Franais."`.
```js
assert.equal(strip('Français.'), 'Franais.');
```
`strip("123\tabc\u0007DEF\u007F+-*/€æŧðłþ")` should return `"123abcDEF+-*/"`.
`strip("123\tabc\u0007DEF\u007F+-*/€æŧðłþ")` deve retornar `"123abcDEF+-*/"`.
```js
assert.equal(strip('123\tabc\u0007DEF\u007F+-*/€æŧðłþ'), '123abcDEF+-*/');

60
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/subleq.md
View File

@ -8,50 +8,50 @@ dashedName: subleq
# --description--
[Subleq](https://rosettacode.org/wiki/eso:Subleq) is an example of a [One-Instruction Set Computer (OISC)](https://en.wikipedia.org/wiki/One_instruction_set_computer).
O [Subleq](https://rosettacode.org/wiki/eso:Subleq) é um exemplo de um [One-Instruction Set Computer (OISC)](https://en.wikipedia.org/wiki/One_instruction_set_computer).
It is named after its only instruction, which is **SU**btract and **B**ranch if **L**ess than or **EQ**ual
Seu nome vem de sua única instrução, que é **SU**btract and **B**ranch if **L**ess than or **EQ**ual (subtraia e ramifique se for menor ou igual)
to zero.
a zero.
Your task is to create an interpreter which emulates such a machine.
Sua tarefa é criar um interpretador que emule esse tipo de máquina.
The machine's memory consists of an array of signed integers. Any reasonable word size is fine, but the memory must be
A memória da máquina consiste em um array de números inteiros com sinal. Qualquer tamanho razoável de palavra serve, mas a memória deve ser
able to hold negative as well as positive numbers.
capaz de conter números negativos e positivos.
Execution begins with the instruction pointer aimed at the first word, which is address 0. It proceeds as follows:
A execução começa com o ponteiro de instrução mirando a primeira palavra, que é o endereço 0. Ela prossegue da seguinte forma:
<ol>
<li>Let A, B, and C be the value stored in the three consecutive words in memory starting at the instruction pointer.</li>
<li>Advance the instruction pointer 3 words to point at the address after the one containing C.</li>
<li>If A is -1, then a character is read from standard input and its code point stored in the address given by B. C
is unused.</li>
<li>If B is -1, then the number contained in the address given by A is interpreted as a code point and the
corresponding character output. C is again unused.</li>
<li>Otherwise, both A and B are treated as the addresses of memory locations. The number contained in the address
given by A is subtracted from the number at the address given by B (and the result stored back in address B). If
the result is zero or negative, the value C becomes the new instruction pointer.</li>
<li>If the instruction pointer becomes negative, execution halts.</li>
<li>Permita que A, B e C sejam valores armazenado nas três palavras consecutivas na memória, começando no ponteiro de instrução.</li>
<li>Avance o ponteiro de instrução 3 palavras para apontar para o endereço após o que contém C.</li>
<li>Se A é -1, então um caractere é lido a partir da entrada padrão e seu ponto de código armazenado no endereço fornecido por B. C
não é usado.</li>
<li>Se B é -1, então o número contido no endereço dado por A é interpretado como um ponto de código e a
saída de caractere correspondente. C, mais uma vez, não é utilizado.</li>
<li>Caso contrário, tanto A quanto B são tratados como endereços de locais de memória. O número contido no endereço
fornecido por A é subtraído do número do endereço fornecido por B (e o resultado é armazenado de volta no endereço B). Se
o resultado for zero ou negativo, o valor C se torna o novo ponteiro da instrução.</li>
<li>Se o ponteiro da instrução se tornar negativo, a execução para.</li>
</ol>
Other negative addresses besides -1 may be treated as equivalent to -1, or generate an error, as you see fit.
Outros endereços negativos além de -1 podem ser tratados como equivalentes a -1 ou gerar um erro, como você achar adequado.
Your solution should accept a program to execute on the machine, separately from the input fed to the program itself.
A solução deve aceitar um programa que será executado na máquina, separadamente da entrada alimentado no programa em si.
This program should be in raw subleq "machine code" - whitespace-separated decimal numbers, with no symbolic names or
Este programa deve estar em "código de máquina" bruto de subleq - números decimais separados por espaços em branco, sem nomes simbólicos ou
other assembly-level extensions, to be loaded into memory starting at address 0. Show the output of your solution when
outras extensões de nível de assembly, a serem carregadas na memória iniciando no endereço 0. Mostre a saída da solução quando
fed this "Hello, world!" program. (Note that the example assumes ASCII or a superset of it, such as any of the Latin-N
recebe esse programa "Hello, world!". (Observe que o exemplo assume ASCII ou um superconjunto dele, como qualquer um dos conjuntos
character sets or Unicode. You may translate it into another character set if your implementation is on a
de caracteres N-latinos ou Unicode. Você pode traduzi-lo para outro conjunto de caracteres se a implementação estiver em um
non-ASCiI-compatible environment.)
ambiente não ASCII compatível.)
<pre>15 17 -1 17 -1 -1 16 1 -1 16 3 -1 15 15 0 0 -1 72 101 108 108 111 44 32 119 111 114 108 100 33 10 0</pre>
Which corresponds to something like this in a hypothetical assembler language:
O que corresponde a algo assim em uma linguagem hipotética de assembler:
<pre>start:
zero, message, -1
@ -66,19 +66,19 @@ message: "Hello, world!\n\0"
# --instructions--
Write a function that takes an array of integers as a parameter. This represents the memory elements. The function
Escreva uma função que receba um array de números inteiros como parâmetro. Ele representa os elementos da memória. A função
should interpret the sequence and return the output string. For this task, assume that there is no standard input.
deve interpretar a sequência e retornar a string de saída. Para esta tarefa, considere que não há uma entrada padrão.
# --hints--
`Subleq` should be a function.
`Subleq` deve ser uma função.
```js
assert(typeof Subleq == 'function');
```
`Subleq([15, 17, -1, 17, -1, -1, 16, 1, -1, 16, 3, -1, 15, 15, 0, 0, -1, 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0])` should return a string.
`Subleq([15, 17, -1, 17, -1, -1, 16, 1, -1, 16, 3, -1, 15, 15, 0, 0, -1, 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0])` deve retornar uma string.
```js
assert(
@ -118,7 +118,7 @@ assert(
);
```
`Subleq([15, 17, -1, 17, -1, -1, 16, 1, -1, 16, 3, -1, 15, 15, 0, 0, -1, 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0])` should return `"Hello, world!"`.
`Subleq([15, 17, -1, 17, -1, -1, 16, 1, -1, 16, 3, -1, 15, 15, 0, 0, -1, 72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0])` deve retornar `"Hello, world!"`.
```js
assert.equal(

12
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sudoku.md
View File

@ -8,17 +8,17 @@ dashedName: sudoku
# --description--
Write a function to solve a partially filled-in normal 9x9 [Sudoku](https://en.wikipedia.org/wiki/Sudoku) grid and return the result. The blank fields are represented by `-1`. [Algorithmics of Sudoku](https://en.wikipedia.org/wiki/Algorithmics_of_sudoku) may help implement this.
Escreva uma função para resolver um tabuleiro 9x9 normal, parcialmente preenchido, de [Sudoku](https://pt.wikipedia.org/wiki/Sudoku) e retorne o resultado. Os campos em branco são representados por `-1`. O [Algoritmo de Sudoku](https://pt.wikipedia.org/wiki/Algoritmo_de_sudoku) pode ajudar a implementar isso.
# --hints--
`solveSudoku` should be a function.
`solveSudoku` deve ser uma função.
```js
assert(typeof solveSudoku == 'function');
```
`solveSudoku([[8, 1, 9, -1, -1, 5, -1, -1, -1],[-1, -1, 2, -1, -1, -1, 7, 5, -1],[-1, 3, 7, 1, -1, 4, -1, 6, -1],[4, -1, -1, 5, 9, -1, 1, -1, -1],[7, -1, -1, 3, -1, 8, -1, -1, 2],[-1, -1, 3, -1, 6, 2, -1, -1, 7],[-1, 5, -1, 7, -1, 9, 2, 1, -1],[-1, 6, 4, -1, -1, -1, 9, -1, -1],[-1, -1, -1, 2, -1, -1, 4, 3, 8]])` should return an array.
`solveSudoku([[8, 1, 9, -1, -1, 5, -1, -1, -1],[-1, -1, 2, -1, -1, -1, 7, 5, -1],[-1, 3, 7, 1, -1, 4, -1, 6, -1],[4, -1, -1, 5, 9, -1, 1, -1, -1],[7, -1, -1, 3, -1, 8, -1, -1, 2],[-1, -1, 3, -1, 6, 2, -1, -1, 7],[-1, 5, -1, 7, -1, 9, 2, 1, -1],[-1, 6, 4, -1, -1, -1, 9, -1, -1],[-1, -1, -1, 2, -1, -1, 4, 3, 8]])` deve retornar um array.
```js
assert(
@ -38,7 +38,7 @@ assert(
);
```
`solveSudoku([[8, 1, 9, -1, -1, 5, -1, -1, -1],[-1, -1, 2, -1, -1, -1, 7, 5, -1],[-1, 3, 7, 1, -1, 4, -1, 6, -1],[4, -1, -1, 5, 9, -1, 1, -1, -1],[7, -1, -1, 3, -1, 8, -1, -1, 2],[-1, -1, 3, -1, 6, 2, -1, -1, 7],[-1, 5, -1, 7, -1, 9, 2, 1, -1],[-1, 6, 4, -1, -1, -1, 9, -1, -1],[-1, -1, -1, 2, -1, -1, 4, 3, 8]])` should return `[[8, 1, 9, 6, 7, 5, 3, 2, 4],[6, 4, 2, 9, 8, 3, 7, 5, 1],[5, 3, 7, 1, 2, 4, 8, 6, 9],[4, 2, 6, 5, 9, 7, 1, 8, 3],[7, 9, 5, 3, 1, 8, 6, 4, 2],[1, 8, 3, 4, 6, 2, 5, 9, 7],[3, 5, 8, 7, 4, 9, 2, 1, 6],[2, 6, 4, 8, 3, 1, 9, 7, 5],[9, 7, 1, 2, 5, 6, 4, 3, 8]]`.
`solveSudoku([[8, 1, 9, -1, -1, 5, -1, -1, -1],[-1, -1, 2, -1, -1, -1, 7, 5, -1],[-1, 3, 7, 1, -1, 4, -1, 6, -1],[4, -1, -1, 5, 9, -1, 1, -1, -1],[7, -1, -1, 3, -1, 8, -1, -1, 2],[-1, -1, 3, -1, 6, 2, -1, -1, 7],[-1, 5, -1, 7, -1, 9, 2, 1, -1],[-1, 6, 4, -1, -1, -1, 9, -1, -1],[-1, -1, -1, 2, -1, -1, 4, 3, 8]])` deve retornar `[[8, 1, 9, 6, 7, 5, 3, 2, 4],[6, 4, 2, 9, 8, 3, 7, 5, 1],[5, 3, 7, 1, 2, 4, 8, 6, 9],[4, 2, 6, 5, 9, 7, 1, 8, 3],[7, 9, 5, 3, 1, 8, 6, 4, 2],[1, 8, 3, 4, 6, 2, 5, 9, 7],[3, 5, 8, 7, 4, 9, 2, 1, 6],[2, 6, 4, 8, 3, 1, 9, 7, 5],[9, 7, 1, 2, 5, 6, 4, 3, 8]]`.
```js
assert.deepEqual(
@ -67,7 +67,7 @@ assert.deepEqual(
);
```
`solveSudoku([[5, 3, -1, -1, 2, 4, 7, -1, -1],[-1, -1, 2, -1, -1, -1, 8, -1, -1],[1, -1, -1, 7, -1, 3, 9, -1, 2],[-1, -1, 8, -1, 7, 2, -1, 4, 9],[-1, 2, -1, 9, 8, -1, -1, 7, -1],[7, 9, -1, -1, -1, -1, -1, 8, -1],[-1, -1, -1, -1, 3, -1, 5, -1, 6],[9, 6, -1, -1, 1, -1, 3, -1, -1],[-1, 5, -1, 6, 9, -1, -1, 1, -1]])` should return `[[5, 3, 9, 8, 2, 4, 7, 6, 1],[6, 7, 2, 1, 5, 9, 8, 3, 4],[1, 8, 4, 7, 6, 3, 9, 5, 2],[3, 1, 8, 5, 7, 2, 6, 4, 9],[4, 2, 5, 9, 8, 6, 1, 7, 3],[7, 9, 6, 3, 4, 1, 2, 8, 5],[8, 4, 1, 2, 3, 7, 5, 9, 6],[9, 6, 7, 4, 1, 5, 3, 2, 8],[2, 5, 3, 6, 9, 8, 4, 1, 7]]`.
`solveSudoku([[5, 3, -1, -1, 2, 4, 7, -1, -1],[-1, -1, 2, -1, -1, -1, 8, -1, -1],[1, -1, -1, 7, -1, 3, 9, -1, 2],[-1, -1, 8, -1, 7, 2, -1, 4, 9],[-1, 2, -1, 9, 8, -1, -1, 7, -1],[7, 9, -1, -1, -1, -1, -1, 8, -1],[-1, -1, -1, -1, 3, -1, 5, -1, 6],[9, 6, -1, -1, 1, -1, 3, -1, -1],[-1, 5, -1, 6, 9, -1, -1, 1, -1]])` deve retornar `[[5, 3, 9, 8, 2, 4, 7, 6, 1],[6, 7, 2, 1, 5, 9, 8, 3, 4],[1, 8, 4, 7, 6, 3, 9, 5, 2],[3, 1, 8, 5, 7, 2, 6, 4, 9],[4, 2, 5, 9, 8, 6, 1, 7, 3],[7, 9, 6, 3, 4, 1, 2, 8, 5],[8, 4, 1, 2, 3, 7, 5, 9, 6],[9, 6, 7, 4, 1, 5, 3, 2, 8],[2, 5, 3, 6, 9, 8, 4, 1, 7]]`.
```js
assert.deepEqual(
@ -96,7 +96,7 @@ assert.deepEqual(
);
```
`solveSudoku([[-1, -1, 3, -1, 2, -1, 6, -1, -1],[9, -1, -1, 3, -1, 5, -1, -1, 1],[-1, -1, 1, 8, -1, 6, 4, -1, -1],[-1, -1, 8, 1, -1, 2, 9, -1, -1],[7, -1, -1, -1, -1, -1, -1, -1, 8],[-1, -1, 6, 7, -1, 8, 2, -1, -1],[-1, -1, 2, 6, -1, 9, 5, -1, -1],[8, -1, -1, 2, -1, 3, -1, -1, 9],[-1, -1, 5, -1, 1, -1, 3, -1, -1]])` should return `[[4, 8, 3, 9, 2, 1, 6, 5, 7],[9, 6, 7, 3, 4, 5, 8, 2, 1],[2, 5, 1, 8, 7, 6, 4, 9, 3],[5, 4, 8, 1, 3, 2, 9, 7, 6],[7, 2, 9, 5, 6, 4, 1, 3, 8],[1, 3, 6, 7, 9, 8, 2, 4, 5],[3, 7, 2, 6, 8, 9, 5, 1, 4],[8, 1, 4, 2, 5, 3, 7, 6, 9],[6, 9, 5, 4, 1, 7, 3, 8, 2]]`.
`solveSudoku([[-1, -1, 3, -1, 2, -1, 6, -1, -1],[9, -1, -1, 3, -1, 5, -1, -1, 1],[-1, -1, 1, 8, -1, 6, 4, -1, -1],[-1, -1, 8, 1, -1, 2, 9, -1, -1],[7, -1, -1, -1, -1, -1, -1, -1, 8],[-1, -1, 6, 7, -1, 8, 2, -1, -1],[-1, -1, 2, 6, -1, 9, 5, -1, -1],[8, -1, -1, 2, -1, 3, -1, -1, 9],[-1, -1, 5, -1, 1, -1, 3, -1, -1]])` deve retornar `[[4, 8, 3, 9, 2, 1, 6, 5, 7],[9, 6, 7, 3, 4, 5, 8, 2, 1],[2, 5, 1, 8, 7, 6, 4, 9, 3],[5, 4, 8, 1, 3, 2, 9, 7, 6],[7, 2, 9, 5, 6, 4, 1, 3, 8],[1, 3, 6, 7, 9, 8, 2, 4, 5],[3, 7, 2, 6, 8, 9, 5, 1, 4],[8, 1, 4, 2, 5, 3, 7, 6, 9],[6, 9, 5, 4, 1, 7, 3, 8, 2]]`.
```js
assert.deepEqual(

28
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sum-digits-of-an-integer.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc803f
title: Sum digits of an integer
title: Soma dos dígitos de um inteiro
challengeType: 5
forumTopicId: 302331
dashedName: sum-digits-of-an-integer
@ -8,60 +8,60 @@ dashedName: sum-digits-of-an-integer
# --description--
Write a function that takes a string as a parameter. This string represents a number that can be in any base (less than 37) and return the sum of its digits.
Escreva uma função que receba uma string como parâmetro. Essa string representa um número que pode estar em qualquer base (inferior a 37) e que retorne a soma de seus dígitos.
<ul>
<li><b>1</b><sub>10</sub> sums to <b>1</b></li>
<li><b>1234</b><sub>10</sub> sums to <b>10</b></li>
<li><b>fe</b><sub>16</sub> sums to <b>29</b></li>
<li><b>f0e</b><sub>16</sub> sums to <b>29</b></li>
<li><b>1</b><sub>10</sub> soma <b>1</b></li>
<li><b>1234</b><sub>10</sub> soma <b>10</b></li>
<li><b>fe</b><sub>16</sub> soma <b>29</b></li>
<li><b>f0e</b><sub>16</sub> soma <b>29</b></li>
</ul>
# --hints--
`sumDigits` should be a function.
`sumDigits` deve ser uma função.
```js
assert(typeof sumDigits == 'function');
```
`sumDigits("1")` should return a number.
`sumDigits("1")` deve retornar um número.
```js
assert(typeof sumDigits('1') == 'number');
```
`sumDigits("1")` should return `1`.
`sumDigits("1")` deve retornar `1`.
```js
assert.equal(sumDigits('1'), 1);
```
`sumDigits("12345")` should return `15`.
`sumDigits("12345")` deve retornar `15`.
```js
assert.equal(sumDigits('12345'), 15);
```
`sumDigits("254")` should return `11`.
`sumDigits("254")` deve retornar `11`.
```js
assert.equal(sumDigits('254'), 11);
```
`sumDigits("fe")` should return `29`.
`sumDigits("fe")` deve retornar `29`.
```js
assert.equal(sumDigits('fe'), 29);
```
`sumDigits("f0e")` should return `29`.
`sumDigits("f0e")` deve retornar `29`.
```js
assert.equal(sumDigits('f0e'), 29);
```
`sumDigits("999ABCXYZ")` should return `162`.
`sumDigits("999ABCXYZ")` deve retornar `162`.
```js
assert.equal(sumDigits('999ABCXYZ'), 162);

18
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sum-multiples-of-3-and-5.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8040
title: Sum multiples of 3 and 5
title: Soma dos múltiplos de 3 e 5
challengeType: 5
forumTopicId: 302332
dashedName: sum-multiples-of-3-and-5
@ -8,47 +8,47 @@ dashedName: sum-multiples-of-3-and-5
# --description--
The objective is to write a function that finds the sum of all positive multiples of 3 or 5 below *n*.
O objetivo é escrever uma função que encontra a soma de todos os múltiplos positivos de 3 ou 5 abaixo de *n*.
# --hints--
`sumMults` should be a function.
`sumMults` deve ser uma função.
```js
assert(typeof sumMults == 'function');
```
`sumMults(10)` should return a number.
`sumMults(10)` deve retornar um número.
```js
assert(typeof sumMults(10) == 'number');
```
`sumMults(10)` should return `23`.
`sumMults(10)` deve retornar `23`.
```js
assert.equal(sumMults(10), 23);
```
`sumMults(100)` should return `2318`.
`sumMults(100)` deve retornar `2318`.
```js
assert.equal(sumMults(100), 2318);
```
`sumMults(1000)` should return `233168`.
`sumMults(1000)` deve retornar `233168`.
```js
assert.equal(sumMults(1000), 233168);
```
`sumMults(10000)` should return `23331668`.
`sumMults(10000)` deve retornar `23331668`.
```js
assert.equal(sumMults(10000), 23331668);
```
`sumMults(100000)` should return `2333316668`.
`sumMults(100000)` deve retornar `2333316668`.
```js
assert.equal(sumMults(100000), 2333316668);

20
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sum-of-a-series.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8041
title: Sum of a series
title: Soma de uma série
challengeType: 5
forumTopicId: 302333
dashedName: sum-of-a-series
@ -8,51 +8,51 @@ dashedName: sum-of-a-series
# --description--
Compute the **n**<sup>th</sup> term of a [series](https://en.wikipedia.org/wiki/Series (mathematics)), i.e. the sum of the **n** first terms of the corresponding [sequence](https://en.wikipedia.org/wiki/sequence). Informally this value, or its limit when **n** tends to infinity, is also called the *sum of the series*, thus the title of this task. For this task, use: $S_n = \displaystyle\sum_{k=1}^n \frac{1}{k^2}$.
Calcule o **n**<sup></sup>-ésimo termo de uma [série](https://en.wikipedia.org/wiki/Series (mathematics)), ou seja, a soma dos **n** primeiros termos da [sequência](https://en.wikipedia.org/wiki/sequence) correspondente. Informalmente, esse valor, ou seu limite quando **n** tende ao infinito, é também chamado de *soma da série*, razão do título desta tarefa. Para esta tarefa, use: $S_n = \displaystyle\sum_{k=1}^n \frac{1}{k^2}$.
# --instructions--
Write a function that take $a$ and $b$ as parameters and returns the sum of $a^{th}$ to $b^{th}$ members of the sequence.
Escreva uma função que receba $a$ e $b$ como parâmetros e retorne a soma do $a$-ésimo ao $b$-ésimo termos da sequência.
# --hints--
`sum` should be a function.
`sum` deve ser uma função.
```js
assert(typeof sum == 'function');
```
`sum(1, 100)` should return a number.
`sum(1, 100)` deve retornar um número.
```js
assert(typeof sum(1, 100) == 'number');
```
`sum(1, 100)` should return `1.6349839001848923`.
`sum(1, 100)` deve retornar `1.6349839001848923`.
```js
assert.equal(sum(1, 100), 1.6349839001848923);
```
`sum(33, 46)` should return `0.009262256361481223`.
`sum(33, 46)` deve retornar `0.009262256361481223`.
```js
assert.equal(sum(33, 46), 0.009262256361481223);
```
`sum(21, 213)` should return `0.044086990748706555`.
`sum(21, 213)` deve retornar `0.044086990748706555`.
```js
assert.equal(sum(21, 213), 0.044086990748706555);
```
`sum(11, 111)` should return `0.08619778593108679`.
`sum(11, 111)` deve retornar `0.08619778593108679`.
```js
assert.equal(sum(11, 111), 0.08619778593108679);
```
`sum(1, 10)` should return `1.5497677311665408`.
`sum(1, 10)` deve retornar `1.5497677311665408`.
```js
assert.equal(sum(1, 10), 1.5497677311665408);

18
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sum-of-squares.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8042
title: Sum of squares
title: Soma dos quadrados
challengeType: 5
forumTopicId: 302334
dashedName: sum-of-squares
@ -8,47 +8,47 @@ dashedName: sum-of-squares
# --description--
Write a function to find the sum of squares of an array of integers.
Escreva uma função para encontrar a soma dos quadrados de um array de números inteiros.
# --hints--
`sumsq` should be a function.
`sumsq` deve ser uma função.
```js
assert(typeof sumsq == 'function');
```
`sumsq([1, 2, 3, 4, 5])` should return a number.
`sumsq([1, 2, 3, 4, 5])` deve retornar um número.
```js
assert(typeof sumsq([1, 2, 3, 4, 5]) == 'number');
```
`sumsq([1, 2, 3, 4, 5])` should return `55`.
`sumsq([1, 2, 3, 4, 5])` deve retornar `55`.
```js
assert.equal(sumsq([1, 2, 3, 4, 5]), 55);
```
`sumsq([25, 32, 12, 7, 20])` should return `2242`.
`sumsq([25, 32, 12, 7, 20])` deve retornar `2242`.
```js
assert.equal(sumsq([25, 32, 12, 7, 20]), 2242);
```
`sumsq([38, 45, 35, 8, 13])` should return `4927`.
`sumsq([38, 45, 35, 8, 13])` deve retornar `4927`.
```js
assert.equal(sumsq([38, 45, 35, 8, 13]), 4927);
```
`sumsq([43, 36, 20, 34, 24])` should return `5277`.
`sumsq([43, 36, 20, 34, 24])` deve retornar `5277`.
```js
assert.equal(sumsq([43, 36, 20, 34, 24]), 5277);
```
`sumsq([12, 33, 26, 18, 1, 16, 3])` should return `2499`.
`sumsq([12, 33, 26, 18, 1, 16, 3])` deve retornar `2499`.
```js
assert.equal(sumsq([12, 33, 26, 18, 1, 16, 3]), 2499);

22
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sum-to-100.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8043
title: Sum to 100
title: Soma até 100
challengeType: 5
forumTopicId: 302335
dashedName: sum-to-100
@ -8,33 +8,33 @@ dashedName: sum-to-100
# --description--
Find solutions to the *sum to one hundred* puzzle.
Encontre soluções para o desafio de *soma até cem*.
Add (insert) the mathematical operators **+** or **─** (plus or minus) before any of the digits in the decimal numeric string **123456789** such that the resulting mathematical expression adds up to a particular sum (in this iconic case, **100**).
Adicione (insira) os operadores matemáticos **+** ou **─** (mais ou menos) antes de cada um dos dígitos na string numérica decimal **123456789**, de modo que a expressão matemática resultante chegue a uma soma específica (no caso conhecido, **100**).
Example:
Exemplo:
<pre><b>123 + 4 - 5 + 67 - 89 = 100</b></pre>
# --instructions--
Write a function that takes a number as parameter. The function should return an array containing all solutions for the given number. The solutions should be strings representing the expressions. For example: "1+23-456+78-9". Sort the array before returning it.
Escreva uma função que receba um número como parâmetro. A função deve retornar um array contendo todas as soluções para o número fornecido. As soluções devem ser strings que representam as expressões. Por exemplo: "1+23-456+78-9". Ordene o array resultante antes de retorná-lo.
# --hints--
`sumTo100` should be a function.
`sumTo100` deve ser uma função.
```js
assert(typeof sumTo100 == 'function');
```
`sumTo100(199)` should return an array.
`sumTo100(199)` deve retornar um array.
```js
assert(Array.isArray(sumTo100(199)));
```
`sumTo100(199)` should return `["-1+2-3+45+67+89", "123-4+5+6+78-9", "123-4+56+7+8+9"]`.
`sumTo100(199)` deve retornar `["-1+2-3+45+67+89", "123-4+5+6+78-9", "123-4+56+7+8+9"]`.
```js
assert.deepEqual(sumTo100(199), [
@ -44,13 +44,13 @@ assert.deepEqual(sumTo100(199), [
]);
```
`sumTo100(209)` should return `["1+234+56+7-89"]`.
`sumTo100(209)` deve retornar `["1+234+56+7-89"]`.
```js
assert.deepEqual(sumTo100(209), ['1+234+56+7-89']);
```
`sumTo100(243)` should return `["-1-234+567-89", "-12+345+6-7-89", "123+45+6+78-9"]`.
`sumTo100(243)` deve retornar `["-1-234+567-89", "-12+345+6-7-89", "123+45+6+78-9"]`.
```js
assert.deepEqual(sumTo100(243), [
@ -60,7 +60,7 @@ assert.deepEqual(sumTo100(243), [
]);
```
`sumTo100(197)` should return `["1-2-3+45+67+89", "12+34-5+67+89", "123+4-5+6+78-9"]`.
`sumTo100(197)` deve retornar `["1-2-3+45+67+89", "12+34-5+67+89", "123+4-5+6+78-9"]`.
```js
assert.deepEqual(sumTo100(197), [

18
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/sutherland-hodgman-polygon-clipping.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8045
title: Sutherland-Hodgman polygon clipping
title: Recorte de polígonos de Sutherland-Hodgman
challengeType: 5
forumTopicId: 302336
dashedName: sutherland-hodgman-polygon-clipping
@ -8,27 +8,27 @@ dashedName: sutherland-hodgman-polygon-clipping
# --description--
The [Sutherland-Hodgman clipping algorithm](https://en.wikipedia.org/wiki/Sutherland-Hodgman clipping algorithm) finds the polygon that is the intersection between an arbitrary polygon (the "subject polygon") and a convex polygon (the "clip polygon"). It is used in computer graphics (especially 2D graphics) to reduce the complexity of a scene being displayed by eliminating parts of a polygon that do not need to be displayed. Take the closed polygon defined by the points:
O [algoritmo de recorte de polígonos de Sutherland-Hodgman](https://en.wikipedia.org/wiki/Sutherland-Hodgman clipping algorithm) encontra o polígono que é a intersecção entre um polígono arbitrário (o "polígono sujeito") e um polígono convexo (o "polígono de recorte"). Ele é usado em gráficos de computador (especialmente gráficos 2D) para reduzir a complexidade de uma cena que está sendo exibida eliminando partes de um polígono que não precisam ser exibidas. Pegue o polígono que se fecha definido pelos pontos:
<pre>[(50, 150), (200, 50), (350, 150), (350, 300), (250, 300), (200, 250), (150, 350), (100, 250), (100, 200)]</pre>
and clip it by the rectangle defined by the points:
e recorte-o pelo retângulo definido pelos pontos:
<pre>[(100, 100), (300, 100), (300, 300), (100, 300)]</pre>
# --instructions--
Write a function that takes 2 arrays as parameters. The first array contains the points of the subject polygon and the second array contains the points of the clipping polygon. The function should return an array containing the points of the clipped polygon. Each number should be rounded to 3 decimal places.
Escreva uma função que receba dois arrays como parâmetro. O primeiro array contém os pontos do polígono sujeito e o segundo array contém os pontos do polígono de recorte. A função deve retornar um array contendo os pontos do polígono recortado. Cada número deve ser arredondado para 3 casas decimais.
# --hints--
`clip` should be a function.
`clip` deve ser uma função.
```js
assert(typeof clip == 'function');
```
`clip([[50, 150], [200, 50], [350, 150], [350, 300], [250, 300], [200, 250], [150, 350], [100, 250], [100, 200]], [[100, 100], [300, 100], [300, 300], [100, 300]])` should return an array.
`clip([[50, 150], [200, 50], [350, 150], [350, 300], [250, 300], [200, 250], [150, 350], [100, 250], [100, 200]], [[100, 100], [300, 100], [300, 300], [100, 300]])` deve retornar um array.
```js
assert(
@ -56,7 +56,7 @@ assert(
);
```
`clip([[50, 150], [200, 50], [350, 150], [350, 300], [250, 300], [200, 250], [150, 350], [100, 250], [100, 200]], [[100, 100], [300, 100], [300, 300], [100, 300]])` should return `[[100, 116.667], [125, 100], [275, 100], [300, 116.667], [300, 300], [250, 300], [200, 250], [175, 300], [125, 300], [100, 250]]`.
`clip([[50, 150], [200, 50], [350, 150], [350, 300], [250, 300], [200, 250], [150, 350], [100, 250], [100, 200]], [[100, 100], [300, 100], [300, 300], [100, 300]])` deve retornar `[[100, 116.667], [125, 100], [275, 100], [300, 116.667], [300, 300], [250, 300], [200, 250], [175, 300], [125, 300], [100, 250]]`.
```js
assert.deepEqual(
@ -94,7 +94,7 @@ assert.deepEqual(
);
```
`clip([[150, 200], [400, 450], [30, 50]], [[10, 10], [300, 200], [400, 600], [100, 300]])` should return `[[150, 200], [350, 400], [348.611, 394.444], [30, 50]]`.
`clip([[150, 200], [400, 450], [30, 50]], [[10, 10], [300, 200], [400, 600], [100, 300]])` deve retornar `[[150, 200], [350, 400], [348.611, 394.444], [30, 50]]`.
```js
assert.deepEqual(
@ -120,7 +120,7 @@ assert.deepEqual(
);
```
`clip([[250, 200], [100, 450], [130, 250]], [[50, 60], [100, 230], [400, 600], [100, 300]])` should return `[[129.167, 329.167], [119.565, 319.565], [121.854, 304.305]]`.
`clip([[250, 200], [100, 450], [130, 250]], [[50, 60], [100, 230], [400, 600], [100, 300]])` deve retornar `[[129.167, 329.167], [119.565, 319.565], [121.854, 304.305]]`.
```js
assert.deepEqual(

20
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/symmetric-difference.md
View File

@ -1,6 +1,6 @@
---
id: 5a23c84252665b21eecc8046
title: Symmetric difference
title: Diferença simétrica
challengeType: 5
forumTopicId: 16086
dashedName: symmetric-difference
@ -8,21 +8,21 @@ dashedName: symmetric-difference
# --description--
Given two [set](https://rosettacode.org/wiki/set)s *A* and *B*, compute $(A \\setminus B) \\cup (B \\setminus A).$ That is, enumerate the items that are in *A* or *B* but not both. This set is called the [symmetric difference](https://en.wikipedia.org/wiki/Symmetric difference) of *A* and *B*. In other words: $(A \\cup B) \\setminus (A \\cap B)$ (the set of items that are in at least one of *A* or *B* minus the set of items that are in both *A* and *B*).
Dados dois [conjuntos ](https://rosettacode.org/wiki/set)*A* e *B*, calcule $(A \\setminus B) \\cup (B \\setminus A). Ou seja, enumere os itens que estão em *A* ou *B* mas não em ambos. Este conjunto é chamado de [diferença simétrica](https://pt.wikipedia.org/wiki/Diferen%C3%A7a_sim%C3%A9trica) de *A* e *B*. Em outras palavras: $(A \\cup B) \\setminus (A \\cap B)$ (o conjunto de itens que estão em pelo menos um dos conjuntos, *A* ou *B*, menos o conjunto de itens que estão em ambos, *A* e *B*).
# --instructions--
Write a function that takes two arrays as parameters and returns the symmetric difference. Sort the resultant array before returning it.
Escreva uma função que receba dois arrays como parâmetros e retorne a diferença simétrica. Ordene o array resultante antes de retorná-lo.
# --hints--
`symmetricDifference` should be a function.
`symmetricDifference` deve ser uma função.
```js
assert(typeof symmetricDifference == 'function');
```
`symmetricDifference(["John", "Bob", "Mary", "Serena"], ["Jim", "Mary", "John", "Bob"])` should return an array.
`symmetricDifference(["John", "Bob", "Mary", "Serena"], ["Jim", "Mary", "John", "Bob"])` deve retornar um array.
```js
assert(
@ -35,7 +35,7 @@ assert(
);
```
`symmetricDifference(["John", "Bob", "Mary", "Serena"], ["Jim", "Mary", "John", "Bob"])` should return `["Jim", "Serena"]`.
`symmetricDifference(["John", "Bob", "Mary", "Serena"], ["Jim", "Mary", "John", "Bob"])` deve retornar `["Jim", "Serena"]`.
```js
assert.deepEqual(
@ -47,13 +47,13 @@ assert.deepEqual(
);
```
`symmetricDifference([1, 2, 3], [3, 4])` should return `[1, 2, 4]`.
`symmetricDifference([1, 2, 3], [3, 4])` deve retornar `[1, 2, 4]`.
```js
assert.deepEqual(symmetricDifference([1, 2, 3], [3, 4]), [1, 2, 4]);
```
`symmetricDifference([1, 2, 3, 4, 5], [3, 4, 8, 7])` should return `[1, 2, 5, 7, 8]`.
`symmetricDifference([1, 2, 3, 4, 5], [3, 4, 8, 7])` deve retornar `[1, 2, 5, 7, 8]`.
```js
assert.deepEqual(symmetricDifference([1, 2, 3, 4, 5], [3, 4, 8, 7]), [
@ -65,7 +65,7 @@ assert.deepEqual(symmetricDifference([1, 2, 3, 4, 5], [3, 4, 8, 7]), [
]);
```
`symmetricDifference([1, 2, 3, 4, 5, 6, 7, 8], [1, 3, 5, 6, 7, 8, 9])` should return `[2, 4, 9]`.
`symmetricDifference([1, 2, 3, 4, 5, 6, 7, 8], [1, 3, 5, 6, 7, 8, 9])` deve retornar `[2, 4, 9]`.
```js
assert.deepEqual(
@ -74,7 +74,7 @@ assert.deepEqual(
);
```
`symmetricDifference([1, 2, 4, 7, 9], [2, 3, 7, 8, 9])` should return `[1, 3, 4, 8]`.
`symmetricDifference([1, 2, 4, 7, 9], [2, 3, 7, 8, 9])` deve retornar `[1, 3, 4, 8]`.
```js
assert.deepEqual(symmetricDifference([1, 2, 4, 7, 9], [2, 3, 7, 8, 9]), [

38
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/taxicab-numbers.md
View File

@ -1,6 +1,6 @@
---
id: 594ecc0d9a8cf816e3340187
title: Taxicab numbers
title: Números taxicab
challengeType: 5
forumTopicId: 302337
dashedName: taxicab-numbers
@ -8,67 +8,67 @@ dashedName: taxicab-numbers
# --description--
A [taxicab number](https://en.wikipedia.org/wiki/Hardy–Ramanujan number "wp: Hardy–Ramanujan number") (the definition that is being used here) is a positive integer that can be expressed as the sum of two positive cubes in more than one way.
Um [Número taxicab](https://pt.wikipedia.org/wiki/N%C3%Bamero_taxicab) (a definição que está sendo usada aqui) é um inteiro positivo que pode ser expressado como a soma de dois cubos positivos em mais de uma maneira.
The first taxicab number is `1729`, which is:
O primeiro número taxicab é `1729`, que é:
1<sup>3</sup> + 12<sup>3</sup> and
1<sup>3</sup> + 12<sup>3</sup> e
9<sup>3</sup> + 10<sup>3</sup>.
Taxicab numbers are also known as:
Os números taxicab também são conhecidos como:
<ul>
<li>taxi numbers</li>
<li>taxi-cab numbers</li>
<li>taxi cab numbers</li>
<li>Hardy-Ramanujan numbers</li>
<li>números taxi</li>
<li>números taxi-cab</li>
<li>números taxi cab</li>
<li>Números de Hardy-Ramanujan</li>
</ul>
# --instructions--
Write a function that returns the lowest `n` taxicab numbers. For each of the taxicab numbers, show the number as well as its constituent cubes.
Escreva uma função que retorne o menor número taxicab de `n`. Para cada um dos números taxicab, mostre o número e os cubos que o constituem.
**See also:**
**Veja também:**
<ul>
<li><a href='https://oeis.org/A001235' target='_blank'>A001235 taxicab numbers</a> on The On-Line Encyclopedia of Integer Sequences.</li>
<li><a href='https://en.wikipedia.org/wiki/Taxicab_number' target='_blank'>taxicab number</a> on Wikipedia.</li>
<li><a href='https://oeis.org/A001235' target='_blank'>A001235 números taxicab</a> na The On-Line Encyclopedia of Integer Sequences.</li>
<li><a href='https://pt.wikipedia.org/wiki/N%C3%Bamero_taxicab' target='_blank'>Número taxicab</a> na Wikipédia.</li>
</ul>
# --hints--
`taxicabNumbers` should be a function.
`taxicabNumbers` deve ser uma função.
```js
assert(typeof taxicabNumbers === 'function');
```
`taxicabNumbers` should return an array.
`taxicabNumbers` deve retornar um array.
```js
assert(typeof taxicabNumbers(2) === 'object');
```
`taxicabNumbers` should return an array of numbers.
`taxicabNumbers` deve retornar um array de números.
```js
assert(typeof taxicabNumbers(100)[0] === 'number');
```
`taxicabNumbers(4)` should return [1729, 4104, 13832, 20683].
`taxicabNumbers(4)` deve retornar [1729, 4104, 13832, 20683].
```js
assert.deepEqual(taxicabNumbers(4), res4);
```
`taxicabNumbers(25)` should return [1729, 4104, 13832, 20683, 32832, 39312, 40033, 46683, 64232, 65728, 110656, 110808, 134379, 149389, 165464, 171288, 195841, 216027, 216125, 262656, 314496, 320264, 327763, 373464, 402597]
`taxicabNumbers(25)` deve retornar [1729, 4104, 13832, 20683, 32832, 39312, 40033, 46683, 64232, 65728, 110656, 110808, 134379, 149389, 165464, 171288, 195841, 216027, 216125, 2656, 314496, 320264, 327763, 373464, 402597]
```js
assert.deepEqual(taxicabNumbers(25), res25);
```
`taxicabNumbers(39)` resulting numbers from 20 - 29 should be [314496,320264,327763,373464,402597,439101,443889,513000,513856].
`taxicabNumbers(39)` resultando números de 20 - 29 devem ser [314496,320264,327763,373464,402597,439101,443889,513000,513856].
```js
assert.deepEqual(taxicabNumbers(39).slice(20, 29), res39From20To29);

42
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/tokenize-a-string-with-escaping.md
View File

@ -1,6 +1,6 @@
---
id: 594faaab4e2a8626833e9c3d
title: Tokenize a string with escaping
title: Tokenizar uma string com escape
challengeType: 5
forumTopicId: 302338
dashedName: tokenize-a-string-with-escaping
@ -8,65 +8,65 @@ dashedName: tokenize-a-string-with-escaping
# --description--
Write a function or program that can split a string at each non-escaped occurrence of a separator character.
Escreva uma função ou programa que possa dividir uma string em cada ocorrência sem escape de um caractere separador.
It should accept three input parameters:
Ela deve aceitar três parâmetros de entrada:
<ul>
<li>The <strong>string</strong></li>
<li>The <strong>separator character</strong></li>
<li>The <strong>escape character</strong></li>
<li>A <strong>string</strong></li>
<li>O <strong>caractere separador</strong></li>
<li>O <strong>caractere de escape</strong></li>
</ul>
It should output a list of strings.
Ela deve ter como saída uma lista de strings.
Rules for splitting:
Regras para a divisão:
<ul>
<li>The fields that were separated by the separators, become the elements of the output list.</li>
<li>Empty fields should be preserved, even at the start and end.</li>
<li>Os campos que foram separados pelos separadores se tornam os elementos da lista de saída.</li>
<li>Campos vazios devem ser preservados, mesmo no início e no fim.</li>
</ul>
Rules for escaping:
Regras para o escape:
<ul>
<li>"Escaped" means preceded by an occurrence of the escape character that is not already escaped itself.</li>
<li>When the escape character precedes a character that has no special meaning, it still counts as an escape (but does not do anything special).</li>
<li>Each occurrences of the escape character that was used to escape something, should not become part of the output.</li>
<li>Com "escape" significa precedido por uma ocorrência do caractere de escape, que já não estiver escapado por si mesmo.</li>
<li>Quando o caractere de escape preceder um caractere que não tem nenhum significado especial, ele ainda conta como um escape (mas não faz nada especial).</li>
<li>Cada ocorrência do caractere de escape que for usada para fazer o escape de algo não deve se tornar parte do resultado.</li>
</ul>
Demonstrate that your function satisfies the following test-case:
Demonstre que sua função satisfaz o seguinte caso de teste:
Given the string
Dada a string
<pre>one^|uno||three^^^^|four^^^|^cuatro|</pre>
and using `|` as a separator and `^` as escape character, your function should output the following array:
e usando `|` como separador e `^` como caractere de escape, a função deve dar como resultado o seguinte array:
<pre> ['one|uno', '', 'three^^', 'four^|cuatro', '']
</pre>
# --hints--
`tokenize` should be a function.
`tokenize` deve ser uma função.
```js
assert(typeof tokenize === 'function');
```
`tokenize` should return an array.
`tokenize` deve retornar um array.
```js
assert(typeof tokenize('a', 'b', 'c') === 'object');
```
`tokenize('one^|uno||three^^^^|four^^^|^cuatro|', '|', '^')` should return `['one|uno', '', 'three^^', 'four^|cuatro', '']`
`tokenize('one^|uno||three^^^^|four^^^|^cuatro|', '|', '^')` deve retornar `['one|uno', '', 'three^^', 'four^|cuatro', '']`
```js
assert.deepEqual(tokenize(testStr1, '|', '^'), res1);
```
`tokenize('a@&bcd&ef&&@@hi', '&', '@')` should return `['a&bcd', 'ef', '', '@hi']`
`tokenize('a@&bcd&ef&&@@hi', '&', '@')` deve retornar `['a&bcd', 'ef', '', '@hi']`
```js
assert.deepEqual(tokenize(testStr2, '&', '@'), res2);

38
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/topological-sort.md
View File

@ -1,6 +1,6 @@
---
id: 594fa2746886f41f7d8bf225
title: Topological sort
title: Ordenação topológica
challengeType: 5
forumTopicId: 302340
dashedName: topological-sort
@ -8,22 +8,22 @@ dashedName: topological-sort
# --description--
Given a mapping between items, and items they depend on, a topological sort orders items so that no item precedes an item it depends upon. There are two popular algorithms for topological sorting: Kahn's (1962) topological sort and depth-first search.
Dado um mapeamento entre itens e itens dos quais eles dependem, uma ordenação topológica de itens faz com que nenhum item preceda um item do qual ele depende. Existem dois algoritmos populares para a ordenação topológica: a ordenação topológica de Kahn (1962) e a busca profunda.
# --instructions--
Write a function that will return a list with valid compile order of libraries from their dependencies.
Escreva uma função que retorne uma lista com ordem de compilação válida de bibliotecas a partir de suas dependências.
- Assume library names are single words.
- Items mentioned as only dependents have no dependents of their own, but their order of compiling must be given.
- Any self dependencies should be ignored.
- Any un-orderable dependencies should be ignored.
- Assuma que os nomes das bibliotecas são palavras únicas.
- Itens mencionados apenas como dependentes não têm dependentes próprios, mas sua ordem de compilação deve ser dada.
- Quaisquer autodependências devem ser ignoradas.
- Quaisquer dependências não ordenáveis devem ser ignoradas.
Use the following data as an example:
Use os seguintes dados como exemplo:
<pre>
LIBRARY LIBRARY DEPENDENCIES
======= ====================
BIBLIOTECA DEPENDÊNCIAS
========== ====================
des_system_lib std synopsys std_cell_lib des_system_lib dw02 dw01 ramlib ieee
dw01 ieee dw01 dware gtech
dw02 ieee dw02 dware
@ -39,11 +39,11 @@ std_cell_lib ieee std_cell_lib
synopsys
</pre>
The compiling of a library in the VHDL language has the constraint that a library must be compiled after any library it depends on. The above data would be un-orderable if, for example, `dw04` is added to the list of dependencies of `dw01`.
A compilação de uma biblioteca na linguagem VHDL tem a restrição de que uma biblioteca deve ser compilada após qualquer biblioteca da qual ela dependa. Os dados acima seriam não ordenáveis se, por exemplo, `dw04` fosse adicionado à lista de dependências de `dw01`.
The input of the function will be a multiline string, each line will consist of the name of the library, followed by its dependencies (if exist).
A entrada da função será uma string em várias linhas. Cada linha será composta pelo nome da biblioteca, seguida por suas dependências (se existirem).
For example:
Por exemplo:
```js
const libsSimple =
@ -53,37 +53,37 @@ const libsSimple =
# --hints--
`topologicalSort` should be a function.
`topologicalSort` deve ser uma função.
```js
assert(typeof topologicalSort === 'function');
```
`topologicalSort(libsSimple)` should return an array.
`topologicalSort(libsSimple)` deve retornar um array.
```js
assert(Array.isArray(topologicalSort(libsSimple)));
```
`topologicalSort(libsSimple)` should return `['bbb', 'aaa']`.
`topologicalSort(libsSimple)` deve retornar `['bbb', 'aaa']`.
```js
assert.deepEqual(topologicalSort(libsSimple), ['bbb', 'aaa']);
```
`topologicalSort(libsVHDL)` should return `['ieee', 'std_cell_lib', 'gtech', 'dware', 'dw07', 'dw06', 'dw05', 'dw02', 'dw01', 'dw04', 'std', 'ramlib', 'synopsys', 'dw03', 'des_system_lib']`.
`topologicalSort(libsVHDL)` deve retornar `['ieee', 'std_cell_lib', 'gtech', 'dware', 'dw07', 'dw06', 'dw05', 'dw02', 'dw01', 'dw04', 'std', 'ramlib', 'synopsys', 'dw03', 'des_system_lib']`.
```js
assert.deepEqual(topologicalSort(libsVHDL), ['ieee', 'std_cell_lib', 'gtech', 'dware', 'dw07', 'dw06', 'dw05', 'dw02', 'dw01', 'dw04', 'std', 'ramlib', 'synopsys', 'dw03', 'des_system_lib']);
```
`topologicalSort(libsCustom)` should return `['base', 'c', 'd', 'b', 'a']`.
`topologicalSort(libsCustom)` deve retornar `['base', 'c', 'd', 'b', 'a']`.
```js
assert.deepEqual(topologicalSort(libsCustom), ['base', 'c', 'd', 'b', 'a']);
```
`topologicalSort` should ignore unorderable dependencies.
`topologicalSort` deve ignorar dependências não ordenáveis.
```js
assert.deepEqual(topologicalSort(libsUnorderable), ['Base']);

12
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/vector-cross-product.md
View File

@ -1,6 +1,6 @@
---
id: 594810f028c0303b75339ad2
title: Vector cross product
title: Produto cruzado de vetor
challengeType: 5
forumTopicId: 302342
dashedName: vector-cross-product
@ -8,27 +8,27 @@ dashedName: vector-cross-product
# --description--
A vector is defined as having three dimensions as being represented by an ordered collection of three numbers: (X, Y, Z).
Um vetor é definido como tendo três dimensões e sendo representado por uma coleção ordenada de três números: (X, Y, Z).
# --instructions--
Write a function that takes two vectors (arrays) as input and computes their cross product. Your function should return `null` on invalid inputs such as vectors of different lengths.
Escreva uma função que receba dois vetores (arrays) como entrada e calcule seu produto cruzado. A função deve retornar `null` em entradas inválidas, como vetores de diferentes tamanhos.
# --hints--
`crossProduct` should be a function.
`crossProduct` deve ser uma função.
```js
assert.equal(typeof crossProduct, 'function');
```
`crossProduct()` should return null.
`crossProduct()` deve retornar null.
```js
assert.equal(crossProduct(), null);
```
`crossProduct([1, 2, 3], [4, 5, 6])` should return `[-3, 6, -3]`.
`crossProduct([1, 2, 3], [4, 5, 6])` deve retornar `[-3, 6, -3]`.
```js
assert.deepEqual(res12, exp12);

20
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/vector-dot-product.md
View File

@ -1,6 +1,6 @@
---
id: 594810f028c0303b75339ad3
title: Vector dot product
title: Produto de ponto de vetor
challengeType: 5
forumTopicId: 302343
dashedName: vector-dot-product
@ -8,51 +8,51 @@ dashedName: vector-dot-product
# --description--
A vector can have one or more values represented by an ordered collection. Examples could be (x), (x, y), or (x, y, z).
Um vetor pode ter um ou mais valores representados por uma coleção ordenada. Exemplos podem ser (x), (x, y), ou (x, y, z).
# --instructions--
Write a function that takes two vectors (represented as one-dimensional arrays) as input and computes their dot product. Your function should return `null` on invalid inputs such as vectors of different lengths or passing anything other than two vectors.
Escreva uma função que receba dois vetores (representados como arrays unidimensionais) como entrada e calcule seu produto cruzado. A função deve retornar `null` para entradas inválidas como vetores de tamanhos diferentes ou que passem qualquer coisa que não seja dois vetores.
# --hints--
`dotProduct` should be a function.
`dotProduct` deve ser uma função.
```js
assert.equal(typeof dotProduct, 'function');
```
`dotProduct()` should return `null`.
`dotProduct()` deve retornar `null`.
```js
assert.equal(dotProduct(), null);
```
`dotProduct([1], [1])` should return `1`.
`dotProduct([1], [1])` deve retornar `1`.
```js
assert.equal(dotProduct([1], [1]), 1);
```
`dotProduct([1], [1, 2])` should return `null`.
`dotProduct([1], [1, 2])` deve retornar `null`.
```js
assert.equal(dotProduct([1], [1, 2]), null);
```
`dotProduct([1, 3, -5], [4, -2, -1])` should return `3`.
`dotProduct([1, 3, -5], [4, -2, -1])` deve retornar `3`.
```js
assert.equal(dotProduct([1, 3, -5], [4, -2, -1]), 3);
```
`dotProduct([3, 2, 1], [2, 4, 2], [5, 3, 1])` should return `null`.
`dotProduct([3, 2, 1], [2, 4, 2], [5, 3, 1])` deve retornar `null`.
```js
assert.equal(dotProduct([3, 2, 1], [2, 4, 2], [5, 3, 1]), null);
```
`dotProduct([ 0, 3, 6, 9, 12 ], [ 0, 4, 8, 12, 16 ])` should return `360`.
`dotProduct([ 0, 3, 6, 9, 12 ], [ 0, 4, 8, 12, 16 ])` deve retornar `360`.
```js
assert.equal(dotProduct([ 0, 3, 6, 9, 12 ], [ 0, 4, 8, 12, 16 ]), 360);

18
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/y-combinator.md
View File

@ -1,6 +1,6 @@
---
id: 594810f028c0303b75339ad5
title: Y combinator
title: Combinador Y
challengeType: 5
forumTopicId: 302345
dashedName: y-combinator
@ -8,11 +8,11 @@ dashedName: y-combinator
# --description--
In strict [functional programming](https://en.wikipedia.org/wiki/Functional programming "wp: functional programming") and the [lambda calculus](https://en.wikipedia.org/wiki/lambda calculus "wp: lambda calculus"), functions (lambda expressions) don't have state and are only allowed to refer to arguments of enclosing functions. This rules out the usual definition of a recursive function wherein a function is associated with the state of a variable and this variable's state is used in the body of the function. The [Y combinator](https://mvanier.livejournal.com/2897.html) is itself a stateless function that, when applied to another stateless function, returns a recursive version of the function. The Y combinator is the simplest of the class of such functions, called [fixed-point combinators](https://en.wikipedia.org/wiki/Fixed-point combinator "wp: fixed-point combinator").
Em [programação funcional](https://en.wikipedia.org/wiki/Functional programming "wp: functional programming") estrita e em [cálculo de lambda](https://en.wikipedia.org/wiki/lambda calculus "wp: lambda calculus"), funções (expressões lambda) não têm estado e é permitido apenas se referir a argumentos de funções encapsuladas. Isso exclui a definição habitual de uma função recursiva, na qual uma função é associada ao estado de uma variável e o estado dessa variável é usado no corpo da função. O [combinador Y](https://mvanier.livejournal.com/2897.html) é uma função sem estado que, ao ser aplicada a outra função sem estado, retorna uma versão recursiva da função. O combinador Y é a mais simples dessas classes de funções, chamada de [combinador de ponto fixo](https://en.wikipedia.org/wiki/Fixed-point combinator "wp: fixed-point combinator").
# --instructions--
Define the stateless Y combinator function and use it to compute [factorial](https://en.wikipedia.org/wiki/Factorial "wp: factorial"). The `factorial(N)` function is already given to you. **See also:**
Defina a função de combinador Y sem estado e use-a para calcular o [fatorial](https://en.wikipedia.org/wiki/Factorial "wp: factorial"). A função de fatorial, `factorial(N)`, você já tem. **Consulte também:**
<ul>
<li><a href="https://vimeo.com/45140590" target="_blank">Jim Weirich: Adventures in Functional Programming</a>.</li>
@ -20,37 +20,37 @@ Define the stateless Y combinator function and use it to compute [factorial](htt
# --hints--
Y should return a function.
Y deve retornar uma função.
```js
assert.equal(typeof Y((f) => (n) => n), 'function');
```
factorial(1) should return 1.
factorial(1) deve retornar 1.
```js
assert.equal(factorial(1), 1);
```
factorial(2) should return 2.
factorial(2) deve retornar 2.
```js
assert.equal(factorial(2), 2);
```
factorial(3) should return 6.
factorial(3) deve retornar 6.
```js
assert.equal(factorial(3), 6);
```
factorial(4) should return 24.
factorial(4) deve retornar 24.
```js
assert.equal(factorial(4), 24);
```
factorial(10) should return 3628800.
factorial(10) deve retornar 3628800.
```js
assert.equal(factorial(10), 3628800);

52
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/zeckendorf-number-representation.md
View File

@ -1,6 +1,6 @@
---
id: 594810f028c0303b75339ad6
title: Zeckendorf number representation
title: Representação do número de Zeckendorf
challengeType: 5
forumTopicId: 302346
dashedName: zeckendorf-number-representation
@ -8,144 +8,144 @@ dashedName: zeckendorf-number-representation
# --description--
Just as numbers can be represented in a positional notation as sums of multiples of the powers of ten (decimal) or two (binary); all the positive integers can be represented as the sum of one or zero times the distinct members of the Fibonacci series. Recall that the first six distinct Fibonacci numbers are: `1, 2, 3, 5, 8, 13`.
Assim como os números podem ser representados em uma notação posicional como somas de múltiplos das potências de dez (decimal) ou de dois (binário), todos os números inteiros positivos podem ser representados como a soma de um ou zero vezes os diferentes membros da série Fibonacci. Lembre-se de que os primeiros seis números de Fibonacci distintos são: `1, 2, 3, 5, 8, 13`.
The decimal number eleven can be written as `0*13 + 1*8 + 0*5 + 1*3 + 0*2 + 0*1` or `010100` in positional notation where the columns represent multiplication by a particular member of the sequence. Leading zeroes are dropped so that 11 decimal becomes `10100`. 10100 is not the only way to make 11 from the Fibonacci numbers however `0*13 + 1*8 + 0*5 + 0*3 + 1*2 + 1*1` or 010011 would also represent decimal 11. For a true Zeckendorf number there is the added restriction that *no two consecutive Fibonacci numbers can be used* which leads to the former unique solution.
O número decimal onze pode ser escrito como `0*13 + 1*8 + 0*5 + 1*3 + 0*2 + 0*1` ou `010100` na notação posicional, onde as colunas representam a multiplicação por um determinado membro da sequência. Zeros à esquerda são descartados para que o número 11 decimal se torne `10100`. Porém, 10100 não é a única maneira de representar 11 nos números de Fibonacci. `0*13 + 1*8 + 0*5 + 0*3 + 1*2 + 1*1` ou 010011 também representaria o 11 decimal. Para um número de Zeckendorf verdadeiro, há a restrição adicional de que *não sejam usados dois números de Fibonacci consecutivos*, o que leva à antiga solução única.
# --instructions--
Write a function that generates and returns the Zeckendorf number representation of `n`.
Escreva uma função que gere e retorne a representação do número de Zeckendorf de `n`.
# --hints--
`zeckendorf` should be a function.
`zeckendorf` deve ser uma função.
```js
assert.equal(typeof zeckendorf, 'function');
```
`zeckendorf(0)` should return `0`.
`zeckendorf(0)` deve retornar `0`.
```js
assert.equal(zeckendorf(0), 0);
```
`zeckendorf(1)` should return `1`.
`zeckendorf(1)` deve retornar `1`.
```js
assert.equal(zeckendorf(1), 1);
```
`zeckendorf(2)` should return `10`.
`zeckendorf(2)` deve retornar `10`.
```js
assert.equal(zeckendorf(2), 10);
```
`zeckendorf(3)` should return `100`.
`zeckendorf(3)` deve retornar `100`.
```js
assert.equal(zeckendorf(3), 100);
```
`zeckendorf(4)` should return `101`.
`zeckendorf(4)` deve retornar `101`.
```js
assert.equal(zeckendorf(4), 101);
```
`zeckendorf(5)` should return `1000`.
`zeckendorf(5)` deve retornar `1000`.
```js
assert.equal(zeckendorf(5), 1000);
```
`zeckendorf(6)` should return `1001`.
`zeckendorf(6)` deve retornar `1001`.
```js
assert.equal(zeckendorf(6), 1001);
```
`zeckendorf(7)` should return `1010`.
`zeckendorf(7)` deve retornar `1010`.
```js
assert.equal(zeckendorf(7), 1010);
```
`zeckendorf(8)` should return `10000`.
`zeckendorf(8)` deve retornar `10000`.
```js
assert.equal(zeckendorf(8), 10000);
```
`zeckendorf(9)` should return `10001`.
`zeckendorf(9)` deve retornar `10001`.
```js
assert.equal(zeckendorf(9), 10001);
```
`zeckendorf(10)` should return `10010`.
`zeckendorf(10)` deve retornar `10010`.
```js
assert.equal(zeckendorf(10), 10010);
```
`zeckendorf(11)` should return `10100`.
`zeckendorf(11)` deve retornar `10100`.
```js
assert.equal(zeckendorf(11), 10100);
```
`zeckendorf(12)` should return `10101`.
`zeckendorf(12)` deve retornar `10101`.
```js
assert.equal(zeckendorf(12), 10101);
```
`zeckendorf(13)` should return `100000`.
`zeckendorf(13)` deve retornar `100000`.
```js
assert.equal(zeckendorf(13), 100000);
```
`zeckendorf(14)` should return `100001`.
`zeckendorf(14)` deve retornar `100001`.
```js
assert.equal(zeckendorf(14), 100001);
```
`zeckendorf(15)` should return `100010`.
`zeckendorf(15)` deve retornar `100010`.
```js
assert.equal(zeckendorf(15), 100010);
```
`zeckendorf(16)` should return `100100`.
`zeckendorf(16)` deve retornar `100100`.
```js
assert.equal(zeckendorf(16), 100100);
```
`zeckendorf(17)` should return `100101`.
`zeckendorf(17)` deve retornar `100101`.
```js
assert.equal(zeckendorf(17), 100101);
```
`zeckendorf(18)` should return `101000`.
`zeckendorf(18)` deve retornar `101000`.
```js
assert.equal(zeckendorf(18), 101000);
```
`zeckendorf(19)` should return `101001`.
`zeckendorf(19)` deve retornar `101001`.
```js
assert.equal(zeckendorf(19), 101001);
```
`zeckendorf(20)` should return `101010`.
`zeckendorf(20)` deve retornar `101010`.
```js
assert.equal(zeckendorf(20), 101010);

56
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/zhang-suen-thinning-algorithm.md
View File

@ -1,6 +1,6 @@
---
id: 594810f028c0303b75339ad7
title: Zhang-Suen thinning algorithm
title: Algoritmo de afinamento de Zhang-Suen
challengeType: 5
forumTopicId: 302347
dashedName: zhang-suen-thinning-algorithm
@ -8,7 +8,7 @@ dashedName: zhang-suen-thinning-algorithm
# --description--
This is an algorithm used to thin a black and white i.e. one bit per pixel images. For example, with an input image of:
Este é um algoritmo usado para afinar imagens em preto e branco, ou seja, imagens de um bit por pixel. Por exemplo, com uma imagem de entrada de:
```js
const testImage1 = [
@ -25,7 +25,7 @@ const testImage1 = [
];
```
It produces the thinned output:
Ele produz a saída fina:
```js
[ ' ',
@ -40,76 +40,76 @@ It produces the thinned output:
' ' ];
```
## Algorithm
## Algoritmo
Assume black pixels are one and white pixels zero, and that the input image is a rectangular N by M array of ones and zeroes. The algorithm operates on all black pixels P1 that can have eight neighbours. The neighbours are, in order, arranged as:
Suponha que os pixels pretos são um e os pixels brancos são zeros. Leve em conta também que a imagem de entrada é um array retangular, de N por M, de uns e zeros. O algoritmo opera em todos os pixels pretos P1 que podem ter oito vizinhos. Os vizinhos estão, por ordem, organizados como:
$$\begin{array}{|c|c|c|} \\hline P9 & P2 & P3\\\\ \\hline P8 & \boldsymbol{P1} & P4\\\\ \\hline P7 & P6 & P5\\\\ \\hline \end{array}$$
Obviously the boundary pixels of the image cannot have the full eight neighbours.
Obviamente que os pixels da borda da imagem não podem ter todos os oito vizinhos.
- Define $A(P1)$ = the number of transitions from white to black, ($0 \to 1$) in the sequence P2, P3, P4, P5, P6, P7, P8, P9, P2. (Note the extra P2 at the end - it is circular).
- Define $B(P1)$ = the number of black pixel neighbours of P1. ($= \\sum(P2 \ldots P9)$)
- Defina $A(P1)$ = o número de transições de branco para preto, ($0 \to 1$) na sequência P2, P3, P4, P5, P6, P7, P8, P9, P2. (Observe o P2 adicional no final - é circular).
- Defina $B(P1)$ = o número de vizinhos de P1 que são pixels pretos. ($= \\sum(P2 \ldots P9)$)
**Step 1:**
**Passo 1:**
All pixels are tested and pixels satisfying all the following conditions (simultaneously) are just noted at this stage.
Todos os pixels são testados e pixels satisfazendo todas as seguintes condições (simultaneamente) são apenas anotados nesta fase.
1. The pixel is black and has eight neighbours
1. O pixel é preto e tem oito vizinhos
2. $2 \le B(P1) \le 6$
3. $A(P1) = 1$
4. At least one of $P2$, $P4$ and $P6$ is white
5. At least one of $P4$, $P6$ and $P8$ is white
4. Pelo menos um dos pixels, entre $P2$, $P4$ e $P6$, é branco
5. Pelo menos um dos pixels, entre $P4$, $P6$ e $P8$, é branco
After iterating over the image and collecting all the pixels satisfying all step 1 conditions, all these condition satisfying pixels are set to white.
Depois de iterar sobre a imagem e coletar todos os pixels satisfazendo todas as condições do passo 1, todos estes pixels que satisfazem as condições são definidos como brancos.
**Step 2:**
**Passo 2:**
All pixels are again tested and pixels satisfying all the following conditions are just noted at this stage.
Todos os pixels são testados novamente e pixels satisfazendo todas as seguintes condições (simultaneamente) são apenas anotados nesta fase.
1. The pixel is black and has eight neighbours
1. O pixel é preto e tem oito vizinhos
2. $2 \le B(P1) \le 6$
3. $A(P1) = 1$
4. At least one of $P2$, $P4$ and $P8$ is white
5. At least one of $P2$, $P6$ and $P8$ is white
4. Pelo menos um dos pixels, entre $P2$, $P4$ e $P8$, é branco
5. Pelo menos um dos pixels, entre $P2$, $P6$ e $P8$, é branco
After iterating over the image and collecting all the pixels satisfying all step 2 conditions, all these condition satisfying pixels are again set to white.
Depois de iterar sobre a imagem e coletar todos os pixels satisfazendo todas as condições do passo 2, todos estes pixels que satisfazem as condições são definidos novamente como brancos.
**Iteration:**
**Iteração:**
If any pixels were set in this round of either step 1 or step 2 then all steps are repeated until no image pixels are so changed.
Se qualquer pixel for definido nessa rodada dos passos 1 ou 2, então todos os passos são repetidos até que nenhum pixels da imagem seja mudado.
# --instructions--
Write a routine to perform Zhang-Suen thinning on the provided `image`, an array of strings, where each string represents single line of the image. In the string, `#` represents black pixel, and whitespace represents white pixel. Function should return thinned image, using the same representation.
Escreva uma rotina que realize o afinamento de Zhang-Suen na `image` fornecida, um array de strings, onde cada string representa uma única linha da imagem. Na string, `#` representa um pixel preto e espaço em branco representa um pixel branco. A função deve retornar a imagem fina, usando a mesma representação.
# --hints--
`thinImage` should be a function.
`thinImage` deve ser uma função.
```js
assert.equal(typeof thinImage, 'function');
```
`thinImage` should return an array.
`thinImage` deve retornar um array.
```js
assert(Array.isArray(thinImage(_testImage1)));
```
`thinImage` should return an array of strings.
`thinImage` deve retornar um array de strings.
```js
assert.equal(typeof thinImage(_testImage1)[0], 'string');
```
`thinImage(testImage1)` should return a thinned image as in the example.
`thinImage(testImage1)` deve retornar uma imagem fina como no exemplo.
```js
assert.deepEqual(thinImage(_testImage1), expected1);
```
`thinImage(testImage2)` should return a thinned image.
`thinImage(testImage2)` deve retornar uma imagem fina.
```js
assert.deepEqual(thinImage(_testImage2), expected2);

20
curriculum/challenges/portuguese/10-coding-interview-prep/rosetta-code/zig-zag-matrix.md
View File

@ -1,6 +1,6 @@
---
id: 594810f028c0303b75339ad8
title: Zig-zag matrix
title: Matriz de zigue-zague
challengeType: 5
forumTopicId: 302348
dashedName: zig-zag-matrix
@ -8,9 +8,9 @@ dashedName: zig-zag-matrix
# --description--
A 'zig-zag' array is a square arrangement of the first $N^2$ integers, where the numbers increase sequentially as you zig-zag along the array's [anti-diagonals](https://en.wiktionary.org/wiki/antidiagonal).
Uma matriz 'zig-zag' é um arranjo quadrado dos primeiros $N^2$ inteiros, onde os números crescem sequencialmente à medida que você percorre em zigue-zague ao longo das [antidiagonais](https://en.wiktionary.org/wiki/antidiagonal) da matriz.
For example, for the input `5`, the following result should be produced:
Por exemplo, para a entrada `5`, o seguinte resultado deve ser produzido:
<pre>
0 1 5 6 14
@ -22,41 +22,41 @@ For example, for the input `5`, the following result should be produced:
# --instructions--
Write a function that takes the size of the zig-zag matrix, and returns the corresponding matrix as two-dimensional array.
Escreva uma função que receba o tamanho da matriz em zigue-zague, e retorne a matriz correspondente como matriz bidimensional.
# --hints--
ZigZagMatrix should be a function.
ZigZagMatrix deve ser uma função.
```js
assert.equal(typeof ZigZagMatrix, 'function');
```
ZigZagMatrix should return array.
ZigZagMatrix deve retornar matriz.
```js
assert.equal(typeof ZigZagMatrix(1), 'object');
```
ZigZagMatrix should return an array of nested arrays.
ZigZagMatrix deve retornar uma matriz de matrizes aninhadas.
```js
assert.equal(typeof ZigZagMatrix(1)[0], 'object');
```
ZigZagMatrix(1) should return \[[0]].
ZigZagMatrix(1) deve retornar \[[0]].
```js
assert.deepEqual(ZigZagMatrix(1), zm1);
```
ZigZagMatrix(2) should return \[[0, 1], [2, 3]].
ZigZagMatrix(2) deve retornar \[[0, 1], [2, 3]].
```js
assert.deepEqual(ZigZagMatrix(2), zm2);
```
ZigZagMatrix(5) should return specified matrix.
ZigZagMatrix(5) deve retornar a matriz especificada.
```js
assert.deepEqual(ZigZagMatrix(5), zm5);