Exercícios de Mumuki

Curso de Introdução à Programação
Capítulo 1: Fundamentos.
1. Primeiros Programas.
Exercício 5: Siga o movimento.
A sintaxe de um programa é bastante simples:
1. Escrevemos uma linha (linha) que diz programa, seguida de um bracre de abertura:
{
2. Em seguida, os comandos: um por linha
3. E, finalmente, uma última chave que fecha a que abrimos anteriormente }
Responder:
programa {
Move (Norte)
Move (Norte)
Move (Norte)
}
Exercício 6: Em todos os lugares.
Responder:
programa {
Move (Sul)
Move (Leste)
Move (Leste)
}
Exercício 7: A ordem das coisas.
Humanos, costumamos pensar em termos do resultado final, ou seja, destacamos o objetivo

do programa. Nós nos preocupamos mais com o que ele faz, não como. Esse caminho
denotacional nos levaria a dizer que, simplesmente, ele move a cabeça para o nordeste.
É por isso que existem várias maneiras de resolver o mesmo problema: podemos criar
vários programas que fazem a mesma coisa (o quê), mas fazem de forma diferente (o
como).
Responder:
programa {
Move (Leste)
Move (Norte)
}
Exercício 8: Sim, isso também pode ser quebrado.
Embora nunca queiramos que nosso programa quebre, é algo que definitivamente vai
acontecer com você muitas vezes. Mas não é motivo para se frustrar, muito menos,
garantimos que aconteceu com todo mundo em algum momento (bem, também 2, 3, 100,
800 vezes...).
Responder:
programa{
Move (Sul)
}
Exercício 9: Nossas primeiras bolas.
Além de se mover, a cabeça também pode colocar pelotas na célula atual. Para isso temos a
operação Put, que manda a cabeça depositar uma bola da cor dada:
Responder:
programa{
Put(Vermelho)
}
Exercício 10: Mais e mais bolas.
Responder:
programa {
Put(Vermelho)
Put(Vermelho)
Put(Azul)
Put(Verde)
Put(Vermelho)
}
Exercício 11: Coloque suas primeiras bolas.
Como você deve ter notado, essas placas são um pouco mágicas, podemos colocar em uma
cela quantas bolas quisermos: 2, 4, 12, 50, 1000. Não há limite!
Isso é algo muito interessante que acontece na hora de programar: podemos trabalhar com
quantidades tão grandes quanto quisermos.
Responder:
programa{
Put(Vermelho)
Put(Vermelho)
Put(Vermelho)
Put(Vermelho)
Put(Preto)
Put(Preto)
Put(Preto)
}
Exercício 12: Tire bolas.
Da mesma forma que existe uma "bola posta" (Poner), temos uma "bolita sacar" (Sacar),
que remove exatamente uma bola da cor dada.
Responder:
programa {
Move (Sul)
Tirar (vermelho)
}
Exercício 13: Quando não há bolas.
Responder:
programa{
Tirar (Verde)
}
Exercício 14: Limpar a célula.
Responder:
programa{
Takeout (Azul)
Tirar (Verde)
Puxar (preto)
Tirar (vermelho)
}
2. Pratique os primeiros programas.
Exercício 1: Aquecimento dos motores.
O programa seguinte coloca uma bola vermelha na posição inicial e uma bola preta na
posição leste.
Responder:
programa {
Put(Vermelho)
Move (Leste)
Put(Preto)
}
Exercício 2: Combinando comandos.
Crie um programa que coloque duas bolas na posição inicial e outras duas na célula ao lado
do Leste. Todos os pellets devem ser vermelhos.
Responder:
programa{
Put(Vermelho)
Put(Vermelho)
Move (Leste)
Put(Vermelho)
Put(Vermelho)
}
Exercício 3: A linha vermelha.
Crie um programa que, a partir de um quadro vazio com a cabeça na origem, desenhe uma
linha de quatro células para o Leste. As bolas devem ser vermelhas e você deve colocar uma
bola por célula.
Responder:
programa{
Put(Vermelho)
Move (Leste)
Put(Vermelho)
Move (Leste)
Put(Vermelho)
Move (Leste)
Put(Vermelho)
}
Exercício 4: Uma pequena escada.
Usando as ferramentas que você já conhece, crie um programa que desenhe uma escada
azul como a vista na imagem. A cabeça começa na origem (isto é, na borda sudoeste) e deve
estar na extremidade inferior direita da escada.
Responder:
programa{
Put(Azul)
Move (Norte)
Put(Azul)
Move (Norte)
Put(Azul)
Move (Sul)
Move (Leste)
Put(Azul)
Move (Sul)
Put(Azul)
Move (Leste)
Put(Azul)
}
Exercício 5: Portugal.
Como não vamos ficar tão agitados, vamos pedir-lhe uma versão simplificada da bandeira
de Portugal.
Responder:
programa{
Put(Verde)
Move (Norte)
Put(Verde)
Move (Leste)
Put(Vermelho)
Move (Sul)
Put(Vermelho)
Move (Leste)
Put(Vermelho)
Move (Norte)
Put(Vermelho)
}
Exercício 6: E agora um mais próximo.
Responder:
programa{
Put(Azul)
Move (Leste)
Put(Azul)
Move (Leste)
Put(Azul)
Move (Leste)
Put(Azul)
Move (Leste)
Put(Azul)
Move (Norte)
Move (Norte)
Put(Azul)
Move (Oeste)
Put(Azul)
Move (Oeste)
Put(Azul)
Move (Sul)
Put(Vermelho)
Move (Norte)
Move (Oeste)
Put(Azul)
Move (Oeste)
Put(Azul)
Move (Sul)
Move (Sul)
}
Exercício 7: Limpeza do jardim.
Com a cabeça na fonte, crie um programa que seja responsável por "podar" o tabuleiro da
imagem: remova todas as bolinhas verdes. Após a conclusão, a cabeça deve terminar onde
começou.
Responder:
programa{
Tirar (Verde)
Move (Leste)
Tirar (Verde)
Move (Leste)
Tirar (Verde)
Move (Norte)
Tirar (Verde)
Move (Norte)
Tirar (Verde)
Move (Oeste)
Tirar (Verde)
Move (Oeste)
Tirar (Verde)
Move (Sul)
Tirar (Verde)
Move (Sul)
}
Exercício 8: Substitua os pellets.
Vamos passar para algo um pouco mais difícil então. Vamos dar-lhe um tabuleiro 2x2 (ou
seja, com 4 células) onde cada um deles tem uma bola vermelha.
Sua tarefa é criar um programa que substitua todas as bolas vermelhas por bolas verdes.
Responder:
programa{
Tirar (vermelho)
Put(Verde)
Move (Leste)
Tirar (vermelho)
Put(Verde)
Move (Norte)
Tirar (vermelho)
Put(Verde)
Move (Oeste)
Tirar (vermelho)
Put(Verde)
Move (Sul)
}
3. Procedimentos.
Exercício 1: Do que se trata?
Você deve tentar descobrir o que o programa faz.
Responder:
 Desenhar uma caixa de bolas pretas
Exercício 2: Um programa ligeiramente longo.
Agora você tem a possibilidade de ver o programa em ação.
Responder:
Continuar
Exercício 3: Coisas pelo nome.
Responder:
Continuar
Exercício 4: Tarefas de ensino para o computador.
Como você viu no exemplo quadrado, você pode começar a diferenciar dois tipos de
comandos dentro de um programa:
 aqueles que são definidos pela linguagem e nos servem para expressar operações
básicas, como Mover, Colocar e Levar. Chamaremos esses comandos primitivos, ou
simplesmente primitivos;
 e aqueles que definimos, que nos servem para expressar tarefas mais complexas.
Como o nome desta lição sugere, estes são os procedimentos.
Quando definimos um procedimento estamos "ensinando" o computador a realizar uma
nova tarefa, que não foi originalmente incluída na linguagem.
Preste atenção na sintaxe do exemplo para ver bem como definimos um procedimento e
como o invocamos em um programa.
Responder:
Copie, cole e envie o código
Exercício 5: Procedimentos em ação.
Complete o código para que, além de definir o procedimento PonerNegroyRojo, você o

invoque no programa.
Responder:
programa{
PonerNegroYRojo()
}
Exercício 6: Procedimentos de escrita.
Neste ponto já sabemos que para programar sempre temos que levar em conta a sintaxe e
que para definir novos procedimentos também temos regras:
 Começamos com o procedimento da palavra reservada;

 Escolhemos um nome que o descreva e escrevemos com letra maiúscula seguida de
parênteses ( );
 Incluímos as ações que queremos que ele faça em chaves { }.
E se quisermos usá-lo, temos que invocá-lo dentro do programa, escrevendo seu nome
como ele é e sem esquecer os parênteses ( ) Preste atenção na sintaxe!
Responder:
procedimento Poner3Greens() {
Put(Verde)
Put(Verde)
Put(Verde)
}
programa{
Poner3Green()
}
Exercício 7: Procedimento, eu o invoco!
Crie um programa que faça isso invocando o procedimento Poner3Verdes. Lembre-se que
já damos para você definido na seção Biblioteca, você não precisa escrevê-lo novamente!.
Responder:
programa{
Poner3Green()
Move (Leste)
Poner3Green()
}
Exercício 8: Uma definição, usos "infinitos".
Crie um programa que coloque 9 bolas vermelhas na célula atual invocando o procedimento
Red3Ball quantas vezes forem necessárias.
Responder:
programa{
Poner3Rojas()
Poner3Rojas()
Poner3Rojas()
}
Exercício 9: Procedimentos dentro dos outros.
Defini o procedimento Poner9Rojas que, usando Poner3Rojas, coloca nove bolas vermelhas
em uma cela. Uma vez definido, chame o novo procedimento em um programa.
Responder:
procedimento Poner9Rojas(){
Poner3Rojas()
Poner3Rojas()
Poner3Rojas()
}
programa{
Poner9Rojas()
}
Exercício 10: Desenhamos com imaginação.
Defini o procedimento DrawBlackTip e invocal dentro de um programa. A cabeça

começa na origem e deve terminar no canto inferior direito da ponta.
Responder:
procedimento DrawBlackTip(){
Put(Preto)
}
programa{
DrawBlackTip()
Move (Norte)
DrawBlackTip()
Move (Sul)
Move (Leste)
DrawBlackTip()
}
Exercício 11: De ponta a ponta.
Defini o procedimento DrawTwoTips e invocalo dentro de um programa. Lembre-se de

usar DrawBlackPoint.
Responder:
procedimento DrawTwoTips() {
DrawBlackTip()
Move (Norte)
Move (Norte)
Move (Leste)
DrawBlackTip()
}
programa{
DrawTwoTips()
}
Exercício 12: Vermelho na borda.
Responder:
procedimento RedEdge() {
IrAlBorde (Norte)
IrAlBorde (Oeste)
Put(Vermelho)
}
programa{
RedEdge()
}
Exercício 13: Decorar o tabuleiro.
Defini dois procedimentos: o procedimento Put Garland que coloca 3 bolas vermelhas e 3
bolas verdes em uma cela e o procedimento DecorateBoard que usa e coloca uma guirlanda
em cada canto superior. Chame DecorateBoard no programa. Note que não sabemos a
posição inicial onde a cabeça estará.
Responder:
procedimento PonerGuirland(){
Poner3Green()
Poner3Rojas()
}
procedimento DecorateBoard(){
IrAlBorde (Norte)
IrAlBorde (Oeste)
PutGarland()
IrAlBorde (Norte)
IrAlBorde (Leste)
PutGarland()
}
programa{
DecorateBoard()
}
Exercício 14: Cores, cores, cores.
Defini um procedimento ColorLineDraw que desenha uma linha multicolorida de quatro

células para o Leste e no final dela coloca a cabeça na célula inicial. Chame o novo
procedimento em um programa.
Responder:
procedimento Color(){
Put(Vermelho)
Put(Verde)
Put(Preto)
Put(Azul)
}
procedimento DrawColoredLine(){
Cor()
Move (Leste)
Cor()
Move (Leste)
Cor()
Move (Leste)
Cor()
IrAlBorde (Oeste)
}
programa{
DrawColorline()
}
Exercício 15: Quadrado de cores.

Defini um procedimento DrawColorfulSquare que desenha um quadrado de 4×4 células em
que cada célula tem uma bola de cada cor e invocal no programa. A cabeça deve estar na
célula inicial.
Responder:
procedimento DrawSquareColored(){
DrawColorline()
Move (Norte)
DrawColorline()
Move (Norte)
DrawColorline()
Move (Norte)
DrawColorline()
IrAlBorde (Sul)
}
programa{
DrawSquareColorful()
}
4. Repetição simples.
Exercício 1: MoveWest10.
Vamos aquecer: defini um procedimento MoveWest10 que move a cabeça 10 vezes para o
Oeste.
Responder:
procedimento MoverOeste10(){
Move (Oeste)
Move (Oeste)
Move (Oeste)
Move (Oeste)
Move (Oeste)
Move (Oeste)
Move (Oeste)
Move (Oeste)
Move (Oeste)
Move (Oeste)
}
Exercício 2: O computador repete para nós.
Quando é necessário repetir um comando (como Move, Put, DrawBlackLine, etc.) um certo
número de vezes, em vez de copiar e colar como temos feito até agora, podemos usar a
instrução repeat.
Responder:
Exercício 3: MoveWest5 usando repetir.
Defini um procedimento MoveWest5 que se move 5 vezes para o Ocidente.
Responder:
procedimento MoverOeste5(){
repeat(5){
Move (Oeste)
}
}
Exercício 4: Não é só repetir.
Defini o procedimento Poner3AlNoreste(), que coloca 3 bolas pretas na primeira célula a

nordeste da cabeça.
Responder:
procedimento Poner3AlNoreste(){
Move (Norte)
Move (Leste)
repetir(3){
Put(Preto)
}
}
Exercício 5: Também se aplica mais tarde.
Defini o procedimento PutBlueAway(), que coloca uma bola azul de 4 células para o Leste
Responder:
procedimento PonerAzulLejos(){
repeat(4){
Move (Leste)
}
Put(Azul)
}
Exercício 6: Repetir vários comandos.
Responder:
procedimento DrawBlackLine6(){
repeat(6){
Put(Preto)
Move (Leste)
}
}
Exercício 7: Onde está o erro?
Responder:
procedimento RedLine4() {
repetir(4) {
Put(Vermelho)
Move (Norte)
}
}
Exercício 8: Diagonal com uma bola.
Defini um procedimentoDiagonal4 Blue() que desenha uma diagonal de

