Feb 19, 2020 · Feb 19, 2020 · Feb 19, 2020 · Feb 19, 2020 · Feb 19, 2020 · Feb 19, 2020
diff --git a/1-js/05-data-types/05-array-methods/1-camelcase/_js.view/solution.js b/1-js/05-data-types/05-array-methods/1-camelcase/_js.view/solution.js
 function camelize(str) {
  return str
    .split('-') //splits 'my-long-word'into array ['my', 'long', 'word']
    .split('-') //separa 'my-long-word'em um array ['my', 'long', 'word']
    .map(
      //capitalizes first letters of allarrayitems except the first one
      //converts ['my', 'long', 'word']into ['my', 'Long', 'Word']
      //deixa as primeiras letras de todos os itens doarrayem maiúsculo exceto o primeiro item
      //converte ['my', 'long', 'word']em ['my', 'Long', 'Word']
      (word, index) => index == 0 ? word : word[0].toUpperCase() + word.slice(1)
    )
    .join(''); //joins ['my', 'Long', 'Word']into 'myLongWord'
    .join(''); //une ['my', 'Long', 'Word']formando 'myLongWord'
 }
diff --git a/1-js/05-data-types/05-array-methods/1-camelcase/task.md b/1-js/05-data-types/05-array-methods/1-camelcase/task.md

 ---

 #Translate border-left-widthto borderLeftWidth
 #Mude border-left-widthpara borderLeftWidth

 Write the function `camelize(str)`that changes dash-separated words like"my-short-string"into camel-cased "myShortString".
 Escreva uma função `camelize(str)`que mude as palavras separadas por traços como"my-short-string"para palavras em camelCase "myShortString".

 That is: removes all dashes, each word after dash becomes uppercased.
 Ou seja: remova todos os traços, cada palavra depois do traço precisa estar em maiúsculo.

 Examples:
 Exemplos:

 ```js
 camelize("background-color") == 'backgroundColor';
 camelize("list-style-image") == 'listStyleImage';
 camelize("-webkit-transition") == 'WebkitTransition';
 ```

 P.S.Hint: use `split`to split the stringinto an array,transform it and`join` back.
 P.S.Dica: use `split`para separar a stringem um array,transforme-os e os junte de volta usando`join`.
