diff --git a/challenge-01/README.md b/challenge-01/README.md
index ea3305e40b..ef0591d906 100644
--- a/challenge-01/README.md
+++ b/challenge-01/README.md
@@ -2,41 +2,49 @@
 
 ```js
 // Declarar uma variável chamada `myvar`, sem valor.
-?
+let myvar;
 
 // Após declarada, atribua o valor 10 à variável `myvar`.
-?
+myvar=10;
 
 // Declare uma nova variável chamada `soma`, e adicione uma instrução somando os valores 15 e 8.
-?
+let soma;
+soma=15+8;
 
 // Atribua à variável `soma` todo o valor dela, somando 1, usando o operador de soma abreviado.
-?
+soma++;
 
 // Atribua à variável `soma` todo o valor dela, multiplicando por 3, usando o operador de multiplicação abreviado.
-?
+soma*=3;
 
 // Qual é o valor da variável `soma` até aqui?
-?
+soma;
+// 72
 
 // Declare uma variável chamada `souninja`, atribuindo à ela o valor booleano que representa `verdadeiro`.
-?
+let souninja=true;
 
 // Declare uma variável chamada `comida` que recebe um array com os valores 'arroz', 'feijão' e 'ovo'.
-?
+let comida=['arroz', 'feijão', 'ovo'];
 
 // Digite a instrução que imprime o valor de 'feijao', que está na variável `comida`.
-?
-
+comida[1];
+'feijão'
 // Digite o código que verifica se a variável `soma' é igual a variável `myvar` (testando também o tipo).
-?
+soma===myvar;
+// false
 
 // Digite o código que verifica se a variável `myvar` é menor ou igual à variável `soma`.
-?
+myvar>=soma;
+// false
 
 // Crie uma função chamada `divisao` que receba como parâmetro dois números, e retorne o resultado da divisão entre eles.
-?
+function divisao (a,b){
+let divisao= a/b;
+return divisao;
+}
 
 // Invoque a função criada acima, passando os parâmetros 10 e 2.
-?
-```
\ No newline at end of file
+divsao(8,2);
+// 4
+```
diff --git a/challenge-02/README.md b/challenge-02/README.md
index 2a4be6970b..5761763c68 100644
--- a/challenge-02/README.md
+++ b/challenge-02/README.md
@@ -4,29 +4,35 @@ Nesse exercício, você está livre para escolher os nomes para suas variáveis
 
 ```js
 // Crie uma função que receba dois argumentos e retorne a soma dos mesmos.
-?
+function soma(x,y){
+return x+y;
+}
 
 // Declare uma variável que receba a invocação da função criada acima, passando dois números quaisquer por argumento, e somando `5` ao resultado retornado da função.
-?
+const resultadoSoma= soma(4,6)+5;
 
 // Qual o valor atualizado dessa variável?
-?
+15
 
 // Declare uma nova variável, sem valor.
-?
+let semValor;
 
 /*
 Crie uma função que adicione um valor à variável criada acima, e retorne a string:
     O valor da variável agora é VALOR.
 Onde VALOR é o novo valor da variável.
 */
-?
+function adiciona(a){
+return 'O valor da variável agora é'+ semValor=a;
+}
 
 // Invoque a função criada acima.
-?
+adiciona(17);
 
 // Qual o retorno da função? (Use comentários de bloco).
-?
+// O valor da variável agora é 17
+semValor;
+//17
 
 /*
 Crie uma função com as seguintes características:
@@ -35,19 +41,26 @@ Crie uma função com as seguintes características:
     Preencha todos os valores corretamente!
 3. O retorno da função deve ser a multiplicação dos 3 argumentos, somando `2` ao resultado da multiplicação.
 */
-?
+function multiplicacao(a,b,c){
+    if(a === undefined || b===undefined || c===undefined){
+    return (' Preencha todos os valores corretamente!');
+    } 
+    return (a*b*c)+2;
+    }
+
+
 
 // Invoque a função criada acima, passando só dois números como argumento.
-?
+console.log(multiplicacao(8,6));
 
 // Qual o resultado da invocação acima? (Use comentários para mostrar o valor retornado).
-?
+//Preencha todos os valores corretamente!
 
 // Agora invoque novamente a função criada acima, mas passando todos os três argumentos necessários.
-?
+console.log(multiplicacao(8,6,9));
 
 // Qual o resultado da invocação acima? (Use comentários para mostrar o valor retornado).
-?
+//  434
 
 /*
 Crie uma função com as seguintes características:
@@ -58,8 +71,28 @@ Crie uma função com as seguintes características:
 5. Se nenhum argumento for passado, retorne o valor booleano `false`.
 6. E ainda, se nenhuma das condições acima forem atendidas, retorne `null`.
 */
-?
-
+function retorne (a,b,c){
+if(a!==undefined && b===undefined && c===undefined){
+return a;
+} else if(a!==undefined && b!==undefined && c===undefined){
+  return a+b;
+} else if(a!==undefined && b!==undefined && c!==undefined){
+return (a+b)/c;
+} else if(a===undefined && b===undefined && c===undefined){
+  return false;
+} else{
+  return null;
+}
 // Invoque a função acima utilizando todas as possibilidades (com nenhum argumento, com um, com dois e com três.) Coloque um comentário de linha ao lado da função com o resultado de cada invocação.
-?
-```
\ No newline at end of file
+console.log(retorne(7));
+// 7
+console.log(retorne(7,3));
+//10
+console.log(retorne(7,3,8));
+//1,25
+console.log(retorne());
+// false
+console.log(retorne(null));
+null
+
+```
diff --git a/challenge-04/README.md b/challenge-04/README.md
index ad0fb2f1b2..b4e27a6ec5 100644
--- a/challenge-04/README.md
+++ b/challenge-04/README.md
@@ -1,122 +1,180 @@
-# Desafio da semana #4
-
-```js
-/*
-Declare uma variável chamada `isTruthy`, e atribua a ela uma função que recebe
-um único parâmetro como argumento. Essa função deve retornar `true` se o
-equivalente booleano para o valor passado no argumento for `true`, ou `false`
+@@ -7,15 +7,29 @@ um único parâmetro como argumento. Essa função deve retornar `true` se o
+equivalente booleano para o valor passado no argumento para `true`, ou `false`
 para o contrário.
 */
 ?