comprimento 4 para o Nordeste, onde cada célula tem uma bola azul. A cabeça deve estar
onde a imagem aparece.
Responder:
procedimento Diagonal4Blue(){
repeat(4){
Put(Azul)
Move (Norte)
Move (Leste)
}
}
Exercício 9: diagonal "pesada".
Defini um procedimento DiagonalPesada4Azul() que ao invés de colocar 1 bola em cada

célula, agora você tem que colocar 21.
Responder:
procedimento Pellets(){
repeat(21){
Put(Azul)
}
}
procedimento DiagonalPesada4Blue(){
repeat(4){
Pellets()
Move (Norte)
Move (Leste)
}
}
Exercício 10: O caso de borda.
Responder:
procedimento Blackline4East(){
repetir(3){
Put(Preto)
Move (Leste)
}
Put(Preto)
}
Exercício 11: De um lado para o outro, desenhe um quadrado.
Defini o procedimento BlackSquare4() para desenhar um quadrado 4x4 com bolas pretas.
Quando você começa, a cabeça está no canto inferior esquerdo do quadrado (não
necessariamente o quadro) e quando o programa é terminado a cabeça deve estar no canto
superior direito do quadrado. Não se esqueça de invocar BlackLine4East() que está
na seção Biblioteca.
Responder:
procedimento SquareBlack4(){
repetir(3){
BlackLine4East()
repetir(3){
Move (Oeste)
}
Move (Norte)
}
BlackLine4East()
}
5. Parâmetros.
Exercício 1: Pensando em subtarefas.
Defini o procedimento DrawBlackLine3() que, como o nome indica, traça uma linha
colocando 3 bolas pretas consecutivas para o Leste e deixando a cabeça onde começou.
Invocalo em um programa.
Na Biblioteca você encontrará o procedimento VolverAtras. Isso significa que você pode
invocá-lo sem ter que defini-lo!
Responder:
procedimento DrawBlackLine3(){
repeat(2){
Put(Preto)
Move (Leste)
}
Put(Preto)
VolverAtras()
}
programa{
DrawBlackLine3()
}
Exercício 2: Desenhar um quadrado com subtarefas.
Defini o procedimento DrawBlackSquareOfSide3() que usando DrawBlackLine3() desenha

um quadrado preto no quadro. Invocalo em um programa.
Responder:
procedimento DrawBlackSquare3(){
repeat(2){
DrawBlackLine3()
Move (Norte)
}
DrawBlackLine3()
}
programa{
DrawBlackSquare3()
}
Exercício 3: Esperança colorida.
Defini o procedimento DrawGreenLine3() para desenhar uma linha verde e vocal no

programa.
Responder:
procedimento DrawGreenLine3(){
repeat(2){
Put(Verde)
Move (Leste)
}
Put(Verde)
VolverAtras()
}
programa{
DrawGreenLine3()
}
Exercício 4: Os que faltam.

Defini os procedimentos DrawRedLine3() e DrawBlueLine3() para adicionar as cores
Vermelho e Azul.
Responder:
procedimento DrawRedLine3(){
repeat(2){
Put(Vermelho)
Move (Leste)
}
Put(Vermelho)
VolverAtras()
}
procedimento DrawBlueLine3(){
repeat(2){
Put(Azul)
Move (Leste)
}
Put(Azul)
VolverAtras()
}
Exercício 5: Procedimentos com furos.
Responder:
Exercício 6: Preenchendo as lacunas.
Crie um programa que coloque três bolas verdes passando a cor verde como parâmetro.
Responder:
programa{
Poner3 (Verde)
}
Exercício 7: DrawLine3.
Defini o procedimento DrawLine3 para receber uma cor e desenhar uma linha dessa cor.
Não se preocupe com os programas para invocá-lo com cada uma das cores, eles passam
por nós.
Responder:
procedimento DrawLine3(color){
repeat(2){
Put(cor)
Move (Leste)
}
Put(cor)
VolverAtras()
}
Exercício 8: DrawSquareOfSide3.
Invocando DrawLine3, defini o procedimento DrawSquareOfSide3 que recebe uma

cor e desenha um quadrado 3x3 dessa cor.
Responder:
procedimento DrawSquareSide3(color){
repeat(2){
DrawLine3 (cor)
Move (Norte)
}
DrawLine3 (cor)
}
Exercício 9: Passar vários parâmetros.
Crie um programa que invoque a nova versão do DrawLine3 (você não precisa defini-lo,
basta invocá-lo) e desenhe um quadrado multicolorido, passando como parâmetros a cor e a
direção.
Responder:
programa{
DrawLine3 (verde, leste)
Move (Leste)
DrawLine3 (Vermelho, Norte)
Move (Norte)
DrawLine3 (Preto, Oeste)
Move (Oeste)
DrawLine3 (Azul, Sul)
}
Exercício 10: Lei, ordem e BOOM.
Crie qualquer programa que invoque DrawLine3, mas desta vez tente invocá-lo com os
argumentos invertidos.
Responder:
programa{
DrawLine3(Norte, Sul)
}
Exercício 11: Um argumento para dois parâmetros.
O que você acha que vai acontecer se passarmos menos argumentos para um procedimento
do que ele precisa?
Crie um programa que invoca DrawLine3, mas passa apenas um argumento.
Responder:
programa{
DrawLine3 (verde)
}
Exercício 12: O terceiro é o perdedor.
Para finalizar esta lição, vamos definir um procedimento chamado Tríade, que recebe três
parâmetros!
Tríade recebe três cores por parâmetro e coloca três bolas, lado a lado voltadas para o leste,
na mesma ordem em que são recebidas. A cabeça começa na origem e deve terminar na
última bola da tríade.
Responder:
procedimento Triada(colorRed, colorGreen, colorBlue){

Put(RedColor)
Move (Leste)
Put(ColorGreen)
Move (Leste)
Put(BlueColor)
}
6. Pratique a repetição simples.
Exercício 1: Aquecimento... Retornando!.
Você se atreve a definir o procedimento Diagonal4AzulVolver? Este procedimento deve

fazer o mesmo que o Diagonal4Azul, mas você tem que deixar a cabeça na posição inicial.
Lembre-se de que você pode invocar tudo o que está na Biblioteca sem ter que redefini-la.
Responder:
procedimento Diagonal4BlueReturn(){
Diagonal4Blue()
repeat(4){
Move (Oeste)
Move (Sul)
}
}
Exercício 2: Uma diagonal mais larga.
O procedimento deve ser chamado de DiagonalBand4.
Responder:
procedimento DiagonalBand4() {
repetir(3) {
Diagonal4BlueReturn()
Move (Norte)
}
IrAlBorde (Sul)
}
Exercício 3: Digamos... Tudo o que queremos!.
Defini o procedimento PonerN (quantidade, cor).
Responder:
procedimento PonerN(a, b){

repetir(a){
Put(b)
}
}
Exercício 4: Dia da Lembrança.
O objetivo, então, é definir um procedimento MemoryDay():
 Na célula atual, coloque 24 bolas azuis, que representam o dia.

 Na cela imediatamente a Leste, coloque 3 bolas verdes, representando o mês.
 Na célula abaixo, coloque bolas pretas de 1976, representando o ano.
Responder:
procedimento MemoryDay(){
PonerN(24, Azul)
Move (Leste)
PonerN(3, Verde)
Move (Leste)
PonerN (1976, Preto)
}
Exercício 5: Escreva qualquer data.

Defini o procedimento Data(dia, mês, ano), que recebe os três valores correspondentes, e
escreve a data que eles representam, assim:
 Na célula atual, tantas bolas azuis para representar o dia.

 Na cela imediatamente a Leste, tantas bolas verdes para representar o mês.
 Na célula abaixo, tantas bolas pretas para representar o ano.
Responder:
procedimento Data(dia, mês, ano){

PonerN(dia, Azul)
Move (Leste)
PonerN(mês, Verde)
Move (Leste)
PonerN(anio, Preto)
}
Exercício 6: Vamos nos mexer... Tudo o que queremos!.
Defini um procedimento MoveN(quantidade, endereço) que faz com que a cabeça mova o
número especificado de vezes na direção indicada.
Respirar:
procedimento MoverN(quantidade, endereço){

Repeat(Quantidade){
Mover (direção)
}
}
Exercício 7: Os números do relógio.
Eu defini um procedimento DrawClock(radius) que coloca os números do relógio como

mostrado acima: ao redor da caixa atual. O tamanho do relógio é indicado pelo raio que
você recebe como parâmetro: quanto maior o raio, mais distantes os números estão do
centro.
Responder:
procedimento DrawClock(Radio){
MoverN (raio, norte)
PonerN(12, vermelho)
MoveN (rádio, leste)
MoverN (rádio, sul)
PonerN (3, vermelho)
MoveN (raio, oeste)
MoverN (rádio, sul)
MoveN (raio, oeste)
MoverN (raio, norte)
MoveN (rádio, leste)
}
Exercício 8: Uma linha pesada.
Defini o procedimento LineEastPast (peso, cor, comprimento). Observe que a cabeça deve
retornar à posição inicial. Para isso, você terá que invocar o MoverN.
Responder:
procedimento LineEastHeavy(peso, cor, comprimento){

repeat(comprimento){
PonerN (peso, cor)
MoverN(1, Leste)
}
MoveN(longitude, Oeste)
}
Exercício 9: Salvar com a guarda.
Defini um procedimento GuardaDe5(), que faz um "guarda" de 5 azulejos (como os que

decoram as paredes). Cada telha é composta por 1 bola verde, 5 pretas e 9 vermelhas.
Responder:
procedimento Save5(){
repeat(4){
PonerN(9, Vermelho)
PonerN(5, Preto)
PonerN(1, Verde)
Move (Leste)
}
PonerN(1, Verde)
PonerN(5, Preto)
PonerN(9, Vermelho)
}
Exercício 10: Um guarda em L.
Defini um procedimento SaveInL() que faz um save em L como mostrado na figura, mas
deixando a cabeça na posição inicial.
Respostas:
procedure MoveTile(num, dir){

repeat(num){
Mover(dir)
PonerAzulejo()
}
}
procedimento GuardaEnL(){
PonerAzulejo()
MoveTile(2, Leste)
MoveN(2, Oeste)
MoveTile(2, Norte)
MoverN(2, Sul)
}
7. Expressões.
Exercício 1: Muitas maneiras de dizer a mesma coisa.
Com essa ideia e invocando o PonerN, crie um programa que coloque cinco bolas pretas,
MAS sem escrever o número 5.
Responder:
programa{
PonerN(3+2, Preto){
}
}
Exercício 2: A soma das partes.
Defini um procedimento PutSum(x, y) que recebe dois parâmetros e coloca o número de

bolas vermelhas que surge da adição dex ey.
Responder:
procedimento PutSum(x, y){

PonerN(x + y, vermelho)
}
Exercício 3: O que você faz antes?
Temos a informação de quantos ônibus, carros e bicicletas compareceram e a partir daí

podemos fazer um cálculo seguindo estas regras:
 Em cada viagem de ônibus 40 pessoas;

 Em cada carro viajam 4 pessoas;
 Cada bicicleta viaja 1 pessoa.
Defini o procedimento CountPeople (micros, carros, bicicletas) que a partir da quantidade

de micros, carros e bicicletas que recebe como parâmetro, faz as contas necessárias e reflete
o resultado com bolas verdes.
Responder:
procedimento Contagem (ônibus, carros, bicicletas){

PonerN (40 * Micros + 4 * Carros +1 * Bicicletas, Verde)
}
Exercício 4: A corrida do salmão.
Responder:
Exercício 5: Dois passos para frente, um passo para trás.
Defini o procedimento WalkDistrustful (passos) que simula a caminhada de Carlos: ele

deve receber o número de passos que deve dar e tomar metade. Ele sempre se move para
o leste.
Responder:
procedimento WalkingDistrustful(steps){
MoveN(passos div 2, leste)
}
Exercício 6: Reserve.
Queremos definir um procedimento que nos ajude a colocar uma bola ao lado de onde está
a cabeça, deixando-a na posição original.
Defini o procedimento PonerAl(direção, cor).
Responder:
procedimento PonerAl(direção, cor){

Mover (direção)
Put(cor)
Mover(oposto(direção))
}
Exercício 7: A linha que retorna.
Usando seus novos conhecimentos sobre expressões, modifique o procedimento Linea

para que a cabeça esteja onde começou.
Responder:
procedimento Linha (direção, cor, comprimento) {
repeat(comprimento) {
Put(cor)
Mover (direção)
}
MoveN(comprimento, oposto(direção))
}
Exercício 8: Desenhando um L.
Descobri qual das novas funções você tem que invocar e defini o procedimento
Ele(direction). Não se preocupe com a posição inicial da cabeça, cuidaremos de colocá-la
no local correspondente para que o L possa ser desenhado.
Responder:
procedimento Ele(endereço){
Line(sentido, Blue, 3)
Line(next(direction), Blue, 3)
}
Exercício 9: Antes do seguinte.
Responder:
Escolha a opção número 4.
Exercício 10: Siga a seta.
Defini o procedimento Arrow(direction) para desenhar uma seta vermelha na direção

correspondente. A cabeça começa e deve estar sempre no centro, como se vê nas placas de
exemplo.
Responder:
procedimento Seta (direção){

Mover(anterior(endereço))
Put(Vermelho)
Mover(next(direction))
Put(Vermelho)
Mover (direção)
Put(Vermelho)
Mover(oposto(direção))
}
Exercício 11: Copiar bolas.
uma tarefa que certamente temos que fazer é colocar muitas bolas, e para isso já sabemos
que existe o procedimento PonerN que construímos vários exercícios atrás. A cor das bolas
que temos que colocar também sabemos: vermelho, mas... Como saber quantos colocar?
Vejamos alguns exemplos:
 Se houver 4 bolas verdes, você tem que colocar 4 bolas vermelhas.

 Se houver 2 bolas verdes, você tem que colocar 2 bolas vermelhas.
 Se não houver bolas verdes, não coloque nenhuma vermelha.