diff --git a/1-js/05-data-types/05-array-methods/10-average-age/task.md b/1-js/05-data-types/05-array-methods/10-average-age/task.md

 ---

 #Get average age
 #Pegar a média de idade

 Write the function `getAverageAge(users)`that gets an arrayof objects with property`age`and gets the average.
 Escreva a função `getAverageAge(users)`que recebe um arrayde objetos com a propriedade`age`e pega a média entre eles.

 The formula for the average is `(age1 + age2 + ... + ageN) / N`.
 A fórmula da média é `(age1 + age2 + ... + ageN) / N`.

 For instance:
 Por exemplo:

 ```js no-beautify
 let john = { name: "John", age: 25 };
diff --git a/1-js/05-data-types/05-array-methods/11-array-unique/solution.md b/1-js/05-data-types/05-array-methods/11-array-unique/solution.md
 Let's walk the array items:
 -For each item we'll check if the resultingarrayalready has that item.
 -If it is so, then ignore, otherwise add to results.
 Vamos percorrer os itens do array:
 -Para cada item, vamos checar se oarray`result` já possui esse item.
 -Se sim, então será ignorado, do contrário será adicionado a `result`.

 ```js run demo
 function unique(arr) {
 alert( unique(strings) ); // Hare, Krishna, :-O
 ```

 The code works, but there's a potential performance problem in it.
 O código funciona, porém existe um potencial problema de performance aqui.

 The method `result.includes(str)`internally walks the array `result`and compares each element against `str`to find the match.
 O método `result.includes(str)`internamente percorre o array `result`e compara cada elemento com `str`para achar um que combine.

 So if there are`100`elements in `result`and no one matches `str`,then it will walk the whole`result`and do exactly`100`comparisons. And if `result`is large, like `10000`,then there would be`10000`comparisons.
 Então se tiver`100`elementos em `result`e nenhum combine com `str`,então ele vai percorrer`result`inteiro e fazer exatamente`100`comparações. E se `result`for muito maior, como `10000`,então terá`10000`comparações.

 That's not a problem by itself, because JavaScriptenginesare very fast, so walk`10000`array is a matter of microseconds.
 Isso não é um problema tão preocupante porque asenginesdo JavaScript são muito rápidas, então percorrer um array de`10000`itens dura questões de microsegundos.

 But we do such test for each element of`arr`, in the`for` loop.
 Porém, nós estamos fazendo estes teste para cada elemento em`arr` no laço de repetição`for`.

 So if `arr.length`is `10000`we'll have something like `10000*10000` = 100millions of comparisons. That's a lot.
 Então se `arr.length`for `10000`vamos ter algo como: `10000*10000` = 100milhões de comparações. Isso é muito.

 So the solution is only good for smallarrays.
 Então, essa solução é somente boa paraarrays pequenas.

 Further in the chapter <info:map-set-weakmap-weakset>we'll see how to optimize it.
 Mais adiante no capítulo <info:map-set-weakmap-weakset>vamos ver como otimizar isso.
diff --git a/1-js/05-data-types/05-array-methods/11-array-unique/task.md b/1-js/05-data-types/05-array-methods/11-array-unique/task.md

 ---

 #Filter unique array members
 #Filtre membros únicos de um array

 Let `arr`be an array.
 Deixe `arr`ser um array.

 Create afunction `unique(arr)`that should return anarraywith unique items of`arr`.
 Crie afunção `unique(arr)`que recebe umarray`string` e retorna outro array`arr` com itens únicos/que mais se repetem do array recebido.

 For instance:
 Por exemplo:

 ```js
 function unique(arr) {
  /*your code */
  /*seu código */
 }

 let strings = ["Hare", "Krishna", "Hare", "Krishna",
diff --git a/1-js/05-data-types/05-array-methods/2-filter-range/_js.view/solution.js b/1-js/05-data-types/05-array-methods/2-filter-range/_js.view/solution.js

 function filterRange(arr, a, b) {
  //added brackets around the expression for better readability
  //colchetes adicionado ao redor da expressão para melhor entendimento
  return arr.filter(item => (a <= item && item <= b));
 }
diff --git a/1-js/05-data-types/05-array-methods/2-filter-range/solution.md b/1-js/05-data-types/05-array-methods/2-filter-range/solution.md
 ```js run demo
 function filterRange(arr, a, b) {
  //added brackets around the expression for better readability
  //colchetes adicionado ao redor da expressão para melhor entendimento
  return arr.filter(item => (a <= item && item <= b));
 }

 let arr = [5, 3, 8, 1];

 let filtered = filterRange(arr, 1, 4);

 alert( filtered ); // 3,1 (matching values)
 alert( filtered ); // 3,1 (valores que coincidem com o que foi pedido)

 alert( arr ); // 5,3,8,1 (not modified)
 alert( arr ); // 5,3,8,1 (array não foi modificada)
 ```
diff --git a/1-js/05-data-types/05-array-methods/2-filter-range/task.md b/1-js/05-data-types/05-array-methods/2-filter-range/task.md

 # Filter range

 Write a function `filterRange(arr, a, b)`that gets an array `arr`,looks for elements between `a`and `b`in it and returns an array of them.
 Escreva uma função `filterRange(arr, a, b)`que pegue um array `arr`,procure por elementos entre `a`e `b`e retorne um array novo com os elementos encontrados.

 The function should not modify the array.It should return the new array.
 A função não deve modificar o array.Deve retornar um novo array.

 For instance:
 Exemplo:

 ```js
 let arr = [5, 3, 8, 1];

 let filtered = filterRange(arr, 1, 4);

 alert( filtered ); // 3,1 (matching values)
 alert( filtered ); // 3,1 (valores que coincidem com o que foi pedido)

 alert( arr ); // 5,3,8,1 (not modified)
 alert( arr ); // 5,3,8,1 (array não foi modificada)
 ```

diff --git a/1-js/05-data-types/05-array-methods/3-filter-range-in-place/_js.view/solution.js b/1-js/05-data-types/05-array-methods/3-filter-range-in-place/_js.view/solution.js
  for (let i = 0; i < arr.length; i++) {
    let val = arr[i];

    //removeif outside of the interval
    //removese estiver fora do intervalo
    if (val < a || val > b) {
      arr.splice(i, 1);
      i--;
diff --git a/1-js/05-data-types/05-array-methods/3-filter-range-in-place/solution.md b/1-js/05-data-types/05-array-methods/3-filter-range-in-place/solution.md
  for (let i = 0; i < arr.length; i++) {
    let val = arr[i];

    //removeif outside of the interval
    //removese estiver fora do intervalo
    if (val < a || val > b) {
      arr.splice(i, 1);
      i--;

 let arr = [5, 3, 8, 1];

 filterRangeInPlace(arr, 1, 4); //removed the numbers except from 1 to 4
 filterRangeInPlace(arr, 1, 4); //remove os números exceto números de 1 á 4

 alert( arr ); // [3, 1]
 ```
diff --git a/1-js/05-data-types/05-array-methods/3-filter-range-in-place/task.md b/1-js/05-data-types/05-array-methods/3-filter-range-in-place/task.md

 # Filter range "in place"

 Write a function `filterRangeInPlace(arr, a, b)`that gets an array `arr`and removes from it all values except those that are between `a`and `b`.The test is: `a ≤ arr[i] ≤ b`.
 Escreva uma função `filterRangeInPlace(arr, a, b)`que pegue um array `arr`e remova dele todos os valores exceto aqueles que estão entre `a`e `b`.A condição é: `a ≤ arr[i] ≤ b`.

 The function should only modify thearray.It should not return anything.
 A função deve modificar aarray.Não deve retornar um valor.

 For instance:
 Exemplo:
 ```js
 let arr = [5, 3, 8, 1];

 filterRangeInPlace(arr, 1, 4); //removed the numbers except from 1 to 4
 filterRangeInPlace(arr, 1, 4); //remove os números exceto números de 1 á 4

 alert( arr ); // [3, 1]
 ```
diff --git a/1-js/05-data-types/05-array-methods/4-sort-back/task.md b/1-js/05-data-types/05-array-methods/4-sort-back/task.md

 ---

 #Sort in the reverse order
 #Ordene (sort) na ordem decrescente

 ```js
 let arr = [5, 2, 1, -10, 8];

 // ...your code to sort it in the reverse order
 // ...seu código para ordenar na ordem decrescente

 alert( arr ); // 8, 5, 2, 1, -10
 ```
diff --git a/1-js/05-data-types/05-array-methods/5-copy-sort-array/solution.md b/1-js/05-data-types/05-array-methods/5-copy-sort-array/solution.md
 We can use`slice()`to make acopy and run thesort on it:
 Podemos usar`slice()`para fazer acópia e executar o método `sort()` logo depois:

 ```js run
 function copySorted(arr) {
diff --git a/1-js/05-data-types/05-array-methods/5-copy-sort-array/task.md b/1-js/05-data-types/05-array-methods/5-copy-sort-array/task.md

 ---

 #Copy and sort array
 #Copie e ordene o array

 We have anarrayof strings `arr`.We'd like to have a sorted copy of it, but keep `arr`unmodified.
 Temos umarrayde strings `arr`.Gostaríamos de ter uma copia ordenada desse array, porém mantenha `arr`do mesmo jeito, sem modificações.

 Create a function `copySorted(arr)`that returns such a copy.
 Crie uma função `copySorted(arr)`que retorna a copia.

 ```js
 let arr = ["HTML", "JavaScript", "CSS"];

 let sorted = copySorted(arr);

 alert( sorted ); // CSS, HTML, JavaScript
 alert( arr ); // HTML, JavaScript, CSS (no changes)
 alert( arr ); // HTML, JavaScript, CSS (arr sem alterções)
 ```
diff --git a/1-js/05-data-types/05-array-methods/6-array-get-names/task.md b/1-js/05-data-types/05-array-methods/6-array-get-names/task.md

 ---

 # Mapto names
 # Mappara nomes

 You have an arrayof`user` objects, each one has `user.name`.Write the code that converts it into anarrayof names.
 Você tem um arrayde objetos`user`, cada um possui `user.name`.Escreva um código que converta o array para umarrayde nomes.

 For instance:
 Exemplo:

 ```js no-beautify
 let john = { name: "John", age: 25 };

 let users = [ john, pete, mary ];

 let names = /* ...your code */
 let names = /* ...seu código */

 alert( names ); // John, Pete, Mary
 ```
diff --git a/1-js/05-data-types/05-array-methods/6-calculator-extendable/solution.md b/1-js/05-data-types/05-array-methods/6-calculator-extendable/solution.md

 -Pleasenotehow methods are stored. They are simply added to the internal object.
 -All tests and numeric conversions are done in the`calculate` method. In future it may be extended to support more complex expressions.
 -Por favor,notecomo os métodos são armazenados. Eles são simplesmente adicionados no objeto interno.
 -Todos os testes e conversões numéricas são feitas no método`calculate`. No futuro, pode ser extendida para suportar mais expressões complexas.
diff --git a/1-js/05-data-types/05-array-methods/6-calculator-extendable/task.md b/1-js/05-data-types/05-array-methods/6-calculator-extendable/task.md

 ---

 #Create an extendable calculator
 #Crie uma calculadora extensível

 Create a constructor function `Calculator`that creates "extendable" calculator objects.
 Construa uma função construtora `Calculator`que crie objetos de calculadora "extensível".

 The task consists of two parts.
 A atividade consiste de duas partes.

 1.First, implement the method `calculate(str)`that takes a stringlike `"1 + 2"`in the format "NUMBER operator NUMBER" (space-delimited) and returns the result. Should understand plus`+`and minus `-`.
 1.Primeiro, implemente o método `calculate(str)`que pegue uma stringcomo `"1 + 2"`e a deixe no formato "NÚMERO operador NÚMERO" (delimitada por espaços) e retorne o resultado. Deve entender os operadores mais`+`e menos `-`.

 Usage example:
 Exemplo:

    ```js
    let calc = new Calculator;

    alert( calc.calculate("3 + 7") ); // 10
    ```
 2.Then add the method `addMethod(name, func)`that teaches the calculator a new operation. It takes the operator`name`and the two-argument function`func(a,b)`that implements it.
 2.Então, adicione o método `addMethod(name, func)`que ensina a calculadora uma nova operação. O método pega o operador`name`e a função que recebe dois argumentos`func(a,b)`para implementar a nova operação.

 For instance, let's add the multiplication`*`,division `/`and power `**`:
 Por exemplo, vamos adicionar multiplicação`*`,divisão `/`e potenciação `**`:

    ```js
    let multCalc = new Calculator;
    let divCalc = new Calculator;
    let powerCalc = new Calculator;
    powerCalc.addMethod("*", (a, b) => a * b);
    powerCalc.addMethod("/", (a, b) => a / b);

    multCalc.addMethod("*", (a, b) => a * b);
    divCalc.addMethod("/", (a, b) => a / b);
    powerCalc.addMethod("**", (a, b) => a ** b);

    let result = powerCalc.calculate("2 ** 3");
    alert( result ); // 8
    ```

 -No brackets or complex expressions in this task.
 -The numbers and the operator are delimited with exactly one space.
 -There may be error handling if you'd like to add it.
 -Sem colchetes ou expressões complexas neste exercício.
 -Os números e o operador são separados por, exatamente, um espaço.
 -Pode haver mensagem de erro se você desejar adicionar.
diff --git a/1-js/05-data-types/05-array-methods/7-map-objects/solution.md b/1-js/05-data-types/05-array-methods/7-map-objects/solution.md
 alert( usersMapped[0].fullName ); // John Smith
 ```

 Pleasenotethat in for thearrow functions we need to use additional brackets.
 Por favor,noteque para usararrow functions, precisamos usar colchetes adicionais.

 We can't write like this:
 Não podemos escrevê-lo dessa forma:
 ```js
 let usersMapped = users.map(user => *!*{*/!*
  fullName: `${user.name} ${user.surname}`,
  id: user.id
 });
 ```

 As we remember, there are twoarrow functions:without body `value => expr`and with body `value => {...}`.
 Como sabemos, existem dois tipos dearrow functions:sem corpo `value => expr`e com corpo `value => {...}`.

 HereJavaScriptwould treat `{`as the start of function body, not the start of the object. The workaround is to wrap them in the "normal" brackets:
 JavaScriptirá tratar `{`como o começo do corpo de uma função, não o começo do objeto. A *gambiarra* é os colocar em volta de colchetes "normais", ou seja, primeiro os parênteses e depois os colchetes `({ ... })`:

 ```js
 let usersMapped = users.map(user => *!*({*/!*
 }));
 ```

 Now fine.
 Dessa forma, nosso código está correto.
Original file line number	Diff line number	Diff line change
		@@ -1,10 +1,10 @@
		function camelize(str) {
		return str
		.split('-') //splits 'my-long-word'into array ['my', 'long', 'word']
		.split('-') //separa 'my-long-word'em um array ['my', 'long', 'word']
		.map(
		//capitalizes first letters of allarrayitems except the first one
		//converts ['my', 'long', 'word']into ['my', 'Long', 'Word']
		//deixa as primeiras letras de todos os itens doarrayem maiúsculo exceto o primeiro item
		//converte ['my', 'long', 'word']em ['my', 'Long', 'Word']
		(word, index) => index == 0 ? word : word[0].toUpperCase() + word.slice(1)
		)
		.join(''); //joins ['my', 'Long', 'Word']into 'myLongWord'
		.join(''); //une ['my', 'Long', 'Word']formando 'myLongWord'
		}
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,18 +2,18 @@ importance: 5

		---

		#Translate border-left-widthto borderLeftWidth
		#Mude border-left-widthpara borderLeftWidth

		Write the function `camelize(str)`that changes dash-separated words like"my-short-string"into camel-cased "myShortString".
		Escreva uma função `camelize(str)`que mude as palavras separadas por traços como"my-short-string"para palavras em camelCase "myShortString".

		That is: removes all dashes, each word after dash becomes uppercased.
		Ou seja: remova todos os traços, cada palavra depois do traço precisa estar em maiúsculo.

		Examples:
		Exemplos:

		```js
		camelize("background-color") == 'backgroundColor';
		camelize("list-style-image") == 'listStyleImage';
		camelize("-webkit-transition") == 'WebkitTransition';
		```

		P.S.Hint: use `split`to split the stringinto an array,transform it and`join` back.
		P.S.Dica: use `split`para separar a stringem um array,transforme-os e os junte de volta usando`join`.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,13 +2,13 @@ importance: 4

		---

		#Get average age
		#Pegar a média de idade

		Write the function `getAverageAge(users)`that gets an arrayof objects with property`age`and gets the average.
		Escreva a função `getAverageAge(users)`que recebe um arrayde objetos com a propriedade`age`e pega a média entre eles.

		The formula for the average is `(age1 + age2 + ... + ageN) / N`.
		A fórmula da média é `(age1 + age2 + ... + ageN) / N`.

		For instance:
		Por exemplo:

		```js no-beautify
		let john = { name: "John", age: 25 };
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -1,6 +1,6 @@
		Let's walk the array items:
		-For each item we'll check if the resultingarrayalready has that item.
		-If it is so, then ignore, otherwise add to results.
		Vamos percorrer os itens do array:
		-Para cada item, vamos checar se oarray`result` já possui esse item.
		-Se sim, então será ignorado, do contrário será adicionado a `result`.

		```js run demo
		function unique(arr) {
Expand All		@@ -22,18 +22,18 @@ let strings = ["Hare", "Krishna", "Hare", "Krishna",
		alert( unique(strings) ); // Hare, Krishna, :-O
		```

		The code works, but there's a potential performance problem in it.
		O código funciona, porém existe um potencial problema de performance aqui.

		The method `result.includes(str)`internally walks the array `result`and compares each element against `str`to find the match.
		O método `result.includes(str)`internamente percorre o array `result`e compara cada elemento com `str`para achar um que combine.

		So if there are`100`elements in `result`and no one matches `str`,then it will walk the whole`result`and do exactly`100`comparisons. And if `result`is large, like `10000`,then there would be`10000`comparisons.
		Então se tiver`100`elementos em `result`e nenhum combine com `str`,então ele vai percorrer`result`inteiro e fazer exatamente`100`comparações. E se `result`for muito maior, como `10000`,então terá`10000`comparações.

		That's not a problem by itself, because JavaScriptenginesare very fast, so walk`10000`array is a matter of microseconds.
		Isso não é um problema tão preocupante porque asenginesdo JavaScript são muito rápidas, então percorrer um array de`10000`itens dura questões de microsegundos.

		But we do such test for each element of`arr`, in the`for` loop.
		Porém, nós estamos fazendo estes teste para cada elemento em`arr` no laço de repetição`for`.

		So if `arr.length`is `10000`we'll have something like `10000*10000` = 100millions of comparisons. That's a lot.
		Então se `arr.length`for `10000`vamos ter algo como: `10000*10000` = 100milhões de comparações. Isso é muito.

		So the solution is only good for smallarrays.
		Então, essa solução é somente boa paraarrays pequenas.

		Further in the chapter <info:map-set-weakmap-weakset>we'll see how to optimize it.
		Mais adiante no capítulo <info:map-set-weakmap-weakset>vamos ver como otimizar isso.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,17 +2,17 @@ importance: 4

		---

		#Filter unique array members
		#Filtre membros únicos de um array

		Let `arr`be an array.
		Deixe `arr`ser um array.

		Create afunction `unique(arr)`that should return anarraywith unique items of`arr`.
		Crie afunção `unique(arr)`que recebe umarray`string` e retorna outro array`arr` com itens únicos/que mais se repetem do array recebido.

		For instance:
		Por exemplo:

		```js
		function unique(arr) {
		/your code /
		/seu código /
		}

		let strings = ["Hare", "Krishna", "Hare", "Krishna",
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -1,5 +1,5 @@

		function filterRange(arr, a, b) {
		//added brackets around the expression for better readability
		//colchetes adicionado ao redor da expressão para melhor entendimento
		return arr.filter(item => (a <= item && item <= b));
		}
Original file line number	Diff line number	Diff line change
		@@ -1,14 +1,14 @@
		```js run demo
		function filterRange(arr, a, b) {
		//added brackets around the expression for better readability
		//colchetes adicionado ao redor da expressão para melhor entendimento
		return arr.filter(item => (a <= item && item <= b));
		}

		let arr = [5, 3, 8, 1];

		let filtered = filterRange(arr, 1, 4);

		alert( filtered ); // 3,1 (matching values)
		alert( filtered ); // 3,1 (valores que coincidem com o que foi pedido)

		alert( arr ); // 5,3,8,1 (not modified)
		alert( arr ); // 5,3,8,1 (array não foi modificada)
		```
Original file line number	Diff line number	Diff line change
Expand Up		@@ -4,19 +4,19 @@ importance: 4

		# Filter range

		Write a function `filterRange(arr, a, b)`that gets an array `arr`,looks for elements between `a`and `b`in it and returns an array of them.
		Escreva uma função `filterRange(arr, a, b)`que pegue um array `arr`,procure por elementos entre `a`e `b`e retorne um array novo com os elementos encontrados.

		The function should not modify the array.It should return the new array.
		A função não deve modificar o array.Deve retornar um novo array.

		For instance:
		Exemplo:

		```js
		let arr = [5, 3, 8, 1];

		let filtered = filterRange(arr, 1, 4);

		alert( filtered ); // 3,1 (matching values)
		alert( filtered ); // 3,1 (valores que coincidem com o que foi pedido)

		alert( arr ); // 5,3,8,1 (not modified)
		alert( arr ); // 5,3,8,1 (array não foi modificada)
		```
Original file line number	Diff line number	Diff line change
Expand Up		@@ -4,7 +4,7 @@ function filterRangeInPlace(arr, a, b) {
		for (let i = 0; i < arr.length; i++) {
		let val = arr[i];

		//removeif outside of the interval
		//removese estiver fora do intervalo
		if (val < a \|\| val > b) {
		arr.splice(i, 1);
		i--;
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -4,15 +4,15 @@ importance: 4

		# Filter range "in place"

		Write a function `filterRangeInPlace(arr, a, b)`that gets an array `arr`and removes from it all values except those that are between `a`and `b`.The test is: `a ≤ arr[i] ≤ b`.
		Escreva uma função `filterRangeInPlace(arr, a, b)`que pegue um array `arr`e remova dele todos os valores exceto aqueles que estão entre `a`e `b`.A condição é: `a ≤ arr[i] ≤ b`.

		The function should only modify thearray.It should not return anything.
		A função deve modificar aarray.Não deve retornar um valor.

		For instance:
		Exemplo:
		```js
		let arr = [5, 3, 8, 1];

		filterRangeInPlace(arr, 1, 4); //removed the numbers except from 1 to 4
		filterRangeInPlace(arr, 1, 4); //remove os números exceto números de 1 á 4

		alert( arr ); // [3, 1]
		```