+var isTruty= função(a){
+    retornar !!a;
 
 // Invoque a função criada acima, passando todos os tipos de valores `falsy`.
 ?
+é Verdade(nulo);
+éVerdade(" ");
+éVerdade(0);
+é Verdade(indefinido);
+éVerdade(NaN);
+éVerdade(-0);
+é Verdadeiro(falso);
 
 /*
 Invoque a função criada acima passando como parâmetro 10 valores `truthy`.
 */
 ?
+éVerdade(".");
+isTruty("Valéria");
+éVerdade("1");
+éVerdade(1);
+isTruty(var minhaVar= função(){});
+isTruty ( var objeto = {});
+é Verdade(matriz=[1,2,3]);
+éVerdadeiro(verdadeiro);
 
 /*
-Declare uma variável chamada `carro`, atribuindo à ela um objeto com as
-seguintes propriedades (os valores devem ser do tipo mostrado abaixo):
-- `marca` - String
-- `modelo` - String
-- `placa` - String
-- `ano` - Number
-- `cor` - String
-- `quantasPortas` - Number
-- `assentos` - Number - cinco por padrão
-- `quantidadePessoas` - Number - zero por padrão
+Declare uma variável chamada `carro`, atribuindo a ela um objeto com as
+@@ -29,35 +43,54 @@ seguintes propriedades (os valores devem ser do tipo mostrado abaixo):
+- `assentos` - Número - cinco por padrão
+- `quantidadePessoas` - Número - zero por padrão
 */
 ?
+var carro = {
+marca :  " chevrolet " ,
+modelo :  " prisma " ,
+placa :  " qnb-236 " ,
+ano : 2018 ,
+cor : " Prata " ,
+QuantasPortas: 4,
+assentos : 5 ,
+quantidadePessoas : 0
+}
 
 /*
 Crie um método chamado `mudarCor` que mude a cor do carro conforme a cor
 passado por parâmetro.
 */
 ?
+carro.mudarCor = function(novaCor){
+carro . cor = novaCor;
+}
 
 /*
-Crie um método chamado `obterCor`, que retorne a cor do carro.
+Crie um método chamado `obterCor`, que retorna a cor do carro.
 */
 ?
+caro.obterCor= função(){
+  retornar carro.cor;
+}
 
 /*
-Crie um método chamado `obterModelo` que retorne o modelo do carro.
+Crie um método chamado `obterModelo` que retorna o modelo do carro.
 */
 ?
+carro . obterModelo = function (){
+retornar carro.modelo;
+}
 
 /*
-Crie um método chamado `obterMarca` que retorne a marca do carro.
+Crie um método chamado `obterMarca` que retorna a marca do carro.
 */
 ?
+carro . obterMarca = function (){
+retornar carro.marca;
+}
 
 /*
-Crie um método chamado `obterMarcaModelo`, que retorne:
+Crie um método chamado `obterMarcaModelo`, que retorna:
 "Esse carro é um [MARCA] [MODELO]"
 Para retornar os valores de marca e modelo, utilize os métodos criados.
 */
 ?
+carro . obterMarcaModelo = function (){
+return  " Esse carro é um " +  carro . marca  + "  " +  carro . modelo ;
+}
 
 /*
-Crie um método que irá adicionar pessoas no carro. Esse método terá as
-seguintes características:
-- Ele deverá receber por parâmetro o número de pessoas entrarão no carro. Esse
-número não precisa encher o carro, você poderá acrescentar as pessoas aos
-poucos.
-- O método deve retornar a frase: "Já temos [X] pessoas no carro!"
-- Se o carro já estiver cheio, com todos os assentos já preenchidos, o método
-deve retornar a frase: "O carro já está lotado!"
-- Se ainda houverem lugares no carro, mas a quantidade de pessoas passadas por
-parâmetro for ultrapassar o limite de assentos do carro, então você deve
-mostrar quantos assentos ainda podem ser ocupados, com a frase:
-"Só cabem mais [QUANTIDADE_DE_PESSOAS_QUE_CABEM] pessoas!"
-- Se couber somente mais uma pessoa, mostrar a palavra "pessoa" no retorno
+Crie um método para adicionar pessoas no carro. Esse método terá como
+@@ -75,7 +108,34 @@ mostrar quantos assentos ainda podem ser ocupados, com a frase:
+- Se couber somente mais uma pessoa, mostre a palavra "pessoa" no retorno
 citado acima, no lugar de "pessoas".
 */
 ?
 
+carro . adicionarPessoas =  function ( numeroPessoas ){
+    var pluralOuSingular = " pessoas " ;
+
+
+    if ( carro . quantidadePessoas  + numeroPessoas > carro . assentos ){
+     var vagas =  carro . assentos -  carro . quantidadePessoas ;
+    se(vagas===1){
+     pluralOuSingular = " pessoa " ;
+    }
+    return "Então cabem mais "+ vagas +" "+ pluralOuSingular +" !";
+    }
+
+       carro . quantidadePessoas  += numeroPessoas;
+
+
+    if ( carro . quantidadePessoas  === carro . assentos ){
+     return  " O carro já está lotado! " ;
+      }
+
+     if ( carro . quantidadePessoas  === 1 ){
+      pluralOuSingular = " pessoa " ;
+      }
+
+
+    return "Já temos " + carro.quantidadePessoas + " " + pluralOuSingular + " no carro!";
+
+}
+
 /*
 Agora vamos verificar algumas informações do carro. Para as respostas abaixo,
-utilize sempre o formato de invocação do método (ou chamada da propriedade),
-adicionando comentários _inline_ ao lado com o valor retornado, se o método
-retornar algum valor.
-
+@@ -85,38 +145,38 @@ retorna algum valor.
 Qual a cor atual do carro?
 */
 ?
+carro . obterCor (); // Prata
 
 // Mude a cor do carro para vermelho.
 ?
+carro . mudarCor = " Rosa " ; // Rosa
 
 // E agora, qual a cor do carro?
 ?
+carro . obterCor (); // Rosa
 
 // Mude a cor do carro para verde musgo.
 ?
+carro . mudarCor ( “ Verde Musgo ” );
 
 // E agora, qual a cor do carro?
 ?
+carro . obterCor (); // 'Verde musgo'
 
 // Qual a marca e modelo do carro?
 ?
+carro . obterMarcaModelo (); // 'Esse carro é umchevrolet prisma'
 
 // Adicione 2 pessoas no carro.
 ?
+carro . adicionarPessoas ( 2 ); // 'Já temos 2 pessoas no carro!'
 
 // Adicione mais 4 pessoas no carro.
 ?
+carro.adicionarPessoas(4); //'Então cabem mais 3 pessoas !'
 
 // Faça o carro encher.
 ?
+carro . adicionarPessoas ( 3 ); // 'O carro já está lotado!'
 
-// Tire 4 pessoas do carro.
+// Pneu 4 pessoas do carro.
 ?
+carro . adicionarPessoas ( - 4 ); // 'Já temos 1 pessoa no carro!'
 
 // Adicione 10 pessoas no carro.
 ?
+carro.adicionarPessoas(10); //'Então cabem mais 4 pessoas !'
 
-// Quantas pessoas temos no carro?
+// Quantas pessoas não temos carro?
 ?
-```
+carro . quantidadePessoas ; // 1
+` ` `
diff --git a/challenge-05/challenge-05.js b/challenge-05/challenge-05.js
index 29e9ee6bb7..e51547fd68 100644
--- a/challenge-05/challenge-05.js
+++ b/challenge-05/challenge-05.js
@@ -2,17 +2,20 @@
 Crie uma variável qualquer, que receba um array com alguns valores aleatórios
 - ao menos 5 - (fica por sua conta os valores do array).
 */
-// ?
+var arr=["valeria", "cursando", "JS NINJA", true];
 
 /*
 Crie uma função que receba um array como parâmetro, e retorne esse array.
 */
-// ?
+function myFunction(arg){
+  return arg;
+}
 
 /*
 Imprima o segundo índice do array retornado pela função criada acima.
 */
-// ?
+console.log(myFunction(arr)[1]);
+'cursando'
 
 /*
 Crie uma função que receba dois parâmetros: o primeiro, um array de valores; e o
@@ -20,19 +23,25 @@ segundo, um número. A função deve retornar o valor de um índice do array que
 no primeiro parâmetro. O índice usado para retornar o valor, deve ser o número passado no
 segundo parâmetro.
 */
-// ?
+function teste(teste1, teste2){
+    return teste1[teste2];
+}
 
 /*
 Declare uma variável que recebe um array com 5 valores, de tipos diferentes.
 */
-// ?
+var recebe = ["Valeria", 22, true, null, undefined];
 
 /*
 Invoque a função criada acima, fazendo-a retornar todos os valores do último
 array criado.
 */
-// ?
-
+//myFunction(recebe); // ['Valeria', 22, true, null, undefined]
+console.log(teste(teste1,0));
+console.log(teste(teste1,1));
+console.log(teste(teste1,2));
+console.log(teste(teste1,3));
+console.log(teste(teste1,4));
 /*
 Crie uma função chamada `book`, que recebe um parâmetro, que será o nome do
 livro. Dentro dessa função, declare uma variável que recebe um objeto com as
@@ -47,30 +56,63 @@ propriedades:
 - Se o parâmetro não for passado, a função deve retornar o objeto com todos
 os livros.
 */
-// ?
+
+function book(nomeLivro){
+  return livros = {
+   "Primo rico":{
+    quantidadePaginas: 200,
+    autor:" ",
+    editora:" "
+  },
+    "Mente milionaria":{
+    quantidadePaginas: 0,
+    autor:" ",
+    editora:" "
+  },
+  "Codigo limpo":{
+    quantidadePaginas: 0,
+    autor:" ",
+    editora:" "
+    return !nomeLivro? livros : livros.[nomeLivro]
+}
+  }
+}
 
 /*
 Usando a função criada acima, imprima o objeto com todos os livros.
 */
-// ?
+console.log(book());
+/*{Primo rico: {…}, Mente milionaria: {…}, Codigo limpo: {…}}
+Codigo limpo: {quantidadePaginas: 0, autor: ' ', editora: ' '}
+Mente milionaria: {quantidadePaginas: 0, autor: ' ', editora: ' '}
+Primo rico: {quantidadePaginas: 0, autor: ' ', editora: ' '}[[Prototype]]: Object*/
 
 /*
 Ainda com a função acima, imprima a quantidade de páginas de um livro qualquer,
 usando a frase:
 "O livro [NOME_DO_LIVRO] tem [X] páginas!"
 */
-// ?
+var nome="";
+console.log("O livro "+ nome + " tem "+ book(nomeLivro).quantidadePagina + " paginas!");
+/*function retornar (nomeLivro){
+  var livro= book(nomeLivro);
+  if(livro){
+    return "O livro "+  nomeLivro+" tem "+ livro.quantidadePaginas +" páginas!";
+  } else{
+    return "nome invalido"}
+*/}
 
 /*
 Ainda com a função acima, imprima o nome do autor de um livro qualquer, usando
 a frase:
 "O autor do livro [NOME_DO_LIVRO] é [AUTOR]."
 */