Responder:
procedimento CopyGreenOnRed() {
PonerN(nroBolitas(Verde), Vermelho)
}
Exercício 12: Tirar bolas.
Continuando com essa contagem das bolas, agora é preciso definir um procedimento que
sirva para retirar todas as bolas de uma cor.
Vamos pensar nas subtarefas necessárias:
1. Poder ter muitas bolas: já está resolvido com o SacarN.

2. Conte quantas bolas você tem que tirar: isso pode ser feito com nroBolitas.
3. Remova todas as bolas de uma cor: você tem que combinar as 2 anteriores.
Defini SacarTodas(cor), que recebe uma cor e tira todas as bolinhas que são dessa cor (você
não deve fazer nada com o resto das cores).
Responder:
procedimento SacarTodas(cor){
SacarN (nroBolitas (cor), cor)
}
8. Alternativa condicional.
Exercício 1: Tire com medo.
Responder:

Exercício 2: Tire com medo, segunda tentativa.
Responder:
Exercício 3: Eliminar a bola vermelha.
Modifique o procedimento que lhe demos para que ele desenhe uma bola vermelha, apenas
se houver.
Responder:
procedimento PullRedWithFear() {
if(hayBalls(Red)){
Tirar (vermelho)
}
}
Exercício 4: Um exemplo meio rebuscado.
Para exercitar este último, vamos pedir que você defina um procedimento CompleteCell(),
se já houver uma bola preta, complete a célula colocando um vermelho, um azul e um
verde.
Responder:
procedimento CompleteCell(){
if(hayBalls(Black)){
Put(Vermelho)
Put(Azul)
Put(Verde)
}
}
Exercício 5: E só serve para ver se há bolas?
Crie um programa que se mova para leste somente se possível. Lembre-se de usar
canMove(address).
Responder:
programa{
if(canMove(Leste)){
Move (Leste)
}
}
Exercício 6: Um pouco de matemática.
Outra coisa que pode ser feita dentro de um se é comparar números, como você
provavelmente já fez em matemática.
Felizmente, isso está escrito em Gobstones assim como na matemática tradicional, com um
< para o menor e um > para o maior. Exemplo: nroBolitas (Verde) > 5 nos diz se há mais de
5 bolas verdes.
Sabendo disso, tente criar um programa que coloque 1 bola preta somente se houver menos
de 5 bolas pretas.
Responder:
programa{
if(nroBolitas(Black) < 5){
Put(Preto)
}
}
Exercício 7: Como dizer não...
Defini um procedimento GreenBall() que garante que haja pelo menos uma bola verde na
célula atual. Ou seja: se já existem bolas verdes você não precisa fazer nada, mas se não
houver você teria que colocar uma.
Responder:
procedure SecureAGreenBall(){
if(not hayBalls(Green)){
Put(Verde)
}
}
Exercício 8: Dois caminhos diferentes.
Responder:
Exercício 9: Um quadro de luzes.

Defini um procedimento Pon OApagarLuz() que é responsável por acender as luzes que
estão apagadas ou apagar as luzes acesas, conforme o caso. Tenha em mente que em cada
célula só pode haver bolas verdes ou pretas.
Responder:
procedure PrenderOApagarLuz(){
if(hayBalls(Black)){
Puxar (preto)
Put(Verde)
} else {
Tirar (Verde)
Put(Preto)
}
}
9. Funções.
Exercício 1: E com isso, com o que você come?
Você tem que ler por vários minutos e interpretar o código e tentar entendê-lo.
Responder:
Exercício 2: A importância de nomear as coisas.
Funções em Gobstone,
Responder:
Exercício 3: MoveSegunBolitas, versão 2.
Modifique a primeira versão do MoveGunBalls() para usar a função total(nroBalls) em vez

da expressão longa.
Responder:
procedimento MoverSegunBolitas() {
if (nroBolitasTotal() > 10) {
Move (Leste)
} else {
Move (Norte)
}
}
Exercício 4: TodosExceto.
Defini a função allExcept para retornar o número de bolas que não são a cor que é passada
pelo parâmetro.
Responder:
função allExcept(color){
return (nroBolitasTotal()-nroBolitas(color))
}
Exercício 5: Uma função de outro tipo.
Defini a função redIsDominant() que nos diz se o número de bolas vermelhas é maior do
que a soma das bolas das outras cores. Na Biblioteca está tudoExcept(color) pronto para ser
invocado.
Responder:
função redIsDominant(){
return (nroBalls(Red)>AllExcept(Red))
}
Exercício 6: Livre.
Há o operador && que serve exatamente isso: ele usa duas expressões booleanas e retorna
True somente se ambas forem verdadeiras. Se você conhece alguma lógica, isso é o que é
comumente chamado de conjunção e geralmente é representado pelo símbolo ∧.
Eu defini a função isFreeSides() para indicar se a cabeça pode se mover tanto para o leste
quanto para o oeste.
Responder:
function esLibreSideados(){
return(canMove(Leste) && canMove(Oeste))
}
Exercício 7: Qualquer bola nos deixa bem.

Ao contrário do exercício anterior, o que queremos saber é se alguma delas é verdadeira,
portanto, devemos usar outro operador: a disjunção, que está escrita | | e retorna verdadeira
se pelo menos uma das duas perguntas for verdadeira.
Tanto && quanto | | podem ser usados várias vezes sem a necessidade de usar parênteses,
desde que tenham expressões booleanas em ambos os lados.
Eu defini a função há someBall() que responde a pergunta existem bolas na célula atual?
Responder:
função haySomeBall(){
retorno(hayBalls(Verde) || hayBalls(Azul) || hayBalls(Vermelho) ||
hayBalls(Preto))
}
Exercício 8: Sempre no limite...
Lembramos os operadores lógicos que vimos até agora:
 Negação: "vira" uma expressão booleana - exemplo: não hayBalls (vermelho).

 Conjunção: determina se ambas as condições são atendidas - exemplo:
canMove(Norte) && canMove(Sul).
 Disjunção: determina se alguma das condições é atendida - exemplo: isSmart() ||
hasBuenaOnda().
Com a ajuda dessa prancha, defini a função I amOnEdge() que determina se a cabeça está
em alguma borda.
Responder:
function estoyEnUnBorde(){
return(not canMove(Norte) || not canMove(Sul) || not canMove(Leste) || not
canMove(West))
}
Exercício 9: Os companheiros ideais.
Vamos agora olhar para as funções que fazem as coisas antes de retornar um resultado.
Para exemplificar isso, vamos querer que você defina uma função que nos diga se há uma
bola de uma cor específica, mas na célula ao lado dela.
Defini a função hayballsAl (direção, cor) que informa se há bolas da cor especificada na
célula vizinha em direção à direção dada.
Responder:
função hayBallsAl(direção,cor){
Mover (direção)
retorno(bolas de feno (cor))
}
Exercício 10: O ideal também pode ser quebrado.
Vamos fazer o teste: vamos testar a função HayBolitasAl do exercício anterior com casos
em que a cabeça não pode se mover. Pressione Enviar e veja o resultado.
Responder:
Toque em Enviar
Exercício 11: Há bolas longe?.
Defini a função hayBallsAwayTo (direção, cor, distância). A ideia de "mover a cabeça

muitas vezes" foi resolvida há várias lições com o procedimento MoverN. Você poderia usá-
lo.
Responder:
função hayBallsAwayTo(direção,cor,distância) {
MoveN (distância, direção)
retorno(bolas de feno (cor))
}
Exercício 12: Estou cercado por bolas velhas.
Usando HayBallsAl, defini a função I am Surrounded By (cor) que indica se a cabeça está
cercada por bolas dessa cor.
Dizemos que a cabeça "é cercada" se houver bolas dessa cor nas quatro direções: Norte,
Leste, Sul e Oeste.
Responder:
função Eu souCercado por(cor) {

retorno (hayBolitasAl(Norte, cor) && hayBolitasAl(Leste, cor) &&
hayBolitasAl(Sul, cor) && hayBolitasAl(Oeste, cor))
}
Exercício 13: Sem limites.

Para fechar, vamos definir a função hayLimite(), que determina se há algum tipo de limite
ao movimentar a cabeça.
O limite pode ser devido a um de dois fatores: porque estou em uma borda e depois não
posso me mover em nenhuma direção, ou porque estou cercado por bolas vermelhas que
me cortam. Se qualquer uma dessas duas condições ocorrer, significa que há um limite.
Usando I'mOnEdge e I'mSurrounded, defini thereLimit.
Responder:
função hayLimite(){
voltar || I'mSurrounded(Vermelho)
}
Capítulo 2: Programação Imperativa.
1. Funções e tipos de dados.
Exercício 2: Funções, declaração.

Vamos ver se é entendido: agora escrevi uma função JavaScript metade, que pega um
número e retorna sua metade. Observe que o operador split em JavaScript é /.
Responder:
função meio(número){
retorno (1/2*número)
}
Exercício 3: Funções, uso.
Vamos ver se é compreendido; Escrevi as seguintes funções:
 Anterior: Pegue um número e devolva esse número menos um.

 triple: Devolve o triplo de um número.
 anteriorTheTriple: que combina as duas funções anteriores: multiplicar um
número por 3 e subtrair 1.
Responder:
função anterior(número){
retorno(número - 1)
}
função triple(número){
retorno(número * 3)
}
função anteriorTheTriple(number){
retorno(anterior(triplo(número)))
}
Exercício 4: Testar funções.
Vamos ver se é entendido, tente no console as seguintes expressões:
 4 + 5
 Matemática.rodada(4.5)
 funcionMisteriosa(1, 2, 3) (já declaramos para você e você pode usá-lo)
Responder:
Testar expressões no console
Exercício 5: Fazendo as contas.
Teste as seguintes expressões no console:
 Matemática.max(4, 7)
 Matemática.min(4, 7)
Responder:
Testar as expressões acima no console
Exercício 6: Fixação de limites máximos.
Responder:
extrato de função(saldo, quantidade) {

retorno Matemática.max((valor do saldo),0);
}
Exercício 7: Livros de boa memória.
Agora é a sua vez! Dani conta ainda que alguém lê LikeLeer, quando o número de livros
que se lembra de ler é maior que 20.
Responder:
função leLikeRead(unNumber){
return(unNumber > 20)
}
Exercício 8: Booleanos.
 Entre, pegue três números e diga se o primeiro é maior que o segundo e menor que
o terceiro.
 isOut of Range: pegue três números e diga se o primeiro é menor que o segundo ou
maior que o terceiro.
Responder:
função estaEntre(num1, num2, num3){

return(num1 > num2 && num1 < num3)
}
função estaOutofRange(num1, num2, num3){
return(num1 > num2 && num1 > num3)
}
Exercício 9: Palavras, apenas palavras.

Vamos ver se está claro: eu escrevi a função isWeekendWeekend que pega uma string que
representa o nome de um dia da semana, e nos diz se é "sábado" ou "domingo".
Responder:
função esWeekend(day){
retorno (dia === "sábado" || dia === "domingo")
}
Exercício 10: Operando cordas.
Vamos ver se está claro: eu escrevi uma função fullName length, que pega um nome e
sobrenome, e retorna seu comprimento total, contando um espaço extra para separar os dois.
Responder:
função lengthFullName(nome, sobrenome){

comprimento de retorno((nome)+(sobrenome)+(1));
}
Exercício 11: GRITO!
Escrevi a função do grito. Deixamos você usar a função convertEnShift, que, ehm... Poço...
Ele basicamente converte uma cadeia de caracteres em maiúsculas.
Responder:
função shout(word){
return("" + convertUppercase(word) + "!")
}
Exercício 12: E se...?
Nenhuma introdução à linguagem JavaScript estaria completa sem mostrar pelo menos
uma estrutura de controle que já conhecemos: a alternativa condicional.
Vamos ver se entende: escrevi uma função máxima, que funciona como Matemática.max
(não vale a pena usá-la!) e retorna o máximo entre dois números. Por exemplo, o máximo
entre 4 e 5 é 5, e o máximo entre 10 e 4 é 10.
Responder:
função máxima(número1, número2) {

if (número1 >= número2) {
retorno número1;
} else {
retorno número2;
}
}
Exercício 13: Que signo você é?
Precisamos de uma função de sinal, que dado um número nos retorna:
 1 se o número for positivo.

 0 se o número for zero.
 -1 se o número for negativo.
Eu escrevi a função de sinal. Talvez você precise de mais de um se.
Responder:
sinal de função (número){

if(número > 0) retornar 1
if(número === 0) retornar 0
if(número < 0) retornar - 1
}
Exercício 14: O retorno do booleano.
Eu escrevi a função isLuckNumberThat dado um número diz se ele atende à lógica acima.
Não vale a pena usar se!
Responder:
função esLuckNumber(number) {
retorno (número)>0 && (número)<100 && (número!=15);
}
Exercício 15: Os prêmios.
O júri de um torneio pediu-nos para desenvolver uma função de medalha SegunPuesto que
devolve a medalha que corresponde aos primeiros lugares, de acordo com a seguinte lógica:
 Primeiro lugar: corresponde a "ouro".

 Segundo lugar: corresponde a "prata".
 Terceiro lugar: corresponde ao "bronze".
 Outras posições: "nada" lhe corresponde.
Responder:
função medalSecondPosition(place){
if(place === 1){
retorno("ouro")
} else if(place === 2) {
Retornar
Retorno ("bronze")
} else {
retorno("nada")
}
}
Exercício 16: Tipos de dados.
Como acabamos de ver, em JavaScript existem números, booleanos e strings:
Além disso, existem operações que funcionam para todos os tipos de dados, por exemplo:
 ===: Diz-nos se duas coisas são iguais.

 !==: nos diz se duas coisas são diferentes.
Tente o seguinte no console:
 5 + 6 (OK, números podem ser adicionados).

 5 === 6 (OK, todas as coisas podem ser comparadas).
 8 > 6 (ok, os números podem ser classificados).
 !true (ok, os booleanos podem recusar).
 falso / verdadeiro (não certo, booleanos não podem ser divididos!).
Responder:
Teste no console
Exercício 17: Dados de todos os tipos.
Antes de terminar um último desafio: Qual o valor das seguintes expressões? Confira todos
os corretos!
Responder:
4 + 4 vale 8
"4" + "4" vale "44"
"on" + "ce" vale "uma vez"
true && false é false

5 >= 6 é falso
! verdadeiro é falso
2. Funções práticas e tipos de dados.
Exercício 1: Comprar hardware.
Eu escrevi uma função quanto me custa para pegar o número de polegadas do monitor e a
quantidade de memória, e calcular o custo estimado do nosso computador.
Responder:
função cuantoCuesta(monitor, memória){

retorno(((monitor * 60) + (memória * 200) + 1000);
}
Exercício 2: É certo para mim?
Agora que sabemos quanto custa um computador, queremos saber se um computador

combina comigo. Isso ocorre quando:
 Custa menos de $6000.

 Ele tem pelo menos um monitor de 32 polegadas.
 Ele tem pelo menos 8GB de memória.
Eu escrevi a função meConveniente, que novamente pega o número de polegadas e

quantidade de memória e nos diz se é conveniente para nós comprá-lo.
Responder:
função meConveniente (polegadas, memória){

return (quantCost(inch,memory) < 6000 && inch >= 32 && memory >= 8);
}
Exercício 3: Triângulos.
Hora de fazer geometria! Queremos saber algumas coisas sobre um triângulo:
 PerimeterTriangle: Dado os três lados de um triângulo, queremos saber quanto

tempo é o seu perímetro.
 areaTriangle: Dada a base e altura de um triângulo, queremos saber qual é a sua
área.
Desenvolver as funções perimetroTriangulo e areaTriangulo.

Responder:
função perímetroTriângulo(side1, side2, side3){

retorno (side1 + side2 + side3)
}
área de funçãoTriângulo(side1, side3){
Retorno (side1 * side3 / 2)
}
Exercício 4: Quadrados.
E agora é a vez das praças; Queremos saber
 Perímetro: dado um lado, queremos saber quanto tempo é o seu perímetro.

 areaSquare: dado um lado, queremos saber qual é a sua área.
Desenvolver as funções SquarePerimeter e SquareArea.
Responder:
função perimeterSquare(side) {
retorno (lado * 4)
}
área de funçãoSquare(side) {
retorno (lado * lado)
}
Exercício 5: Você está em sintonia?
Desenvolva uma função sintonizada, que recebe a frequência (um número) da troca, e diz
se essa frequência é igual a 440Hz.
Responder:
função isTuned(frequency){
retorno (frequência === 440)
}
Exercício 6: Está perto?
Agora queremos saber se o piano central está perto de estar em sintonia. Isso ocorre quando
está entre 437Hz e 443Hz, mas NÃO é exatamente 440Hz.
Eu escrevi a função éPerto.
Responder:
função isClose(frequency){
retorno (437 <= frequência && frequência de & <= 443 &&& frequência !==
440)
}
Exercício 7: Pôsteres.
Eu escrevi a função writePoster, que pega um título, um nome e um sobrenome e forma

uma única string.
Responder:
função writePoster(title, nome, sobrenome){

return(título + " " + primeiro nome + " " + sobrenome)
}
Exercício 8: Mais cartazes.
Responder:
função writePoster(title, nome, sobrenome, bool){

return (título + " " + (!bool?nome+" "+sobrenome:sobrenome))
}
Exercício 9: Pôsteres ótimos.
Agora que podemos escrever nossos sinais de identificação grandes e pequenos, queremos
uma nova função que nos dê o sinal de tamanho ideal:
 Se nome e sobrenome têm, no total, mais de 15 letras, queremos um sinal curto;

 Caso contrário, queremos um pequeno sinal longo.
Defini a função writeOptimalPoster que leva um título, um primeiro nome e um sobrenome,

e usando writePosterito gerar um poster curto ou longo, de acordo com as regras anteriores.
Responder:
função writeOptimalPoster(title, nome, sobrenome){

return writePoster(title, first name, last name,(length(first + last name)
>= 15))
}
Exercício 10: Rosto ou hortelã.
Eu escrevi uma função decisionWithCoin, que pega três parâmetros e retorna o segundo se
o primeiro for "cabeças", ou o terceiro, se "menta" sair.
Responder:
função decisãoConMoneda(moeda, pizzas, empanadas){
if(coin === "cabeça"){
devolver pizzas;
}else{
retorno empanadas;
}
}
Exercício 11: Inveja!.
Queremos saber o valor das cartas de truque quando jogamos inveja. Sabemos que:
 Todas as cartas de 1 a 7, inclusive, valem sua numeração.

 Os cartões 10 a 12, inclusive, valem 0.
 Você não joga com 8s ou 9s.
Eu escrevi uma função envidovalue, que pega um número de letra e retorna seu valor de
envio.
Responder:
função valueEnvido(letter){
if(letra >= 1 && letra <= 7)
{carta de retorno}
{retornar 0}
}
Exercício 12: Eu quero retruco!.
Bem, ehm, não, pare, primeiro queremos calcular quantos pontos de inveja um jogador
marca. Sabemos que:
 Se as duas cartas são do mesmo naipe, o valor da inveja é a soma de seus valores de
inveja mais 20.
 Caso contrário, o valor do envio é o maior valor de envio entre eles.
Usando a função EnvidoValue (que já escrevemos para você), desenvolva a função

EnvidoTotalPoints que pega os valores e naipes de duas cartas e diz quanto Envido elas
somam no total.
Responder:
pontos de funçãoTotalEnvido(n1, p1, n2, p2){

if(p1 === p2){
return (EnvidoValue(n1) + EnvidoValue(n2) + 20)
}else{
retornar Matemática.max(n1, n2)
}
}
Exercício 13: Quero valer quatro!
Ao jogar o truque, as equipes adversárias podem alternativamente subir a antena. Por

exemplo, se um jogador canta truque, outro jogador pode cantar truque para ele.
Obviamente, os pontos em jogo estão crescendo:
Cantoria Pontos em jogo

truque 2
Retruco 3
vale
4
quatro
Escrevi a função valueCantoTruco, que pega a música e devolve quantos pontos ela vale.
Responder:
função valueCantoTrick(singing){
if(cantando === "truque"){
retorno(2)
}
if(cantando === "retruco"){
retorno(3)
}
if(canto === "vale cuatro"){
retorno(4)
}
}
3. Variáveis e Procedimentos.
Exercício 1: E o tabuleiro?.
Responder:
misterioso(2, 1)
Exercício 2: Serigrafia.
Responder:
Experimente o Egocentrica() no console.
Exercício 3: Martin Fierro.

Vamos ver se está ficando claro, escrevi uma função versosMartinFierro que imprime na
tela os primeiros versos de Martín Fierro:
Aqui começo a cantar

Al compás de la vigüela;
Que o homem que o revela
Uma tristeza extraordinária
Esta função deve retornar 0
Responder:
function versosMartinFierro() {
print("Aqui começo a cantar");
print("Al compás de la vigüela;");
print ("Deixe o homem que a desvenda");
print("Pena extraordinária");
retornar 0
}
Exercício 4: E os procedimentos?
Quando quiséssemos reutilizar o código, poderíamos declarar:
 funções, que sempre retornam algo e não produzem efeito.

 procedimentos, que não retornam nada, e produzem efeitos.
Envie esta nova versão do versosMartinFierro.
Responder:
}
Exercício 5: E o programa?.
Em JavaScript, tudo o que escrevemos fora de uma função será, implicitamente, esse
ponto de entrada. Por exemplo, se quisermos um programa que imprima na tela o clássico
"Olá, mundo!", podemos escrevê-lo assim:
print("Olá Mundo!");
Responder:
print("Rolando dados");
print("A primeira tiragem deu " + roll());
print("A segunda tiragem deu " + roll());
print("O terceiro rolo deu " + roll());
Exercício 6: Coerção.
Vamos ver se está claro, eu escrevi uma função elefantesEquilibristas de corda bamba, que
pega uma série de elefantes e devolve uma rima de uma conhecida música "3 elefantes
balançaram".
Responder:
função elefantesEquilibristas (número){

return(número + " " + "elefantes balançaram")
}
Exercício 7: O círculo da vida.
Considerando o número pi igual a 3,14159265358979 (não infinito, mas preciso o suficiente

para nossos cálculos):
Defini as funções de perímetroCircle e areaCircle que recebem o raio de um círculo e dele

retornam seu perímetro e sua área.
Responder:
função perimeterCircle(radius){
retorno(3.14159265358979*2*radio)
}
área de funçãoCircle(radius) {
retorno(3.14159265358979 * rádio * rádio)
}
Exercício 8: Acho que é mais fácil.
deixe pi = 3,14159265358979;
Altere os locais onde 3.14159265358979 aparece para a variável pi nas funções que
definimos.
Responder:
deixe pi = 3,14159265358979;
Retorno (PI*2*Radio)
}
return(pi * rádio * rádio)
}
Exercício 9: Isso não tem valor.
À medida que você entende como as variáveis são atribuídas, trazemos algo para você
pensar: e se eu tentar usar uma variável à qual nunca atribuí um valor?
Responder:
Copiar, colar e testar no console
Exercício 10: Variáveis globais.
As variáveis declaradas dentro de uma função, conhecidas como variáveis locais, não
apresentam mais mistério. No entanto, é preciso ter um cuidado especial: eles só podem ser
usados a partir da função em questão.
No entanto, variáveis declaradas diretamente no programa, conhecidas como variáveis

globais, podem ser usadas a partir de qualquer função.
Responder:
deixe carregarMaximaEnKilograms = 300

função elevadorSobrecarregado(pessoas){
return(people * weightAveragePersonInKilograms) > loadMaximumInKilograms
}
Exercício 11: Tornar-se rico.
Eu escrevi um procedimento increaseFortune que dobra o valor da variável global

pesosEnMyWallet. Não declare a variável, nós já fizemos isso para você (com uma quantia
secreta de dinheiro).
Responder:
função increaseFortune(){
pesosEnMyWallet = pesosInMyWallet * 2
}
Exercício 12: E quanto vale isso?
Vimos que uma variável só pode ter um valor, então toda vez que atribuímos um novo,
perdemos o anterior.
Responder:
20
4. Lógica booleana.
Exercício 1: Deixe o último apagar a luz!
Vamos começar com algo simples, você se lembra do operador! ? Chama-se negação, não
ou complemento lógico e serve para negar um valor booleano.
Se eu tiver o booleano representado por hasHungry, o complemento será !hasHunger.
Defini o procedimento a ser usado para que possamos abrir e fechar o fechamento de uma
mochila.
Responder:
deixe mochilaOpen = verdadeiro;

função usClose() {
backpackOpen = !backpackOpenOpen
}
Exercício 2: Negar não custa nada.
Agora é a sua vez! Eu defini que éAdulto, que recebe uma idade, e depois éMinorAge a
partir dele.
Responder:
função esOlder(age){
retorno (idade >= 18)
}
função esMinor(age){
return(!isAdult(age))
}
Exercício 3: Os peripatéticos.
Defini uma função peripatética que leva a profissão de uma pessoa, a nacionalidade e o
número de quilômetros que ela caminha por dia. Alguém é peripatético quando é filósofo
grego e gosta de caminhar (anda mais de 2 quilômetros por dia).
Responder:
função esPeripatetico(professor, nacionalidade, kms){

retorno (professor === "filósofo" & nacionalidade === "grego" && kms > 2)
}
Exercício 4: A verdade por trás da conjunção.
Responder:
Teste no console:
consumoPocaEnergia(24, 5)
Exercício 5: Vamos jogar T.E.G.!
Responder:
Teste no console:
vitória (verdadeiro, 25)
Vitória (falso, 30)
win(falso, 20)
Exercício 6: E agora... Quem pode nos ajudar?
Sabemos que o banco está fechado quando:

 É um feriado, ou
 É o fim de semana, ou
 Não estamos dentro do horário bancário.
Defini as funções isWeekendWeekend e isClosed.
Responder:
let isHoliday = verdadeiro;

Retorno (dia === "sábado" || dia === "domingo")
}
função éFechado(esFeriado, dia, horário){
return(esFeriado|| !dentroDeHorarioBancario(horario) || esFinDesemana(dia))
}
Exercício 7: Bom dia!
Na família Buendía acontece que:
 Arcadio é filho de José Arcadio e Pilar Ternera.

 Aureliano José é filho do coronel Aureliano e de Pilar Ternera.
 Aureliano Segundo e Remedios são filhos de Arcadio e Sofía De La Piedad.
Para começar a analisar essa família, já definimos as funções mãeDe e paiDe.
Agora cabe a você definir a função areHalfBrothers. Lembre-se que meio-irmãos podem
compartilhar mãe ou pai, mas não ambos porque... Nesse caso, seriam irmãos!
Responder:
função haveTheSameMother(child1, child2){

deixar mãe1 = mãede(filho1);
Mãe de retorno1 === Mãe2;
}
função haveTheSameParent(child1, child2){
deixar pai1 = paide(filho1);
retorno pai1 === pai2;
}
função sonHalfBrothers(child1, child2){
retorno (terTheSameMother(child1, child2) !== haveTheSameFather(son1,
child2));
}
Exercício 8: A verdade é que não há verdade.
Teste sua função sonHalfBrothers com os seguintes valores e verifique se ela se comporta
como a tabela:
Responder:
sonHalfBrothers(arcadio, aurelianoJose)
sonHalfBrothers(AurelianoSegundo, remédios)
sonMediaHermanos(aurelianoJose, remédios)
Exercício 9: Olá! Meu nome é Xor.
Ao contrário de e, ou não, xor não é geralmente definido em línguas. No entanto, agora que
você já sabe como funciona, se precisar pode defini-lo manualmente.
Vamos ver se é entendido: defini a função genérica xor, que pega dois booleanos e retorna o
valor verdade correspondente.
Responder:
função xor(a, b){

retorno (a !== b)
}
Exercício 10: Precedência.
Quando uma expressão matemática tem vários operadores, sabemos que multiplicações e
divisões ocorrerão antes da adição e subtração:
5 * 3 + 8 / 4 - 3 = 14
Como na matemática, quando usamos operadores lógicos as expressões são avaliadas em

uma determinada ordem chamada precedência.
Responder:
Teste-o no console com os valores:
payWithCard(verdadeiro, "crédito", 320)
paywithcard(falso, "crédito", 80)
payWithCard(verdadeiro, "débito", 215)
paywithcard(verdadeiro, "débito", 32)
Exercício 11: Um exercício sem precedentes.