-// ?
+
+console.log("O livro "+ nome + " e "+ book(nomeLivro).autor + ".");
 
 /*
 Ainda com a função acima, imprima o nome da editora de um livro qualquer, usando
 a frase:
 "O livro [NOME_DO_LIVRO] foi publicado pela editora [NOME_DA_EDITORA]."
 */
-// ?
+console.log(("O livro "+ nome + " foi publicado pela editora " book(nomeLivro).editora + " .");
diff --git a/challenge-06/challenge-06.js b/challenge-06/challenge-06.js
index a689ed84d4..a94f694994 100644
--- a/challenge-06/challenge-06.js
+++ b/challenge-06/challenge-06.js
@@ -4,7 +4,8 @@ para começar o desafio.
 Declare uma variável chamada `championship` que receberá o nome do campeonato,
 e imprima o nome desse campeonato no console.
 */
-// ?
+var championship = 'Campeonato Carioca';
+console.log(championship);
 
 /*
 Declare uma variável chamada `teams`, que receberá um array com 5 elementos.
@@ -12,7 +13,7 @@ Os elementos serão nomes de times do campeonato escolhido, e os nomes devem
 estar na ordem em que eles aparecem na tabela no momento da solução desse
 desafio.
 */
-// ?
+var teams=['Flamengo','Fluminense','Vasco','Botafogo','Bangu'];
 
 console.log( 'Times que estão participando do campeonato:', teams );
 
@@ -32,19 +33,54 @@ Crie uma função chamada `showTeamPosition` com as seguintes características:
     - Se não houver time para a posição passada, deve retornar a mensagem:
     "Não temos a informação do time que está nessa posição."
 */
-// ?
-
+function showTeamPosition(a){
+  /*var posicao=a;
+  switch(posicao){
+    case 1:{
+      posicao=0;
+      break;
+    }
+      case 2:{
+      posicao=1;
+      break;
+    }
+      case 3:{
+      posicao=2;
+      break;
+    }
+      case 4:{
+      posicao=3;
+      break;
+    }
+      case 5:{
+      posicao=4;
+      break;
+    }
+  }*/
+  if(posicao<1 || posicao>5 ){
+      console.log('Não temos a informação do time que está nessa posição.');
+  } 
+  console.log('O time que está em '+ a +'º lugar é o '+ teams[a-1] +' .');
+   
+}
 /*
 Escolha 4 times do campeonato selecionado e mostre a posição dele, usando a
 função acima. Entre esses 4, adicione 1 que não esteja entre os 5 primeiros.
 */
-// ?
+showTeamPosition(1); // O time que está em 1º lugar é o lider tens .
+showTeamPosition(2); // O time que está em 2º lugar é o theobroma .
+showTeamPosition(3); // O time que está em 3º lugar é o rufus .
+showTeamPosition(6); // Não temos a informação do time que está nessa posição.
+
 
 /*
 Mostre os números de 20 a 30 no console (inclusive o 30), usando a estrutura de
 repetição "while".
 */
-// ?
+var cont=20;
+while(cont<=30){
+  console.log (cont++);
+}
 
 /*
 Crie uma função chamada `convertToHex`, com as seguintes características:
@@ -58,9 +94,48 @@ Crie uma função chamada `convertToHex`, com as seguintes características:
     a frase:
     "Não temos o equivalente hexadecimal para [COR]."
 */
-// ?
+function convertToHex(cor){
+  switch(cor){
+    case  'rosa':{ 
+      var hex=' #FFC0CB';
+      break;
+    }
+      
+      case  'azul':{ 
+        var hex='#0000FF';
+        break;
+      }
+      
+      case 'amarelo':{
+        var hex='#FFFF00';
+        break;
+      }
+      
+      case  'roxo':{
+        var hex='#800080';
+        break;
+      }
+      
+      case 'verde':{
+        var hex='#008000';
+        break;
+      }
+      
+    default:{
+      return ('Não temos o equivalente hexadecimal para '+ cor +'.');
+    }
+  }
+        return ('O hexadecimal para a cor '+ cor +' é '+ hex +'.');
+}
 
 /*
 Tente mostrar o hexadecimal de 8 cores diferentes usando a função criada acima.
 */
-// ?
\ No newline at end of file
+conolose.log(convertToHex('rosa')); //VM170:5 O hexadecimal para a cor rosa é  #FFC0CB.
+console.log(convertToHex('preto')); //VM170:34 Não temos o equivalente hexadecimal para preto.
+console.log(convertToHex('verde')); //VM170:29 O hexadecimal para a cor verde é #008000.
+console.log(convertToHex('marrom')); //VM170:34 Não temos o equivalente hexadecimal para marrom.
+console.log(convertToHex('dourado')); //VM170:34 Não temos o equivalente hexadecimal para dourado.
+console.log(convertToHex('amarelo')); //VM170:17 O hexadecimal para a cor amarelo é #FFFF00.
+console.log(convertToHex('roxo')); //VM170:23 O hexadecimal para a cor roxo é #800080.
+console.log(convertToHex('azul')); //VM170:11 O hexadecimal para a cor azul é #0000FF.
diff --git a/challenge-07/challenge-07.js b/challenge-07/challenge-07.js
index f9769d008d..e4de957600 100644
--- a/challenge-07/challenge-07.js
+++ b/challenge-07/challenge-07.js
@@ -1,60 +1,105 @@
 /*
 Crie um array com 5 items (tipos variados).
 */
-// ?
+var arr=[true, 'valeria', 22, ['valeria', 'Vaz', true], nomeCompleto()];
 
 /*
 Crie uma função chamada `addItem`, que irá adicionar itens no array criado.
 A função deverá retornar o array atualizado.
 */
-// ?
+function addItem(a){
+arr.push(a);
+  return arr;
+}
 
 /*
 Adicione um novo array ao array criado no início do desafio, com ao menos 3
 itens de tipos diferentes, mostrando o resultado no console.
 */
-// ?
+addItem(['Theobroma', 16,true]);
+/*0 : true
+1 : "valeria"
+2 : 22
+3: (3) ['valeria', 'Vaz', true]
+4: ƒ nomeCompleto()
+5: (3) ['Theobroma', 16, true]*/
 
 /*
 Mostre no console o segundo elemento desse último array, criado acima, com a
 frase:
 "O segundo elemento do segundo array é [ELEMENTO]."
 */
-// ?
+console.log('O segundo elemento do segundo array é '+ arr[5][1] +'.');
+// O segundo elemento do segundo array é 16.
 
 /*
 Mostre no console quantos itens tem o primeiro array criado, com a frase:
 "O primeiro array tem [QUANTIDADE DE ITENS] itens."
 */
-// ?
+console.log('O primeiro array tem '+ arr.length +' itens.');
+// O primeiro array tem 6 itens.
+
+
 
 /*
 Agora mostre no console quantos itens tem o segundo array criado, com a frase:
 "O segundo array tem [QUANTIDADE DE ITENS] itens."
 */
-// ?
+console.log('O primeiro array tem '+ arr[5].length +' itens.');
+// O primeiro array tem 3 itens.
 
 /*
 Utilizando a estrutura de repetição `while`, mostre no console todos os números
 pares entre 10 e 20, inclusive esses 2.
 */
-console.log( 'Números pares entre 10 e 20:' );
+var start=10;
+while(start <=20){
+  if(start % 2 === 0){
+    console.log( 'Números pares entre 10 e 20: '+ start );
+  }
+  start++;
+}
+Números ímpares entre 10 e 20: 11
+ Números ímpares entre 10 e 20:13
+ Números ímpares entre 10 e 20:15
+ Números ímpares entre 10 e 20:17
+ Números ímpares entre 10 e 20:19
+
 // ?
 
 /*
 Na mesma ideia do exercício acima: mostre agora os números ímpares.
 */
-console.log( 'Números ímpares entre 10 e 20:' );
+var start=10;
+while(start <=20){
+  if(start % 2 === 1){
+    console.log( 'Números ímpares entre 10 e 20:'+ start );
+    start++;
+  }
+}
+ /*Números ímpares entre 10 e 20: 11
+ Números ímpares entre 10 e 20:13
+ Números ímpares entre 10 e 20:15
+ Números ímpares entre 10 e 20:17
+ Números ímpares entre 10 e 20:19*/
 // ?
-
+var start=10;
+while(start <20){
+  start % 2 !== 0? console.log( 'Números ímpares entre 10 e 20:'+ start ):' ';
 /*
 Repita os mesmos exercícios feitos acima, mas agora usando o loop "for".
 Só vamos mudar o range:
 - No primeiro "for", mostre os números pares entre 100 e 120, inclusive eles;
 - No segundo "for", mostre os números ímpares entre 111 e 125, inclusive eles.
 */
-console.log( 'Números pares entre 100 e 120:' );
-// ?
+for(var i=100; i<=120; i++){
+  if(i % 2 === 0){
+     console.log( 'Números pares entre 100 e 120:'+ i );
+  }
+}
 
-console.log( 'Números ímpares entre 111 e 125:' );
-// ?
\ No newline at end of file
+for(var i=111; i<=125; i++){
+  if(i % 2 === 1){
+     console.log( 'Números ímpares entre 111 e 125:'+ i );
+  }
+}
diff --git a/challenge-08/challenge-08.js b/challenge-08/challenge-08.js
index 4a451d0da0..e37d342026 100644
--- a/challenge-08/challenge-08.js
+++ b/challenge-08/challenge-08.js
@@ -3,38 +3,46 @@ Declare uma variável chamada `sum` e atribua a ela uma função chamada
 `calculateSum`. A função deve receber dois parâmetros e retornar a soma
 desses parâmetros.
 */
-// ?
+var sum= function calculateSum(x,y){
+  return x+y;
+}
 
 /*
 Invoque a função criada acima, passando dois números que serão somados, e mostre
 o resultado no console, com a frase:
 "A soma de [VALOR 1] e [VALOR2] é igual a [RESULTADO]."
 */
-// ?
+var valor1=3;
+var valor2=2;
+console.log('A soma de'+ valor1 +'e'+ valor2 +'é igual a'+ sum(valor1,valor2) +'.');
 
 /*
 Mostre no console o nome da função criada acima, com a frase:
 "O nome da função que faz a soma é [NOME DA FUNÇÃO]."
 */
-// ?
+console.log('O nome da função que faz a soma é'+ sum.name +'.')
+sum.name; //'calculateSum'
 
 /*
 Crie uma função literal chamada `showName`. Essa função deve retornar o
 seu nome.
 */
-// ?
+function showName(){
+  return 'Valeria';
+}
 
 /*
 Declare uma variável chamada `varShowName` que recebe a função criada acima.
 */
-// ?
+var varShowName= showName;
 
 /*
 Usando a variável criada acima, mostre no console o nome e o retorno da função
 atribuída a ela, com a seguinte frase:
 "A função [NOME DA FUNÇÃO] retorna [RETORNO DA FUNÇÃO]."
 */
-// ?
+console.log('A função'+ varShowName.name +'retorna'+ varShowName() +'.')
+
 
 /*
 Crie uma função literal chamada `calculator`, que funcione assim:
@@ -48,28 +56,48 @@ vai efetuar. Será uma string com os valores `+`, `-`, `*`, `/` ou `%`;
   - Se o operador não for válido, retornar a frase:
   "Operação inválida."
 */
-// ?
-
+function calculator(operador){
+    return function (num1,num2){
+      var resultado;
+        switch(operador){
+          case '*': {resultado= num1 * num2; break;}
+             case '+':  {resultado= num1 + num2; break;}
+             case '-':  {resultado= num1 - num2; break;}
+             case '/':  {resultado= num1 / num2; break; }
+            case '%':  {resultado= num1 % num2; break;}
+          default: 'Operação inválida';
+        }
+console.log('Resultado da operação: '+ num1 + operador + num2 +'='+ resultado +'.');
+    }
+calculator('-')(5,2) //Resultado da operação: 5-2=3.
 /*
 Declare uma variável chamada `sum`, que receberá a função acima, passando como
 parâmetro o operador de soma.
 */
-// ?
+var sum=calculator('+');
 
 /*
 Agora `sum` é uma função. Mostre no console a soma de dois números, usando ela.
 */
-// ?
+console.log(sum(5,2));// Resultado da operação: 5+2=7.
+
 
 /*
 Agora, declare algumas variáveis com os nomes `subtraction`, `multiplication`,
 `division` e `mod`, e atribua a elas a função `calculator`, passando o operador
 correto por parâmetro para cada uma delas.
 */
-// ?
+var subtraction=calculator('-');
+var multiplication=calculator('*');
+var division = calculator('/');
+var mod = calculator('%');
+
 
 /*
 Faça uma operação com cada uma das funções criadas acima, mostrando o resultado
 no console.
 */
-// ?
\ No newline at end of file
+console.log(subtraction(5,2)); // Resultado da operação: 5-2=3.
+onsole.log(multiplication(5,2)); // Resultado da operação: 5*2=10.
+console.log(mod(5,2)); //Resultado da operação: 5%2=1.
+console.log(division(5,2)); //Resultado da operação: 5/2=2.5.
diff --git a/challenge-09/challenge-09.js b/challenge-09/challenge-09.js
index f248dc1f86..7f9aa2fdd6 100644
--- a/challenge-09/challenge-09.js
+++ b/challenge-09/challenge-09.js
@@ -1,107 +1,137 @@
-/*
-Crie uma IIFE que envolva todo o código desse arquivo. Faça também a
-indentação correta do código, para ficar dentro da IIFE.
-*/
-
-/*
-Analise as funções abaixo (`myFunction`, `myFunction2` e `myFunction3`, e
-ajuste o posicionamento das variáveis e funções internas, para que os códigos
-dentro de `console.log` que estão retornando `undefined` retornem o valor
-correto da variável ou função chamada.
-*/
-function myFunction() {
-    console.log( 'Na função `myFunction`, o primeiro número é', number1 );
-    console.log( 'Na função `myFunction`, o segundo número é', number2 );
+(function(){/*
+  Crie uma IIFE que envolva todo o código desse arquivo. Faça também a
+  indentação correta do código, para ficar dentro da IIFE.
+  */
+  
+  /*
+  Analise as funções abaixo (`myFunction`, `myFunction2` e `myFunction3`, e
+  ajuste o posicionamento das variáveis e funções internas, para que os códigos
+  dentro de `console.log` que estão retornando `undefined` retornem o valor
+  correto da variável ou função chamada.
+  */
+  function myFunction() {
     var number1 = 10;
-    return number1 + number2;
     var number2 = 20;
-}
-myFunction();
-
-/*
-    myFunction2();
-*/
-function myFunction2() {
-    console.log( 'A soma de 10 e 20 é igual a', sum ? sum() : undefined );
-    var sum = function sum() {
-        return number1 + number2;
-    };
-    var number1 = 10;
-    var number2 = 20;
-    return sum();
-}
-myFunction2();
-
-/*
-    myFunction3();
-*/
-function myFunction3() {
-    console.log( 'A soma de 40 e 50 é igual a', sum() );
-    var number2 = 50;
-    console.log( 'Na função myFunction3, number1 é igual a', number1 );
-    var number1 = 40;
-    return sum();
+      console.log( 'Na função `myFunction`, o primeiro número é', number1 );
+      console.log( 'Na função `myFunction`, o segundo número é', number2 );
+      
+      return number1 + number2;
+      
+  }
+  myFunction();
+  
+  /*
+      myFunction2();
+  */
+  function myFunction2() {
+     var number1 = 10;
+      var number2 = 20;
+      var sum = function sum() {
+          return number1 + number2;
+      };
+     console.log( 'A soma de 10 e 20 é igual a', sum ? sum() : undefined );
+      return sum();
+  }
+  myFunction2();
+  
+  /*
+      myFunction3();
+  */
+  function myFunction3() {
+     var number1 = 40;
+     var number2 = 50;
     function sum() {
-        return number1 + number2;
-    };
-}
-myFunction3();
+          return number1 + number2;
+      };
+    
+      console.log( 'A soma de 40 e 50 é igual a', sum() );
+      console.log( 'Na função myFunction3, number1 é igual a', number1 );
+       return sum();
+      
+  }
+  myFunction3();
+  
+  /*
+  No desafio anterior criamos uma calculadora, usando uma estrutura funcional.
+  Agora vamos criar uma outra calculadora, usando uma outra abordagem :D
+  - Crie uma função `calculator` que recebe dois valores (números)
+  por parâmetro.
+  - Essa função deve retornar uma outra função, que recebe um parâmetro
+  chamado `callback`.
+  - Esse `callback` será uma função, que passaremos por parâmetro ao invocar
+  o retorno de `calculator`.
+  - O retorno dessa segunda função deve ser a função de `callback` passada
+  por parâmetro, INVOCADA, e passando a ela por parâmetro os dois valores
+  que foram passadas para a primeira função `calculator`.
+  */
 
-/*
-No desafio anterior criamos uma calculadora, usando uma estrutura funcional.
-Agora vamos criar uma outra calculadora, usando uma outra abordagem :D
-- Crie uma função `calculator` que recebe dois valores (números)
-por parâmetro.
-- Essa função deve retornar uma outra função, que recebe um parâmetro
-chamado `callback`.
-- Esse `callback` será uma função, que passaremos por parâmetro ao invocar
-o retorno de `calculator`.
-- O retorno dessa segunda função deve ser a função de `callback` passada
-por parâmetro, INVOCADA, e passando a ela por parâmetro os dois valores
-que foram passadas para a primeira função `calculator`.
-*/
-// ?
-
-/*
-Declare uma variável chamada `sum`, e atribua a ela a função `calculator`,
-passando dois números por parâmetro.
-*/
-// ?
-
-/*
-Sabemos que `sum` agora tem uma função atribuída a ela, que é o retorno de
-`calculator`. E essa função espera um parâmetro `callback`. O `callback`
-tem dois parãmetros disponíveis, que são os números que você acabou de passar
-para a chamada à `calculator` acima.
-- Mostre no console o retorno da invocação de `sum`, passando por parâmetro
-uma função anônima que irá retornar a soma dos dois números que essa função
-anônima tem como seus argumentos.
-*/
-console.log( 'O resultado da soma é:' );
-// ?
-
-/*
-Agora declare outra variáveis chamadas `subtraction`, `multiplication`,
-`division` e `mod`, e atribua à elas `calculator`, passando números
-diferentes para cada chamada.
-*/
-// ?
-
-/*
-Mostre as variáveis acima no `console` (uma chamada de console por variável),
-criando a função de `callback` que faz o cálculo para subração, multiplicação,
-divisão e módulo (resto de divisão), conforme a função utilizada.
-As suas respostas devem estar abaixo dos `console.log` referentes à cada
-chamada.
-*/
-console.log( 'O resultado da subtração é:' );
-// ?
-
-console.log( 'O resultado da multiplicação é:' );
-// ?
+  function calculator (x,y){
+    return function (callback){
+      return callback(x,y);
+    };
+  }
+  
+  /*
+  Declare uma variável chamada `sum`, e atribua a ela a função `calculator`,
+  passando dois números por parâmetro.
+  */
+  var sum=calculator(10,20);
+  
+  /*
+  Sabemos que `sum` agora tem uma função atribuída a ela, que é o retorno de
+  `calculator`. E essa função espera um parâmetro `callback`. O `callback`
+  tem dois parãmetros disponíveis, que são os números que você acabou de passar
+  para a chamada à `calculator` acima.
+  - Mostre no console o retorno da invocação de `sum`, passando por parâmetro
+  uma função anônima que irá retornar a soma dos dois números que essa função
+  anônima tem como seus argumentos.
+  */
+   
+  
+  console.log( 'O resultado da soma é:'  );
+  console.log(sum(function(x,y){
+    return x+y;
+  }));
+  
+  console.log(callback(subtraction(x,y){
+     return x-y;    
+  }));
+  
+  /*
+  Agora declare outra variáveis chamadas `subtraction`, `multiplication`,
+  `division` e `mod`, e atribua à elas `calculator`, passando números
+  diferentes para cada chamada.
+  */
+  var subtraction= calculator(5,3);
+  var multiplication= calculator(5,4);
+  var division= calculator(10,2);
+  var mod= calculator(6,4);
 
-console.log( 'O resultado da divisão é:' );
-// ?
+  /*
+  Mostre as variáveis acima no `console` (uma chamada de console por variável),
+  criando a função de `callback` que faz o cálculo para subração, multiplicação,
+  divisão e módulo (resto de divisão), conforme a função utilizada.
+  As suas respostas devem estar abaixo dos `console.log` referentes à cada
+  chamada.
+  */
+ 
+  console.log( 'O resultado da subtração é:' );
+   console.log(subtraction(function(x,y){
+    return x-y;
+  }));
 
-console.log( 'O resto da divisão é:' );
-// ?
\ No newline at end of file
+  console.log( 'O resultado da multiplicação é:' );
+  console.log(multiplication(function(x,y){
+    return x*y;
+  }));
+  
+  console.log( 'O resultado da divisão é:' );
+  console.log(division(function(x,y){
+    return x/y;
+  }));
+  
+  console.log( 'O resto da divisão é:' );
+console.log(mod(function(x,y){
+    return x%y;
+  }));
+}());
diff --git a/challenge-10/challenge-10.js b/challenge-10/challenge-10.js
index d4b58e21eb..fa738e86d3 100644
--- a/challenge-10/challenge-10.js
+++ b/challenge-10/challenge-10.js
@@ -1,4 +1,5 @@
-/*
+(function(){
+  /*
 Crie uma IIFE que envolva todo esse arquivo (inclusive esse comentário),
 e faça a indentação correta.
 */
@@ -9,10 +10,10 @@ deles seja "true", usando os Wrapper Objects como "conversores" nos valores
 das variáveis. Analise o que está sendo impresso no console para saber como
 resolver o problema corretamente.
 */
-var five = '5';
+var five = Number('5');
 console.log( five + ' é número?', typeof five === 'number' );
 
-var concat = 10 + 10;
+var concat = String (10) + 10;
 console.log( '"' + concat + '" é uma string? E é igual a "1010"?', typeof concat === 'string' );
 
 /*
@@ -24,7 +25,24 @@ funcional, mas dessa vez, separando algumas responsabilidades.
 função receberá dois parâmetros e retornará a operação referente à sua
 propriedade, usando os valores passados por parâmetro.
 */
-// ?
+var operation=
+{
+  '+': function(number1, number2){
+    return number1+number2;
+  },
+  '-': function(number1, number2){
+    return number1-number2;
+  },
+  '*': function(number1, number2){
+    return number1*number2;
+  },
+  '/': function(number1, number2){
+    return number1/number2;
+  },
+  '%': function(number1, number2){
+    return number1%number2;
+  }
+}
 
 /*
 Crie uma função chamada `isOperatorValid`, que receberá um operador por
@@ -36,7 +54,11 @@ parâmetro a ela é válido, ou seja, se ele é igual a '+', '-', '*', '/' ou
 Caso contrário, "false".
 - O desafio é fazer o retorno sem usar "if" ou "switch".
 */
-// ?
+function isOperatorValid(operator){
+  return !!operation[operator];
+  }
+  //return (operator===operation|| operator===operation|| operator===operation||operator===operation||operator===operation);
+
 
 /*
 Agora vamos criar a calculadora.
@@ -50,7 +72,19 @@ parâmetros;
 operador passado para a função "calculator", e passando para esse método
 os dois parâmetros da função de retorno de "calculator".
 */
-// ?
+function calculator(operator){
+  if(!isOperatorValid(operator)){
+    return false;
+  }
+    
+    return function(number1, number2){
+      if(typeof number1 !== 'number' || typeof number2 !== 'number'){
+        return false;
+      }
+      return operation[operator](number1, number2);
+    }
+ 
+};
 
 /*
 Crie uma função chamada "showOperationMessage" que recebe três parâmetros:
@@ -59,7 +93,9 @@ deve ser a frase:
 'A operação [NUMBER1] [OPERATOR] [NUMBER2] =';
 Essa função mostrará a mensagem da operação que criaremos mais abaixo.
 */
-// ?
+function showOperationMessage(number1, operator, number2){
+  console.log('A operação'+  number1 + operator +  number2 + '=');
+}
 
 /*
 Crie uma função chamada "showErrorMessage" que recebe um parâmetro: o
@@ -67,7 +103,10 @@ operador da operação cálculo, quando a operação não for válida.
 Essa função deverá retornar a frase:
 'Operação "[OPERATOR]" não permitida!'
 */
-// ?
+function showErrorMessage(operator) {
+    return 'Operação ' + operator + ' não permitida!';
+    }
+  }
 
 /*
 Nossa calculadora está pronta! Agora vamos testá-la:
@@ -75,7 +114,10 @@ PASSO 1:
 - Declare 3 variáveis: "number1" e "number2", iniciando com valor zero, e
 "operationSignal", sem valor por enquanto.
 */
-// ?
+var number1=0;
+var number2=0;
+var operationSignal;
+
 
 /*
 PASSO 2:
@@ -83,7 +125,9 @@ Atribua à variável operationSignal o operador de soma, e declare uma
 variável chamada "sum", que receba a função "calculator", passando por
 parâmetro a variável que recebeu o sinal da operação.
 */
-// ?
+operationSignal='+';
+var sum= calculator(operationSignal);
+
 
 /*
 PASSO 3:
@@ -97,17 +141,74 @@ parâmetros para o método "log" de "console":
 - O segundo, a função de soma, passando os dois operandos.
 - Se "sum" for "false", mostrar no console a mensagem de erro.
 */
-// ?
+if(sum){
+  number1=10;
+  number2=20;
+  console.log(showOperationMessage (operationSignal, number1, number2), sum(number1, number2) );
+}
+else{
+  console.log(showErrorMessage(operationSignal));
+}
 
 /*
 Repita desde o "PASSO 2" com as operações de subtração, multiplicação,
 divisão e resto. Crie variáveis com os nomes "subtraction",
 "multiplication", "division" e "mod".
 */
-// ?
+
+operationSignal='-';
+var subtraction= calculator(operationSignal);
+if(subtraction){
+  number1=10;
+  number2=20;
+  console.log(showOperationMessage (operationSignal, number1, number2), subtraction(number1, number2) );
+}
+else{
+  console.log(showErrorMessage(operationSignal));
+}
+operationSignal='*';
+var multiplication= calculator(operationSignal);
+if(multiplication){
+  number1=10;
+  number2=20;
+  console.log(showOperationMessage (operationSignal, number1, number2), multiplication(number1, number2) );
+}
+else{
+  console.log(showErrorMessage(operationSignal));
+}
+operationSignal='/';
+var division= calculator(operationSignal);
+if(division){
+  number1=10;
+  number2=20;
+  console.log(showOperationMessage (operationSignal, number1, number2), division(number1, number2) );
+}
+else{
+  console.log(showErrorMessage(operationSignal));
+}
+operationSignal='%';
+var mod= calculator(operationSignal);
+if(mod){
+  number1=10;
+  number2=20;
+  console.log(showOperationMessage (operationSignal, number1, number2), mod(number1, number2) );
+}
+else{
+  console.log(showErrorMessage(operationSignal));
+}
 
 /*
 Repita o PASSO 2 novamente, mas passando um operador inválido, para ver se
 a mensagem de erro será mostrada no console.
 */
-// ?
\ No newline at end of file
+operationSignal=':';
+var division = calculator(operationSignal);
+if(mod){
+  number1=10;
+  number2=20;
+  console.log(showOperationMessage (operationSignal, number1, number2), division(number1, number2) );
+}
+else{
+  console.log(showErrorMessage(operationSignal));
+}
+ })();
diff --git a/challenge-11/challenge-11.js b/challenge-11/challenge-11.js
index ce533c6d30..b6e63692d5 100644
--- a/challenge-11/challenge-11.js
+++ b/challenge-11/challenge-11.js
@@ -1,3 +1,4 @@
+(funtion(){
 // Envolva todo o código desse arquivo em uma IIFE (incluindo esse comentário).
 
 /*
@@ -7,14 +8,23 @@ loop, mostre no console a mensagem:
 'Entrou ao menos uma vez!'
 Qual loop você deve usar para que essa mensagem seja mostrada no console?
 */
-// ?
+var once = false;
+  
+do{
+  console.log('Entrou ao menos uma vez!');
+} while(once===true);
 
 /*
 Crie um objeto chamado `person`, que receba as seguintes propriedades:
 - 'name', 'age', 'weight' e 'birthday'. Preencha com os valores corretos
 para o nome, idade, peso e data de nascimento dessa pessoa.
 */
-// ?
+var person={
+  name:'Valeria',
+  age:22,
+  weight:51,
+  birthday: '25/04/2002'
+}
 
 /*
 Use um loop para percorrer o objeto criado acima, mostrando no console
@@ -25,7 +35,13 @@ esse objeto tem.
 Após o loop, mostre a frase:
 'The person has [COUNTER] properties'
 */
-// ?
+var counter=0;
+for(var prop in person){
+  console.log('The '+ prop +' of person is '+ person[prop]);
+  counter++;
+  }
+   console.log('The person has '+ counter +' properties');
+}
 
 /*
 Crie uma função chamada `moreThan`, que vai verificar se a pessoa (objeto
@@ -34,15 +50,26 @@ Se verdadeiro, retornar `true`. Senão, retornar false.
 Após a função, mostrar a mensagem no console:
 'The person has more than 25 years old? [TRUE/FALSE]'
 */
-// ?
+function moreThan(idade){
+  var idadePessoa=;
+  return person.age > idade?;
+}
+ console.log('The person has more than 25 years old? ', moreThan(idade) );
 
 /*
 Faça um loop de 0 a 20, que adicione cada número como um item de um
 array chamado `numbers`. Se o contador for maior que 10, saia do loop.
 Mostre no console os números no array.
 */
-console.log( 'De 0 a 10:' );
-// ?
+  var numbers=[];
+ for(var i=0; i<=20; i++){
+ 
+    if(i>10){
+        break;
+    }
+    numbers.push(i);
+}
+console.log( 'De 0 a 10:', numbers );
 
 /*
 Faça outro loop de 0 a 20, que adicione a um array chamado `numbers` (já
@@ -50,5 +77,18 @@ criado acima, só precisa ser reiniciado) números de 0 a 20, inclusive
 esses. Se o número for ímpar, pular para o próximo número.
 Mostrar no console os números do array.
 */
-console.log( 'Pares de 0 a 20:' );
+var numbers=[];
+ for(var i=0; i<=20; i++){
+    if(i % 2  === 0){
+         numbers.push(i);
+      
+    }
+   else{
+     continue;
+   }
+    console.log( 'Pares de 0 a 20:', numbers );
+    
+ }
+
 // ?
+})();