Escrevi a função canretire que recebe a idade e o sexo de uma pessoa, além dos anos de
contribuição previdenciária que ela tem.
A idade mínima para realizar o procedimento para as mulheres é de 60 anos, enquanto para
os homens é de 65 anos. Em ambos os casos, é preciso ter pelo menos 30 anos de
contribuição.
Tente resolvê-lo em uma única função! Então vamos ver como seria se delegássemos.
Responder:
função podeAposentar(idade, sexo, contribuição){

retorno((sexo === "F" && idade >= 60) || (sexo === "M" && idade >= 65)) &&
contribuição >= 30
}
Exercício 12: Posso subir?.
Os requisitos para subir a atração são:
 Atingir a altura mínima de 1,5m (ou 1,2m se acompanhado por um adulto).

 Não ter nenhuma condição cardíaca.
Defini a função de 3 parâmetros canRise que recebe uma altura de uma pessoa em metros,
se ela está acompanhada e se tem algum problema cardíaco.
Responder:
função pode ser escalada (altura, acompanhado, condição){

retorno((altura >= 1,5) || (altura >= 1,2 && acompanhado)) && !afeto
}
5. Listas.
Exercício 1: Série favorita.
Para representar um conjunto de strings, colocamos todas as strings que nos interessam,
entre colchetes ([ e ]) separadas por vírgulas. Fácil, não é?
Responder:
Teste as seguintes consultas no console:
sérieFavoritosDeAna
sérieFavoritosDeHector
["Olá","Mundo!"]
["olá","olá"]
Exercício 2: E esta é uma lista.
O que acabamos de ver é como modelar facilmente conjuntos de coisas. Usando [], em
JavaScript temos uma maneira simples de agrupar esses itens em listas.
Existe um número máximo de itens? Não, não há limite! As listas podem ter qualquer
número de itens.
E não só isso, mas a ordem é importante. Por exemplo, ["hello", "world"] não é o mesmo
que ["world", "hello"]: ambos têm os mesmos elementos, mas em posições diferentes.
Responder:
Equallists(["olá", "mundo"], ["mundo", "olá"])
Equallists(["olá", "mundo"], ["olá", "mundo"])
Equallists(["olá", "mundo"], ["olá", "todos", "o", "mundo"])
Equallists(["olá"], ["olá", "mundo"])
["hello", "world"] === ["mundo", "hello"]
povo
["mara", "Julian"] ===Pessoas
Pessoas === Pessoas
Exercício 3: Jogo.
Também podemos representar conjuntos de números ou booleanos, da mesma forma:
escrevendo-os entre colchetes e separados por vírgulas. Podemos ter listas de números,
strings, booleanos, etc. Podemos até ter listas de listas!
Responder:
Vamos ver se está claro. Teste as seguintes consultas no console:
Números da loteria
SalioCara
[[1, 2, 3], [4, 5, 6]]
Exercício 4: Listas vazias.
Ótimo, parece que uma lista pode conter qualquer tipo de item! Podemos ter listas de
booleanos, números, strings, listas...
E não só isso, mas eles também podem conter qualquer número de elementos: um, dois,
quinze, centenas.
Podemos, então, ter listas vazias, ou seja, aquelas que não têm elementos? É claro!
deixe aEmptyList = []
Responder:
Tente digitar uma lista vazia no console
Exercício 5: Quantos elementos você tem?
No momento, já sabemos o que podemos representar com listas e como fazê-lo. Mas o que
podemos fazer com eles?
Vamos começar pelo fácil: saber quantos itens estão na lista. Podemos fazer isso usando a
função length, semelhante ao que fizemos com strings.
Responder:
Execute as seguintes consultas no console:
comprimento([])
comprimento (números de loteria)
comprimento([4, 3])
Exercício 6: Adicionando sabor.
As listas são muito úteis por conter vários itens. Mas há mais! Também podemos adicionar
itens a ele a qualquer momento, usando a função add, que recebe dois parâmetros: a lista e o
item.
Como podemos ver, adicionar adiciona um item à lista, o que faz com que seu tamanho
aumente. Mas onde na lista você adiciona isso? Inicialmente? No final? No meio?.
Descubra você mesmo: inspecione no console quais itens contêm pertences, adicione uma
"besta" e inspecione os pertences novamente.
Há também um procedimento de remoção, que só recebe a lista por parâmetro. Descubra o

que ele faz no seu console.
Responder:
Teste no console
add(pertences, "amuleto mágico")
Exercício 7: Mova-se.
Ele declarará um procedimento para mover, que pega duas listas, tira o último elemento da
primeira e adiciona à segunda.
Responder:
função move(oneList, anotherList){

adicionando(anotherList, removendo(aList))
}
Exercício 8: E onde fica?

E o que acontece se você passar por parâmetro para posicionar um elemento que não tem?
Descubra-se!
Responder:
Copiar e colar no console
cargo(diasLaboral, "osvaldo")
Exercício 9: Contém.
Eu escrevi a função contém para nos dizer se uma lista contém um determinado item.
Se você tem prestado atenção aos exemplos de consulta, você terá notado que as listas
também podem ter elementos duplicados: [1, 2, 1], ["hello", "hello"], etc.
Portanto, a posição realmente retorna a posição da primeira aparição do item na lista.
Responder:
função contém(matriz, pesquisa){

return(position(array, pesquisa) >- 1)
}
Exercício 10: Nono elemento.
Assim como existe uma função para descobrir em que posição um elemento está, também
pode acontecer de querermos saber o contrário: qual elemento está em determinada
posição.
Para descobrir, podemos usar o operador de indexação, escrevendo após a coleção e entre
colchetes [] a posição que queremos descobrir.
Responder:
deixar lista =[]
lista[0]
Exercício 11: Mais prêmios.

Se você pedir um item em uma posição igual ou maior que o tamanho da lista, você ficará
indefinido. Não parece uma coisa terrível, mas o problema é que com undefined você não
pode fazer nada realmente útil.
Por isso, o aviso é: não exagere!
Com isso em mente, há um desafio: escrevi a função medalha novamente, mas desta vez
usando no máximo um único se. Talvez as listas possam ser úteis aqui.
Lembramos o que a função faz: tem que devolver a medalha que corresponde às primeiras
posições de uma competição.
Responder:
deixe medalha = ["nada", "ouro", "prata", "bronze"]
função medalSecondPosition(position){
if(posição <= 3){
retorno(medalha[posição])
} else {
Retorno(medalha[0])
}
}
Exercício 12: Não se esqueça de dizer olá.
Vamos conhecer uma maneira de percorrer os elementos de uma lista com um novo amigo:
o loop for.
Responder:
função greet(people){
for(let persona1 de personas){
print("olá" + " " + pessoa1);
}
}
6. Registros.
Exercício 1: Os primeiros registros.
Responder:
Copie e cole o código no console

estátua da liberdade
Christthe Redentor
torreEiffel
tajMahal
coliseu
Exercício 2: Seu próprio monumento.
É o seu momento monumento! Mantenha nas variáveis torreAzadi e monumento

NacionalALaBandera registros desses monumentos, originários das cidades de Teerã, Irã e
Rosário, Argentina, respectivamente. Você se atreve a investigar em que ano eles foram
concluídos para completar esse campo?
Responder:
let torreAzadi = {nome: "Torre Azadi", localização: "Teerã, Irã",

anioDeConstruccion: 1971}
let monumentoNacionalALaBandera = {nome: "Monumento Nacional A La Bandera",
localização: "Rosario, Argentina", anioDeConstruccion: 1957 }
Exercício 3: Acessando o campo.
Declaramos os planetas mercúrio, Marte e Saturno como registros com as seguintes

informações: nome, temperatura média e se possui anéis. Experimente-os no console!
Responder:
Declaramos os planetas mercúrio, Marte e Saturno como registros Problos no

console!
Exercício 4: Planejar a temperatura.
Desenvolva uma função planettemperature que receba um registro de planeta por parâmetro
e retorne uma string indicando seu nome e temperatura média. Tem que funcionar para
qualquer planeta!
Responder:
função temperaturadePlaneta(planeta){
return(planet.name + " tem uma temperatura média de " +
planet.temperatureAverage + " graus")
}
Exercício 5: Movendo arquivos.
Desenvolva o procedimento moveFile, que recebe um registro e um novo caminho e

modifica o arquivo com o novo caminho.
Responder:
função moveFile(registry, Newpath){

deixe readme = log.path = caminhoNovo
}
Exercício 6: Registros de dois milênios.
No exercício anterior, modificamos o caminho do registro, mas não usamos sua data de
criação. Vamos usá-lo! Queremos saber se um arquivo é do último milénio, o que acontece
quando o seu ano é anterior ao ano 2000.
Desenvolva a função LastMillenniumPast, que recebe um arquivo e retorna um booleano.
Responder:
função enMillenniumPast(file){
return(anio(file.creation) < 2000)
}
Exercício 7: Sobremesas complexas.
Crie uma função difícil de cozinhar, que recebe dois registros de sobremesa por parâmetro e
retorna aquele com mais ingredientes dos dois.
Responder:
função masDifícilCozinhar (sobremesa1, sobremesa2){

if(length(dessert1.ingredients) < length(dessert2.ingredients)){
sobremesa de retorno2;
}
if(length(dessert1.ingredients) >= length(dessert2.ingredients)){
}
}
Exercício 8: Listas de inscrição.
Assim como trabalhamos com listas de números, booleanos, strings ou mais listas, também
podemos listar registros. Você pode fazer tudo o que você fez antes, como mexer, saber seu
comprimento ou pedir o elemento de uma determinada posição usando os colchetes [ ].
Experimente as listas de Favoritos e Monumentos da América no seu console. Tem uma
sobremesa que a gente não mostrava antes, você percebe o que é só lendo seus
ingredientes?
Responder:
Teste no console:
sobremesasFavoritos
monumentos da América
Exercício 9: 60 minutos doces.
Desenvolva o procedimento addAPostresRapidos, que recebe uma lista com sobremesas

rápidas e uma sobremesa por parâmetro. Se o tempo de cozimento for de uma hora ou
menos, o registro será adicionado à lista.
Responder:
função addAPostresRapidos(lista, sobremesa){

if(sobremesa.tempo decozimento <= 60){
add(lista, sobremesa)
}
}
Exercício 10: Há um registro no meu registro.
Descubra o que o campo de ingredientes retorna no campo de sobremesa do registro

ChildrenMenu. Há um disco dentro do outro!
Responder:
Teste no console
menuInfantil.sobremesa.ingredientes
Exercício 11: Açúcar!
Defini um procedimento para adoçar o cardápio, que recebe um registro do cardápio e

adiciona açúcar aos ingredientes de sua sobremesa. Se você já tem açúcar, não importa...
Adicione mais!
Responder:
função sweetenMenu(menu){
adicionar(menu.dessert.ingredients, "açúcar")
retornar menu.sobremesa
}
7. Rotas.
Exercício 1: Ganhos semestrais.
O recurso Ganho Semestral que escrevemos anteriormente tem algum problema? Vai
funcionar com balanços trimestrais? E com os períodos de quatro meses?
Experimente no console!
Responder:
Teste no console:
ResultadosSemestre
Exercício 2: E o restante dos lucros?
O que gostaríamos é de poder somar os lucros de todos os saldos de uma lista,

independentemente de quantos realmente existam; queremos uma função de lucro total, que
pode somar saldos de qualquer período de meses: semestres, trimestres, trimestres, etc. Que
difícil!
Responder:
TotalProfit([
{ mês: "Janeiro", lucro: 2 },
{ mês: "Fevereiro", lucro: 3 }
])
Exercício 3: Todos os lucros, o ganho.
Responder:
função profitTotal4(saldosDe um período){

Soma let = 0
soma = soma + período de balanço[0].lucro
soma = soma + saldo[1].lucro
soma = soma + saldo período[2].lucro
Retorno de soma
}
Exercício 4: Um velho amigo nos visita.
O que temos que fazer, então, é repetir a operação de acumular várias vezes, uma para cada
item da lista. Vamos dizer olá (novamente) para o for... de!
Como você pode ver, o... de nos permite visitar e fazer algo com cada item de uma lista;
neste caso, visitaremos cada balanço do SinglePeriod.
Responder:
TotalProfit([
{ mês: "Março", lucro: 8 },
{ mês: "Agosto", lucro: 10 }
])
Exercício 5: Contas claras.
Ana tem novas exigências! Agora ele nos perguntou o seguinte: "Quero saber quantos
saldos foram positivos, ou seja, aqueles em que o lucro foi maior que zero".
Conclua a função PositiveBalanceQuantity . Se você prestar atenção, notará que ele tem
uma estrutura semelhante ao problema anterior.
Responder:
valor da funçãoSaldosPositivos(SaldosDeUm Período){

deixe a quantidade = 0
for(let balance of balancesDeUnPeriodo){
quantidade = quantidade + ((saldo.lucro) > 0)
}
quantidade de retorno;
}
Exercício 6: O ganho médio.
Vamos ao próximo pedido de Anne. Já podemos calcular uma soma de lucros e também
criar contadores, agora vamos calcular médias.
Ana gostaria de saber, dado qualquer conjunto de saldos, qual é o seu lucro médio.
Responder:
função gainAverage(Totalgain){
Soma let = 0
for(let balance of gainTotal){
soma = (soma + saldo.lucro)
}
retorno da soma / comprimento (gainTotal)
}
Exercício 7: Quem ganha, quem perde.
Vendo que podemos fazer tudo o que pede, Ana quer saber o ganho médio dos saldos
positivos.
Defini as funções:
 Ganho positivo, que é a soma dos ganhos dos balanços positivos.

 médiaGanhos Positivos invocando PositiveGain e PositiveBalanceAmount.
Responder:
ganho de funçãoPositivo(saldosDeperíodo){
Soma let = 0
if(balance.profit > 0){
soma = soma + (saldo.ganho)
}
}
Retorno de soma
}
função médiaLucrosPositivo(SaldosDeUmPeríodo){
retorno lucroPositivo(SaldosDeUm Período) / montantePositivo(saldosDeUm
Período)
}
Exercício 8: Eu sou o mapa, eu sou o mapa.
Infelizmente, você não pode usar o recurso médio com nossa lista de registros. O que
precisamos é de uma lista que tenha apenas os lucros de cada balanço. Para fazer isso,
devemos transformar, ou mapear, cada item da lista.
Complete a função de lucro que pega uma lista de saldos e retorna uma lista que possui
apenas os lucros de cada um.
Responder:
ganhos de função(saldosOfAPeriod){
deixar ganhos = []
agregado(lucro, saldo.lucro)
}
retorno de lucros
}
Exercício 9: Filtre, filtre tudo em seu lugar.
Com a programação você pode fazer qualquer coisa, ou quase. Já fizemos uma função para
poder saber a quantidade de saldos positivos (amountofPositiveBalances), agora vamos ver
como podemos fazer para saber quais são esses saldos.
Conclua a função Saldos Positivos que pega os saldos de um período e retorna uma lista
daqueles cujo lucro foi maior que zero.
Responder:
saldos de funçãoPositivo(OnePeriodsbalances){
deixe saldos = []
add(saldos, saldo)
}
}
Saldos de Retorno
}
Exercício 10: Uma média mais positiva.
Agora que temos a função lucros e saldos positivos podemos usar a função média genérica
para saber qual é o lucro médio dos saldos positivos.
Defini a função PositiveBalanceGains e depois a usei ao lado da média para definir

PositiveBalancesAverage.
Responder:
função ganhos deSaldos positivos(saldo período){

ganhos de retorno(Saldos positivos(OnePeriod)
}
função médiaSaldosPositivos(SaldosDeUm Período){
Rendimento médio (ganhos de saldos positivos)
}
Exercício 11: Este é o máximo.
Vamos conhecer uma nova função, maximo, que nos permite saber qual é o valor mais alto
em uma lista de números.
Usando esta nova função, defini a função maximaGain que nos diz qual é o maior lucro
entre os saldos de um período de tempo.
Responder:
função maximaGain(balancesOfA period){

retorno máximo (ganhos(saldos OnePeriod))
}
Exercício 12: No mínimo.
Supomos que você adivinhou o nome. Se não, é mínimo.
Defini a função minimaPositiveGain que nos diz qual é o menor ganho de todos os saldos
positivos.
Responder:
função minimaPositiveGain(balancesOfA period){

retorno mínimo(ganhos deSaldos Positivos(SaldosDeUmPeríodo));
}
Exercício 13: Os melhores meses do ano.
Para isso vamos fazer as seguintes funções:
 meses, que dada uma lista com registros retorna uma lista de meses;
 lucky, que filtra aqueles registros que tiveram lucro superior a R$ 1 mil;
 mesesLucky, devolva aqueles meses que foram de sorte.
Defini as funções meses, sorte, meses.
Responder:
Capítulo 2: Programação Imperativa.

1. Funções e tipos de dados.
Exercício 2: Funções, declaração.
Vamos ver se é entendido: agora escrevi uma função JavaScript metade, que pega um
número e retorna sua metade. Observe que o operador split em JavaScript é /.
Responder:
função meio(número){
retorno (1/2*número)
}
Exercício 3: Funções, uso.
 Anterior: Pegue um número e devolva esse número menos um.

 triple: Devolve o triplo de um número.
 anteriorTheTriple: que combina as duas funções anteriores: multiplicar um
número por 3 e subtrair 1.
Responder:
função anterior(número){
retorno(número - 1)
}
função triple(número){
retorno(número * 3)
}
função anteriorTheTriple(number){
retorno(anterior(triplo(número)))
}
Exercício 4: Testar funções.
Vamos ver se é entendido, tente no console as seguintes expressões:
 4 + 5
 funcionMisteriosa(1, 2, 3) (já declaramos para você e você pode usá-lo)
Responder:
Testar expressões no console

Exercício 5: Fazendo as contas.
Teste as seguintes expressões no console:
 Matemática.max(4, 7)
 Matemática.min(4, 7)
Responder:
Testar as expressões acima no console
Exercício 6: Fixação de limites máximos.
Responder:
extrato de função(saldo, quantidade) {

retorno Matemática.max((valor do saldo),0);
}
Exercício 7: Livros de boa memória.
Agora é a sua vez! Dani conta ainda que alguém lê LikeLeer, quando o número de livros
que se lembra de ler é maior que 20.
Responder:
função leLikeRead(unNumber){
return(unNumber > 20)
}
Exercício 8: Booleanos.
 Entre, pegue três números e diga se o primeiro é maior que o segundo e menor que
o terceiro.
 isOut of Range: pegue três números e diga se o primeiro é menor que o segundo ou
maior que o terceiro.
Responder:
função estaEntre(num1, num2, num3){

return(num1 > num2 && num1 < num3)
}
função estaOutofRange(num1, num2, num3){
return(num1 > num2 && num1 > num3)
}
Exercício 9: Palavras, apenas palavras.
Vamos ver se está claro: eu escrevi a função isWeekendWeekend que pega uma string que
representa o nome de um dia da semana, e nos diz se é "sábado" ou "domingo".
Responder:
retorno (dia === "sábado" || dia === "domingo")
}
Exercício 10: Operando cordas.
Vamos ver se está claro: eu escrevi uma função fullName length, que pega um nome e
sobrenome, e retorna seu comprimento total, contando um espaço extra para separar os dois.
Responder:
função lengthFullName(nome, sobrenome){

comprimento de retorno((nome)+(sobrenome)+(1));
}
Exercício 11: GRITO!
Escrevi a função do grito. Deixamos você usar a função convertEnShift, que, ehm... Poço...
Ele basicamente converte uma cadeia de caracteres em maiúsculas.
Responder:
função shout(word){
return("" + convertUppercase(word) + "!")
}
Exercício 12: E se...?
Nenhuma introdução à linguagem JavaScript estaria completa sem mostrar pelo menos
uma estrutura de controle que já conhecemos: a alternativa condicional.
Vamos ver se entende: escrevi uma função máxima, que funciona como Matemática.max
(não vale a pena usá-la!) e retorna o máximo entre dois números. Por exemplo, o máximo
entre 4 e 5 é 5, e o máximo entre 10 e 4 é 10.
Responder:
função máxima(número1, número2) {

if (número1 >= número2) {
retorno número1;
} else {
retorno número2;
}
}
Exercício 13: Que signo você é?
Precisamos de uma função de sinal, que dado um número nos retorna:
 1 se o número for positivo.

 0 se o número for zero.
 -1 se o número for negativo.
Eu escrevi a função de sinal. Talvez você precise de mais de um se.
Responder:
sinal de função (número){

if(número > 0) retornar 1
if(número === 0) retornar 0
if(número < 0) retornar - 1
}
Exercício 14: O retorno do booleano.
Eu escrevi a função isLuckNumberThat dado um número diz se ele atende à lógica acima.
Não vale a pena usar se!
Responder:
função esLuckNumber(number) {
retorno (número)>0 && (número)<100 && (número!=15);
}
Exercício 15: Os prêmios.
O júri de um torneio pediu-nos para desenvolver uma função de medalha SegunPuesto que
devolve a medalha que corresponde aos primeiros lugares, de acordo com a seguinte lógica:
 Primeiro lugar: corresponde a "ouro".

 Segundo lugar: corresponde a "prata".
 Terceiro lugar: corresponde ao "bronze".
 Outras posições: "nada" lhe corresponde.
Responder:
função medalSecondPosition(place){
if(place === 1){
retorno("ouro")
Retornar
Retorno ("bronze")
} else {
retorno("nada")
}
}
Exercício 16: Tipos de dados.
Como acabamos de ver, em JavaScript existem números, booleanos e strings:
Além disso, existem operações que funcionam para todos os tipos de dados, por exemplo:
 ===: Diz-nos se duas coisas são iguais.

 !==: nos diz se duas coisas são diferentes.
Tente o seguinte no console:
 5 + 6 (OK, números podem ser adicionados).

 5 === 6 (OK, todas as coisas podem ser comparadas).
 8 > 6 (ok, os números podem ser classificados).
 !true (ok, os booleanos podem recusar).
 falso / verdadeiro (não certo, booleanos não podem ser divididos!).
Responder:
Teste no console
Exercício 17: Dados de todos os tipos.
Antes de terminar um último desafio: Qual o valor das seguintes expressões? Confira todos
os corretos!
Responder:
4 + 4 vale 8
"4" + "4" vale "44"

"on" + "ce" vale "uma vez"
true && false é false
5 >= 6 é falso
! verdadeiro é falso
2. Funções práticas e tipos de dados.
Exercício 1: Comprar hardware.
Eu escrevi uma função quanto me custa para pegar o número de polegadas do monitor e a
quantidade de memória, e calcular o custo estimado do nosso computador.
Responder:
função cuantoCuesta(monitor, memória){

retorno(((monitor * 60) + (memória * 200) + 1000);
}
Exercício 2: É certo para mim?
Agora que sabemos quanto custa um computador, queremos saber se um computador

combina comigo. Isso ocorre quando:
 Custa menos de $6000.

 Ele tem pelo menos um monitor de 32 polegadas.
 Ele tem pelo menos 8GB de memória.
Eu escrevi a função meConveniente, que novamente pega o número de polegadas e

quantidade de memória e nos diz se é conveniente para nós comprá-lo.
Responder:
função meConveniente (polegadas, memória){

return (quantCost(inch,memory) < 6000 && inch >= 32 && memory >= 8);
}
Exercício 3: Triângulos.
Hora de fazer geometria! Queremos saber algumas coisas sobre um triângulo:
 PerimeterTriangle: Dado os três lados de um triângulo, queremos saber quanto

tempo é o seu perímetro.
 areaTriangle: Dada a base e altura de um triângulo, queremos saber qual é a sua
área.
Desenvolver as funções perimetroTriangulo e areaTriangulo.
Responder:
função perímetroTriângulo(side1, side2, side3){

retorno (side1 + side2 + side3)
}
área de funçãoTriângulo(side1, side3){
Retorno (side1 * side3 / 2)
}
Exercício 4: Quadrados.
E agora é a vez das praças; Queremos saber
 Perímetro: dado um lado, queremos saber quanto tempo é o seu perímetro.

 areaSquare: dado um lado, queremos saber qual é a sua área.
Desenvolver as funções SquarePerimeter e SquareArea.
Responder:
função perimeterSquare(side) {
retorno (lado * 4)
}
área de funçãoSquare(side) {
retorno (lado * lado)
}
Exercício 5: Você está em sintonia?
Desenvolva uma função sintonizada, que recebe a frequência (um número) da troca, e diz
se essa frequência é igual a 440Hz.
Responder:
função isTuned(frequency){
retorno (frequência === 440)
}
Exercício 6: Está perto?
Agora queremos saber se o piano central está perto de estar em sintonia. Isso ocorre quando
está entre 437Hz e 443Hz, mas NÃO é exatamente 440Hz.
Eu escrevi a função éPerto.
Responder:
função isClose(frequency){
retorno (437 <= frequência && frequência de & <= 443 &&& frequência !==
440)
}
Exercício 7: Pôsteres.
Eu escrevi a função writePoster, que pega um título, um nome e um sobrenome e forma

uma única string.
Responder:
função writePoster(title, nome, sobrenome){

return(título + " " + primeiro nome + " " + sobrenome)
}
Exercício 8: Mais cartazes.
Responder:
função writePoster(title, nome, sobrenome, bool){

return (título + " " + (!bool?nome+" "+sobrenome:sobrenome))
}
Exercício 9: Pôsteres ótimos.
Agora que podemos escrever nossos sinais de identificação grandes e pequenos, queremos
uma nova função que nos dê o sinal de tamanho ideal:
 Se nome e sobrenome têm, no total, mais de 15 letras, queremos um sinal curto;

 Caso contrário, queremos um pequeno sinal longo.
Defini a função writeOptimalPoster que leva um título, um primeiro nome e um sobrenome,

e usando writePosterito gerar um poster curto ou longo, de acordo com as regras anteriores.
Responder:
função writeOptimalPoster(title, nome, sobrenome){

return writePoster(title, first name, last name,(length(first + last name)
>= 15))
}
Exercício 10: Rosto ou hortelã.

Eu escrevi uma função decisionWithCoin, que pega três parâmetros e retorna o segundo se
o primeiro for "cabeças", ou o terceiro, se "menta" sair.
Responder:
função decisãoConMoneda(moeda, pizzas, empanadas){

if(coin === "cabeça"){
devolver pizzas;
}else{
retorno empanadas;
}
}
Exercício 11: Inveja!.
Queremos saber o valor das cartas de truque quando jogamos inveja. Sabemos que:
 Todas as cartas de 1 a 7, inclusive, valem sua numeração.

 Os cartões 10 a 12, inclusive, valem 0.
 Você não joga com 8s ou 9s.
Eu escrevi uma função envidovalue, que pega um número de letra e retorna seu valor de
envio.
Responder:
função valueEnvido(letter){
{carta de retorno}
{retornar 0}
}
Exercício 12: Eu quero retruco!.
Bem, ehm, não, pare, primeiro queremos calcular quantos pontos de inveja um jogador
marca. Sabemos que:
 Se as duas cartas são do mesmo naipe, o valor da inveja é a soma de seus valores de
inveja mais 20.
 Caso contrário, o valor do envio é o maior valor de envio entre eles.
Usando a função EnvidoValue (que já escrevemos para você), desenvolva a função

EnvidoTotalPoints que pega os valores e naipes de duas cartas e diz quanto Envido elas
somam no total.
Responder:
pontos de funçãoTotalEnvido(n1, p1, n2, p2){
if(p1 === p2){
return (EnvidoValue(n1) + EnvidoValue(n2) + 20)
}else{
retornar Matemática.max(n1, n2)
}
}
Exercício 13: Quero valer quatro!
Ao jogar o truque, as equipes adversárias podem alternativamente subir a antena. Por

exemplo, se um jogador canta truque, outro jogador pode cantar truque para ele.
Obviamente, os pontos em jogo estão crescendo:
Cantoria Pontos em jogo

truque 2
Retruco 3
vale
4
quatro
Escrevi a função valueCantoTruco, que pega a música e devolve quantos pontos ela vale.
Responder:
função valueCantoTrick(singing){
if(cantando === "truque"){
retorno(2)
}
if(cantando === "retruco"){
retorno(3)
}
if(canto === "vale cuatro"){
retorno(4)
}
}
3. Variáveis e Procedimentos.
Exercício 1: E o tabuleiro?.
Responder:
misterioso(2, 1)
Exercício 2: Serigrafia.
Responder:
Experimente o Egocentrica() no console.
Exercício 3: Martin Fierro.
Vamos ver se está ficando claro, escrevi uma função versosMartinFierro que imprime na
tela os primeiros versos de Martín Fierro:
Aqui começo a cantar

Al compás de la vigüela;
Que o homem que o revela
Uma tristeza extraordinária
Esta função deve retornar 0
Responder:
retornar 0
}
Exercício 4: E os procedimentos?
Quando quiséssemos reutilizar o código, poderíamos declarar:
 funções, que sempre retornam algo e não produzem efeito.

 procedimentos, que não retornam nada, e produzem efeitos.
Envie esta nova versão do versosMartinFierro.
Responder:
}
Exercício 5: E o programa?.
Em JavaScript, tudo o que escrevemos fora de uma função será, implicitamente, esse
ponto de entrada. Por exemplo, se quisermos um programa que imprima na tela o clássico
"Olá, mundo!", podemos escrevê-lo assim:
print("Olá Mundo!");
Responder:
print("Rolando dados");
print("A primeira tiragem deu " + roll());
print("A segunda tiragem deu " + roll());
print("O terceiro rolo deu " + roll());
Exercício 6: Coerção.
Vamos ver se está claro, eu escrevi uma função elefantesEquilibristas de corda bamba, que
pega uma série de elefantes e devolve uma rima de uma conhecida música "3 elefantes
balançaram".
Responder:
função elefantesEquilibristas (número){

return(número + " " + "elefantes balançaram")
}
Exercício 7: O círculo da vida.
Considerando o número pi igual a 3,14159265358979 (não infinito, mas preciso o suficiente

para nossos cálculos):
Defini as funções de perímetroCircle e areaCircle que recebem o raio de um círculo e dele

retornam seu perímetro e sua área.
Responder:
retorno(3.14159265358979*2*radio)
}
retorno(3.14159265358979 * rádio * rádio)
}
Exercício 8: Acho que é mais fácil.
deixe pi = 3,14159265358979;
Altere os locais onde 3.14159265358979 aparece para a variável pi nas funções que
definimos.
Responder:
deixe pi = 3,14159265358979;
Retorno (PI*2*Radio)
}
return(pi * rádio * rádio)
}
Exercício 9: Isso não tem valor.
À medida que você entende como as variáveis são atribuídas, trazemos algo para você
pensar: e se eu tentar usar uma variável à qual nunca atribuí um valor?
Responder:
Copiar, colar e testar no console
Exercício 10: Variáveis globais.
As variáveis declaradas dentro de uma função, conhecidas como variáveis locais, não
apresentam mais mistério. No entanto, é preciso ter um cuidado especial: eles só podem ser
usados a partir da função em questão.
No entanto, variáveis declaradas diretamente no programa, conhecidas como variáveis

globais, podem ser usadas a partir de qualquer função.
Responder:
deixe carregarMaximaEnKilograms = 300

função elevadorSobrecarregado(pessoas){
return(people * weightAveragePersonInKilograms) > loadMaximumInKilograms
}
Exercício 11: Tornar-se rico.
Eu escrevi um procedimento increaseFortune que dobra o valor da variável global

pesosEnMyWallet. Não declare a variável, nós já fizemos isso para você (com uma quantia
secreta de dinheiro).
Responder:
função increaseFortune(){
pesosEnMyWallet = pesosInMyWallet * 2
}
Exercício 12: E quanto vale isso?
Vimos que uma variável só pode ter um valor, então toda vez que atribuímos um novo,
perdemos o anterior.
Responder:
20
4. Lógica booleana.
Exercício 1: Deixe o último apagar a luz!
Vamos começar com algo simples, você se lembra do operador! ? Chama-se negação, não
ou complemento lógico e serve para negar um valor booleano.
Se eu tiver o booleano representado por hasHungry, o complemento será !hasHunger.
Defini o procedimento a ser usado para que possamos abrir e fechar o fechamento de uma
mochila.
Responder:
deixe mochilaOpen = verdadeiro;

função usClose() {
backpackOpen = !backpackOpenOpen
}
Exercício 2: Negar não custa nada.
Agora é a sua vez! Eu defini que éAdulto, que recebe uma idade, e depois éMinorAge a
partir dele.
Responder:
função esOlder(age){
retorno (idade >= 18)
}
função esMinor(age){
return(!isAdult(age))
}
Exercício 3: Os peripatéticos.
Defini uma função peripatética que leva a profissão de uma pessoa, a nacionalidade e o
número de quilômetros que ela caminha por dia. Alguém é peripatético quando é filósofo
grego e gosta de caminhar (anda mais de 2 quilômetros por dia).
Responder:
função esPeripatetico(professor, nacionalidade, kms){

retorno (professor === "filósofo" & nacionalidade === "grego" && kms > 2)
}
Exercício 4: A verdade por trás da conjunção.
Responder:
Teste no console:
Exercício 5: Vamos jogar T.E.G.!
Responder:
Teste no console:
Vitória (falso, 30)
win(falso, 20)

Exercício 6: E agora... Quem pode nos ajudar?
Sabemos que o banco está fechado quando:
 É um feriado, ou
 É o fim de semana, ou
 Não estamos dentro do horário bancário.
Defini as funções isWeekendWeekend e isClosed.
Responder:
let isHoliday = verdadeiro;

Retorno (dia === "sábado" || dia === "domingo")
}
função éFechado(esFeriado, dia, horário){
return(esFeriado|| !dentroDeHorarioBancario(horario) || esFinDesemana(dia))
}
Exercício 7: Bom dia!
Na família Buendía acontece que:
 Arcadio é filho de José Arcadio e Pilar Ternera.

 Aureliano José é filho do coronel Aureliano e de Pilar Ternera.
 Aureliano Segundo e Remedios são filhos de Arcadio e Sofía De La Piedad.
Para começar a analisar essa família, já definimos as funções mãeDe e paiDe.
Agora cabe a você definir a função areHalfBrothers. Lembre-se que meio-irmãos podem
compartilhar mãe ou pai, mas não ambos porque... Nesse caso, seriam irmãos!
Responder:
função haveTheSameMother(child1, child2){

Mãe de retorno1 === Mãe2;
}
função haveTheSameParent(child1, child2){
retorno pai1 === pai2;
}
função sonHalfBrothers(child1, child2){
retorno (terTheSameMother(child1, child2) !== haveTheSameFather(son1,
child2));
}
Exercício 8: A verdade é que não há verdade.
Teste sua função sonHalfBrothers com os seguintes valores e verifique se ela se comporta
como a tabela:
Responder:
sonHalfBrothers(arcadio, aurelianoJose)
sonHalfBrothers(AurelianoSegundo, remédios)
sonMediaHermanos(aurelianoJose, remédios)
Exercício 9: Olá! Meu nome é Xor.
Ao contrário de e, ou não, xor não é geralmente definido em línguas. No entanto, agora que
você já sabe como funciona, se precisar pode defini-lo manualmente.
Vamos ver se é entendido: defini a função genérica xor, que pega dois booleanos e retorna o
valor verdade correspondente.
Responder:
função xor(a, b){

retorno (a !== b)
}
Exercício 10: Precedência.
Quando uma expressão matemática tem vários operadores, sabemos que multiplicações e
divisões ocorrerão antes da adição e subtração:
5 * 3 + 8 / 4 - 3 = 14
Como na matemática, quando usamos operadores lógicos as expressões são avaliadas em

uma determinada ordem chamada precedência.
Responder:
Teste-o no console com os valores:
payWithCard(verdadeiro, "crédito", 320)
paywithcard(falso, "crédito", 80)

payWithCard(verdadeiro, "débito", 215)
paywithcard(verdadeiro, "débito", 32)
Exercício 11: Um exercício sem precedentes.
Escrevi a função canretire que recebe a idade e o sexo de uma pessoa, além dos anos de
contribuição previdenciária que ela tem.
A idade mínima para realizar o procedimento para as mulheres é de 60 anos, enquanto para
os homens é de 65 anos. Em ambos os casos, é preciso ter pelo menos 30 anos de
contribuição.
Tente resolvê-lo em uma única função! Então vamos ver como seria se delegássemos.
Responder:
função podeAposentar(idade, sexo, contribuição){

retorno((sexo === "F" && idade >= 60) || (sexo === "M" && idade >= 65)) &&
contribuição >= 30
}
Exercício 12: Posso subir?.
Os requisitos para subir a atração são:
 Atingir a altura mínima de 1,5m (ou 1,2m se acompanhado por um adulto).

 Não ter nenhuma condição cardíaca.
Defini a função de 3 parâmetros canRise que recebe uma altura de uma pessoa em metros,
se ela está acompanhada e se tem algum problema cardíaco.
Responder:
função pode ser escalada (altura, acompanhado, condição){

retorno((altura >= 1,5) || (altura >= 1,2 && acompanhado)) && !afeto
}
5. Listas.
Exercício 1: Série favorita.
Para representar um conjunto de strings, colocamos todas as strings que nos interessam,
entre colchetes ([ e ]) separadas por vírgulas. Fácil, não é?
Responder:
sérieFavoritosDeAna
sérieFavoritosDeHector
["Olá","Mundo!"]
["olá","olá"]
Exercício 2: E esta é uma lista.
O que acabamos de ver é como modelar facilmente conjuntos de coisas. Usando [], em
JavaScript temos uma maneira simples de agrupar esses itens em listas.
Existe um número máximo de itens? Não, não há limite! As listas podem ter qualquer
número de itens.
E não só isso, mas a ordem é importante. Por exemplo, ["hello", "world"] não é o mesmo
que ["world", "hello"]: ambos têm os mesmos elementos, mas em posições diferentes.
Responder:
Equallists(["olá", "mundo"], ["mundo", "olá"])
Equallists(["olá", "mundo"], ["olá", "mundo"])
Equallists(["olá", "mundo"], ["olá", "todos", "o", "mundo"])
Equallists(["olá"], ["olá", "mundo"])
["hello", "world"] === ["mundo", "hello"]
povo
["mara", "Julian"] ===Pessoas

Pessoas === Pessoas
Exercício 3: Jogo.
Também podemos representar conjuntos de números ou booleanos, da mesma forma:

escrevendo-os entre colchetes e separados por vírgulas. Podemos ter listas de números,
strings, booleanos, etc. Podemos até ter listas de listas!
Responder:
Vamos ver se está claro. Teste as seguintes consultas no console:
Números da loteria
SalioCara
[[1, 2, 3], [4, 5, 6]]
Exercício 4: Listas vazias.
Ótimo, parece que uma lista pode conter qualquer tipo de item! Podemos ter listas de
booleanos, números, strings, listas...
E não só isso, mas eles também podem conter qualquer número de elementos: um, dois,
quinze, centenas.
Podemos, então, ter listas vazias, ou seja, aquelas que não têm elementos? É claro!
deixe aEmptyList = []
Responder:
Tente digitar uma lista vazia no console
Exercício 5: Quantos elementos você tem?
No momento, já sabemos o que podemos representar com listas e como fazê-lo. Mas o que
podemos fazer com eles?
Vamos começar pelo fácil: saber quantos itens estão na lista. Podemos fazer isso usando a
função length, semelhante ao que fizemos com strings.
Responder:
Execute as seguintes consultas no console:
comprimento([])
comprimento (números de loteria)
comprimento([4, 3])
Exercício 6: Adicionando sabor.
As listas são muito úteis por conter vários itens. Mas há mais! Também podemos adicionar
itens a ele a qualquer momento, usando a função add, que recebe dois parâmetros: a lista e o
item.
Como podemos ver, adicionar adiciona um item à lista, o que faz com que seu tamanho
aumente. Mas onde na lista você adiciona isso? Inicialmente? No final? No meio?.
Descubra você mesmo: inspecione no console quais itens contêm pertences, adicione uma
"besta" e inspecione os pertences novamente.
Há também um procedimento de remoção, que só recebe a lista por parâmetro. Descubra o

que ele faz no seu console.
Responder:
Teste no console
add(pertences, "amuleto mágico")
Exercício 7: Mova-se.
Ele declarará um procedimento para mover, que pega duas listas, tira o último elemento da
primeira e adiciona à segunda.
Responder:
função move(oneList, anotherList){
adicionando(anotherList, removendo(aList))
}
Exercício 8: E onde fica?
E o que acontece se você passar por parâmetro para posicionar um elemento que não tem?
Descubra-se!
Responder:
Copiar e colar no console
cargo(diasLaboral, "osvaldo")
Exercício 9: Contém.
Eu escrevi a função contém para nos dizer se uma lista contém um determinado item.
Se você tem prestado atenção aos exemplos de consulta, você terá notado que as listas
também podem ter elementos duplicados: [1, 2, 1], ["hello", "hello"], etc.
Portanto, a posição realmente retorna a posição da primeira aparição do item na lista.
Responder:
função contém(matriz, pesquisa){

return(position(array, pesquisa) >- 1)
}
Exercício 10: Nono elemento.
Assim como existe uma função para descobrir em que posição um elemento está, também
pode acontecer de querermos saber o contrário: qual elemento está em determinada
posição.
Para descobrir, podemos usar o operador de indexação, escrevendo após a coleção e entre
colchetes [] a posição que queremos descobrir.
Responder:
deixar lista =[]

lista[0]
Exercício 11: Mais prêmios.
Se você pedir um item em uma posição igual ou maior que o tamanho da lista, você ficará
indefinido. Não parece uma coisa terrível, mas o problema é que com undefined você não
pode fazer nada realmente útil.
Por isso, o aviso é: não exagere!
Com isso em mente, há um desafio: escrevi a função medalha novamente, mas desta vez
usando no máximo um único se. Talvez as listas possam ser úteis aqui.
Lembramos o que a função faz: tem que devolver a medalha que corresponde às primeiras
posições de uma competição.
Responder:
deixe medalha = ["nada", "ouro", "prata", "bronze"]
função medalSecondPosition(position){
if(posição <= 3){
retorno(medalha[posição])
} else {
Retorno(medalha[0])
}
}
Exercício 12: Não se esqueça de dizer olá.
Vamos conhecer uma maneira de percorrer os elementos de uma lista com um novo amigo:
o loop for.
Responder:
função greet(people){
for(let persona1 de personas){
print("olá" + " " + pessoa1);
}
}
6. Registros.
Exercício 1: Os primeiros registros.
Responder:
Copie e cole o código no console
estátua da liberdade
Christthe Redentor
torreEiffel
tajMahal
coliseu
Exercício 2: Seu próprio monumento.
É o seu momento monumento! Mantenha nas variáveis torreAzadi e monumento

NacionalALaBandera registros desses monumentos, originários das cidades de Teerã, Irã e
Rosário, Argentina, respectivamente. Você se atreve a investigar em que ano eles foram
concluídos para completar esse campo?
Responder:
let torreAzadi = {nome: "Torre Azadi", localização: "Teerã, Irã",

anioDeConstruccion: 1971}
let monumentoNacionalALaBandera = {nome: "Monumento Nacional A La Bandera",
localização: "Rosario, Argentina", anioDeConstruccion: 1957 }
Exercício 3: Acessando o campo.
Declaramos os planetas mercúrio, Marte e Saturno como registros com as seguintes

informações: nome, temperatura média e se possui anéis. Experimente-os no console!
Responder:
Declaramos os planetas mercúrio, Marte e Saturno como registros Problos no

console!
Exercício 4: Planejar a temperatura.
Desenvolva uma função planettemperature que receba um registro de planeta por parâmetro
e retorne uma string indicando seu nome e temperatura média. Tem que funcionar para
qualquer planeta!
Responder:
função temperaturadePlaneta(planeta){
return(planet.name + " tem uma temperatura média de " +
planet.temperatureAverage + " graus")
}
Exercício 5: Movendo arquivos.
Desenvolva o procedimento moveFile, que recebe um registro e um novo caminho e

modifica o arquivo com o novo caminho.
Responder:
função moveFile(registry, Newpath){

deixe readme = log.path = caminhoNovo
}
Exercício 6: Registros de dois milênios.
No exercício anterior, modificamos o caminho do registro, mas não usamos sua data de
criação. Vamos usá-lo! Queremos saber se um arquivo é do último milénio, o que acontece
quando o seu ano é anterior ao ano 2000.
Desenvolva a função LastMillenniumPast, que recebe um arquivo e retorna um booleano.
Responder:
função enMillenniumPast(file){
return(anio(file.creation) < 2000)
}
Exercício 7: Sobremesas complexas.
Crie uma função difícil de cozinhar, que recebe dois registros de sobremesa por parâmetro e
retorna aquele com mais ingredientes dos dois.
Responder:
função masDifícilCozinhar (sobremesa1, sobremesa2){

if(length(dessert1.ingredients) < length(dessert2.ingredients)){
}
if(length(dessert1.ingredients) >= length(dessert2.ingredients)){
}
}
Exercício 8: Listas de inscrição.

Assim como trabalhamos com listas de números, booleanos, strings ou mais listas, também
podemos listar registros. Você pode fazer tudo o que você fez antes, como mexer, saber seu
comprimento ou pedir o elemento de uma determinada posição usando os colchetes [ ].
Experimente as listas de Favoritos e Monumentos da América no seu console. Tem uma

sobremesa que a gente não mostrava antes, você percebe o que é só lendo seus
ingredientes?
Responder:
Teste no console:
sobremesasFavoritos
monumentos da América
Exercício 9: 60 minutos doces.
Desenvolva o procedimento addAPostresRapidos, que recebe uma lista com sobremesas

rápidas e uma sobremesa por parâmetro. Se o tempo de cozimento for de uma hora ou
menos, o registro será adicionado à lista.
Responder:
função addAPostresRapidos(lista, sobremesa){

if(sobremesa.tempo decozimento <= 60){
add(lista, sobremesa)
}
}
Exercício 10: Há um registro no meu registro.
Descubra o que o campo de ingredientes retorna no campo de sobremesa do registro

ChildrenMenu. Há um disco dentro do outro!
Responder:
Teste no console
menuInfantil.sobremesa.ingredientes
Exercício 11: Açúcar!

Defini um procedimento para adoçar o cardápio, que recebe um registro do cardápio e
adiciona açúcar aos ingredientes de sua sobremesa. Se você já tem açúcar, não importa...
Adicione mais!
Responder:
função sweetenMenu(menu){
adicionar(menu.dessert.ingredients, "açúcar")
retornar menu.sobremesa
}
7. Rotas.
Exercício 1: Ganhos semestrais.
O recurso Ganho Semestral que escrevemos anteriormente tem algum problema? Vai
funcionar com balanços trimestrais? E com os períodos de quatro meses?
Experimente no console!
Responder:
Teste no console:
ResultadosSemestre
Exercício 2: E o restante dos lucros?
O que gostaríamos é de poder somar os lucros de todos os saldos de uma lista,

independentemente de quantos realmente existam; queremos uma função de lucro total, que
pode somar saldos de qualquer período de meses: semestres, trimestres, trimestres, etc. Que
difícil!
Responder:
TotalProfit([
{ mês: "Janeiro", lucro: 2 },
{ mês: "Fevereiro", lucro: 3 }
])
Exercício 3: Todos os lucros, o ganho.

Responder:
função profitTotal4(saldosDe um período){

Soma let = 0
soma = soma + período de balanço[0].lucro
soma = soma + saldo[1].lucro
Retorno de soma
}
Exercício 4: Um velho amigo nos visita.
O que temos que fazer, então, é repetir a operação de acumular várias vezes, uma para cada
item da lista. Vamos dizer olá (novamente) para o for... de!
Como você pode ver, o... de nos permite visitar e fazer algo com cada item de uma lista;
neste caso, visitaremos cada balanço do SinglePeriod.
Responder:
TotalProfit([
{ mês: "Março", lucro: 8 },
{ mês: "Agosto", lucro: 10 }
])
Exercício 5: Contas claras.
Ana tem novas exigências! Agora ele nos perguntou o seguinte: "Quero saber quantos
saldos foram positivos, ou seja, aqueles em que o lucro foi maior que zero".
Conclua a função PositiveBalanceQuantity . Se você prestar atenção, notará que ele tem
uma estrutura semelhante ao problema anterior.
Responder:
valor da funçãoSaldosPositivos(SaldosDeUm Período){

deixe a quantidade = 0
quantidade = quantidade + ((saldo.lucro) > 0)
}
quantidade de retorno;
}
Exercício 6: O ganho médio.

Vamos ao próximo pedido de Anne. Já podemos calcular uma soma de lucros e também
criar contadores, agora vamos calcular médias.
Ana gostaria de saber, dado qualquer conjunto de saldos, qual é o seu lucro médio.
Responder:
função gainAverage(Totalgain){
Soma let = 0
for(let balance of gainTotal){
soma = (soma + saldo.lucro)
}
retorno da soma / comprimento (gainTotal)
}
Exercício 7: Quem ganha, quem perde.
Vendo que podemos fazer tudo o que pede, Ana quer saber o ganho médio dos saldos
positivos.
Defini as funções:
 Ganho positivo, que é a soma dos ganhos dos balanços positivos.

 médiaGanhos Positivos invocando PositiveGain e PositiveBalanceAmount.
Responder:
ganho de funçãoPositivo(saldosDeperíodo){
Soma let = 0
soma = soma + (saldo.ganho)
}
}
Retorno de soma
}
função médiaLucrosPositivo(SaldosDeUmPeríodo){
retorno lucroPositivo(SaldosDeUm Período) / montantePositivo(saldosDeUm
Período)
}
Exercício 8: Eu sou o mapa, eu sou o mapa.
Infelizmente, você não pode usar o recurso médio com nossa lista de registros. O que
precisamos é de uma lista que tenha apenas os lucros de cada balanço. Para fazer isso,
devemos transformar, ou mapear, cada item da lista.
Complete a função de lucro que pega uma lista de saldos e retorna uma lista que possui
apenas os lucros de cada um.
Responder:
ganhos de função(saldosOfAPeriod){
deixar ganhos = []
agregado(lucro, saldo.lucro)
}
retorno de lucros
}
Exercício 9: Filtre, filtre tudo em seu lugar.
Com a programação você pode fazer qualquer coisa, ou quase. Já fizemos uma função para
poder saber a quantidade de saldos positivos (amountofPositiveBalances), agora vamos ver
como podemos fazer para saber quais são esses saldos.
Conclua a função Saldos Positivos que pega os saldos de um período e retorna uma lista
daqueles cujo lucro foi maior que zero.
Responder:
saldos de funçãoPositivo(OnePeriodsbalances){
deixe saldos = []
add(saldos, saldo)
}
}
Saldos de Retorno
}
Exercício 10: Uma média mais positiva.
Agora que temos a função lucros e saldos positivos podemos usar a função média genérica
para saber qual é o lucro médio dos saldos positivos.
Defini a função PositiveBalanceGains e depois a usei ao lado da média para definir

PositiveBalancesAverage.
Responder:
função ganhos deSaldos positivos(saldo período){

ganhos de retorno(Saldos positivos(OnePeriod)
}
função médiaSaldosPositivos(SaldosDeUm Período){
Rendimento médio (ganhos de saldos positivos)
}
Exercício 11: Este é o máximo.
Vamos conhecer uma nova função, maximo, que nos permite saber qual é o valor mais alto
em uma lista de números.
Usando esta nova função, defini a função maximaGain que nos diz qual é o maior lucro
entre os saldos de um período de tempo.
Responder:
função maximaGain(balancesOfA period){

retorno máximo (ganhos(saldos OnePeriod))
}
Exercício 12: No mínimo.
Supomos que você adivinhou o nome. Se não, é mínimo.
Defini a função minimaPositiveGain que nos diz qual é o menor ganho de todos os saldos
positivos.
Responder:
função minimaPositiveGain(balancesOfA period){

retorno mínimo(ganhos deSaldos Positivos(SaldosDeUmPeríodo));
}
Exercício 13: Os melhores meses do ano.
Para isso vamos fazer as seguintes funções:
 meses, que dada uma lista com registros retorna uma lista de meses;
 lucky, que filtra aqueles registros que tiveram lucro superior a R$ 1 mil;
 mesesLucky, devolva aqueles meses que foram de sorte.
Defini as funções meses, sorte, meses.
Responder:
meses de função(earningsPeriod){
deixe o mês = []
for(let period of earningsPeriod){
add(mês, período.mês)
}
mês de retorno
}
função fortunate(earningsPeriod){
deixe a sorte =[]
for(let period of earningsPeriod){
if(period.profit > 1000){
adicionar (sorte, ponto final);
}
}
retornos de sorte;
}
função mesesLucky(earningsPeriod){
meses de retorno (lucky(earningsPeriod));
}

Exercícios de Mumuki

Enviado por

Dados do documento

Descrição original:

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Exercícios de Mumuki

Enviado por

Direitos autorais:

Formatos disponíveis

Curso de Introdução à Programação

Exercício 5: Siga o movimento.

A sintaxe de um programa é bastante simples:

Exercício 6: Em todos os lugares.

Exercício 7: A ordem das coisas.

Humanos, costumamos pensar em termos do resultado final, ou seja, destacamos o objetivo

Exercício 8: Sim, isso também pode ser quebrado.

Exercício 9: Nossas primeiras bolas.

Exercício 10: Mais e mais bolas.

Exercício 11: Coloque suas primeiras bolas.

Exercício 12: Tire bolas.

Exercício 13: Quando não há bolas.

Exercício 14: Limpar a célula.

2. Pratique os primeiros programas.

Exercício 1: Aquecimento dos motores.

Exercício 2: Combinando comandos.

Exercício 3: A linha vermelha.

Exercício 4: Uma pequena escada.

Exercício 6: E agora um mais próximo.

Exercício 7: Limpeza do jardim.

Exercício 8: Substitua os pellets.

Exercício 1: Do que se trata?

Você deve tentar descobrir o que o programa faz.

 Desenhar uma caixa de bolas pretas

Exercício 2: Um programa ligeiramente longo.

Agora você tem a possibilidade de ver o programa em ação.

Exercício 3: Coisas pelo nome.

Exercício 4: Tarefas de ensino para o computador.

Copie, cole e envie o código

Exercício 5: Procedimentos em ação.

Complete o código para que, além de definir o procedimento PonerNegroyRojo, você o

Exercício 6: Procedimentos de escrita.

 Começamos com o procedimento da palavra reservada;

Exercício 8: Uma definição, usos "infinitos".

Exercício 9: Procedimentos dentro dos outros.

Exercício 10: Desenhamos com imaginação.

Defini o procedimento DrawBlackTip e invocal dentro de um programa. A cabeça

Exercício 11: De ponta a ponta.

Defini o procedimento DrawTwoTips e invocalo dentro de um programa. Lembre-se de

Exercício 12: Vermelho na borda.

Exercício 13: Decorar o tabuleiro.

Exercício 14: Cores, cores, cores.

Defini um procedimento ColorLineDraw que desenha uma linha multicolorida de quatro

Exercício 15: Quadrado de cores.

Exercício 2: O computador repete para nós.

Exercício 3: MoveWest5 usando repetir.

Defini um procedimento MoveWest5 que se move 5 vezes para o Ocidente.

Exercício 4: Não é só repetir.

Defini o procedimento Poner3AlNoreste(), que coloca 3 bolas pretas na primeira célula a

Exercício 5: Também se aplica mais tarde.

Exercício 6: Repetir vários comandos.

Exercício 7: Onde está o erro?

Exercício 8: Diagonal com uma bola.

Defini um procedimentoDiagonal4 Blue() que desenha uma diagonal de

Exercício 9: diagonal "pesada".

Defini um procedimento DiagonalPesada4Azul() que ao invés de colocar 1 bola em cada

Exercício 11: De um lado para o outro, desenhe um quadrado.

Exercício 1: Pensando em subtarefas.

Exercício 2: Desenhar um quadrado com subtarefas.

Defini o procedimento DrawBlackSquareOfSide3() que usando DrawBlackLine3() desenha

Exercício 3: Esperança colorida.

Defini o procedimento DrawGreenLine3() para desenhar uma linha verde e vocal no

Exercício 4: Os que faltam.