Java Svetlin Nakov

Machine Translated by Google
Livro "Fundamentos de programação com

Java" Autor: Svetlin Nakov e equipe
ISBN: 978-619-00-0636-7
Páginas: 420
Idioma: Búlgaro
Editora: Faber, Veliko Tarnovo
Sófia, 2017
Livro básico de programação C#
Livro "Fundamentos da Programação Java"
Livro Fundamentos da Programação JavaScript
Livro básico de programação em Python
Livro "Fundamentos de Programação com C++"
Livro "Fundamentos de Programação com PHP"
Livros "Introdução à Programação C# e Java"
Fundação da Universidade de Software (Fundação SoftUni)
SoftUni (Universidade de Software)
Curso gratuito com videoaulas sobre "Fundamentos de programação com a linguagem C#"
Svetlin Nakov – site oficial, cursos de programação e aulas
Etiquetas: programação; programação de livros; livro de programação; um livro; livro grátis; grátis; livro eletrônico; livro
eletrônico; Java; Livro Java; livro Java; código do programa; livro Java; livro Java; Java; Livro básico de Java;
Noções básicas de programação Java; livro de programação Java; livro básico de programação; livro básico de
programação Java; programação de computadores; conceitos de programação; noções básicas de
programação; livro didático; autodidata; Introdução ao Java; Introdução Java; livro java; aulas de programação;
aulas de programação; aprender Java; tutoriais Java; tutoriais Java; aprender programação; como programar;
programador; programação prática; técnicas de programação; pensamento lógico; pensamento algorítmico; codificador;
codificador; codificação; codificação; habilidades de codificação; habilidades de programação; linguagem de programação;
linguagem de programação; noções básicas de programação; primeiros passos da programação; aulas; Código fonte;
Código fonte; Código aberto; Código fonte; Código aberto; compilador; compilador; depuração; depurador; Eclipse;
IntelliJ IDEA; IDE; ambiente de desenvolvimento; Java; JVM; JavaSE; dados; variáveis; operadores; expressões;
console; console; entrada do console; saída do console; Aplicação de console; Construções condicionais; se
declaração; se construir; se; if-else; switch-caixa; ciclos; enquanto; fazer enquanto; loop for; laço foreach; laços
aninhados; métodos; métodos de chamada; parâmetros; tarefas de programação, resolução de problemas; tarefas e
decisões; escrever código; teste de código; exercícios; tarefas; decisões; instruções de programação; tarefas
de programação; exercícios de programação; bom programador; programador pessoal; Nakov; Nakov; Svetlin
Nakov; Svetlin Nakov; universidade de software; SoftUni; academia de software; ISBN 978-619-00-0636-7; ISBN9786
Livro Java Basics - Capa frontal

Conteúdo curto
Breve Conteúdo ....................................... ................................................ .. ............... 3
Conteúdo .................................. ................................................ ..... .........................................
7 Prefácio ..... .......................................... ....... ......................................... ......... ................... 11
Capítulo 1. Começando na Programação........................... ....................................... 25
Capítulo 2.1. Cálculos simples com números.............................................. ..... ...............................
69 Capítulo 2.2. Cálculos simples com números - problemas de exame .............................. .........
99 Capítulo 3.1. Verificações simples ..................................... .....................................................
117
Capítulo 3.2. Verificações simples - tarefas de exame .............................. ..... 141 Capítulo4.1.
Verificações mais complexas ....................................... .... ......................................... 155
Capítulo 4.2. Verificações mais complexas - tarefas de exame ........................... .............. 175
Capítulo 5.1. Repetições (ciclos) .............................................. ................................................
197
Capítulo 5.2. Repetições (ciclos) - tarefas de exame .................................. .. ............ 225
Capítulo 6.1. Loops aninhados .......................................... .....................................................
243 Capítulo 6.2. Ciclos aninhados - tarefas de exame .............................. ...................... 259
Capítulo 7.1. Ciclos mais complexos ....................................... .... .................................................. ...
273 Capítulo 7.2. Ciclos mais complexos - tarefas de exame ....................................... ................
293 Capítulo 8.1. Preparação para exame prático - parte I ........................................ ....... 305
Capítulo 8.2. Preparação para exame prático - parte II ........................................ ...... 329
Capítulo 9.1. Tarefas do Campeão - Parte I ............................... .............................. 345
Capítulo 9.2. Tarefas do Campeão - Parte II.................................. ..................... 359 Capítulo
10. Métodos ........... ..................................................... . .................................................. 375
Capítulo 11. Truques e hacks ....................................... ................................................. 401
Conclusão ......................................................... .. ................................................ ......................... 413
Noções
básicas de
programação Java
Svetlin Nakov e equipe
Asya Dikova-Kirova Milena Georgieva

Vaidin Kachanov Nikolai Bankin
Vencislav Petrov Peter Ivanov

Daniel Tsvetkov Rositsa Nenova
Dimitar Dalev Svetlin Nakov
Julieta Atanasova Teodor Kurtev
Ivaylo Ivanov Tsvetan Georgiev
Christian Pamidov
ISBN: 978-619-00-0636-7
Sófia, 2017
Noções básicas de programação Java

© Svetlin Nakov e equipe, 2017.
Primeira edição: dezembro de 2017
Este livro é distribuído gratuitamente sob a licença aberta CC-BY-SA, que especifica os
seguintes direitos e obrigações:
• Compartilhamento - Você pode copiar e distribuir o livro livremente em

todos os formatos e mídias.
• Adaptação – você pode copiar, misturar e alterar partes do livro
e criar novos materiais com base em trechos dele.
• Atribuição – ao usar trechos do livro, você deve citar a fonte original, a licença atual e
descrever as alterações feitas sem enganar o usuário de que os autores originais
endossam seu trabalho.
• Compartilhamento similar – se você criar material misturando, modificando e copiando

trechos do livro, você deve compartilhar o resultado sob a mesma licença ou similar.
Todas as marcas registradas usadas neste livro são de propriedade de seus respectivos
proprietários.

ISBN: 978-619-00-0636-7
Canela: Marina Shiderova - http://shideroff.com
Site oficial: https://java-book.softuni.bg
Página oficial do Facebook: https://fb.com/IntroProgrammingBooks
Código-fonte: https://github.com/SoftUni/Programming-Basics-Book-Java-BG
Contente
Breve Conteúdo ....................................... ................................................ .. ............... 3
Conteúdo .................................. ................................................ ..... ......................................... 7
Prefácio ..... .......................................... ....... ......................................... ......... ................... 11
Para quem é este livro? ................................................ .. ............................................. .... ......................11
Por que escolhemos a linguagem Java?.............. . ............................................. ... .........................................
Programação aprende-se escrevendo muito, não lendo!.......................................... . ......................12
Sobre a Universidade de Software (SoftUni).............. ................................................ .. ......................13
Como se tornar um programador? ................................................ .. ............................................. .... ..............
O livro para ajudar os professores............................ .. ............................................. .... ...........................20
A história deste livro........ ................................................ ..... ............................................21 Site
oficial do livro ........................................ ......................................... ........ .............22 Fórum para suas
perguntas........................... ......................................... ............ ................................22 Página oficial
do livro no Facebook......... ......................................... ........ .............................23 Licença e
Distribuição........ ....... ......................................... ......... ........................................23 Relatando
erros .. ......................................... ............ ..................................... .............. ................23 Boa
leitura!............. ............... ................................ ................. ............................. ................... ....23
Capítulo 1. Iniciando na Programação............................ ............................. .... 25
Vídeo ................................................. .. ................................................ ................................................ .. ...
O que significa "programar"?.............................. ................................................ ..... .....25 Como
escrever um programa de console?........................... . ............................................. ... ............29
Exemplo: criando um programa de console "Hello Java"............ .........................35 Erros típicos
em programas Java............ ......................................... ......... ................................39 O que
aprendemos com este capítulo? ........ ....................................... .......... .......................................40
Exercícios: primeiro passos na codificação ....................................... ........................................40
Console, aplicações gráficas e web ..................................... .............. .................................46
Capítulo 2.1. Cálculos simples com números.............................................. ..... ............................... 69
Vídeo ............... ..................................................... ..................................................... ..............................69
Console do sistema ....... . ................................................ . ............................................. ... ...........69
Lendo números do console ....................... ................................................ ..... ................................70
Cálculos na programação ....... ..... .......................................... ....... .........................................72
Tipos de dados e variáveis.... ............................................. ... ................................................ ..... ..........73
Lendo um número fracionário do console........................... ...................................................... .........73
Lendo e imprimindo texto............................... ....................................... .......... .........................74
Unindo texto e números........ ......... ......................................... ........... ......................................... 74
Operações aritméticas........ ......................................... ......... ......................................... ........... ...........75
Unir texto e número ....................... ..................................... .............. .........................77 Expressões
numéricas ........ .............. ................................ ................ ................................ .................. ...........78
O que aprendemos com este capítulo?........................... ................................ .................. .........................80
Exercícios: cálculos simples .................. ............................. .................... ......................... 81 Capítulo
2.2. Cálculos simples com números - problemas de exame .............................. ......... 99
Lendo números do console ....................................... . ................................................ . .............99
Saída de texto usando especificadores de formato (especificadores de formato) .............. .. ...99
Operadores aritméticos........................................... ................................................ .. .........................99
Concatenação........... ................................................ ..... .......................................... ....... ............100
tarefas de exame............................ ......................................... ......... ....................................100
Tarefa: Estudo Salão ........................ ........... ..................................... ............. ......................100
8 Fundamentos da Programação Java
Tarefa: mercado de hortaliças.............................................. ..................................................... ....................

104 Missão: Conserto de Azulejos ....................... .. ................................................ .........................................
106 Tarefa: moedas......... ................................................ .. ............................................. .... .....................
109 Tarefa: lucro diário..... ..... .......................................... ....... ......................................... 112 Capítulo
3.1. Verificações simples ..................................... ..................................................... .. 117
Vídeo................................................. .. ................................................ ................................................ .. ...
117 Comparando Números.......................................... ..................................................... ..................................
117 Verificações simples........ .... .................................................. .. ................................................ ...................
118 Verificações com construção if-else ........................ ................................................ .. ............................ 119
Sobre chaves { } após if / else........ .. ............................................. .... ................................ 119 Vida de
uma variável ........... ................................................ ..... .......................................... ....... .... 122 Série de
cheques............................... ......................................... ......... ................................ 122 Exercícios:
verificações simples .. ......... ......................................... ........... ...................................... 123 Depuração
- operações simples com um depurador .. ......................................... ........... ................................ 128
Exercícios: verificações simples ........... ..................................... ............. ...................................... 129
Capítulo 3.2. Verificações simples - tarefas de exame .............................. ..... ................. 141 Tarefas do
exame ....................... ..... .......................................... ..................................................... ... .... 141 Tarefa:
preço do transporte............................... ..... .......................................... ..... ........................ 141 Tarefa:
canos em uma piscina.............. ..................................................... ..................................................... 144
Missão: Tom Gato Sonolento.......................................... .. ................................................ .......... 146
Tarefa: Colheita .................................... ................................................ .. ......................................... 149
Tarefa: empresa ................................................ . ............................................. ... .........................................
152 Capítulo 4.1. Verificações mais complexas ....................................... .... ......................................... 155
Vídeo. .... .................................................. .. ................................................ ................................................
155 Verificações aninhadas ................................................. ................................................ .. .......................
155 Verificações mais complexas............... ... ................................................ ..... .......................................... ....... ..
158 "OU" Lógico .................................... ....... ......................................... ......... .........................................
160 Negação lógica.. ......... ......................................... ........... ..................................... ............. ........ 162
O operador parênteses () .............. .................. ............................. ................... ............................. 162
Condições lógicas mais complexas .............. ..................................... ............. ..................... .......... 163
Interruptor de construção condicional- caso ...................................... ................................ ................ 166
O que aprendemos com este capítulo? ................................................ .. ............................................. ....
169 Exercícios: verificações mais complexas........................................... .......................................... ....... ...
170 Capítulo 4.2. Verificações mais complexas - tarefas de exame ........................... .............. 175
Verificações aninhadas ............................... . ................................................ . .........................................
175 Verificações de caso de comutação.. . ............................................. ... ................................................ ..... ...........
175 Tarefas do exame ............... .......................................... ....... ......................................... ......... 176
Tarefa: a tempo para o exame.............................. ......................................... ......... ......................... 176
Missão: Jornada............... ......... ......................................... ........... ......................................... 180 Tarefa:
operações entre números ....................................... ................................... ............... .... 184 Tarefa:
Bilhetes de jogo ....................................... ................................ .................. ............................. 187 Tarefa:
quarto de hotel.............. ................................ .................. ............................. .................... ..... 191
Capítulo 5.1. Repetições (ciclos) .............................................. ......................................... 197
Vídeo................................................. .. ................................................ ................................................ .. ...
197 Repetições de bloco de código (loop for)............... ......................................... .. 197 Trecho de código
para um loop for no IntelliJ IDEA........................................... ......................................... 199
Conteúdo 9
O que aprendemos com este capítulo? ...................................... ...... .......................................... .... ............206
Exercícios: repetições (ciclos) ........................... .... .................................................. .. ....................207
Exercícios: Aplicações Gráficas e Web ..................... .. ................................................ ..........213
Capítulo 5.2. Repetições (ciclos) - tarefas de exame .................................. .. ............ 225 Tarefas do
exame........................... ................................................ .. ............................................. ..225 Tarefa :
Histograma ....................................... .... ...................................................... .............................225
Missão: Clever Lily ........... .... ...................................................... ......................................... ........ ......230
Missão: Retorno ao Passado ....................... ......................................... ......... .............233 Missão:
Hospital............................ ......................................... ........... ..................................... ............. 235
Problema: divisão sem resto ....................................... ..................................... .............. .............238
Tarefa: Logística........................... ................................... ............... .................................239 Capítulo
6.1. Loops aninhados .......................................... ..................................................... 243
Vídeo .............................................. . ............................................. ... ................................................ ..... ..243
Loops aninhados ............................... ..... .......................................... ....... .........................................245
Desenhando figuras mais complexas ....... ......................................... ......... ........................................251
O que aprendemos com este capítulo? ....................................... ......................................... ........... ..........258
Capítulo 6.2. Ciclos aninhados - tarefas de exame .............................. ...................... 259 Tarefas do
exame............... ........ .......................................... ...... .......................................... ........259 Tarefa:
desenhar uma fortaleza .............................. .... .................................................. .. .......................259
Tarefa: Borboleta ............... . ................................................ . ............................................. ... .........262
Tarefa: Sinal de "Pare" .................. .. ............................................. .... .........................................264
Tarefa: seta .... ............................................. ... ................................................ ..... .............................266
Missão: Machado .......... ..... .......................................... ....... ......................................... ......... ................269
Capítulo 7.1. Ciclos mais complexos ....................................... .... .................................................. ... 273
Vídeo .............................................. ...... .......................................... .... .................................................. .. .....27
Ciclos de passo ............................... ........ .......................................... ...... .........................................273
Loop while. ..................................................... ..................................................... .....................................276
Máximo Divisor Comum (MDC) .... . ............................................. ... ................................................ 277
Algoritmo de Euclides .. ...................................................... ......................................... ........ ...................278
Loop Do-While ..................... ....................................... .......... ......................................... ............ ........279
Laços infinitos e a instrução break........................... ......................................... ........... ......281 Loops
aninhados e a instrução break ....................................... ......................................... ............ .......284
Manipulando dados inválidos: try-catch ....................... .......... ..................................... .............. .........286
Tarefas com loops ....................... .............. ................................ ................ ................................ .............287
O que aprendemos deste capítulo? .......................... .............. ................................ ................ ..........292
Capítulo 7.2. Ciclos mais complexos - tarefas de exame ....................................... ............... 293 Tarefas
de exame............................ . ............................................. ... ................................................ ..... .293
Tarefa: Gerador de senha fictício ....................................... ......................................... ........ ....293
Tarefa: números mágicos............................... ....................................... .......... .........................295
Problema: número de parada........ ......... ......................................... ........... ........................................299
Problema : números especiais ....................................... ..................................... .............. ...................300
Tarefa: números ............. .............. ................................ ................ ................................ .................. .......302
Capítulo 8.1. Preparação para exame prático - parte I ........................................ ....... 305
Vídeo ................................................. .. ................................................ ................................................ .. ...305
Exame prático de "Fundamentos de Programação" .................................. .. ......................305 Sistema
de Julgamento Online (Juiz) ............... ... ................................................ ..... ......................305
Problemas com cálculos simples.............................................. ..................................................... ... ...........

305 Tarefas de Verificação Única .............................. . ................................................ . .......................
309 Tarefas com verificações mais complexas............... .. ............................................. .... .........................................
312 Problemas de ciclo único ..... ... ................................................ ..... .......................................... .......
316 Tarefas para desenhar figuras no console ....................................... ...................................... 320
Tarefas com loops aninhados com lógica mais complexa . .......................................... ....... .......................
325 Capítulo 8.2. Preparação para exame prático - parte II ........................................ ....... 329
Vídeo................................................. .. ................................................ ................................................ .. ...
329 Tarefas do exame ........................... .. ............................................. .... ......................................... 329
Tarefa: distância.... ... ................................................ ..... .......................................... ....... ................ 329
Missão: Troque de Peças ....................... ......................................... ........... .........................................
332 Tarefa: Floricultura......... ......................................... ............ ..................................... .............. ......
334 Atribuição: Estimativas........................... ................................ ................ ................................ 337
Tarefa: Chapéu de Natal ... ................................ .................. ............................. .................... ...............
339 Tarefa: combinações de letras ....................... ........................ ....................... ......................... 342
Capítulo 9.1. Tarefas do Campeão - Parte I ............................... .............................. 345
Tarefas mais complexas sobre o material estudado............................... ..................... 345 Problema:
Linhas que se cruzam ......... ..................................................... ..................................... 345 Tarefa: magia
datas .................................................. . ................................................ . ................ 349 Tarefa: cinco
letras especiais ....................... . ............................................. ... ......................... 353 Capítulo 9.2. Tarefas
do Campeão - Parte II ....................................... . ............................. 359
Tarefas mais complexas sobre o material estudado............................... ...... .............................. 359
Missão: Dias de Compras Apaixonadas..... ...... .......................................... .... ................................ 359
Problema: expressão numérica ......... .... .................................................. .. ................................................ ...........
364 Tarefa: touros e vacas .............................. ................................................ .. .........................................
368 Capítulo 10. Métodos ........ .. ............................................. .... ...................................................... 375 O
que é um "método"? ................................................ .. ............................................. .... ....................... 375
Métodos com parâmetros .............. .... ...................................................... ......................................... ........ ..
379 Retornando um resultado de um método............................. ....................................... .......... ..........
383 Variantes de métodos ........................ .......... ......................................... ............ .........................................
387 Designação de métodos e boas práticas ...... ......................................... ........... .............................
390 O que aprendemos com este capítulo? ................................................ .. ............................................. ....
392 Exercícios.............................................. ................................................ ..... .........................................
393 Capítulo 11. Truques e Cortes ....................................... ..... ......................................... 401 Formatação
de código.... ............................................. ... ................................................ ..... ...................... 401
Nomeando os elementos do código.............. ...................................................... ......................... 403
Atalhos no IntelliJ IDEA.............. ......................................... ......... ......................................... 404 Modelos
de Código ( trechos de código)....... ......................................... ......... ......................................... Código
405 Técnicas de depuração ....................................... ................................... ............... ...... 407 Guia de
Cheats........................... ............. ................................... ............... ............................. 409 O que
aprendemos com esta cabeça? ................................................ .. ............................................. .... 412
Conclusão ......................................................... ................................................ . ...................... 413
Este livro é apenas o primeiro passo! ................................................ .. .................................. 413 Onde
devemos ir atrás deste livro? ....................................... .................................................. 414 Comunidades
online para iniciantes em programação........................................... ....... .......... 417 Boa sorte a
todos! ................................................ .. ............................................. .... ......................... 418
Prefácio
O livro "Programming Basics" é um livro-texto oficial do curso "Programming Basics" de
programação para iniciantes da Software University (SoftUni): https://softuni.bg/courses/
programming-basics. Ele apresenta aos leitores habilidades básicas de codificação,
trabalhando com um ambiente de desenvolvimento (IDE), usando variáveis e dados,
operadores e expressões, trabalhando com o console (lendo dados de entrada e
imprimindo resultados), usando construções condicionais (if, if- else , switch -case),
loops (for, while, do-while) e trabalhar com métodos (declarar e chamar métodos, passar
parâmetros e retornar um valor). A linguagem de programação Java e o ambiente de
desenvolvimento IntelliJ IDEA são usados. O material do curso abordado fornece uma
preparação básica para um estudo mais aprofundado da programação e prepara os
leitores para o vestibular do SoftUni.
Este livro fornece apenas os primeiros passos para a programação.

Abrange habilidades muito básicas que você está prestes a desenvolver
por anos até atingir um nível suficiente para começar a trabalhar como
programador.
O livro também é usado como um livro não oficial para cursos de programação escolar
em escolas profissionais que estudam as profissões de "Programador", "Programador
aplicado" e "Programador de sistema", bem como um livro adicional em cursos de
programação elementares em escolas secundárias, escolas secundárias perfiladas e
matemáticas, para turmas com o perfil "informática e tecnologias da informação".
Para quem é este livro?

Este livro é indicado para iniciantes em programação que desejam experimentar como é
programar e aprender as construções básicas para a criação de código de programa que
são usados no desenvolvimento de software, independentemente das linguagens de
programação e tecnologias utilizadas. O livro fornece uma base sólida de habilidades
práticas que são usadas para treinamento adicional em programação e desenvolvimento
de software.
Para quem ainda não fez o curso gratuito Básico de Programação para iniciantes da
SoftUni, recomendamos que se inscreva totalmente grátis, pois programação se aprende
fazendo, não lendo! No curso você terá acesso gratuito a tutoriais, explicações e
demonstrações ao vivo ou online (como tutoriais em vídeo), muita prática e escrita de
código, ajuda com
resolução de problemas após cada tópico, acesso a tutores, assistentes e mentores,
além de fóruns e grupos de discussão para dúvidas, acesso a uma comunidade de
milhares de programadores e toda outra ajuda para o iniciante.
O curso gratuito da SoftUni para iniciantes é adequado para alunos (5ª série em diante),
estudantes e profissionais que desejam obter
conhecimento técnico e descobrir se eles gostam de programação e levam a sério o

desenvolvimento de software daqui para frente.
Um novo grupo começa a cada mês. O curso "Fundamentos de Programação" da
SoftUni é organizado regularmente com várias linguagens de programação diferentes,
então experimente. O treinamento é gratuito e você pode cancelar a qualquer momento
se não gostar. As inscrições para treinamento gratuito presencial ou online para
iniciantes em programação estão disponíveis através do formulário de inscrição do
SoftUni: https://softuni.bg/apply.
Por que escolhemos a linguagem Java?

Escolhemos Java para este livro porque é uma linguagem de programação moderna, de
alto nível e de código aberto, fácil de aprender e adequada para iniciantes. Como uso, o
Java é bastante difundido, amplamente utilizado no desenvolvimento de sistemas
servidores e aplicações móveis, com um ecossistema muito desenvolvido, com inúmeras
bibliotecas e frameworks tecnológicos, e por isso oferece muitas perspectivas de trabalho
e desenvolvimento profissional.
Java combina os paradigmas de programação procedural, orientado a objetos e funcional
de uma maneira moderna com uma sintaxe fácil de usar, embora um pouco mais
descritiva do que Python e JavaScript. No livro, utilizaremos a linguagem Java e o
ambiente de desenvolvimento IntelliJ IDEA, disponível gratuitamente.
Como explicaremos mais tarde, a linguagem de programação com a qual começamos

realmente não importa, mas ainda precisamos usar alguma linguagem de programação
e, neste livro, escolhemos Java. O livro também pode ser encontrado traduzido para
outras linguagens de programação, como C# e JavaScript (consulte https://csharp
book.softuni.bg).
O livro em outras linguagens de programação: C#, Java, JavaScript, Python,

C++, PHP
Este livro de programação para iniciantes está disponível em (ou em processo de
adaptação para) várias linguagens de programação:
• Fundamentos da Programação C# •
Fundamentos da Programação Java •
Fundamentos da Programação JavaScript
• Fundamentos da Programação Python •
Fundamentos da Programação C++ •
Fundamentos da Programação PHP
Se preferir outro idioma, escolha na lista acima.
A programação é aprendida escrevendo muito, não lendo!

Prefácio 13
Se alguém pensa que vai ler um livro e aprender a programar sem escrever código e resolver bem os problemas,
com certeza está enganado. a programação
aprenda fazendo muita e muita prática, escrevendo código todos os dias e resolvendo centenas,
mesmo milhares de tarefas, com seriedade e persistência, durante anos.
Você tem que resolver problemas difíceis, bagunçar, se corrigir, buscar soluções e informações na internet, tentar,
experimentar, encontrar soluções melhores, se acostumar com o código, a sintaxe, a linguagem de programação,
o ambiente de desenvolvimento, com encontrar erros e depuração de código quebrado, com raciocínio sobre
tarefas, com pensamento algorítmico, com quebra de problemas em etapas e implementação de cada etapa, para
ganhar experiência e melhorar suas habilidades a cada dia, porque aprender a escrever código é apenas o
primeiro passo para o profissão de "engenheiro de software". Você tem muito a aprender, muito mesmo!
No mínimo, aconselhamos o leitor a experimentar todos os exemplos do livro, brincar com eles, alterá-los e testá-
los. Ainda mais importante do que os exemplos, no entanto, são os problemas práticos porque desenvolvem as
habilidades práticas do programa.
erro.
Resolva todos os problemas do livro, porque programação se aprende fazendo! Os problemas após cada tópico
são cuidadosamente selecionados para cobrir em profundidade o material de estudo abordado, e o objetivo de
resolver todos os problemas de todos os tópicos abordados é fornecer habilidades abrangentes de codificação de
nível básico (que também é o objetivo deste livro). . Nos cursos da SoftUni, não é por acaso que enfatizamos a
prática e a resolução de problemas, e na maioria dos cursos a codificação presencial é mais de 70% de todo o
curso.
Resolva todos os problemas de exercícios do livro. Caso contrário, você não aprenderá
nada! A programação é aprendida escrevendo muito código e resolvendo milhares de
problemas!
Sobre a Universidade de Software (SoftUni)

A Software University (SoftUni) é o maior centro educacional para engenheiros de software na Bulgária. Dezenas
de milhares de estudantes passam por ela todos os anos. A SoftUni abriu suas portas em 2014 como uma
continuação dos esforços do Dr. Svetlin Nakov para formar massivamente especialistas profissionais de software
por meio de educação real, moderna e de qualidade, que combina conhecimento fundamental com tecnologias
de software modernas e muita prática.
A Software University oferece educação de qualidade, oportunidades de carreira, trabalho e bacharelado para
programadores, engenheiros de software e profissionais de TI. A SoftUni é extremamente bem-sucedida na
construção de um relacionamento duradouro entre educação e indústria, cooperando com centenas de empresas
de software, fornecendo empregos e estágios para seus alunos, fornecendo serviços de qualidade
especialistas para a indústria de software e atende diretamente às necessidades dos empregadores através do
processo de aprendizagem.
Os cursos gratuitos de programação da SoftUni

A SoftUni organiza cursos de programação gratuitos para iniciantes em toda a Bulgária - pessoalmente e online.
O alvo é qualquer pessoa que tenha interesse em
programação e tecnologia, para tentar programar e ver por si mesmo se é interessante para ele e se ele quer
levar a sério o desenvolvimento de software. Você pode se inscrever no curso básico de programação gratuito na
página do aplicativo SoftUni: https://softuni.bg/apply.
Os cursos básicos de programação gratuitos da SoftUni visam apresentá-lo às construções básicas de

programação do mundo do desenvolvimento de software que você poderá aplicar a qualquer linguagem de
programação. Isso inclui trabalhar com dados, variáveis e expressões, usando verificações, construindo loops e
definindo e chamando métodos e outras técnicas para construir a lógica do programa. O treinamento é
extremamente prático, o que significa que há uma forte ênfase em exercícios e você tem a oportunidade de
aplicar seus conhecimentos à medida que os aprende.
Este livro de programação acompanha os cursos gratuitos de programação para iniciantes da SoftUni e serve
como um auxiliar de aprendizagem adicional para auxiliar no processo de aprendizagem.
Julgue o sistema para verificar tarefas

O sistema SoftUni Judge (https://judge.softuni.bg) é um sistema automatizado na Internet para verificação de
soluções para tarefas de programação por meio de uma série de testes. As tarefas são enviadas e verificadas em
tempo real: você envia uma solução e, em segundos, obtém uma resposta se está correta. Cada teste aprovado
com sucesso dá os pontos fornecidos para ele. Para uma resposta correta, você recebe todos os pontos da
tarefa. Para uma resposta parcialmente correta, você ganha parte dos pontos da tarefa dada. Para uma decisão
completamente errada, você obtém 0
pontos.
Todos os problemas deste livro estão disponíveis para teste no juiz SoftUni, e recomendamos fortemente que
você os teste após resolvê-los para saber se está faltando alguma coisa e se sua solução realmente funciona
corretamente conforme necessário
a natureza da tarefa.
Observe também algumas características do juiz SoftUni:
• Para cada tarefa, o sistema de juízes mantém o maior resultado alcançado. Se você carregar
uma solução com código errado ou um resultado inferior ao anterior
enviado, o sistema não deduzirá pontos de você.
• A saída do seu programa é comparada pelo sistema estritamente com o resultado esperado.
Qualquer caractere extra, falta de vírgula ou espaço pode levar a 0 pontos no teste
correspondente. A saída que
Prefácio 15
O juiz que o sistema espera é descrito na condição de cada tarefa e nada mais deve
ser adicionado a ele.
Exemplo: se a saída exigir que um número seja impresso (por exemplo, 25), não envie
mensagens descritivas como O resultado é: 25, mas imprima exatamente o que é
requer, ou seja, apenas o número.
O sistema de juízes SoftUni está disponível a qualquer momento em seu site: https://judge.
softuni.bg.
• Para fazer login, use sua autenticação no site da SoftUni: https://softuni.bg.
• O uso do sistema é gratuito e não está vinculado à participação em cursos da

SoftUni.
Temos certeza de que, após algumas tarefas enviadas, você adorará receber feedback
instantâneo sobre se sua solução escrita está correta, e o sistema de juízes se tornará seu
ajudante favorito ao aprender a programar.
Como se tornar um programador?

Caros leitores, muitos de vocês provavelmente têm a ambição de se tornar um programador,
ganhar a vida no desenvolvimento de software ou trabalhar no setor de TI. Por isso,
preparamos para você um pequeno guia "Como se tornar um programador" para orientá-lo
nos passos para essa profissão tão desejada. Tornar-se um
programador (no nível inicial em uma empresa de software) leva pelo menos 1 a 2 anos
de aprendizado intenso e escrita de código todos os dias, resolvendo vários milhares de
tarefas de programação, desenvolvendo alguns projetos práticos mais sérios e ganhando
muita experiência com a escrita desenvolvimento de código e software. Não acontece em
um mês, nem mesmo em dois! A profissão de engenheiro de software requer uma grande
quantidade de conhecimentos cobertos por muita e muita
prática. Existem 4 conjuntos de habilidades principais que todos os programadores devem
possuir. A maioria dessas habilidades é estável ao longo do tempo e não é significativamente
afetada pelo desenvolvimento de tecnologias específicas (que estão em constante
mudança). Estas são as habilidades que todo bom programador tem e todo novato deve
buscar: • escrever código
(20%) • pensamento
algorítmico (30%) • conhecimento
fundamental da profissão (25%) • linguagens e
tecnologias de desenvolvimento (25% )
Habilidade #1 - Codene (20%)

Aprender a escrever código representa cerca de 20% das habilidades mínimas de
programador necessárias para começar um trabalho em uma empresa de software. A
capacidade de codificar inclui os seguintes componentes:
• trabalhar com variáveis, verificações, loops •

usar funções, métodos, classes e objetos • trabalhar com
dados: arrays, listas, tabelas hash, strings
A habilidade de codificar pode ser dominada em alguns meses de estudo árduo e resolução sólida de problemas
práticos escrevendo código todos os dias. Este livro aborda apenas o primeiro ponto da codificação: trabalhar com
variáveis, verificações e loops. O resto fica por aprender em treinamentos, cursos e
livros.
O livro (e os cursos nele baseados) são apenas o começo de um longo e sério estudo, no caminho da programação
profissional. Se você não dominar o material de estudo deste livro com perfeição, não há como se tornar um
programador. Você carecerá de fundamentos e será cada vez mais difícil para você seguir em frente. Portanto, preste
bastante atenção aos fundamentos da programação: resolva problemas difíceis e escreva muito código por meses até
aprender a resolver todos os problemas deste livro com facilidade. Então siga em frente. Observamos especialmente
que a linguagem de programação não é essencial para a capacidade de codificar. Ou você pode codificar ou não. Se
você pode codificar em C#, aprenderá facilmente a codificar em Java, C++ e qualquer outra linguagem. É por isso
habilidades de codificação são estudadas com muita seriedade em cursos introdutórios para
engenheiros de software da SoftUni (ver currículo), e todo livro de programação para iniciantes completos começa com
eles, inclusive o nosso.
Habilidade #2 – Pensamento algorítmico (30%)

O pensamento algorítmico (lógico, de engenharia, matemático, abstrato) forma cerca de 30% das habilidades mínimas
do programador para iniciar a profissão. O pensamento algorítmico é a capacidade de dividir um problema em uma
sequência lógica de etapas (um algoritmo) e encontrar uma solução para cada etapa e, em seguida, montar as etapas
em uma solução viável para o problema original. Esta é a habilidade mais importante de um programador. Como
construir o pensamento algorítmico?
• O pensamento algorítmico é desenvolvido resolvendo muitos (1000+) problemas de

programação, tão diversos quanto possível. Esta é a receita: resolva milhares de problemas
práticos, crie um algoritmo para eles e implemente o algoritmo, além de depurar os erros
ao longo do caminho.
• Física, Matemática e/ou ciências relacionadas ajudam, mas não são obrigatórias! Pessoas
com inclinações técnicas e de engenharia tendem a aprender a pensar logicamente com
mais facilidade porque já desenvolveram habilidades de resolução de problemas, embora
não algorítmicas.
• A capacidade de resolver tarefas de programação (que requerem pensamento algorítmico)
é extremamente importante para um programador. Muitas empresas só testam essa
habilidade em entrevistas de emprego.
Prefácio 17
Este livro desenvolve um nível inicial de pensamento algorítmico, mas não é suficiente para torná-lo um bom
programador. Para se tornar proficiente na profissão, você precisará adicionar raciocínio lógico e habilidades de
resolução de problemas além do escopo deste livro, como trabalhar com estruturas de dados (arrays, listas,
matrizes, tabelas hash, estruturas de árvore) e algoritmos básicos (pesquisa , ordenação, travessia de árvore,
recursão e outros). As habilidades de pensamento algorítmico são desenvolvidas seriamente nos cursos
introdutórios para engenheiros de software da SoftUni (veja o currículo), bem como nos cursos especializados em
estruturas
de dados e algoritmos.
Como você pode imaginar, uma linguagem de programação é irrelevante para o desenvolvimento do pensamento
algorítmico. Pensar logicamente é universal, não se trata apenas de programação. Precisamente por causa da
lógica altamente desenvolvida
pensamento é considerado que os programadores são bastante inteligentes e que uma pessoa simples não pode
tornar-se um programador.
Habilidade #3 – Fundamentos da Profissão (25%)

Conhecimentos e habilidades fundamentais em programação, desenvolvimento de software, engenharia de software
e ciência da computação representam cerca de 25% das habilidades mínimas de nível básico de um programador.
Aqui estão os mais importantes
conhecimento e habilidades:
• conceitos matemáticos básicos relacionados à programação: sistemas de coordenadas,

vetores e matrizes, funções matemáticas discretas e não discretas, máquinas de
estados finitos e máquinas de estados, conceitos de combinatória e
estatísticas, complexidade do algoritmo, modelagem matemática e muito mais
• habilidades de programação - escrever código, trabalhar com dados, usar estruturas
condicionais e loops, trabalhar com arrays, listas e arrays associativos, strings e
processamento de texto, trabalhar com streams e arquivos, usar interfaces de
programa (APIs), trabalhar com depurador e outros
• estruturas de dados e algoritmos - listas, árvores, tabelas de hash, gráficos, pesquisa,
classificação, recursão, travessia de estruturas de árvore e outros • programação
orientada a objetos (OOP) – trabalhando com classes, objetos, herança, polimorfismo,
abstração, interfaces, encapsulamento de dados, tratamento de exceções, padrões
de design
• programação funcional (FP) - trabalhando com funções lambda, funções de ordem
superior, funções que retornam uma função como resultado, fechando um estado em
uma função (fechamento) e outros
• bancos de dados - bancos de dados relacionais e não relacionais, modelagem de
banco de dados (tabelas e relacionamentos entre eles), linguagem de consulta SQL,
tecnologias de acesso a dados objeto-relacionais (ORM), transacionalidade e gerenciamento
em transações
• programação de rede - protocolos de rede, comunicação de rede, TCP /

IP, conceitos, ferramentas e tecnologias de redes de computadores
• interação cliente-servidor, comunicação entre sistemas, back-end
tecnologias, tecnologias de front-end, arquiteturas MVC
• tecnologias para desenvolvimento de servidor (back-end) - arquitetura de servidor web,
Protocolo HTTP, arquitetura MVC, arquitetura REST, estruturas para desenvolvimento web,
mecanismos de modelagem
• tecnologias web front-end (desenvolvimento do cliente) - HTML, CSS, JS, HTTP, DOM,
AJAX, comunicação de back-end, chamadas de API REST, frameworks de front-end, design
básico e conceitos de UX (experiência do usuário)
• tecnologias móveis - aplicativos móveis, desenvolvimento Android e iOS, interface de usuário
móvel (UI), lógica de servidor de chamada
• sistemas embarcados - microcontroladores, controle digital e analógico
entrada e saída, acesso ao sensor, gerenciamento de borda
• sistemas operacionais - trabalhando com sistemas operacionais (Linux, Windows e outros),
instalação, configuração e administração básica do sistema, trabalhando com processos,
memória, sistema de arquivos, usuários, multitarefa, virtualização e contêineres
• programação paralela e assíncrona - gerenciamento de thread, assíncrono

tarefas, promessas, recursos compartilhados e sincronização de acesso
• engenharia de software - sistemas de controle de origem, gerenciamento de desenvolvimento,
planejamento e gerenciamento de tarefas, metodologias de desenvolvimento de software,
requisitos e protótipos de software, design de software, arquiteturas de software,
documentação de software
• teste de software - teste de componentes (teste de unidade), desenvolvimento orientado a
testes, engenharia de controle de qualidade, relatórios de bugs e rastreadores de bugs,
automação de teste, processos de construção e integração contínua
Precisamos deixar claro mais uma vez que a linguagem de programação não é importante para
a aquisição de todas essas habilidades. Eles se acumulam lentamente, ao longo de muitos anos
de prática na profissão. Alguns conhecimentos são fundamentais e podem ser aprendidos
teoricamente, mas para entendê-los completamente e perceber sua profundidade, são necessários
anos de prática.
Conhecimentos e habilidades fundamentais em programação, desenvolvimento de software,
engenharia de software e ciência da computação são aprendidos ao longo do abrangente
programa de engenharia de software da SoftUni, bem como em vários cursos eletivos. Trabalhar
com uma variedade de bibliotecas de software, APIs, estruturas e tecnologias de software e suas
interações desenvolve gradualmente esse conhecimento e essas habilidades, portanto, não
espere obtê-los em um único curso, livro ou projeto.
Prefácio 19
Para começar a trabalhar como programador, geralmente basta apenas conhecimentos básicos nas áreas listadas
acima, e o aprofundamento ocorre no local de trabalho de acordo com as tecnologias e ferramentas de
desenvolvimento utilizadas na respectiva empresa e equipe.
Habilidade #4 - Linguagens de Programação e Tecnologias de Software

(25%)
Linguagens de programação e tecnologias de desenvolvimento de software formam cerca de 25% das habilidades
mínimas de um programador. Eles são os mais volumosos para aprender, mas mudam mais rapidamente com o
tempo. Se olharmos para ofertas de emprego na indústria de software, todos os tipos de chavões (como os listados
abaixo) são frequentemente mencionados, mas, na verdade, as três principais habilidades estão implicitamente
implícitas nas ofertas de emprego: codificação, pensamento algorítmico e domínio do fundamentos da ciência da
computação e engenharia de software.
Para essas habilidades puramente tecnológicas, a linguagem de programação já importa.
• Atenção: só para esses 25% da profissão a linguagem de programação importa!
• Para os 75% restantes das habilidades, o idioma não importa e essas habilidades são
sustentáveis ao longo do tempo e transferíveis entre diferentes idiomas e tecnologias.
Aqui estão algumas linguagens e tecnologias comumente usadas (pilhas de desenvolvimento
de software) que as empresas de software estão procurando (atual em maio de 2017):
• C# + OOP + FP + classes .NET + banco de dados SQL Server + Entity Framework (EF) +
ASP.NET MVC + HTTP + HTML + CSS + JS + DOM + jQuery
• Java + Java API classes + OOP + FP + bancos de dados + MySQL + HTTP + programação
web + HTML + CSS + JS + DOM + jQuery + JSP/Servlets + Spring MVC ou Java EE /
JSF
• PHP + OOP + bancos de dados + MySQL + HTTP + programação web + HTML + CSS +
JS + DOM + jQuery + Laravel / Symfony / outro framework MVC para PHP •
JavaScript (JS ) + OOP + FP + bancos de dados + MongoDB ou MySQL + HTTP +
programação web + HTML + CSS + JS + DOM + jQuery + Node.js + Express + Angular
ou React • Python +
OOP + FP + bancos de dados + MongoDB ou MySQL + HTTP + web
programação + HTML + CSS + JS + DOM + jQuery + Django
• C++ + OOP + STL + Boost + desenvolvimento nativo + bancos de dados + HTTP + outros
línguas
• Swift + MacOS + iOS + Cocoa + Cocoa Touch + XCode + HTTP + REST + ÿÿÿÿÿ
línguas
Se as palavras listadas acima parecem assustadoras e absolutamente incompreensíveis para você, então você
está no início de sua carreira e tem mais anos para estudar até alcançar a profissão de "engenheiro de software".
Não se preocupe, todos
um programador passa por uma ou mais pilhas de tecnologia e precisa aprender um conjunto
de tecnologias interconectadas, mas no centro de tudo isso está a habilidade de escrever a
lógica do programa (para codificar), que é desenvolvida neste livro, e a habilidade de pensar
algoritmicamente (para resolver as tarefas do programa antecipadamente). Você não pode
fazer sem eles!
A linguagem de programação não importa

Como já ficou claro, a diferença entre as linguagens de programação e, mais precisamente,
entre as habilidades dos programadores de diferentes linguagens e tecnologias, é de cerca de
10 a 20% das habilidades.
• Todos os programadores têm cerca de 80-90% das mesmas habilidades que não dependem
do idioma! Essas são as habilidades para programar e desenvolver software muito
semelhantes entre linguagens de programação e tecnologias de desenvolvimento.
• Quanto mais idiomas e tecnologias você conhecer, mais rápido você aprenderá
novo e menos você sentirá diferença entre eles.
Realmente, a linguagem de programação é quase irrelevante, você só precisa aprender a

programar, e isso começa com a codificação (este livro), continua nos conceitos mais
complexos de programação (como estruturas de dados, algoritmos, OOP e FP) e inclui a
aquisição de conhecimentos e habilidades fundamentais para desenvolvimento de software,
engenharia de software e ciência da computação.
Finalmente, quando você colocar tecnologias específicas em um projeto de software, precisará

de uma linguagem de programação específica, conhecimento de bibliotecas de programação
(APIs) específicas, estruturas e tecnologias de software (tecnologias de UI de front-end,
tecnologias de back-end, tecnologias ORM e outras ). Acalmar
mas, você os aprenderá, todos os programadores os aprendem, mas primeiro eles aprendem
os fundamentos: programar e programar bem.
Este livro usa a linguagem Java, mas não é essencial e pode ser substituída por C#, JavaScript,
Python, PHP, C++, Ruby, Swift, Go, Kotlin ou qualquer outra linguagem. Para dominar a
profissão de "desenvolvedor de software", é necessário aprender a codificar (20%), aprender a
pensar algoritmicamente e resolver problemas (30%), adquirir conhecimentos fundamentais de
programação e informática (25%) e dominar uma programação específica linguagem e as
tecnologias que a cercam (25%). Seja paciente, em um ano ou dois tudo isso pode ser
dominado para sempre
nível de entrada, desde que você seja sério e diligente.
O livro para ajudar os professores

Se você é professor de programação, ciência da computação ou tecnologia da informação, ou
deseja ensinar programação, este livro oferece mais do que um material de aprendizado bem
estruturado, com muitos exemplos e exercícios. Livre para
Prefácio 21
livro, você obtém conteúdo educacional de qualidade para ensinar na escola, em búlgaro, de acordo com
os requisitos da escola:
• Apresentações educativas (slides em PowerPoint) para cada tema educacional, de

acordo com as aulas de 45 minutos nas escolas - gratuitas.
• Tarefas bem desenvolvidas para exercícios em sala de aula e para trabalhos de casa,
com condições detalhadas e exemplos de entrada e saída - grátis.
• Sistema de checagem automatizada de tarefas e deveres de casa (juiz online
sistema) para ser utilizado pelos alunos, também gratuitamente.
• Vídeo-aulas com instruções metódicas do curso gratuito de programação para

professores, realizado regularmente pela Fundação SoftUni.
Todos esses recursos de ensino gratuitos podem ser encontrados no site da Fundação SoftUni, juntamente
com o conteúdo do curso para uma ampla gama de cursos de programação e tecnologia de software.
Baixe-os gratuitamente aqui: http://softuni.foundation/projects/applied-software-developer-profession.
A história deste livro

O principal impulsionador e gerente de projeto para a criação deste livro de programação de código aberto
gratuito para iniciantes é o Dr. Svetlin Nakov. É o principal idealizador e criador do conteúdo de
aprendizagem do curso de Fundamentos da Programação da SoftUni, que serviu de base para o livro.
Tudo começa com os massivos cursos gratuitos de noções básicas de programação que acontecem em
todo o país desde 2014, quando foi lançada a iniciativa SoftUni. No início, esses cursos tinham um escopo
maior e incluíam mais teoria, mas em 2016, o Dr. Svetlin Nakov revisou completamente, atualizou,
simplificou e os orientou fortemente para a prática. Assim, o núcleo do conteúdo de aprendizagem deste
livro foi criado.
Os cursos gratuitos de treinamento em programação da SoftUni são provavelmente os maiores já

realizados na Bulgária. Até 2017, o curso SoftUni sobre noções básicas de programação foi realizado mais
de 100 vezes em quase 30 cidades búlgaras pessoalmente e muitas vezes online, com mais de 40.000
participantes. Naturalmente, surge também a necessidade de escrever um livro didático para as dezenas
de milhares de participantes dos cursos de programação para iniciantes da SoftUni. Com base no princípio
do software livre e do conhecimento livre, Svetlin Nakov lidera uma equipe de voluntários e
impulsiona este projeto de código aberto, inicialmente para criar um livro sobre os fundamentos da
programação com a linguagem C# e, posteriormente, com outras linguagens de programação. O presente
livro é quase uma tradução espelhada para Java de sua versão original em C#.
O projeto faz parte dos esforços da Software University Foundation para criar e distribuir conteúdo de
aprendizado aberto para treinamento de engenheiros de software e especialistas em TI.
Autor coletivo
Este livro foi desenvolvido por um grande grupo de autores voluntários que ofereceram
seu tempo para fornecer a você esse conhecimento sistematizado e orientação para
começar a programar. Lista de todos os autores e editores (em ordem alfabética):
Asya Dikova-Kirova, Vaidin Kachanov, Ventsislav Petrov, Daniel Tsvetkov,

Dimitar Dalev, Julieta Atanasova, Ivaylo Ivanov, Kristian Pamidov, Milena
Georgieva, Nikolay Bankin, Petar Ivanov, Rositsa Nenova, Svetlin Nakov,
Teodor Kurtev, Tsvetan Georgiev
O livro é baseado em sua versão original em C# (Introduction to Programming with C#:
https://csharp-book.softuni.bg), que foi desenvolvida por uma grande equipe de autores
e que também contribuíram para este livro:
Alexander Krastev, Alexander Lazarov, Angel Dimitriev, Vasko Viktorov, Ventsislav
Petrov, Daniel Tsvetkov, Dimitar Tatarski, Dimo Dimov, Diyan Tonchev, Elena
Rogleva, Zhivko Nedyalkov, Julieta Atanasova, Zaharia Pehlivanova, Ivelin Kirilov,
Iskra Nikolova, Kalin Primov, Kristiyan Pamidov, Lyuboslav Lyubenov, Nikolay
Bankin, Nikolay Dimov, Pavlin Petkov, Petar Ivanov, Rositsa Nenova, Ruslan Filipov,
Svetlin Nakov, Stefka Vasileva, Teodor Kurtev, Tonyo Zhelev, Hristiyan Hristov,
Hristo Hristov, Tsvetan Iliev, Julian Linev, Yanitsa Valeva
Site oficial do livro

Este livro Java Programming Basics for Beginners está disponível gratuitamente na
Internet em:
https://java-book.softuni.bg
Este é o site oficial do livro e sua versão mais recente será carregada lá. O livro também
foi traduzido para outras linguagens de programação listadas em seu site.
Um fórum para suas perguntas

Tire suas dúvidas sobre este livro Programming Fundamentals no fórum SoftUni:
https://softuni.bg/forum Neste
fórum de discussão você receberá uma resposta adequada e gratuita sobre quaisquer
questões do conteúdo educacional deste livro, bem como sobre outras questões de
programação. A comunidade SoftUni para iniciantes é tão grande que uma resposta a
uma pergunta geralmente é recebida em alguns minutos. Docentes, assistentes e
mentores da SoftUni também são responsáveis
constantemente às suas perguntas.
Prefácio 23
Devido ao grande número de alunos deste livro, no fórum você pode encontrar uma solução para
quase qualquer tarefa dele, compartilhada por um colega. Milhares de alunos antes de você já
resolveram os mesmos problemas; portanto, se você travar, pesquise no fórum. Embora as tarefas
do curso de Fundamentos da Programação mudem de tempos em tempos, o compartilhamento é
sempre incentivado no SoftUni, assim você encontrará facilmente soluções e orientações para
todas as tarefas.
Se você ainda tiver uma pergunta específica, por exemplo, por que não inicia um determinado
programa no qual você está pensando há várias horas, pergunte no fórum e você receberá uma
resposta. Você ficará surpreso com o quão bem-intencionados e receptivos são os habitantes do
fórum SoftUni.
Página oficial do livro no Facebook

O livro conta também com uma página oficial no Facebook, onde você pode acompanhar
novidades sobre os livros da série "Fundamentos da Programação", novas edições, eventos e
iniciativas:
fb.com/IntroProgrammingBooks
Licença e distribuição
O livro é distribuído gratuitamente em formato eletrônico sob uma licença aberta CC-BY-SA
(https://creativecommons.org/licenses/by-sa/4.0).
O livro é publicado e distribuído em papel pela SoftUni e uma cópia em papel pode ser adquirida
na recepção da SoftUni (ver https://softuni.bg/contacts).
O código-fonte do livro pode ser encontrado em seu repositório GitHub: https://github.com/SoftUni/

Programming-Basics-Book-Java-BG.
Número de livro padrão internacional ISBN: 978-619-00-0636-7.
Relatório de erros
Caso encontre erros, imprecisões ou defeitos no livro, você pode denunciá-los no rastreador
oficial do projeto:
https://github.com/SoftUni/Programming-Basics-Book-Java-BG/issues Não prometemos

corrigir tudo o que você nos enviar, mas queremos melhorar constantemente a qualidade deste
livro, portanto, os bugs relatados e todas as sugestões razoáveis serão consideradas.
Gostar de ler!
E não se esqueça de escrever muito código, experimente os exemplos de cada tópico e, acima
de tudo, resolva os exercícios. Você não aprenderá a programar apenas lendo, então resolva
problemas difíceis!
Capítulo 1. Introdução à programação

Neste capítulo vamos entender o que é programação em sua essência. Apresentaremos a ideia de linguagens de
programação e veremos os ambientes de desenvolvimento de software (IDEs) e como trabalhar com eles, em
particular o IntelliJ IDEA. Escreveremos e executaremos nosso primeiro programa na linguagem de programação
Java e, em seguida, praticaremos várias tarefas: criaremos um programa de console, um aplicativo gráfico e um
aplicativo da web. Aprenderemos como verificar se as soluções de problemas deste livro estão corretas no sistema
de juízes do SoftUni e, finalmente, conheceremos os erros típicos que costumam ser cometidos ao escrever código
e como
proteger deles.
Vídeo
Assista a um tutorial em vídeo sobre este capítulo: https://youtube.com/watch?v=sU_JUiersZg.
O que significa "programar"?

Programar é dar comandos ao computador sobre o que fazer, por exemplo “imprimir algo na tela” ou “multiplicar
dois números”. Quando há vários comandos um após o outro, eles são chamados de programa de computador. O
texto dos programas de computador é chamado de código do programa (ou código-fonte, ou código para abreviar).
Programas de computador
Programas de computador são uma série de comandos escritos em uma linguagem de programação pré-selecionada,
como Java, C#, JavaScript, Python, Ruby, PHP, C, C++, Swift, Go ou outra. Para escrever comandos, precisamos
conhecer a sintaxe e a semântica da linguagem com a qual trabalharemos, no nosso caso Java. Portanto, vamos
apresentar neste livro a sintaxe e semântica da linguagem Java e programação em geral, aprendendo passo a passo
escrever código, das construções de programação mais simples às mais complexas.
Algoritmos
Os programas de computador geralmente executam algum tipo de algoritmo. Algoritmos são uma sequência de
passos necessários para realizar um determinado trabalho e atingir algum resultado esperado, uma espécie de
“receita”. Por exemplo, se fritarmos ovos, seguimos uma determinada receita (algoritmo): esquentamos a gordura
em uma panela, quebramos os ovos, esperamos até que estejam fritos, retiramos do fogo. Da mesma forma, na
programação, os programas de computador executam algoritmos: uma sequência de comandos necessários para
realizar um determinado trabalho. Por exemplo, para organizar uma série de números em ordem crescente, é
necessário um algoritmo, por exemplo, encontre o menor número e imprima-o, a partir dos números restantes,
encontre o menor número novamente e imprima
imprimir e isso se repete até que os números acabem.

Para facilitar a criação de programas, para escrever o código do programa (comandos), para
executar programas e para outras operações relacionadas à programação, também precisamos
de um ambiente de desenvolvimento, por exemplo, IntelliJ IDEA.
Linguagens de programação, compiladores, interpretadores e

ambientes de desenvolvimento
Uma linguagem de programação é uma linguagem artificial (sintaxe de expressão) projetada
para especificar comandos que queremos que o computador leia, processe e execute. Por
meio de linguagens de programação, escrevemos sequências de comandos (programas) que
dizem ao computador o que fazer. A execução de programas de computador pode ser realizada
com um compilador ou com um interpretador.
O compilador traduz o código de uma linguagem de programação em código de máquina,
selecionando para cada uma das construções (comandos) no código um fragmento de código
de máquina adequado e previamente preparado, enquanto verifica se há erros no texto do
programa. Juntos, os fragmentos compilados compõem o programa em código de máquina
conforme esperado pelo microprocessador do computador. Uma vez compilado, o programa
pode ser executado diretamente pelo microprocessador em cooperação com o sistema
operacional. Em linguagens de programação compiláveis, o programa deve ser compilado
antes de sua execução, e erros de sintaxe (comandos atribuídos incorretamente) são
detectados durante a compilação. Linguagens como C++, C#, Java, Swift e Go funcionam
com o compilador. Algumas linguagens de programação não usam um compilador, mas são
interpretadas diretamente por um software especializado chamado "intérprete". Um interpretador
é um "programa para executar programas" escrito em alguma linguagem de programação. Ele
executa comandos de programa um após o outro, compreendendo não apenas comandos
únicos e sequências de comandos, mas também outras construções de linguagem (verificações,
iterações, funções, etc.). Linguagens como PHP, Python e JavaScript rodam com um
interpretador e rodam sem serem compiladas. Devido à falta de pré-compilação, com
linguagens interpretadas, os erros são detectados em tempo de execução após o início da
execução do programa, e não antes.
O ambiente de programação (Integrated Development Environment - IDE, ambiente de

desenvolvimento integrado) é um conjunto de ferramentas tradicionais para o desenvolvimento
de aplicativos de software. No ambiente de desenvolvimento, escrevemos o código, compilamos
e executamos os programas. Os ambientes de desenvolvimento integram em si um editor de
texto para escrever o código, uma linguagem de programação, um ambiente compilador ou
interpretador para executar os programas, um depurador para rastrear o programa e procurar
erros, ferramentas de design de interface com o usuário e outras ferramentas e plugins.
Os ambientes de programação são convenientes porque integram tudo o que é necessário

para o desenvolvimento do programa sem sair do ambiente. Se não estivermos usando um
ambiente de desenvolvimento, teremos que escrever o código em um editor de texto, compilá-lo com
comando do console, para executá-lo com outro comando do console e sim
Capítulo 1. Introdução à programação 27
escrevemos mais comandos adicionais quando necessário e isso desperdiçará nosso tempo. É por isso que a
maioria dos programadores usa IDEs em seu trabalho diário. Para a programação Java,
costuma-se usar o ambiente de desenvolvimento IntelliJ IDEA, que é desenvolvido e distribuído gratuitamente
pela JetBrains e pode ser baixado em seu site: https://jetbrains.com/idea. Alternativas ao IntelliJ IDEA são Eclipse
(https://eclipse.org/downloads/packages), NetBeans
(https://netbeans.org/downloads) e muitos outros. Neste livro, usaremos o ambiente de desenvolvimento IntelliJ

IDEA.
Se você não tiver a oportunidade de instalar um ambiente de desenvolvimento, também pode usar um IDE Java
online, como o Repl.it: https://repl.it/languages/java.
Linguagens de baixo e alto nível, ambientes de tempo de execução (Runtime

Ambientes)
Um programa é essencialmente um conjunto de instruções que fazem um computador realizar uma determinada
tarefa. Eles são inseridos pelo programador e executados incondicionalmente pela máquina. Existem diferentes
tipos de linguagens de
programação. As linguagens de baixo nível podem ser usadas para escrever as próprias instruções que controlam
o processador, por exemplo com a linguagem Assembler. Com linguagens de nível ligeiramente superior, como
C e C++, um sistema operacional, drivers de gerenciamento de hardware (por exemplo, driver de placa de vídeo),
navegadores da Web, compiladores, mecanismos de jogos e outros componentes do sistema podem ser criados
e programas. Com linguagens de nível ainda mais alto, como C#, Python e JavaScript, os programas aplicativos
são criados
rami, como um leitor de e-mail ou programa de bate-papo.
As linguagens de baixo nível controlam diretamente o hardware e exigem muito esforço e um grande número de
comandos para fazer uma unidade de trabalho. Linguagens de alto nível requerem menos código por unidade de
trabalho, mas não têm acesso direto ao hardware. Software de aplicativo, como aplicativos da Web e móveis,
são desenvolvidos neles
formulários.
A maioria dos softwares que usamos diariamente, como reprodutor de música, reprodutor de vídeo, programa de
GPS, etc., são escritos em linguagens de programação de aplicativos de alto nível, como Java, C#, Python, C++,
JavaScript, PHP, etc.
Java é uma linguagem compilável, o que significa que escrevemos comandos que são compilados antes de
serem executados. O código escrito em Java não é compilado em código de máquina para um processador
específico, mas em código específico da linguagem chamado bytecode Java. Portanto, uma Java Virtual Machine
(JVM) é necessária para executar um programa escrito em Java.
O compilador Java, a máquina virtual e um conjunto de bibliotecas estão no centro da plataforma Java. A
plataforma Java é desenvolvida em diversas variedades:
• Java Standard Edition (Java SE) – a versão base usada para

desenvolvimento de aplicações cliente, etc. Applet Java.
• Java Enterprise Edition (Java EE) – é baseado na Standard Edition, é usado com mais
frequência em aplicativos de servidor na Internet, mas também inclui um grande número
de outras tecnologias de software.
• Java Micro Edition (Java ME) – versão leve independente para operação em dispositivos
com capacidade de computação limitada, como telefones celulares, smartphones,
dispositivos PDA e outros.
Programas de computador - compilação e execução

Como já mencionado, um programa é uma sequência de comandos, ou seja, descreve uma
série de cálculos, verificações, repetições e quaisquer operações semelhantes que visam
alcançar algum resultado.
O programa é escrito em formato de texto e o próprio texto do programa é chamado de código-
fonte. O processo de compilação de código pré-runtime é usado apenas com linguagens
compiláveis, como Java, C# e C++. Em linguagens de script e interpretadas, como JavaScript,
Python e PHP, o código-fonte é executado passo a passo por um interpretador.
Programas de computador - exemplos

Vamos começar com um exemplo muito simples de um pequeno programa Java que consiste
em um único comando.
Exemplo: um comando que imprime algum texto Nosso

primeiro programa será um único comando Java que imprime a palavra “Hello”:
System.out.println("Olá");
Veremos como podemos executar esse comando daqui a pouco, mas por enquanto vamos
apenas ver quais comandos estão na programação. Vamos nos familiarizar com mais alguns
exemplos.
Exemplo: um comando que verifica se uma palavra está contida dentro de outra
Podemos verificar se a palavra "gosho" contém a palavra "go" usando o método contains():
System.out.println("gosho".contains("ir"));
Exemplo: um programa que converte de BGN para EUR

Vamos considerar outro programa simples que lê do usuário uma quantia em BGN (número
inteiro), converte para Euro (dividindo pela taxa de câmbio do Euro) e imprime o resultado. Este
é um programa de 4 comandos consecutivos:
Console do scanner = new Scanner(System.in); leva

dupla = Double.parseDouble(console.nextLine()); euro duplo = leva /
1,95583; System.out.println(euro);
Vimos três exemplos de programas de computador: dois comandos simples e uma

sequência de três comandos. Agora vamos para a parte mais interessante: como
podemos escrever nossos próprios programas Java e como podemos compilá-los e
executá-los?
Como escrever um programa de console?

Vamos percorrer as etapas para criar e executar um programa de computador que lê e
grava seus dados de e para um console de texto (uma janela de entrada e saída de
texto). Esses programas são chamados de "console". Antes disso, precisamos primeiro
instalar e preparar o ambiente de desenvolvimento no qual escreveremos e executaremos
os programas Java deste livro e os exercícios nele contidos.
Conjunto de Desenvolvimento Java (JDK)

Para poder criar programas com a linguagem Java, é necessário instalar o Java
Development Kit (JDK). O Java Development Kit inclui uma máquina virtual, um
compilador Java e uma variedade de ferramentas utilitárias. O JDK não deve ser
confundido com o Java Runtime Environment (JRE). A instalação do JRE nos permite
abrir e trabalhar com programas Java, mas não nos dá a capacidade de desenvolver
nossos próprios.
Instalando o Java Development Kit (JDK)

O Java Development Kit (JDK) é distribuído gratuitamente e pode ser baixado aqui:
https://oracle.com/technetwork/java/javase/downloads. Selecione o Java SE mais
recente (Java Standard Edition).
Marcamos a caixa com a qual concordamos com os termos das licenças (Aceitar Contrato
de Licença) e selecionamos o arquivo de instalação de acordo com nosso sistema
operacional. Por exemplo, Windows de 64 bits:
Baixamos o arquivo de instalação e o executamos. A seguir está o instalador, que em um

ambiente Windows se parece com isso:
Pressionamos o botão [Next] várias vezes até que a instalação do pacote de

desenvolvimento Java comece:
Esperamos até que a instalação termine e fechamos o instalador com [Fechar].

A instalação do JDK em um ambiente Linux pode ser bem diferente, geralmente instalando
um pacote padrão de um repositório central: sudo apt install default-jdk.
Ambiente de Desenvolvimento (IDE)

Como já mencionado, para programar precisamos de um ambiente de desenvolvimento -
Ambiente de Desenvolvimento Integrado (IDE). Na verdade, é um editor de programas
onde escrevemos o código do programa e podemos compilá-lo e executá-lo, ver os erros,
corrigi-los e executar o programa novamente.
• Para programação Java, IntelliJ IDEA, Eclipse ou
NetBeans.
• Se programarmos em C#, podemos utilizar o ambiente Visual Studio para o sistema
operacional Windows e Raider para Linux ou macOS.
• Se vamos escrever em Python, podemos usar o ambiente PyCharm.
Instalando o IntelliJ IDEA

Iniciamos com a instalação do ambiente integrado IntelliJ IDEA Community (versão 2017,
vigente desde julho de 2017).
A versão comunitária do IntelliJ IDEA é distribuída gratuitamente pela JetBrains e pode
ser baixada aqui: https://jetbrains.com/idea/download.
As linhas a seguir detalham as etapas de instalação do IntelliJ IDEA (versão Community
2017). Depois de baixar o arquivo de instalação e executá-lo, a seguinte tela será exibida:
Apertamos o botão [Next], então veremos a janela abaixo:

Selecionamos [Next] novamente e uma janela com o painel de instalação do IntelliJ IDEA é
carregada.
Escolhemos o iniciador de 32 bits ou o iniciador de 64 bits, dependendo de quão pouco é o

sistema operacional que estamos usando. Verificamos [.java], [.groovy] e [.kt] e, em seguida,
pressionamos o botão [Next].
Salve o nome da pasta no menu Iniciar e pressione o botão [Instalar]. A instalação do IntelliJ
IDEA é iniciada e uma tela como a abaixo deve aparecer:
Após a instalação do IntelliJ IDEA, aparecerá uma tela informativa na qual marcamos a caixa de
seleção [Run IntelliJ IDEA] e pressionamos o botão [Finish] para concluir a instalação e iniciar
o ambiente de desenvolvimento:
Na janela inicial do IntelliJ IDEA, selecionamos [Create New Project]:
Uma janela aparece mostrando que um kit de desenvolvimento de software (SDK)

selecionado está faltando:
Pressionamos [Novo] e encontramos o caminho para o Java Development Kit (JDK)

já instalado, tomando cuidado para não selecionar o JRE:
Selecionamos a pasta com a instalação do JDK (não JRE) e pressionamos o botão [OK].
Isso é tudo. Estamos prontos para usar o IntelliJ IDEA.
Versões antigas no IntelliJ IDEA

Também podemos usar versões mais antigas do IntelliJ IDEA, mas isso não é recomendado,
pois elas podem não conter alguns dos recursos de desenvolvimento mais recentes e nem
todos os exemplos do livro serão executados.
Ambientes de desenvolvimento online

Existem também ambientes alternativos de desenvolvimento online, diretamente no seu
navegador. Esses ambientes não são muito convenientes, mas se você não tiver outra
opção, pode começar seu treinamento com eles e instalar o IntelliJ IDEA posteriormente. Aqui está
alguns links:
• Para Java, podemos usar o seguinte Java IDE online: https://www.compile

java.net. Outra opção é Repl.it: https://repl.it/languages/java.
• Para a linguagem C#, o site .NET Fiddle permite escrever código e executá-lo online:
https://dotnetfiddle.net.
• Para JavaScript, podemos escrever código JS diretamente no console de um navegador
pressionando [F12].
Soluções de design e projetos no IntelliJ IDEA

Um projeto no IntelliJ IDEA agrupa logicamente vários arquivos que compõem um aplicativo
ou componente. Um projeto IntelliJ IDEA contém um ou mais arquivos de origem Java,
arquivos de configuração e outros recursos. Em cada arquivo fonte Java há uma ou mais
definições de tipo (classes ou outros
definições). As classes têm métodos (ações) e consistem em sequências de comandos.

Parece complicado, mas para grandes projetos essa estrutura é muito conveniente e
permite uma boa organização dos arquivos de trabalho.
Exemplo: Criando um programa de console "Hello Java"

Vamos voltar ao nosso programa de console. Agora temos o IntelliJ IDEA e podemos
executá-lo. Em seguida, criamos um novo projeto de console em [Create New Project].
Escolhemos na caixa de diálogo [Java] ÿ [Command Line App] e damos um nome
adequado ao projeto, por exemplo HelloJava:
O IntelliJ IDEA criará um programa Java vazio para nós que precisamos adicionar.
Escrevendo o código do programa

O código-fonte dos programas Java é escrito na seção main(String[] args), entre as
chaves de abertura e fechamento { }. Este é o método principal (ação) que é executado
quando um programa Java é iniciado. Pressionamos [Enter] após o colchete de abertura
{ e começamos a digitar. O código do programa é escrito offset
para dentro, como parte da formatação do texto, para facilitar a revisão e/ou depuração.
Escrevemos o seguinte comando:
System.out.println("Olá Java");
É assim que nosso programa deve ficar no IntelliJ IDEA:
O comando System.out.println("Hello Java") na linguagem Java significa imprimir no console

out.println(…) e imprimir uma mensagem de texto Hello Java. As aspas servem para esclarecer que se
trata de texto. O símbolo ; , que indica que o comando termina neste local (ou seja, não continua na
próxima linha). Este comando é típico para programação: especificamos para encontrar um objeto (neste
caso um objeto PrintStream chamado out, que está localizado no objeto
System) e realizar alguma ação sobre ele (neste caso imprimir algo que está especificado entre
parênteses) . Mais tecnicamente explicado, chamamos o método println(…) da classe PrintStream, que
faz parte da classe System , e passamos a ele o literal de texto "Hello Java" como parâmetro.
Classes e arquivos em Java

A linguagem Java é uma linguagem de programação orientada a objetos e, portanto, todos
os programas Java consistem em uma ou mais classes. Para classes públicas em Java, o
nome da classe deve corresponder ao nome do arquivo + .java. No exemplo acima , a
classe Main definida com public class Main { … } reside em um arquivo chamado
Main.java na pasta src do projeto . Se a classe for chamada HelloJava, seu código-fonte
deve ser armazenado em um arquivo chamado HelloJava.java. Caso contrário, obteremos
um erro de tempo de compilação.
Iniciar o programa
Para iniciar o programa, pressione [Ctrl+Shift+F10]. Se não houver erros, o programa será
executado. O resultado será gravado no console (a janela localizada na parte inferior do
IntelliJ IDEA):
Na verdade, a saída do programa é a seguinte mensagem de texto:
Olá Java
A mensagem "Processo concluído com código de saída 0" é impressa adicionalmente

na linha inferior do console pelo IntelliJ IDEA e nos mostra que o programa foi concluído
com sucesso e sem erros.
Testando o programa no sistema de juízes

O teste das tarefas deste livro é automatizado e é realizado via Internet, a partir do site do
sistema Juiz: https://judge.softuni.bg. A avaliação de
tarefas são executadas atualmente pelo sistema. Cada tarefa passa por uma série de testes, e cada
teste aprovado com sucesso dá os pontos destinados a ele. Os testes que são enviados para as
atribuições ficam ocultos.
O programa acima pode ser testado aqui: https://judge.softuni.bg/Contests/Practice /Index/646#0.

Colocamos todo o código-fonte do programa na caixa preta, certificando-nos de selecionar o código Java
no menu suspenso:
Enviamos a decisão de avaliação com o botão [Enviar]. O sistema retorna um resultado após alguns
segundos na tabela de soluções enviadas. Se necessário, podemos pressionar o botão para atualizar os
resultados [refresh] na parte superior direita da tabela com as soluções enviadas para verificação:
Na tabela com as decisões submetidas, o sistema de juízes exibirá um dos seguintes resultados possíveis:
• Número de pontos (entre 0 e 100) quando o código passado compila com sucesso
(sem erros de sintaxe) e pode ser testado.
o Com uma solução correta, todos os testes são marcados em verde e obtemos
100 pontos.
o No caso de uma decisão errada, alguns dos testes são marcados em vermelho e
obtemos um número incompleto de pontos ou 0 pontos.
• No caso de um programa errado, receberemos uma mensagem de erro durante o

compilação.
Como faço para me cadastrar no SoftUni Juiz?

Usamos nossa identificação (nome de usuário + senha) para o site softuni.bg. Se você
não possui cadastro no SoftUni, crie um. Leva apenas um minuto - registro padrão no
site da Internet.
Erros típicos em programas Java

Um dos erros comuns que os iniciantes cometem é escrever fora do corpo do método
main(String[] args) porque o ambiente interno ou compilador não seria capaz de
interpretar corretamente os comandos definidos no programa. Aqui está um exemplo de
um programa mal escrito:
public static void main(String[] args) { }
System.out.println("Olá SoftUni");
Outro erro é misturar letras maiúsculas e minúsculas, e elas importam na hora de chamar
os comandos e seu bom funcionamento. Aqui está um exemplo de
tal erro:
public static void main(String[] args)

{ System.out.Println("Olá SoftUni");
}
No exemplo acima, Println está escrito incorretamente e deve ser corrigido para println.
Faltar um ponto e vírgula (;) no final dos comandos é um dos eternos problemas do
programador novato. A falta deste sinal faz com que o programa funcione mal e muitas
vezes o problema passa despercebido. Aqui está um exemplo de código de erro:

{ System.out.println("Olá SoftUni")
}
Uma aspa ausente ou parênteses de abertura ou fechamento ausentes também podem

ser problemas. Tal como acontece com o ponto e vírgula, aqui o problema faz com que
o programa funcione mal ou não seja executado. Essa omissão é difícil de notar em
códigos mais volumosos.
Aqui está um exemplo de um programa errado que tem uma aspa aberta:

{ System.out.println("Olá SoftUni);
Este programa dará um erro ao tentar compilar e executar, e antes mesmo disso o código
será destacado para chamar a atenção do programador para o erro que ele cometeu (a
falta de aspas de fechamento).
Outro erro comum que iniciantes cometem é tentar escrever o método main(…)
fora da classe:
classe pública Exemplo { }

{ System.out.println("Método fora da classe");
}
O correto é colocar o método main(…) dentro da classe Example, e escrever todo o

código do programa no arquivo Example.java:
// Coloque este código no arquivo: Example.java
classe pública Exemplo {

{ System.out.println(" Classe correta");
}
}
O que aprendemos com este capítulo?

Em primeiro lugar, aprendemos o que é programação - definir comandos escritos em uma
linguagem de computador que uma máquina entende e pode executar. descobrimos mais
o que é um programa de computador - é uma série de comandos organizados um após o
outro. Aprendemos sobre a linguagem de programação Java em um nível básico e como
criar programas de console simples com o IntelliJ IDEA. Também observamos a estrutura
do código do programa na linguagem Java, de modo que os comandos são definidos
principalmente na seção estática void main(String[] args) entre as chaves de abertura
e fechamento. Vimos como imprimir com
System.out.println(…) e como executar nosso programa com [Ctrl+Shift+F10].
Aprendemos a testar nosso código no SoftUni Judge.
Bom trabalho! Vamos aos exercícios. Você não esqueceu que a programação é aprendida
escrevendo muito código e resolvendo problemas? vamos decidir
várias tarefas para reforçar o que aprendemos.
Exercícios: primeiros passos na codificação

Bem-vindo aos exercícios. Agora escreveremos alguns programas de console para dar mais
alguns primeiros passos na programação e, em seguida, mostraremos como podemos
programar algo mais complexo - programas com uma interface gráfica e de usuário da web.
Tarefa: programa de console "Expression"

Para escrever um programa Java de console que calcule e imprima o valor da seguinte
expressão numérica:
(3522 + 52353) * 23 - (2336 * 501 + 23432 - 6743) * 3
Nota: não é permitido calcular o valor antecipadamente (por exemplo, com a Calculadora do
Windows).
Diretrizes e dicas Criamos

um novo projeto de console Java chamado "Expression" e escrevemos o código abaixo:
Encontramos o método static void main(String[] args) e inserimos seu corpo entre { e }. Em
seguida, precisamos escrever o código para avaliar a expressão numérica acima e imprimir
seu valor no console. Passamos a expressão numérica acima entre parênteses para o
comando System.out.println(…). Iniciamos o programa
com [Ctrl+Shift+F10] e verificamos se o resultado é o mesmo
como na foto:
Testes no sistema de juízes

Teste sua solução: https://judge.softuni.bg/Contests/Practice/Index/646#1.
Tarefa: os números de 1 a 20
Escrever um programa de console Java que imprima os números de 1 a 20 em linhas separadas
para o console.
Diretrizes e dicas
Criamos uma nova classe Java chamada "Nums1To20" (clique com o botão direito na pasta [src] ÿ
[Novo] ÿ [Classe Java]):
No método static void main(String[] args) , escrevemos 20 comandos System.out . println(…),

cada um em uma linha separada, para imprimir os números de 1 a 20, um após o outro
algo mais. Os mais perspicazes devem estar se perguntando se não existe uma maneira mais
inteligente. Relaxe, há, mas mais sobre isso depois.
Agora executamos o programa e verificamos se a saída é a esperada:
1
2
…
20
Teste no sistema de juízes Teste

sua solução: https://judge.softuni.bg/Contests/Practice/Index/646#2.
Agora considere se poderíamos escrever o programa de uma maneira mais inteligente para não
repetir o mesmo comando 20 vezes. Pesquise na Internet por "for loop Java".
Tarefa: um triângulo de 55 estrelas

Para escrever um programa de console Java que imprima um triângulo de 55 asteriscos
espaçados em 10 linhas:
*
**
***
****
*****
******
*******
********
*********
**********
Diretrizes e dicas
Estamos criando um novo aplicativo de console Java chamado “TriangleOf55Stars”.
Nela, precisamos escrever um código que imprima o triângulo de asteriscos, por
exemplo, através de 10 comandos como os abaixo:
System.out.println("*");
System.out.println("**");
…
Testando no sistema de juízes

Teste sua solução: https://judge.softuni.bg/Contests/Practice/Index/646#3. Tente
melhorar a solução para que não haja muitos comandos repetidos. Isso pode ser feito
com um loop for ? Você conseguiu encontrar uma solução inteligente (por exemplo,
com um loop) para o problema anterior? Algo semelhante pode ser usado para esta
tarefa, mas um pouco mais complicado (dois loops um dentro do outro). Se você falhar,
não há problema, aprenderemos loops em alguns capítulos e você se lembrará dessa tarefa nova
Problema: face de um retângulo

Escreva um programa Java que leia dois números a e b do console, calcule e imprima a
face de um retângulo com lados a e b.
Exemplo de entrada e saída
área abdominal a b área área abdominal
2 7 14 12 5 60 78 56
Diretrizes e dicas
Criamos um novo programa Java de console. Para ler os dois números, usamos o seguinte
código:
importar java.util.Scanner;
public class RectangleArea { public

static void main(String[] args) {
Console do scanner = new Scanner(System.in); int a =
Integer.parseInt(console.nextLine()); int b =
Integer.parseInt(console.nextLine());
// TODO: calcula a área e imprime

}
}
Para ler a entrada do console, importamos e usamos a classe java.util.Scanner, que

abordaremos em detalhes posteriormente. Por enquanto, apenas suponha que a leitura de
um número seja feita como no exemplo acima.
Resta adicionar o programa acima para calcular a face do retângulo e imprimi-lo. Use o
conhecido comando System.out .println(…) e dê a ele o produto dos números aeb entre
parênteses. Na programação, a multiplicação é feita com o operador *.
Teste sua solução Teste sua

solução com vários exemplos. Você deve obter um resultado semelhante a este (inserimos
2 e 7 como entrada e o programa imprime como resultado 14 - o produto deles):
2
7
14

*
Tarefa: um quadrado de estrelas
Para escrever um programa de console Java que leia do console como um todo
um número positivo n e imprime no console um quadrado de n asteriscos, como em
os exemplos abaixo.

Entrada Saída Conecte-se Saída Entrada Saída

*****
****
*** **
**
** **
3 4 ** 5
*** **
****
*****
Diretrizes e dicas
Estamos fazendo um novo programa de console Java. Para ler o número n (2 ÿ n
ÿ100), usamos o seguinte código:
Console do scanner = new Scanner(System.in); int n

= Integer.parseInt(console.nextLine());
// TODO: imprimir o retângulo
Não se esqueça de importar a classe java.util.Scanner e colocar seu código no método

main(…) da classe principal do seu programa. Adicione o programa acima para imprimir
um quadrado formado por asteriscos. Pode ser necessário usar loops For . Pesquise
informações na Internet.
Atenção: esta tarefa é mais difícil do que as outras e é dada deliberadamente agora e
marcada com um asterisco para provocar a busca de informações na Internet. Esta é
uma das habilidades mais importantes que você deve desenvolver ao aprender a
programar: pesquisar informações na Internet. Isso é o que você fará todos os dias se
trabalhar como programador, então não tenha medo, apenas experimente. Se você
tiver dificuldades, também pode buscar ajuda no fórum SoftUni: https://softuni.bg/forum.

Console, aplicações gráficas e web

Em aplicativos de console (aplicativos de console), como você pode imaginar, todas
as operações de leitura de entrada e impressão de saída são feitas por meio do
console. Os dados de entrada são inseridos lá, que são lidos por um aplicativo
os dados de saída também são impressos após ou durante a execução de
o programa.
Enquanto os aplicativos de console usam o console de texto, os aplicativos da Web
usam uma interface de usuário baseada na web. Para conseguir sua implementação,
duas coisas são necessárias - um servidor web e um navegador web, com o
navegador desempenhando o papel principal na visualização de dados e na interação
do usuário. Os aplicativos da Web são muito mais agradáveis para
para o usuário, eles ficam muito melhores visualmente, usam mouse e toque do dedo (em tablets e
telefones), mas por trás de tudo está a programação. E é por isso que temos que aprender a programar e
já fizemos nossos primeiros
passos muito pequenos.
Os aplicativos gráficos (GUI) têm uma interface visual do usuário, diretamente em seu computador ou
dispositivo móvel, sem a necessidade de um navegador da web. Os aplicativos gráficos (aplicativos de
desktop ou, em outras palavras, aplicativos de desktop) consistem em uma ou mais janelas gráficas nas
quais estão localizados determinados controles (campos de texto, botões, figuras, tabelas, etc.), servindo
para um diálogo com o usuário em um maneira mais intuitiva. Os aplicativos móveis em seu telefone e
tablet são semelhantes: usamos formulários, caixas de texto, botões e outros controles e os gerenciamos
por meio de código de programação. É por isso que aprendemos a escrever código agora: o código está
em toda parte no desenvolvimento de software.
Exercícios: Aplicações Gráficas e Web

Agora vamos fazer uma aplicação web simples e uma gráfica simples
aplicativo para que possamos ter uma ideia do que seremos capazes de criar à medida que avançamos
na programação e no desenvolvimento de software. Não vou entrar em detalhes sobre as técnicas
utilizadas e as construções básicas, mas vamos apenas dar uma olhada no layout e na funcionalidade do
que criamos. À medida que avançamos com nosso conhecimento, seremos capazes de fazer aplicativos e
sistemas de software grandes e complexos. Esperamos que os exemplos abaixo despertem seu interesse,
e não o desencorajem.
Tarefa: aplicativo gráfico "Number Adder"

Escrever um aplicativo gráfico (GUI) que calcula a soma de dois números. Ao inserir dois números nas
duas primeiras caixas de texto e pressionar o botão [Calcular], sua soma é calculada e o resultado é
exibido na terceira caixa.
Ao contrário dos aplicativos de console, que leem e gravam seus dados como texto no console, os
aplicativos gráficos (GUI) têm uma interface visual com o usuário. Os aplicativos gráficos (aplicativos de
desktop) consistem em uma das várias janelas gráficas nas quais existem controles: campos de texto,
botões, figuras, tabelas e outros.
Para nossa aplicação, utilizaremos a tecnologia JavaFX, que permite a criação de

aplicações gráficas para todas as plataformas com a linguagem de programação Java.
Usaremos o programa IntelliJ IDEA para o ambiente de desenvolvimento.
Para facilitar a criação de aplicações gráficas com JavaFX, usaremos o programa
SceneBuilder, que baixaremos aqui: https://gluonhq.com /products/scene-builder/
#download.
Instalamos o SceneBuilder para projetar interfaces de usuário JavaFX:
No IntelliJ IDEA, crie um novo projeto Java do tipo JavaFX Application:

Ao criar um aplicativo JavaFX, ele gerará um projeto com vários arquivos:
O arquivo que contém nossa visão de aplicação está localizado no caminho [src/sample/
sample.fxml]. Vamos lá abrir:
O arquivo se parece com isso. Não trabalharemos diretamente com ele, mas usaremos
o mencionado SceneBuilder, que gerará o código para nós. Clique com o botão direito
do mouse no arquivo e selecione [Abrir no SceneBuilder]:
Ao selecionar esta opção pela primeira vez, o IntelliJ IDEA solicitará o caminho para o
SceneBuilder.exe:
Em uma instalação típica do Windows, o SceneBuilder está localizado em [C:

\Users{nome de usuário}\AppData\Local\SceneBuilder]. Depois de especificar o
caminho correto, o SceneBuilder é aberto e vemos a seguinte tela:
À esquerda, temos os tipos de controles que podemos adicionar, então encontraremos

[AnchorPane] e vamos adicioná-lo arrastando-o para o meio onde está o nosso design:
Esta é a nossa janela onde agora podemos começar a adicionar controles que tiramos do mesmo local
em que adicionamos o [AnchorPane] (no menu [Containers]). Para nossa interface precisamos:
• 3 campos de texto: TextField
• 2 rótulos entre os campos de texto (para + e =): Rótulo
• 1 botão para calcular o resultado: Botão
Depois de adicioná-los, nosso aplicativo deve ficar assim:
Iremos renomear os controles, escolhendo nomes mais adequados que correspondam à funcionalidade
do nosso aplicativo ("+" e "="). Isso é feito clicando no controle que queremos alterar e indo à direita de
suas propriedades ([Propriedades]). Para começar, vamos alterar a propriedade Text dos rótulos. Seu
nome padrão é Label:
Para melhor atender a lógica do nosso programa, escolhemos nomes mais significativos. Substituímos o
primeiro texto Label por +:
Da mesma forma, alteramos o texto do segundo rótulo para = e o rótulo do botão para
Calcular:
Salvamos as alterações no design com [Ctrl+S]:
Voltamos ao IntelliJ IDEA e iniciamos o aplicativo com [Shift+F10]:
Talvez o aplicativo pareça maior ou menor do que eu esperava. A razão para isso é que
há uma parte em nosso código de aplicativo que diz explicitamente quais devem ser suas
dimensões. Vamos corrigir este problema.
Vamos para a classe Main e encontramos este pedaço de código:
Excluímos o código que informa ao nosso programa qual será o tamanho da janela para usar o
dimensionamento que escolhemos no SceneBuilder:
Nosso código agora está assim:
Rodamos o programa novamente com [Shift+F10] e verificamos se o dimensionamento está correto

corretamente:
Como etapa final para concluir nosso projeto, retornaremos ao nosso

code e mudaremos o título da aplicação, que fica nesta linha:
Mudamos o nome de "Hello World" para "Sumator":
Lançamos o aplicativo:
O design da parte gráfica parece pronto. Agora é hora de algo muito mais interessante - a lógica do programa. É
hora de escrever o código que soma os números dos dois primeiros campos e exibe o resultado no terceiro campo.
Para fazer isso, precisamos voltar ao SceneBuilder e dar nomes aos campos de texto para
podemos acessá-los no código:

Clicamos no primeiro campo de texto com o mouse e vamos para a seção [Código] à direita,
onde daremos o nome num1 no campo fx:id:
Renomeamos o segundo campo para num2:
Assim, nomeamos o resultado do terceiro campo:
Agora vamos dizer ao botão qual função executar quando for clicado. Vamos ao campo On
Action e damos a ele o nome da função de cálculo, que criaremos em instantes:
Salve as alterações do SceneBuilder com [Ctrl+S] e retorne ao arquivo sample.fxml:
Podemos ver que nossos campos possuem nomes e nosso botão possui uma função
a ser executada ao ser clicado. Até aqui tudo bem, mas esses campos e a função do
botão ainda não existem em nosso código. Para gerá-los, iremos a cada um deles e
pressionaremos [Alt+Enter] ÿ [Criar campo] [nome do campo]:
Uma vez criado um dos campos, seremos redirecionados para o arquivo Controller.java,
onde o campo será criado em um código como este:
Adicionamos os campos num2, result e a função de cálculo da mesma forma . O código

no arquivo Controller.java deve ficar assim:
Escrevemos o seguinte código Java entre as chaves de abertura e fechamento { } de

nossa função de cálculo:
Este código pega o primeiro número do campo num1 em uma variável num1, então o
segundo número do campo num2 em uma variável num2, então soma num1 + num2
em uma variável de resultado e, finalmente, gera o valor de texto do resultado no
campo de resultado .
Reiniciamos o programa com [Shift+F10] e tentamos se funciona. Testamos se

podemos calcular a soma de diferentes valores corretamente. Primeiro, inserimos dois
números inteiros - por exemplo, 4 e 5:
Em seguida, tentamos adicionar um não inteiro negativo e um positivo - por exemplo

-12,5 e 1,3:
Tentando inserir uma entrada inválida, por exemplo, aaa e bbb:
Vemos que há um problema quando o usuário insere dados de entrada inválidos:

Isso acontece devido à conversão de um campo de texto em um número. Se o valor no campo não for um número,
o programa será interrompido e lançará uma exceção. Pudermos
corrija o código assim:
Com esse código, detectamos erros ao trabalhar com números (capturar exceções) e, em caso de erro, exibimos
um valor de "erro" no campo de resultado. Reiniciamos o programa com [Shift+F10] e tentamos se funcionar. Desta
vez, para um número errado, o resultado é "erro" e o programa não quebra:
É complicado? Tudo bem ser complicado, claro. Estamos entrando na programação. O exemplo acima requer muito
mais conhecimento e habilidades que desenvolveremos neste livro e até além. Apenas deixe-me me divertir um
pouco com a programação de desktop.
Se algo não funcionar, assista ao vídeo no início deste capítulo ou pergunte no fórum SoftUni: https://softuni.bg/
forum. Ou sinta-se à vontade para passar para o próximo exemplo ou o próximo capítulo do livro. A hora vai chegar
e vai
é fácil para você, mas você realmente tem que se esforçar e persistir. A programação é
aprendida lentamente e com muita e muita prática.
Aplicativo da Web: Somador de Números

Agora vamos escrever algo ainda mais complicado, mas também mais interessante: uma
aplicação web que calcula a soma de dois números. Ao inserir dois números nas duas
primeiras caixas de texto e pressionar o botão [Calcular], sua soma é calculada e o
resultado é exibido na terceira caixa de texto. Espera-se que o aplicativo se pareça com
isto:
Ao contrário dos aplicativos de console, que lêem e gravam seus dados como texto no
console, os aplicativos da web têm uma interface de usuário baseada na web. Os
aplicativos da Web são carregados de algum endereço da Internet (URL) por meio de
um navegador da Web padrão. Os usuários gravam os dados de entrada em uma página
renderizada pelo aplicativo da web, os dados são processados no servidor da web e os
resultados são exibidos de volta na página no navegador da web.
Para nossa aplicação web, utilizaremos a tecnologia Spring MVC, que permite criar
aplicações web com a linguagem de programação Java no ambiente de desenvolvimento
IntelliJ IDEA. No IntelliJ
IDEA, importe o projeto (esqueleto do aplicativo) deste link: https://github.com/SoftUni/
Programming-Basics-Book-Java-BG/blob/master/assets/ Chapter-1-assets via [Import
Project ]:
Encontramos a pasta na qual baixamos Selecionamos [Import project from external

esqueleto: model] e depois [Maven]:
Essa tela segue:

Capítulo 1. Introdução à Programação 63
Avançamos com [Next]:
Mais uma vez avançamos com [Next]:
E mais uma vez avançamos com [Next]:
Depois de colocarmos o projeto no IntelliJ, ele deve ficar assim:

Executamos o projeto para ver se ele inicia sem erros. Para isso, iremos até a pasta
[src/main/java/com.softuni] e abriremos o arquivo SumatorApplication:
Para executar o programa, podemos usar o atalho de teclado [Ctrl+Shift+F10] ou

selecionar [Run 'SumatorApplication.main()'] no menu de contexto:
Após o carregamento do aplicativo da web, devemos ver esta mensagem na parte

inferior do console que se abre:
Podemos executar o aplicativo e verificar se ele está funcionando acessando nosso

navegador da Web e digitando localhost:8080:
Até aqui tudo bem, exceto quando inserimos dois números e pressionamos [Calcular],
nada acontece. Vamos escrever a lógica para o somador funcionar corretamente. Abra o
arquivo HomeController na mesma pasta e você verá o seguinte:
A parte que nos interessa é a função soma:

Atualmente, esta função pega dois textos num1 e num2, os alimenta no servidor e retorna o índice do
arquivo para o usuário. Como você pode imaginar, não há nenhum código interno para calcular os números
nas duas caixas de texto e alimentá-los na terceira caixa. Vamos escrever a lógica que realizará isso.
Vamos entre as chaves e escrevemos o seguinte código:
É assim que o arquivo HomeController deve ficar após a alteração:
Antes de voltarmos ao aplicativo, precisamos aplicar nossas alterações. Faremos isso indo para a janela
do console e pressionando o botão [Rerun application]:
O aplicativo está pronto. Se inserirmos dois números nas caixas de texto e pressionarmos o botão
[Calcular], o resultado deverá aparecer na terceira caixa de texto:
Parece assustador? Não tenha medo! Ainda temos muito que aprender para atingir o nível de conhecimento e
habilidades para escrever livremente aplicações baseadas na web como o exemplo acima e outras bem maiores e
mais complexas. Se você não conseguir, não se preocupe, apenas continue. Com o tempo, você se lembrará com
um sorriso de como foi incompreensível e emocionante seu primeiro encontro com a web.
a programação.
Se você tiver problemas com o exemplo acima, assista ao vídeo no início deste capítulo. Lá o aplicativo é feito
passo a passo ao vivo com muitas explicações. Ou pergunte no fórum SoftUni: https://softuni.bg/forum. O propósito
dos dois exemplos acima (aplicativo de desktop gráfico e aplicativo da web) não é aprender, mas tocar
a programação mais profundamente, despertar seu interesse no desenvolvimento de software e inspirá-lo a estudar
muito. Você ainda tem muito a aprender, mas é interessante, não é?
Capítulo 2.1. Cálculos simples com números

• Qual é o console do sistema? Neste capítulo você vai conhecer
em com os seguintes conceitos e técnicas de programação:
• Como ler os números do console do sistema? •

Como trabalhar com tipos de dados e variáveis que precisamos em
processar números e as operações entre eles?
• Como exibir um resultado (número) no console do sistema? •

Como realizar operações aritméticas simples: adição, subtração,
multiplicar, dividir, concatenar uma string?
Vídeo
Assista a um tutorial em vídeo sobre este capítulo: https://youtube.com/watch?v=7u4X5X-a9Qg.
console do sistema
Normalmente chamado apenas de "console", o sistema ou console do computador é o dispositivo através do qual
emitimos comandos para o computador em
forma de texto e obtemos os resultados de sua execução novamente como texto.
Na maioria dos casos, o console do sistema é um terminal de texto, ou seja, aceita e renderiza apenas texto, sem
elementos gráficos como botões, menus, etc. Geralmente se parece com uma janela preta na qual digitamos
executar comandos do console que imprimem a saída de texto. No Windows
o console fica assim:
Na maioria dos sistemas operacionais, o console geralmente está disponível como um aplicativo autônomo no qual
escrevemos vários comandos de console. No Windows é chamado de Prompt de Comando e no Linux e macOS é
chamado de Terminal. Os aplicativos de console são executados no console. Eles lêem a entrada de texto da linha
de comando e
imprimir sua saída como saída de texto para o console. Neste livro, aprenderemos a
programar criando principalmente aplicativos de console.
É assim que o console do Linux se parece:
Lendo números do console

Na verdade, em Java, existem várias maneiras de ler algumas entradas do console. Uma
é usando a classe interna Scanner, que usaremos agora, e a outra é usando
BufferedReader. O segundo é um pouco mais rápido, mas só começaremos a usá-lo
depois de nos familiarizarmos com streams em Java.
Para ler um número inteiro (não fracionário) do console, primeiro precisamos importar a
classe Scanner na primeira linha do nosso programa, antes mesmo da declaração da
classe principal. Colocamos esta linha no topo:
Em seguida, no método main(…) do programa , precisamos criar uma nova instância

Scanner para anexar à entrada do sistema. Então, através do scanner de scanner
criado , podemos ler números inteiros e fracionários, texto e outros dados. Por exemplo,
com s.nextInt() lemos o próximo inteiro passado como entrada:
Scanner scanner = new Scanner(System.in); int num

= scanner.nextInt();
Agora na variável num do tipo inteiro int lemos o valor passado como entrada do console.
Java é uma linguagem tipada estaticamente, o que significa que as variáveis possuem
um tipo que é determinado em tempo de compilação e não pode ser alterado
instantaneamente (como em linguagens dinâmicas como JavaScript e Python). No
exemplo acima, a variável do scanner é do tipo java.util.Scanner (leitor de texto de
varredura) e a variável num é do tipo int (inteiro).
Exemplo: calcular a face de um quadrado de lado a

Por exemplo, considere o seguinte programa, que lê um inteiro do console, multiplica-o
por si mesmo (eleva-o ao quadrado) e imprime o resultado de
Capítulo 2.1. Cálculos simples com números 71
a multiplicação. Assim, podemos calcular a face de um quadrado por um determinado comprimento

do lado. Segue todo o código fonte do programa. Salve-o em um arquivo chamado SquareArea.java,
senão dará um erro de compilação:
// Coloque este código no arquivo: SquareArea.java
public class SquareArea { public

static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("a = "); int a =

scanner.nextInt(); área int = a
*
a;
System.out.print(" Área quadrada = ");

System.out.println(área);
}
}
Veja como o programa funcionaria para um quadrado com tamanho de lado 15:
Tente digitar um número errado, por exemplo "alô". Você receberá uma mensagem de erro de tempo
de execução (exceção).
Isso é perfeitamente normal porque a linguagem Java é uma linguagem fortemente tipada. Mais tarde,
veremos como podemos detectar esses erros e forçar o usuário a digitar novamente um número.
Como funciona o exemplo?

A primeira linha Scanner scanner = new Scanner(System.in); cria uma nova instância da
classe Scanner com syslog padrão.
A próxima linha System.out.print("a = "); imprime uma mensagem informativa solicitando
ao usuário que insira o lado a do quadrado. Após a impressão, o cursor permanece na
mesma linha. Permanecer na mesma linha é mais conveniente para o usuário puramente
visual. Ele usa System.out.print(…); em vez de System.out.println( …); e assim o cursor
permanece na mesma
linha. A próxima linha int a = scanner.nextInt();
ler um inteiro do console. O resultado é gravado em uma variável chamada a.
O seguinte comando int area = a é o * a; grava em uma nova variável de área

resultado da multiplicação de a por a.
O seguinte comando System.out.print("Square area = "); imprime o texto especificado
sem quebrar. Novamente , System.out.print(…); é usado , não System.out.println("…");
e assim o cursor permanece na mesma linha para que a face computada de possa ser
impressa também
quadrado.
O último comando System.out.println(area); imprime a posição calculada

da variável área.

Lendo números fracionários

Tente reescrever o programa acima para que ele aceite não apenas números inteiros (int) ,
mas também números fracionários (double). Você pode usar o scanner. nextDouble().
Aprenderemos mais sobre números fracionários em um momento.
Cálculos em programação
Sabemos sobre computadores que são máquinas que processam dados. Todos os dados
são armazenados na memória do computador (memória RAM) em variáveis. As variáveis
são áreas nomeadas da memória que armazenam dados de um tipo específico, como um
número ou texto. Cada variável em Java tem um nome, um tipo e um valor. Veja como
definiríamos uma variável, declarando-a e atribuindo-lhe um valor:
Após o processamento, os dados são gravados de volta em variáveis (ou seja, em algum
lugar da memória alocada por nosso programa).
Tipos de dados e variáveis

Na programação, cada variável armazena um determinado valor de um determinado tipo. Os
tipos de dados podem ser, por exemplo: número, letra, texto (string), data, cor, imagem, lista,
etc. Aqui estão alguns exemplos de tipos de dados:
• tipo inteiro: 1, 2, 3, 4, 5, … • tipo de
número fracionário: 0,5, 3,14, -1,5, … • tipo
de letra do alfabeto (símbolo): 'a', 'b', 'c', … • tipo de
texto (string): "Olá", "Olá", "Cerveja", … • tipo de dia
da semana: segunda-feira, terça-feira, …
Lendo um número fracionário do console

Para ler um número fracionário do console, precisamos declarar uma variável novamente,
especificar o tipo do número e usar o comando padrão para ler as informações do console
do sistema:
Double num = scanner.nextDouble();
Exemplo: conversão de polegadas para centímetros

Vamos escrever um programa que leia um número fracionário em polegadas e o converta em
centímetros:

System.out.print("Polegadas = ");
Polegadas duplas = scanner.nextDouble();
Centímetros duplos = polegadas * 2,54;
System.out.print("Centímetros = ");
System.out.println(centímetros);
Vamos rodar o programa e garantir que ao passarmos um valor em polegadas, obtemos um

resultado correto em centímetros:

Leitura e impressão de texto

Para ler o texto (string) do console, declaramos novamente uma nova variável e usamos
o comando padrão para ler as informações do sistema
console:
String str = scanner.nextLine();
Atentemos para o fato de que na leitura de texto não é necessária a conversão para
outro tipo. Isso ocorre porque, por padrão, o scanner. nextLine(…) retorna texto como
resultado. Além disso, podemos definir o texto a ser convertido em um número inteiro
usando Integer.parseInt(…) ou um número fracionário usando Double.parseDouble(…).
Se isso não for feito, para o programa cada número será apenas um texto com o qual não
poderíamos fazer nada
operaçoes aritimeticas.
Exemplo: saudação pelo nome

Vamos escrever um programa que insira o nome do usuário e o cumprimente com o texto
"Olá, nome".
Scanner scanner = new Scanner(System.in); String

nome = scanner.nextLine();
System.out.printf("Olá, %s!", nome);
Neste caso, a expressão %s é substituída pelo primeiro argumento passado, que no

exemplo é a variável name:

Mesclar texto e números

Ao imprimir texto, números e outros dados no console, podemos concatená-los usando
os padrões %s, %d, %f , etc. Na programação, esses padrões são chamados de espaços
reservados e, dependendo do tipo da variável, diferentes símbolos são usados para
denotar diferentes tipos de argumentos. Os principais são: %s para texto (string), %d para
inteiros, %f para números decimais. Aqui está um exemplo de impressão de texto
formatado com espaços reservados:
String primeiroNome = scanner.próximaLinha();

String lastName = scanner.nextLine(); int idade
= Integer.parseInt(scanner.nextLine()); String cidade =
scanner.nextLine(); System.out.printf( "Você
é %s %s, uma pessoa
de %d anos de %s.", primeiroNome, Sobrenome, idade,
cidade);
Aqui está a saída que obteremos após executar este exemplo:
Observe como cada variável deve ser passada na ordem em que queremos que seja
impressa e corresponda ao tipo passado no modelo. Essencialmente, o modelo
(placeholder) aceita variáveis de qualquer tipo.

Operaçoes aritimeticas
Vejamos as operações aritméticas básicas na programação.
Adição de números (operador +)

Podemos somar números com o operador +:
int a = 5; int
b = 7; int
soma = a + b; // resultado é 12
Subtração de números (operador -)

A subtração de números é feita com o operador -:
int a = Integer.parseInt(scanner.nextLine());
int b = Integer.parseInt(scanner.nextLine()); int resultado =

a - b;
System.out.println(resultado);
Aqui está o resultado da execução do programa (para os números 10 e 3):
Multiplicação por números (operador *)

Para multiplicar números, usamos o operador *:
int a = 5; int
b = 7; int
produto = a * b; // 35
Divisão por números (operador /)

A divisão de números é feita com o operador /. Funciona de maneira diferente para números inteiros e
para números fracionários.
• Quando dividimos dois inteiros, a divisão inteira é realizada e o resultado é um inteiro com
a parte fracionária truncada. Por exemplo, 11 / 3 = 3. • Quando dividimos dois números,
dos quais pelo menos um é uma fração, uma divisão fracionária é realizada e o resultado
resultante é um número fracionário, como na matemática. Por exemplo, 11/4,0 = 2,75. Se
for impossível dividir exatamente, o resultado é arredondado, por exemplo 11,0 / 3 =
3,66666666666667.
• A divisão de inteiro por 0 gera um erro de tempo de execução (Java.lang.ArithmeticException).
• A divisão fracionária por 0 não causa erro e o resultado é +/- infinito

ness ou o valor especial NaN. Por exemplo, 5 / 0,0 = ÿ.
Aqui estão alguns exemplos de uso do operador de divisão:
int a = 25; int

i = a/ 4; // executa o chamado divisão inteira: o resultado será // 6, a parte fracionária
é cortada (divisão inteira) int f = a / 4.0; // 6.25 – divisão
fracionária. Nós explicitamente // dissemos ao número 4 para ser
interpretado como uma fração // adicionando o ponto
decimal seguido de 0
erro int = a/ 0; // Erro: divisão inteira por 0
Vejamos também alguns exemplos de divisão de inteiros (lembre-se que ao dividir inteiros
na linguagem Java, o resultado é um inteiro):
int a = 25;
System.out.println(a / 4); // Resultado inteiro: 6 System.out.println(a /
0); // Erro: divisão por 0
Vejamos alguns exemplos de divisão de frações. Na divisão fracionária, o resultado é sempre

um número fracionário e a divisão nunca dá erro e funciona corretamente com os valores
especiais +ÿ e -ÿ:
int a = 15;
System.out.println(a / 2.0); // Resultado fracionário: 7.5 System.out.println(a /
0.0); // Output: Infinity System.out.println(-a / 0.0); // Output: -Infinity
System.out.println(0.0 / 0.0); // Resultado: NaN (não é um número), // ie.
não é um valor numérico válido
A impressão dos valores ÿ e -ÿ no console pode resultar em ? porque o console do Windows

não suporta Unicode corretamente e corrompe a maioria dos símbolos, letras e caracteres
especiais não padrão. O exemplo acima provavelmente produzirá o seguinte resultado:
7.5 ?
-?
NaN
Mesclar texto e número

O operador + , além de adicionar números, também serve para unir texto (colar duas strings
de caracteres uma após a outra). Na programação, juntar texto com texto ou com número é
chamado de "concatenação". Veja como podemos concatenar texto e um número com o
operador +:
String primeiroNome = "Maria";

String lastName = "Ivanova"; int idade
= 19; String str =
""
primeiroNome + + sobrenome + " @ " + idade;

System.out.println(str); // Maria Ivanova @19
Aqui está outro exemplo:
duplo a = 1,5, b = 2,5; String

soma = "A soma é: " + a + b;
System.out.println(soma); // A soma é: 1.52.5
Você percebe algo estranho? Talvez você esperasse que os números a e b somassem? Na verdade, a
concatenação funciona da esquerda para a direita e o resultado acima está absolutamente correto. Se
quisermos somar os números, precisaremos usar parênteses para mudar a ordem das operações:
duplo a = 1,5; b duplo

= 2,5; String soma =
"A soma é: " + (a + b); System.out.println(soma); // A soma
é: 4
expressões numéricas
Na programação, também podemos calcular expressões numéricas, por exemplo:
int expr = (3 + 5) * (4 – 2);
A regra padrão para prioridades de operações aritméticas se aplica: a multiplicação e a divisão são
sempre realizadas antes da adição e da subtração. Quando uma expressão está presente entre
parênteses, ela é avaliada primeiro, mas sabemos tudo isso de
matemática escolar.
Exemplo: calcular a face de um trapézio

Vamos escrever um programa que insira os comprimentos das duas bases de um trapézio e sua altura
(um número fracionário por linha) e calcule a face do trapézio usando a fórmula matemática padrão.
duplo b1 = Double.parseDouble(scanner.nextLine()); duplo b2 =

Double.parseDouble(scanner.nextLine()); double h =
Double.parseDouble(scanner.nextLine()); área dupla = (b1 + b2) * h/ 2,0;
System.out.println(" Área do trapézio =
" + área);
Se rodarmos o programa e entrarmos para os países 3, 4 e 5 respectivamente, obtemos o seguinte

resultado:
34
5
Área do trapézio = 17,5
Testando no sistema de juízes Teste

Exemplo: perímetro e face de um círculo

Vamos escrever um programa que, dado o raio r de um círculo, calcule a face e o perímetro
do círculo. Fórmulas:
* *
• Face = ÿ • r r
* *
Perímetro = 2 r
pi
• ÿ ÿ 3,14159265358979323846…
System.out.print("Digite o raio do círculo. r = "); duplo r =

Double.parseDouble(scanner.nextLine()); System.out.println("Area =
+ Math.PI * * r); // Math.PI - Constante" Java graduada para r ÿ
System.out.println("Perímetro = + 2 * Math.PI" * r);
Vamos tentar o programa com raio r = 10:

Exemplo: face de um retângulo no plano

Um retângulo é especificado com as coordenadas de dois de seus dois cantos opostos. Para
calcular sua área e perímetro:
Neste problema temos que considerar que se subtrairmos o x menor do x maior,

obteremos o comprimento do retângulo. Da mesma forma, se subtrairmos o y menor do
y maior, obtemos a altura do retângulo. Resta multiplicar os dois lados. Aqui está um
exemplo de implementação da lógica descrita:
duplo x1 = Double.parseDouble(scanner.nextLine()); duplo y1 =

Double.parseDouble(scanner.nextLine()); duplo x2 =
Double.parseDouble(scanner.nextLine()); duplo y2 =
Double.parseDouble(scanner.nextLine());
// Calcula os lados do retângulo: double width =

Math.max(x1, x2) - Math.min(x1, x2); altura dupla = Math.max(y1,
y2) - Math.min(y1, y2);
DecimalFormat decimalFormat = new DecimalFormat("#.#########");

System.out.println(decimalFormat.format(largura * altura));
System.out.println(decimalFormat.format(2 * (largura + altura)));
Usamos Math.max(a, b) para encontrar o maior dos valores a e b e da mesma forma

Math.min(a, b) para encontrar o menor dos dois valores.
Ao executar o programa com os valores do sistema de coordenadas na condição,

obtemos o seguinte resultado:


Para resumir o que aprendemos neste capítulo do livro:
• Entrada de texto: String str = scanner.nextLine(); (primeiro tornando Scanner
scanner = new Scanner(System.in);).
• Entrada de inteiro: int num = Integer.parseInt(scanner.

proximaLinha());.
• Inserindo um número fracionário: double num = Double.parseDouble(scanner.
proximaLinha());.
• Realizar cálculos com números e usar a aritmética apropriada
operadores ticos [+, -, *, /, (, )]: int soma = 5 + 3;.
• Texto de saída de acordo com o padrão do console: System.out.printf("%d + %d =
%d", 3, 5, 3 + 5);.
Exercícios: cálculos simples

Vamos reforçar o que aprendemos neste capítulo com alguns exercícios.
Solução Prazno IntelliJ IDEA (Projeto)

Começamos criando um projeto vazio (Projeto) no IntelliJ IDEA. Projetos (projetos) no IntelliJ
IDEA unem um grupo de tarefas. Esta opção é extremamente conveniente quando queremos
trabalhar em várias tarefas e alternar rapidamente entre elas, ou queremos combinar
logicamente várias tarefas interligadas. Nesta atividade prática, usaremos um Projeto
multitarefa (aulas Java) para organizar as soluções para as tarefas do exercício - cada tarefa
em uma classe Java separada e todas as classes Java em um projeto comum.
• Lançamos o IntelliJ IDEA. •

Criamos um novo Projeto: [Arquivo] ÿ [Novo] ÿ [Projeto].
Selecionamos [Java] na caixa de diálogo, no campo Project SDK especificamos qual

versão do Java usaremos e, finalmente, pressionamos os botões [Next] ÿ [Next]:
Damos ao projeto um nome adequado, por exemplo "SimpleCalculations" e onde

salvar nosso projeto, então pressione o botão [Finish]:
Agora temos um projeto IntelliJ IDEA vazio criado (sem nenhuma classe Java nele, que
deve estar localizada na pasta src):
O objetivo deste projeto é adicionar uma classe .Java para cada tarefa de
Os exercícios.
Tarefa: calcular a face de um quadrado

A primeira tarefa deste tópico é esta: escrever um programa de console que insira um
inteiro a e calcule a face de um quadrado com lado a. A tarefa é trivialmente fácil: você
insere um número no console, multiplica por ele mesmo e
você imprime o resultado resultante no console.
Diretrizes e dicas
Criamos uma nova classe .Java em um projeto IntelliJ IDEA existente. Clique com o botão
direito do mouse na pasta [ src] . Selecione [Novo] ÿ [Classe Java]:
Uma caixa de diálogo será aberta para selecionar um nome de classe Java, por exemplo
“Área Quadrada”:
Agora temos um projeto com uma classe Java nele. Resta escrever o código para resolver a tarefa.
Para fazer isso, adicionamos à nossa classe Java o método Main (como mostrado na figura) e vamos
ao corpo do método Main(string[] args) , onde escrevemos o seguinte código entre as chaves de
abertura e fechamento:
O código insere um número inteiro por meio de a = Integer.parseInt(scanner.nextLine()), ae ,

area. Iniciamos o programa com * finalmente, imprime o valor da variável e calcula area = a
[Ctrl+Shft+F10] e o testamos com diferentes valores de entrada:
sua solução: https://judge.softuni.bg/Contests/Practice/Index/649#0. Você deve obter 100 pontos

(solução completamente correta):
Tarefa: de polegadas a centímetros

Escrever um programa que leia do console um número (não necessariamente um número inteiro)
e converta o número de polegadas para centímetros. Para fazer isso, multiplique as polegadas por
2,54 (já que 1 polegada = 2,54 centímetros).
Diretrizes e dicas Primeiro

criamos uma nova classe Java no projeto “SimpleCalculations”. Clicamos com o mouse na pasta
[src] e selecionamos [Novo] ÿ [Classe Java]:
Aparece uma caixa de diálogo na qual escrevemos o nome do arquivo. No nosso caso
é "InchesToCentimeters" ÿ [OK]:
Devemos escrever o código do programa:
Iniciamos o programa com o botão direito do mouse na janela do programa atual.

Selecionamos [Run 'InchesToCentim...main()'] ou pressionamos [Ctrl+Shift+F10]. Esta
combinação de teclas inicia o programa na classe Java atual (aquela que escrevemos
pela última vez):
O que nos dá o seguinte resultado:
Agora vamos mudar para o programa/tarefa anterior ("rosto em um quadrado"). Isso é

feito clicando duas vezes no arquivo SquareArea.java da pasta [src] no projeto
[SimpleCalculations]:
Se usarmos [Shift+F10] ou pressionar uma das duas setas verdes (localizadas no canto
superior direito e no canto inferior esquerdo da janela do IntelliJ IDEA)
o último programa compilado (InchesToCentimeters) será executado. Dela

podemos ver como um nome no canto superior direito da janela antes do verde
seta:
Alternar entre projetos é muito fácil, certo? Simplesmente selecionamos o arquivo com o código-fonte do
programa, clicamos duas vezes nele com o mouse e, ao iniciar, o programa inicia a partir deste arquivo.
Vamos testar com números fracionários, por exemplo com 2,5:
Dependendo das configurações regionais do sistema operacional, é possível usar um

ponto decimal (configurações de GB) em vez de um ponto decimal (configurações dos
EUA).
Se o programa espera uma vírgula e um número com vírgula é digitado, ou vice-versa (é digitada uma
vírgula quando se espera uma vírgula), ocorrerá o seguinte erro:
É recomendável alterar as configurações do computador para usar um ponto decimal:


A decisão deve ser aceita como completamente correta:
Tarefa: saudação pelo nome

Escrever um programa que leia o nome de uma pessoa no console e imprima Olá,
<nome>!, onde <nome> é o nome digitado anteriormente.
Diretrizes e dicas
Primeiro, criamos uma nova classe Java chamada “Greeting” no projeto “SimpleCalculations”
Precisamos escrever o código do programa. Se estiver com problemas, você pode usar o
código de exemplo abaixo:
Iniciamos o programa com [Ctrl+Shift+F10] e testamos se funciona:

Tarefa: juntar texto e números

Escreva um programa Java que leia o nome, sobrenome, idade e cidade do console e
imprima uma mensagem como esta :
Diretrizes e dicas
Adicionamos ao projeto IntelliJ IDEA atual outra classe Java chamada "ConcatenateData".
Escrevemos o código que lê os dados de entrada do console:
Deve ser adicionado o código que imprime a mensagem descrita na condição da tarefa.
Na imagem acima, o código está deliberadamente desfocado para que você possa pensar em como fazê-lo
escreva você mesmo.
A solução deve ser testada localmente com [Ctrl+Shift+F10] e inserindo entradas de

exemplo.

Tarefa: face de um trapézio

Escreva um programa que leia no console três números b1, b2 e h e calcule a face de um
trapézio com bases b1 e b2 e altura h. A fórmula da face de um trapézio é (b1 + b2) * h/2.
A figura acima mostra um trapézio com lados 8 e 13 e altura 7. Tem uma face de (8 + 13) * 7 / 2
= 73,5.
Diretrizes e dicas
Novamente, precisamos adicionar ao projeto atual no IntelliJ IDEA outra classe Java chamada
"TrapezoidArea" e escrever o código que lê os dados de entrada do console
lata, calcula a face do trapézio e a imprime:
O código na imagem é deliberadamente desfocado para que você possa pensar sobre ele e
escrevê-lo você mesmo.
Teste a solução localmente com [Ctrl+Shift+F10] e inserindo dados de exemplo.

Problema: perímetro e face de um círculo

Escreva um programa que leia do console um número r e calcule e imprima a face e o perímetro
de um círculo de raio r.
Conecte-se Saída Conecte-se Saída
Área = 28,2743338823081 Perímetro =

Área = 28,2743338823081 Perímetro =
3 3
18,8495559215388
18.8495559215388
Diretrizes e dicas
Para cálculos, você pode usar as seguintes fórmulas:
• Área = Math.PI * r * r.
• Perímetro = 2 * Math.PI * r.

Problema: face de um retângulo no plano

Um retângulo é definido com as coordenadas de dois de seus cantos opostos (x1, y1) – (x2, y2).
Calcule sua área e perímetro. A entrada é lida no console. Os números x1, y1, x2 e y2 são dados
um por linha. A saída é enviada para o console e deve conter duas linhas com um número em
cada linha –
face e perímetro.
Entrada Saída Entrada Saída Conecte-se Saída
60 30 600,25
20 1500 40 2000 500,75 350449.6875
10 160 70 180 100,50 2402
50 -10 -200,5

Problema: face de um triângulo

Escreva um programa que leia no console o lado e a altura de um triângulo e calcule sua face.
Use a fórmula da face do triângulo: area = ah / 2. Arredonde o resultado para 2 casas decimais
* usando Math.round(area, 2).
20 15
Área do triângulo = 300 Área do triângulo = 262,5
30 35
7,75 1,23456
Área do triângulo = 32,74 Área do triângulo = 2,82
8,45 4,56789

Tarefa: conversor de console - de graus °C a graus °F

Escreva um programa que leia graus Celsius (°C) e os converta para graus Fahrenheit (°F).
Pesquise na Internet uma fórmula adequada para fazer os cálculos. Arredonde o resultado para 2
casas decimais. Aqui estão alguns exemplos:
Entrada Saída Entrada Saída Entrada Saída Entrada Saída
25 77 0 32 -5,5 22.1 32.3 90,14

Tarefa: conversor cantilever - de radianos para graus

Escreva um programa que leia um ângulo em radianos (rad) e o converta em graus (graus).
Pesquise na Internet uma fórmula adequada. O número ÿ em programas Java está disponível
através do Math.PI. Arredonde o resultado para o inteiro mais próximo usando o método
Math.round(…).
3.1416 180 0,7854 45
6.2832 360 0,5236 30

Tarefa: conversor de console - USD para BGN

Escreva um programa para converter Dólares americanos (USD) em Leva búlgaro (BGN). Arredonde o
resultado para 2 casas decimais. Use uma taxa de câmbio fixa entre o dólar e o lev: 1 USD = 1,79549 BGN.
Entrada Saída Conecte-se Saída Conecte-se Saída
20 35,91 BGN 100 179,55 BGN 12.5 22,44 BGN
Teste no sistema de juízes Teste sua
solução: https://judge.softuni.bg/Contests/Practice/Index/649#10.
*
Tarefa: conversor de moeda do console
Escreva um programa para converter uma quantia em dinheiro de uma moeda para outra. As seguintes
moedas devem ser suportadas: BGN, USD, EUR, GBP. Use as seguintes taxas de câmbio fixas:
Curso USD EUR GBP
1 BGN 1,79549 1,95583 2,53405
A entrada é o valor a ser convertido, a moeda de entrada e a moeda de saída. A saída é um único número -
o valor convertido nas taxas acima, arredondado para 2 casas decimais.
20 12h35
USD 35,91 BGN EUR 9,53 libras esterlinas
BGN GBP
100 150,35
BGN 51,13 euros USD 138,02 euros
EUR EUR
**
Tarefa: acerto de contas com datas - 1000 dias na Terra
Escreva um programa que insira uma data de nascimento no formato dd-MM-aaaa e

calcule a data que é 1000 dias a partir dessa data de nascimento e a imprima no mesmo
formato.
Conecte-se Saída Conecte-se Saída Conecte-se Saída
25-02-1995 20-11-1997 14-06-1980 10-03-1983 30-12-2002 24-09-2005
11-07-2003 08-02-2006 01-01-2012 26-09-2014
Diretrizes e dicas
• Encontre informações sobre os tipos Date, Calendar e SimpleDateFormat em Java
e examine especificamente os métodos Calendar.setTime(date),
Calendar.add(countDays) e SimpleDateFormat.format(date). Com a ajuda deles,
você pode resolver a tarefa sem precisar calcular dias,
meses e anos bissextos.
• Não imprima nada extra no console além da data exigida!

Capítulo 2.2. Cálculos simples com números -

problemas de exame
No capítulo anterior, nos familiarizamos com o console do sistema e como trabalhar com
ela - como ler um número do console e como imprimir o resultado do con zola. Cobrimos
operações aritméticas básicas e mencionamos brevemente os tipos de dados. Neste
capítulo, praticaremos e reforçaremos o que aprendemos até agora examinando alguns
dos problemas de exame mais complexos.
Lendo números do console

Antes de passar para as tarefas, vamos relembrar o mais importante do material estudado
do tópico anterior. Começaremos lendo os números do console.
Lendo um número inteiro

Precisamos de uma variável para armazenar o número (por exemplo, num), e sim
usamos o comando padrão para ler dados do console em conjunto com
a função Integer.parseInt(…) que converte texto em número:
int num = Integer.parseInt(scanner.nextLine());
Lendo uma fração

Da mesma forma que lemos um inteiro, mas desta vez usaremos a função
double.parseDouble(…):
double num = Double.parseDouble(scanner.nextLine());
Saída de texto usando especificadores de formato
Um especificador de formato é uma expressão que será substituída por um valor

específico quando impressa. O método System.out.printf(…) suporta a impressão de
texto usando os especificadores de formato, o primeiro argumento que precisamos
passar é a string de formato, seguido do número de argumentos igual ao número de
especificadores.
System.out.printf( "Você
é %s %s, uma pessoa de %d anos de %s.", primeiroNome,
Sobrenome, idade, cidade);
Operadores aritméticos
Vamos relembrar os operadores aritméticos básicos para cálculos com números.
Operador +
int resultado = 3 + 5; // resultado é 8
Operador -
int resultado = 3 - 5; // resultado é -2
*
Operador
resultado int = 3 * 5; // resultado é 15
Operador /
resultado int = 7/3 ; // resultado é 2 (divisão inteira) double result2 = 5 / 2.0; //

resultado é 2,5 (divisão fracionária)
Concatenação
Ao usar o operador + entre variáveis de tipo de texto (ou entre texto e um número), o
chamado concatenação (concatenação de string).
String primeiroNome = "Ivan";

String lastName = "Ivanov"; int
idade = 19;
String str = primeiroNome +
""
+ sobrenome + "é " +
+ " anos"; idade
// Ivan Ivanov tem 19 anos
Tarefas de exame
Agora que lembramos como realizar cálculos com números e como ler e imprimir
números no console, vamos às tarefas. Resolveremos várias tarefas do vestibular para
a candidatura ao SoftUni.
Tarefa: sala de aula

Uma sala de aula tem uma dimensão retangular de l por w metros, sem colunas em seu
interior. O corredor é dividido em duas partes - esquerda e direita, com um corredor -
aproximadamente no meio. Há fileiras de mesas à esquerda e à direita. Na parte de trás do
corredor há uma grande porta de entrada. Na parte da frente do corredor há uma cadeira
com pódio para o professor. Um local de trabalho ocupa 70 por 120 cm (mesa medindo 70
por 40 cm + espaço para cadeira e passagem medindo 70 por 80 cm). O corredor é largo pelo menos
Capítulo 2.2. Cálculos simples com números - problemas de exame 101
100 cm. Estima-se que exatamente 1 trabalho seja perdido por causa da porta da frente (que tem
abertura de 160 cm) e por causa da cadeira (que tem 160 por 120 cm) exatamente 2 empregos
sejam perdidos. Escreva um programa que insira as dimensões de uma sala de aula e calcule o
número de locais de trabalho nela para o layout descrito (veja a figura). Dados de entrada
2 números são lidos no console, um por linha: l (comprimento em metros) ew (largura em metros).
Restrições:
3 ÿ w ÿ l ÿ 100.
Dados de saída
Para imprimir um único inteiro no console: o número de assentos na sala de aula.

Conecte-se Saída Desenho
15
129
8.9
8,4
39
5,2
Explicações dos exemplos No

primeiro exemplo, o corredor tem 1500 cm de comprimento. 12 linhas podem ser colocadas nele
(12 * 120 cm = 1440 + 60 cm restantes). O corredor tem 890 cm de largura. Destes, 100 cm vão
para o corredor do meio. 11 podem ser colocados nos restantes 790 cm
*
mesas por fila (11 * 70 cm = 770 cm + 20 cm restantes). Número de assentos = 12 - 3 = 11 - 3 = 132
129 (temos 12 filas de 11 assentos = 132 menos 3 assentos para a cadeira e porta da frente).
No segundo exemplo, o corredor tem 840 cm de comprimento. 7 linhas podem ser colocadas nele (7 * 120
cm = 840, sem resto). O corredor tem 520 cm de largura. Destes, 100 cm vão para o corredor do meio. Os
420 cm restantes podem acomodar 6 mesas por fileira (6 * 70 cm = 420 cm, sem sobra). Número de
*
assentos = 7 6 - 3 = 42 - 3 = 39 (temos 7 fileiras de 6 assentos = 42 menos 3 assentos para a cadeira e
porta da frente).
Diretrizes e dicas
Tente resolver a tarefa sozinho primeiro. Se você falhar, confira as diretrizes
e as dicas.
Ideia para uma solução
Como em qualquer tarefa de programação, é importante ter uma ideia para a solução antes de começarmos
a escrever o código. Vamos dar uma olhada mais de perto em nossa condição definida. Somos obrigados
a escrever um programa que calcule o número de postos de trabalho em um hall, e esse número depende
de seu comprimento e altura. Percebemos que eles nos serão dados como dados de entrada em metros,
e as informações sobre quanto espaço ocupam os locais de trabalho e o corredor nos são fornecidas em
centímetros. Para realizar os cálculos, teremos que usar as mesmas unidades de medida, não importa se
optamos por converter a altura e o comprimento em centímetros ou o restante dos dados em metros. Para
a solução aqui apresentada, a primeira opção é escolhida.
Precisamos calcular quantas colunas e quantas fileiras de mesas serão coletadas. Podemos calcular as
colunas subtraindo o espaço necessário para o corredor (100 cm) da largura e dividindo o restante por 70
cm (o comprimento de um local de trabalho). Encontraremos as linhas dividindo o comprimento por 120 cm.
Em ambas as operações, pode-se obter um número real com uma parte inteira e uma parte fracionária,
mas devemos salvar apenas a parte inteira em uma variável. Por fim, multiplicamos o número de linhas
pelo número de colunas e subtraímos 3 dele (os lugares que se perdem por causa da porta da frente e da
catedral). Assim obteremos o valor solicitado.
Seleção de tipos de dados
A partir da entrada de amostra, podemos ver que para a entrada podemos receber um número real com um
inteiro e uma parte fracionária, portanto, não é apropriado escolher o tipo int, vamos usar double para
eles . A escolha do tipo para as seguintes variáveis depende do método de solução que escolhemos. Como
qualquer problema de programação, este tem mais de uma solução. Dois deles serão mostrados aqui.
Responder
É hora de partir para a solução. Podemos dividi-lo mentalmente em três subtarefas:

• Leia os dados de entrada. • Efetue

os cálculos. • Saída para o console.
A primeira coisa que precisamos fazer é ler a entrada do console. Com scanner.nextLine()
lemos os valores do console, e com a função Double.parseDouble(…) convertemos o
valor set string (texto) em um double.
Vamos aos cálculos. O especial aqui é que depois de fazer a divisão, precisamos salvar
em uma variável apenas a parte inteira do resultado.
Pesquise no Google! Sempre que temos uma ideia de como resolver

um problema, mas não sabemos como escrevê-lo em Java, ou quando
nos deparamos com um que presumimos que muitas outras pessoas já
tiveram, a maneira mais fácil de lidar com isso é procurar para
informações na Internet.
Neste caso, podemos tentar a seguinte busca: java get integer part of double. Achamos
que precisamos usar o método Math.floor(…). Como funciona com variáveis do tipo
double, criamos uma variável para o número de linhas e colunas
livi também deste tipo.
Segunda opção: como já sabemos, o operador de divisão / tem um efeito diferente em

números inteiros e reais. Ao dividir um inteiro por um tipo inteiro (por exemplo, int), o
resultado retornado é um inteiro novamente. Portanto, podemos pesquisar como
converter os números reais que temos como valores de altura e largura para inteiros e
depois fazer a divisão.
Como neste caso pode haver perda de dados decorrente da remoção da parte
fracionária, é necessário tornar a conversão explícita (typecasting explícito). Usamos o
operador de conversão de dados (tipo) substituindo a palavra type pelo tipo de dados
necessário e colocando-o antes da variável. Você pode ler mais sobre conversão de tipo
de dados no livro "Introduction to Java Programming", páginas 119-123.
Com System.out.println(…) imprimimos o resultado no console.

Tarefa: mercado de vegetais

Um jardineiro vende a colheita de sua horta no mercado de vegetais. Vende legumes por N BGN por quilo
e frutas por M BGN por quilo. Escreva um programa para calcular a receita da colheita em euros (supondo
que um euro seja igual a BGN 1,94).
Dados de entrada
4 números são lidos no console, um por linha:
• Primeira linha - preço por quilo de vegetais - número de ponto flutuante. • Segunda
linha – preço por quilo de fruta – número de ponto flutuante. • Terceira linha -
quilogramas totais de vegetais - número inteiro.
• Quarta linha - quilos totais de frutas - número inteiro.
Limites: Todos os números estarão entre 0,00 e 1000,00.
Dados de saída
Para imprimir um único número de ponto flutuante no console: a receita de todas as frutas e legumes em
euros.
0,194 1,5
19,4 2,5
101 20.6185567010309
10 10
10 10
Notas sobre o primeiro exemplo:

*
• Custo dos vegetais: BGN 0,194. 10kg. = BGN 1,94
*
• Custo das frutas: BGN 19,4 • 10kg. = BGN 194
Total: BGN 195,94 = 101 euros.
Diretrizes e dicas
Primeiro, daremos algum raciocínio e, em seguida, orientações específicas para resolver o problema, bem
como a parte essencial do código.
Idéia de solução Vamos
primeiro olhar para nossa condição dada. Nesse caso, somos solicitados a calcular a receita total da
colheita. É igual à soma do lucro em baht das frutas e verduras, e podemos calculá-los multiplicando o
preço do quilo pela quantidade. Os dados de entrada são fornecidos em BGN e a saída deve ser em Euro.
Por condição, 1 euro é igual a 1,94 BGN, portanto, para obter o valor de saída solicitado, devemos dividir a
soma por 1,94.
Seleção dos tipos de dados
Depois de esclarecer nossa ideia de resolver o problema, podemos proceder à seleção dos tipos de dados
apropriados. Vejamos a entrada: dados dois números inteiros para o número total de quilos de vegetais e
frutas, respectivamente, as variáveis que declaramos para manter seus valores serão do tipo int. Para
preços de frutas e vegetais, especifica-se que serão fornecidos dois números de ponto flutuante, ou seja.
variáveis serão do tipo double.
Poderíamos também declarar duas variáveis para manter o valor do lucro de frutas e vegetais
separadamente. Como estamos multiplicando uma variável int (total de quilogramas) por um double
(preço), o resultado também deve ser um double. Vamos deixar claro: em geral, os operadores trabalham
com argumentos do mesmo tipo. Portanto, para realizar uma operação como a multiplicação em dois tipos
de dados diferentes, precisamos convertê-los para o mesmo tipo de dados. Quando existem tipos com
escopos diferentes em uma expressão, a conversão é sempre feita para aquele com maior escopo, neste
caso double. Como não há risco de perda de dados, a conversão é implícita e feita automaticamente pelo
compilador.
Um número de ponto flutuante também é necessário como saída, ou seja, armazenaremos o

resultado em uma variável do tipo double.
Responder
É hora de partir para a solução. Podemos dividi-lo mentalmente em três subtarefas:

os cálculos.
• Saída para o console.
Para ler os dados de entrada, declaramos variáveis, tendo o cuidado de nomeá-las de forma que nos diga
quais valores as variáveis contêm. Com scanner.nextLine() lemos os valores do console, e com as funções
Integer.parseInt(…) e Double.parseDouble(…) convertemos o valor da string especificada em int e
double, respectivamente.
Realizamos os cálculos necessários:
Nenhuma formatação de saída especial é especificada na condição da tarefa, então

simplesmente precisamos calcular o valor solicitado e imprimi-lo no console. Tanto na
matemática quanto na programação, a divisão tem precedência sobre a adição. Porém,
para o problema devemos primeiro somar a soma dos dois valores obtidos e depois dividir
por 1,94. Para dar precedência à agregação, podemos usar parênteses. Com
System.out.println(…) nós imprimimos a saída no console.

Tarefa: reparação de azulejos

As telhas devem ser colocadas no local em frente a um bloco de apartamentos. O terreno
tem a forma de um quadrado com lado N metros. As telhas têm W metros de largura e L
metros de comprimento. Há um banco no local, com M metros de largura e O metros de
comprimento. Não há necessidade de colocar ladrilhos sob ele. Cada ladrilho é
colocado por 0,2 minutos. Escreva um programa que leia no console as dimensões do
parquinho, dos ladrilhos e da bancada e calcule quantos ladrilhos são necessários para cobrir o parqu
calcula o tempo para colocar todas as peças.
Exemplo: um terreno de 20 m2 tem uma área de 400 m2. Uma bancada com 1 m de largura
e 2 m de comprimento ocupa uma área de 2 m2. Uma telha tem 5 m de largura e 4 m de
comprimento e uma área = 20 m2. A área a ser coberta é de 400 – 2 = 398 m2. 398 / 20 =
*
19,90 ladrilhos são necessários. O tempo necessário é 19,90 0,2 = 3,98 minutos.
Dados de entrada
5 números são lidos no console:
• N – o comprimento de um lado do terreno no intervalo [1 … 100]. • W – a

largura de um ladrilho no intervalo [0,1 … 10,00]. • L – o comprimento
de uma telha no intervalo [0,1 … 10,00].
• M – a largura da bancada no intervalo [0 … 10]. • O – o
comprimento da bancada no intervalo [0 … 10].
Dados de saída
Para imprimir dois números no console: o número de telhas necessárias para o reparo e
o tempo de colocação, cada um em uma nova linha.
Entrada Saída Conecte-se Saída
20 40
5 0,8
19,9 3302.08333333333
4 0,6
3,98 660.416666666667
1
2 35
Explicação de exemplo: • Área

*
total = 20 • Área de 20 = 400.
*
bancada = 1 • Área de 2 = 2.
cobertura = 400 – 2 = 398.

*
• Área de ladrilhos = 5 • 4 = 20.
Ladrilhos necessários = 398 / 20 = 19,9. • Tempo

*
necessário = 19,9 0,2 = 3,98.
Diretrizes e dicas
Vamos fazer um desenho para
explicar a condição da tarefa. Pode
parecer o carro da direita.
Ideia de solução
Somos obrigados a calcular o número de
ladrilhos a serem colocados, bem como
o tempo que levará. Para calcular o
número, é necessário considerar a área
a ser coberta e dividi-la pela face de uma
telha. Na condição de plano-
o quintal é quadrado, portanto vamos encontrar a área total multiplicando seu lado pelo seu valor N *
N. A seguir calculamos a área ocupada pela bancada, também multiplicando seus dois lados M * O.
Subtraindo a área de a bancada da de todo o playground, obtemos a área que precisamos
reparos.
Calculamos a face de um único ladrilho multiplicando um lado pelo outro - W * L. Como já observamos,
agora precisamos dividir a área para cobrir a área de um único ladrilho. Dessa forma, descobriremos
qual é o número necessário de ladrilhos. Multiplicamos por 0,2 (o tempo em que, por condição, uma
peça é colocada). Assim já teremos os valores de saída solicitados.
Seleção de tipos de dados

O comprimento de um lado do terreno, a largura e o comprimento da bancada serão dados inteiros,
então para armazenar seus valores podemos declarar variáveis do tipo int. Para a largura e o
comprimento dos ladrilhos, receberemos números reais (com parte inteira e parte fracionária),
portanto, usaremos o dobro para eles. A saída do problema será novamente um número real, ou
seja, variáveis também serão do tipo double.
Responder
Como nos problemas anteriores, podemos dividir mentalmente a solução em três
peças:

A primeira coisa que precisamos fazer é olhar para a entrada da tarefa. É importante prestar atenção
à ordem em que são dadas. Com digitalizador. nextLine() lemos os valores do console, e com
Integer.parseInt(…) e Double.ParseInt(…) convertemos o valor set string em int e double,
respectivamente.
Veja como a leitura da entrada pode parecer:

Depois de inicializarmos as variáveis e armazenarmos nelas os valores correspondentes,

procedemos aos cálculos. Como os valores das variáveis n, a e b com as quais trabalhamos
são armazenados em variáveis do tipo int, podemos definir variáveis do tipo int para os
resultados dos cálculos.
As variáveis w e h são do tipo double, ou seja , para a face de um ladrilho criamos uma
variável do mesmo tipo. Por fim, calculamos os valores que precisamos imprimir no console.
O número de ladrilhos necessários é obtido dividindo a área a ser coberta pela área de um
único ladrilho. Ao dividir dois números, um dos quais é real, o resultado é um número real
com uma parte inteira e uma parte fracionária. Portanto, para que nossos cálculos fiquem
corretos, armazenamos o resultado em uma variável do tipo double. Nenhuma formatação
ou arredondamento de saída especial é especificado na condição da tarefa, então
simplesmente imprimimos os valores com System.out.println(…).

Tarefa: moedas
Algum tempo atrás, Peso comprou alguns bitcoins. Agora ele vai fazer uma viagem pela
Europa e vai precisar de euros. Além dos bitcoins, também existem o yuan chinês. Peso
quer trocar seu dinheiro por euros para a excursão. Escreva um programa para calcular
quantos euros ele pode comprar com as seguintes taxas de câmbio:
• 1 bitcoin = BGN 1168.
• 1 Yuan Chinês = 0,15 USD. • 1 dólar
= 1,76 BGN. • 1 euro = 1,95
BGN.
A casa de câmbio tem uma comissão de 0 a 5 por cento do valor final em euros.
Dados de entrada
• Na primeira linha – o número de bitcoins. Um número inteiro no intervalo [0 … 20]. •
Na segunda linha – o número de yuans chineses. Um número real no intervalo [0,00 … 50
000,00].
• Na terceira linha – a comissão. Um número real no intervalo [0,00 … 5,00].
Dados de saída
No console para imprimir 1 número - o resultado da troca de moedas. O resultado não precisa
ser arredondado.
1 20
5 569.668717948718 5678 12442.2442010256
5 2.4
Conecte-se Saída
7
50200.12 10659.4701177436
3
Explicação:
• 1 bitcoin = BGN 1168
• 5 yuan = 0,75 dólares •
0,75 dólares = 1,32 leva • 1168
+ 1,32 = 1169,32 leva = 599,651282051282 euros

• Comissão: 5% de 599,651282051282 = 29,9825641025641
• Resultado: 599.651282051282 - 29.9825641025641 = 569.668717948718

euro
Diretrizes e dicas
Novamente, vamos primeiro pensar em como podemos resolver o problema antes de
começarmos a escrever o código.
Ideia de solução
Vemos que seremos alimentados com o número de Bitcoins e o número de Yuan chinês. O valor
de saída é especificado em Euros. A condição também especifica as taxas de câmbio com as
quais devemos trabalhar. Notamos que só podemos converter um valor em BGN para Euro,
portanto, precisamos primeiro calcular o valor total que Pesho possui em BGN e depois calcular
o valor de saída.
Como recebemos informações sobre a taxa de câmbio de bitcoins para leva, podemos fazer essa conversão
diretamente. Por outro lado, para obter o valor do yuan chinês em BGN, devemos primeiro convertê-los em
dólares e depois converter os dólares em BGN. Por fim, somaremos os dois valores resultantes e
vamos calcular a quantos euros correspondem.
Resta o último passo: calcular quanto será a comissão e subtrair o valor recebido do total. Como comissão,
receberemos um número real, que representará uma certa porcentagem do valor total. Vamos começar dividindo
o número dado por 100 para calcular seu valor percentual. Vamos multiplicá-lo pelo valor em euros e subtrair o
resultado do mesmo valor. Iremos imprimir o valor recebido no console.
Escolhendo tipos de dados Bitcoins
são dados como um número inteiro, então podemos declarar seu valor como uma variável int. Como o número
de yuan chinês e comissão, obteremos um número real, portanto, usamos o dobro para eles. Como double é
o tipo de dados de escopo maior e a saída também será um número real, também o usaremos para o restante
das variáveis que criamos.
Responder
Uma vez que tenhamos uma ideia da solução do problema e tenhamos escolhido as estruturas de dados com
as quais trabalharemos, é hora de começar a escrever o código. Como nos problemas anteriores, podemos
dividir a solução em três
subtarefas:

Declaramos as variáveis que usaremos, novamente tendo o cuidado de escolher nomes significativos que
sugiram o que elas contêm. Inicializamos seus valores: com scanner.nextLine() lemos os números fornecidos
no console e convertemos a string inserida pelo usuário em int ou double.
Realizamos os cálculos necessários:
Por fim, calculamos o valor da comissão e subtraímos ao valor em euros. Vamos prestar atenção à forma
como podemos escrever isto: euro -= comissão * euro é uma forma abreviada de escrever euro = euro -
(comissão * euro). Nesse caso, usamos um operador de atribuição composto -=, que subtrai o valor do
operando à direita daquele à esquerda. O operador for tem precedência maior que o operador composto,
então a expressão euro é executada primeiro, então seu valor é subtraído. Você pode ler mais sobre
comissão de * operadores no livro "Introduction to Java Programming" (p. 116).
multiplicação *
Nenhuma formatação especial ou arredondamento do resultado é especificado na condição de atribuição,

então só precisamos calcular a saída e imprimi-la
no console.
Atentemos para algo que se aplica a todas as tarefas desse tipo: assim disposta, a solução da tarefa é
bastante detalhada. Como a condição geralmente não é complicada, poderíamos, em teoria, escrever uma
grande expressão na qual, logo após receber os dados de entrada, calculamos o valor de saída. Por exemplo,
tal expressão ficaria assim:
Este código daria o resultado correto, mas é difícil de ler. Não será fácil para nós descobrir o que ele faz e se
contém erros, bem como como corrigi-los. Uma prática melhor é escrever várias expressões simples em vez
de uma expressão complexa e armazenar seus resultados em variáveis com nomes apropriados. Isso torna o
código claro e fácil de alterar.

Tarefa: lucro diário

Ivan é programador de uma empresa americana e trabalha em casa em média N dias por mês,
ganhando em média M dólares por dia. Ao final do ano, Ivan recebe um bônus equivalente a 2,5
salários mensais. Impostos de 25% são deduzidos de seus ganhos durante o ano. Escreva um
programa para calcular o lucro líquido médio de Ivan por dia em BGN, já que ele gasta seus
ganhos na Bulgária. Supõe-se que o ano tenha exatamente 365 dias. A taxa de câmbio do dólar
em relação ao leva será
lê do console.
Dados de entrada
• Na primeira linha – dias úteis do mês. Um número inteiro no intervalo [5 … 30]. • Na segunda
linha – dinheiro gasto por dia. Um número real no intervalo [10,00 …
2.000,00].
• Na terceira linha – a taxa de câmbio do dólar contra o leva /1 dólar = X leva/. Realisticamente
número no intervalo [0,99 ... 1,99].
Dados de saída
1 número deve ser impresso no console - o lucro médio por dia em BGN. Formate o resultado para
o segundo dígito após o ponto decimal.
Conecte-se Saída Entrada Saída Conecte-se Saída
21 15 22
75,00 74,61 105 80,24 199,99 196,63
1,59 1,71 1,50
Explicação:
• 1 salário mensal = 21 *
75 = $ 1575.
• Rendimento anual = 1575 • * *
12 + 1575 2,5 = 22837,5 dólares.
Imposto = 25% de 22837,5 = 5709,375 BGN. • Lucro
líquido anual = 17.128,125 dólares = 27233,71875 BGN. • Lucro médio por dia
= 27233,71875 / 365 = BGN 74,61.
Diretrizes e dicas
Primeiro, vamos analisar a tarefa e descobrir como resolvê-la. Em seguida, escolheremos os tipos
de dados e, finalmente, escreveremos o código da solução.
Ideia de solução
Vamos primeiro calcular quanto é o salário mensal de Ivan. Faremos isso multiplicando
os dias úteis do mês pelo dinheiro que ele ganha por dia. Multiplicamos o resultado
resultante primeiro por 12 para calcular quanto é o salário dele por 12 meses e depois
por 2,5 para calcular o bônus. Somando os dois valores obtidos, calcularemos sua renda
anual total. Temos que subtrair 25% disso. Podemos fazer isso multiplicando a renda
total por 0,25 e subtraindo o resultado dela. Com base em nossa taxa de câmbio,
convertemos dólares em
BGN, então dividimos o resultado pelos dias do ano, que supomos serem 365.
Escolhendo os tipos de
dados Os dias úteis de um mês são dados como um número inteiro, portanto podemos
declarar uma variável do tipo int para o seu valor. Para o dinheiro ganho, assim como
para a cotação do dólar em relação ao leva, obteremos um número real, portanto usamos
o dobro para eles. Como double é o tipo de dados de escopo maior e o valor de saída
também requer um número real (com um número inteiro e uma parte fracionária), vamos
usá-lo para o restante das variáveis que criamos.
Responder
Novamente: uma vez que tenhamos uma ideia de como resolver o problema e tenhamos
pensado nos tipos de dados com os quais trabalharemos, passamos a escrever o
programa. Assim como nas tarefas anteriores, podemos dividir a solução em três subtarefas:
• Leia os dados de entrada.
• Efetue os cálculos.
• Saída para o console.
Declaramos as variáveis que usaremos, novamente tomando cuidado para escolher os
nomes apropriados. Com scanner.nextLine() , lemos os números passados no console
e convertemos a string inserida pelo usuário em um int ou double com Integer/
Double.parseInt/Double(…).
Realizamos os cálculos:
Poderíamos escrever a expressão com a qual calculamos a renda anual total sem os parênteses. Como a
multiplicação é uma operação de prioridade mais alta do que a adição, ela será executada primeiro. No entanto,
recomenda-se escrever parênteses,
quando usamos mais declarações porque torna o código mais fácil de ler e
a possibilidade de errar é menor.
Por fim, resta enviar o resultado para o console. Notamos que é necessário formatar o valor numérico para a
segunda vírgula decimal. Para isso, podemos usar especificadores de formatação, ou seja, local que será substituído
por um valor específico quando impresso. Em Java, um % seguido de uma letra especificada (especificador) é
usado para uma string de formato. Podemos formatar um número inteiro ou fracionário com os especificadores F/f
ou D/d. É seguido por um número inteiro positivo indicando o número de dígitos após o ponto decimal. Você pode
ler mais sobre formatação no livro "Introduction to Java Programming" (páginas 137-143). Obtemos o resultado final
assim:

Capítulo 3.1. perdoar cheques

Neste capítulo, veremos as construções condicionais na linguagem Java, por meio das quais
nosso programa pode ter uma ação diferente, dependendo de uma determinada condição.
Explicaremos a sintaxe das instruções de verificação condicional (if e if else) com exemplos
relevantes e veremos em que intervalo uma variável reside (seu escopo). Por fim, veremos as
técnicas de depuração para rastrear passo a passo o caminho que nosso programa percorre
durante
seu desempenho.
Vídeo
Assista a um tutorial em vídeo sobre este capítulo: https://youtube.com/watch?v=cXKIVmjEgHw.
Comparando números
Na programação, podemos comparar valores usando os seguintes operadores:
• Operador < (menor que) •
Operador > (maior que)
• Operador <= (menor ou igual a) • Operador
>= (maior ou igual a) • Operador == (igual a)
• Operador != (diferente)
Em uma comparação, o resultado é um valor booliano — verdadeiro ou falso, dependendo se o
resultado da comparação é verdadeiro ou falso.
Exemplos de comparação de números
Operadores de comparação
Na linguagem Java, podemos usar os seguintes operadores para comparar números:
Operador Significado
==
verificação de igualdade
Verifique a diferença !=
Maior >
Maior ou igual >=
Menos <
Menos que ou igual a <=
Aqui está um exemplo:
perdoar cheques
Na programação, frequentemente verificamos determinadas condições e executamos diferentes ações com
base no resultado da verificação. Isso é feito através da verificação if which
tem a seguinte construção:
if (expressão booleana) { //
corpo da construção condicional, // que só será
executada se a expressão booleana for verdadeira;
}
Exemplo: nota excelente

Colocamos uma pontuação no console e verificamos se está excelente (ÿ 5,50).
Teste o código de exemplo localmente. Tente inserir pontuações diferentes, por exemplo, 4,75, 5,49, 5,50 e
6,00. Para pontuações menores que 5,50, o programa não produzirá nada e, para pontuações de 5,50 ou
maiores, exibirá "Excelente!".

Capítulo 3.1. Desculpe Cheques 119
Verifica com uma construção if-else

A construção if também pode conter uma cláusula else para executar uma ação específica caso a
expressão booleana (que é definida no início if (expressão booleana)) retorne um resultado negativo
(falso). Construída dessa forma, chamamos a construção condicional if-else e seu comportamento é o
seguinte: se o resultado da condição for positivo (verdadeiro) - realizamos as ações descritas nas chaves
após a cláusula if, e quando for negativo (falso) - outras ações encontradas dentro das chaves da cláusula
else . O formato de construção é:
if (condição booleana) { // corpo

da construção condicional; } else { // corpo do else-
construct;
Exemplo: nota excelente ou não

Como no exemplo acima, inserimos uma nota, verificamos se está excelente, mas imprimimos um resultado
em ambos os casos.
Para as chaves { } depois de if / else

Quando temos apenas uma instrução no corpo da instrução if , podemos omitir as chaves que denotam
o corpo da instrução condicional. Quando queremos executar um bloco de código (grupo de comandos),
as chaves são obrigatórias. Se os omitirmos, apenas a primeira linha após a cláusula if será executada.
É uma boa prática sempre colocar chaves porque torna nosso código mais legível e
organizado.
Aqui está um exemplo em que soltar as chaves causa confusão:

A execução do código acima produzirá a seguinte saída no console:
Com o uso de chaves:
O seguinte será impresso no console:
Absolutamente, ambos os usos estão corretos e podem ser usados

dependendo do caso específico, requisitos de documentação e/ou outros
requisitos, mas sempre tenha cuidado e considere os resultados.
Exemplo: par ou ímpar

Escrever um programa que verifica se um dado inteiro é par ou ímpar.
Podemos resolver o problema usando uma construção if-else e o operador %, que

retorna um resto quando dois números são divididos.
Devemos obter a seguinte resposta:

Exemplo: o maior número

Escrever um programa que leia dois inteiros e imprima o maior deles. Nossa primeira
tarefa é ler os dois inteiros. Então, através de uma construção if else simples ,
combinada com o operador maior que (>), vamos fazer uma verificação. Parte do código
é ofuscada de propósito para testar o que aprendemos até agora.
Se tudo for verdade, devemos obter a resposta abaixo para os números 3 e 5.
Vida de uma variável

Cada variável tem um escopo no qual ela existe, chamada de escopo de variável. Este escopo especifica
onde uma variável pode ser usada. Na linguagem Java, a área onde existe uma variável começa na linha
em que a definimos e termina na primeira chave de fechamento } (do método, da construção if , etc.). Para
isso, é importante saber que qualquer variável definida dentro do corpo if não estará acessível fora dele, a
menos que a tenhamos definido mais adiante no código.
No exemplo abaixo, na última linha onde tentamos imprimir a variável salario, que está definida na
construção do if , teremos um erro porque não temos acesso a ela (caso a própria IDE nos avise sobre o
escopo da variável ).
Série de cheques
Às vezes, precisamos realizar uma série de verificações antes de decidir quais ações nosso programa
executará. Nesses casos, podemos aplicar a construção if-else if…-else em série. Para tanto, utilizamos
o seguinte formato:
if (condição) { //
corpo da construção condicional;
} senão if (condição2) {
// corpo de construção condicional;
} senão if (condição3) {
// corpo de construção condicional; } …
else { //
corpo da construção else;
}
Exemplo: Número de 1 a 9 em inglês

Escrever um número no intervalo de 1 a 9 com texto em inglês (o número é lido pelo
console). Podemos ler o número e depois, por meio de uma série de verificações, imprimir
sua palavra em inglês correspondente:
Scanner scanner = new Scanner(System.in); int num

= Integer.parseInt(scanner.nextLine());
if (num == 1)
{ System.out.println("um"); } else
if (num == 2)
{ System.out.println("dois"); }
senão se (…) {
…
} else if (num == 9)
{ System.out.println("nine"); } else
{ System.out.println("número muito grande");

}
A lógica do programa do exemplo acima compara sequencialmente o número de entrada

do console com os dígitos de 1 a 9, com cada comparação subseqüente realizada apenas
se a comparação anterior não for verdadeira. Por fim, se nenhuma das condições if for
atendida, a última cláusula else é executada.

Exercícios: verificações simples

Para reforçar nosso conhecimento das condicionais if e if-else , resolveremos
várias tarefas práticas.
Tarefa: bônus de pontos

Um número inteiro é dado - número de pontos. Os pontos de bônus são acumulados de acordo
com as regras descritas abaixo. Escreva um programa que calcule os pontos de bônus para esse
número e o número total de pontos com os bônus.
• Se o número for até 100, inclusive, os pontos de bônus são 5.
• Se o número for maior que 100, os pontos de bônus são 20% do número. • Se o número
for maior que 1000, os pontos de bônus são 10% do número. • Pontos de bônus adicionais
(cobrados separadamente dos anteriores):

o Para um número par ÿ + 1 pt.
o Para um número que termina em 5 ÿ + 2 pt.
Entrada Saída Entrar Sair Sair Conecte-se Saída
37 270,3 1589,5
20 175 2703 15875
6 26 212 2973,3 17464,5
Diretrizes e dicas
Podemos calcular os pontos de bônus principais e adicionais com uma série de várias verificações
if-else-if-else . Quanto aos pontos de bónus principais, temos 3 casos (quando o número
introduzido for até 100, entre 100 e 1000 e superior a 1000), e para os pontos de bónus adicionais
- mais 2 casos (quando o número for par e ímpar) .
Capítulo 3.1. Desculpe verifica 125
Aqui está como a solução para a tarefa pode parecer em ação:
Tarefa: somar segundos

Três competidores esportivos terminam em algum número de segundos (entre 1 e 50). Escrever um
programa que insira os tempos dos competidores e calcule seu tempo total no formato "minutos:segundos".
Os segundos devem ser exibidos com um zero à esquerda (2 ÿ "02", 7 ÿ "07", 35 ÿ "35").
Entrada Saída Entrada Saída Entrada Saída Conecte-se Saída
35 22 50 14
45 2:04 1:03 50 2:29 12 0:36
44 7 34 49 10
Diretrizes e dicas
Podemos resolver a tarefa de várias maneiras. A primeira que combina com o tema é esta: primeiro
somamos os três números para obter o resultado total em segundos. Como 1 minuto = 60 segundos,
precisaremos calcular o número de minutos e o número de segundos no intervalo de 0 a 59:
• Se o resultado estiver entre 0 e 59, imprimimos 0 minutos + o calculado

segundos.
• Se o resultado estiver entre 60 e 119, imprimimos 1 minuto + os segundos calculados menos

60.
• Se o resultado estiver entre 120 e 179, imprimimos 2 minutos + o calculado
segundos menos 120.
• Se os segundos forem menores que 10, emitimos um zero à esquerda antes deles.
126 Noções básicas de programação Java
A segunda forma, que não utiliza construções if-else, é melhor porque pode ser utilizada
para grandes valores de tempos:
Tarefa: conversor de unidades

Escreva um programa que converta uma distância entre as seguintes 8 unidades de medida: m, mm,
cm, mi, in, km, ft, yd. Use as correspondências da tabela abaixo:
Unidade de entrada Unidade de saída
1 metro (m) 1000 milímetros (mm)
1 metro (m) 100 centímetros (cm)
1 metro (m) 0,000621371192 mil (mi)
1 metro (m) 39,3700787 polegadas (polegadas)
1 metro (m) 0,001 quilômetros (km)
1 metro (m) 3,2808399 pés (pés)
1 metro (m) 1,0936133 jardas (jardas)
A entrada consiste em três linhas:
• Primeira linha: número a converter. •

Segunda linha: unidade de medida de
entrada. • Terceira linha: unidade de medida de saída (para o resultado).
12 150 450
km 39370.0788 milhas 9503999.99393599 0,41147999937455
pés em jardas km
Diretrizes e dicas Lemos
nossos dados de entrada e, para ler as unidades, podemos adicionar a função toLowerCase(), que
tornará todas as letras minúsculas. Como podemos ver na tabela na condição, só podemos converter
entre metros e alguma outra unidade de medida. Portanto, devemos primeiro calcular o número a ser
convertido em metros. Portanto, precisamos fazer um conjunto de verificações para determinar qual é
a unidade de medida de entrada e, em seguida, para a unidade de medida de saída.
Observe que em Java a comparação de strings não funciona usando == e as

funções internas de comparação de strings devem ser usadas para esse propósito.
Depuração - operações simples do depurador

Escrevemos muito código até agora e geralmente há erros, certo? Agora vamos mostrar uma
ferramenta com a qual podemos encontrar os erros com mais facilidade.
O que é "depuração"?
A depuração é o processo de "enganchar" a execução do programa, o que nos permite rastrear passo
a passo todo o processo de execução. Podemos acompanhar linha por linha o que acontece com
nosso programa, que caminho ele segue, que valores têm as variáveis definidas em cada passo do
debugging, e muitas outras coisas que nos permitem encontrar erros (bugs).
Debgwane no IntelliJ Idea

Através de uma combinação dos botões [Shift + F9], iniciamos o programa atual no modo de
depuração. Vamos para a próxima linha com [F7]. Usando [CTRL + F8] criamos stoppers - os
chamados breakpoints, que podemos alcançar diretamente no início do programa.
É assim que a tela do depurador do IntelliJ IDEA fica quando o programa parou em um ponto de
interrupção e permite visualizar os valores atuais de todos
variáveis:
Exercícios: verificações simples

Vamos reforçar o que aprendemos neste capítulo com alguns exercícios.
Projeto Prazen Java no IntelliJ Idea

Criamos um novo projeto (Java) no IntelliJ Idea sem marcar nada. Para organizar melhor as soluções
das tarefas do exercício, cada tarefa ficará em uma classe separada e todas as classes estarão no
diretório [src] do projeto. Lançamos o IntelliJ Idea. Criamos um novo projeto Java: [File] ÿ [New] ÿ
[Project].
Selecionamos Java no painel esquerdo sem marcar mais nada e pressionamos [Avançar]. Na próxima
caixa de diálogo, temos várias opções, uma das quais é sim
O ConsoleApp está configurado. Normalmente é isso que faremos, mas não podemos
marcar nada e clicar em [Avançar] novamente.
Na última caixa de diálogo, damos um nome ao projeto e um local de armazenamento e,

em seguida, clique em [Concluir].
Agora temos um projeto Java vazio criado:
Tarefa: verifique se há uma nota excelente

Capítulo 3.1. Cheques de desculpas 131
A primeira tarefa de exercício para este tópico é escrever um programa de console que insere
uma nota (um número decimal) e imprime "Excelente!" se a nota for 5,50 ou superior.
6 Excelente! 5.5 Excelente! 5,49 (sem saída)

uma nova classe no projeto existente no IntelliJ Idea clicando com o botão direito do mouse na
pasta [src]. Escolhemos [Novo] ÿ [Classe Java]:
Abre-se uma caixa de diálogo com 2 campos - no superior inserimos o nome da turma, e no
inferior - o tipo (existem outras opções além das turmas, mas para os próximos capítulos),
então criamos o aula. Definimos um nome, por exemplo "Avaliações":
Agora temos uma classe com um aplicativo de console. Resta escrever o código para
resolver a tarefa.
Para fazer isso, vamos ao corpo do método main(string[] args) e colocamos o cursor
entre as chaves de abertura e fechamento do método. Se o método principal não for
criado automaticamente no IntelliJ Idea, existe um atalho de teclado que o faz - psvm.
Dentro do método escrevemos o seguinte código:
Iniciamos o programa a partir da seta verde na frente do nome da classe para testá-lo
com diferentes valores de entrada:

Capítulo 3.1. Cheques Desculpas 133
Tarefa: excelente ou não A próxima

tarefa neste tópico é escrever um programa de console que insira uma
nota (um número decimal) e imprima "Excelente!" se a nota for 5,50 ou
superior, ou "Não excelente". de outra forma.
6 Excelente! 5 Não excelente! 5,49 Não excelente.
Diretrizes e dicas
Criamos uma nova classe no projeto existente no IntelliJ Idea clicando ,com o botão direito do
mouse na pasta [src]. Selecionamos [Novo] ÿ [Classe Java].
Precisamos escrever o código do programa. Podemos ajudar com o código de exemplo da imagem:
Agora rodamos o programa normalmente com a seta verde e testamos para ver se funciona
corretamente:

Atribuição: Par ou Ímpar

Para escrever um programa que insere um inteiro e imprime se é par ou não
chance.
2 até 3 chance 25 chance 25 chance
Diretrizes e dicas
Criamos uma nova classe no projeto existente no IntelliJ Idea clicando com o botão
direito do mouse na pasta [src]. Escolhemos [Novo] ÿ [Classe Java]:
No método public static void main() , precisamos escrever o código do programa. A
verificação se um determinado número é par pode ser implementada com o operador %,
que retornará o resto quando um inteiro for dividido por 2 da seguinte forma: boolean
isEven = (number %2 == 0);.
Resta executar o programa e testá-lo:
Testando no sistema de juízes Teste sua
Tarefa: encontre o número maior

Para escrever um programa que insere dois inteiros e imprime o maior
de ambos.
3 10 -5
5 5 10 5
53 5 10 5
uma nova classe no projeto existente no IntelliJ Idea clicando com o botão direito do mouse na pasta [src].
Selecionamos [Novo] ÿ [Classe Java]. Para o código do programa, precisamos de uma única construção if-
else . Você pode se ajudar parcialmente com o código da imagem, que é deliberadamente ofuscado, para
pensar em como completá-lo você mesmo:
Depois de terminar, executamos o programa e o testamos:
Tarefa: escrever um número até 9 em palavras

Escrever um programa que insere um inteiro no intervalo [0 … 9] e o escreve em palavras em inglês.
Se o número estiver fora do intervalo, ele exibe uma mensagem "número muito grande".
Entrar Sair Entrar Entrar Sair Conecte-se Saída
5 cinco 1 um 9 nove 10 número muito grande
Diretrizes e dicas
Podemos usar uma série de instruções if-else para considerar os 11 casos possíveis.

Tarefa: adivinhar a senha

Escrever um programa que insira uma senha (uma linha de texto aleatório) e verifique se o que foi
inserido corresponde à frase "s3cr3t!P@ssw0rd". Se corresponder, exiba "Bem-vindo" e, se não
corresponder, exiba "Senha incorreta!".
Senha
qwerty s3cr3t!P@ssw0rd Bem vindo s3cr3t!p@ss Senha errada!
incorreta!
Diretrizes e dicas
Use a construção if-else .

Tarefa: um número de 100 a 200

Escreva um programa que receba um inteiro e verifique se ele é menor que 100, entre 100 e 200 ou
maior que 200. Imprima as mensagens de acordo, como nos exemplos abaixo.
95 Menos de 100 120 Entre 100 e 200 210 Maior que 200

Tarefa: mesmas palavras

Escrever um programa que insere duas palavras e verifica se são iguais. Não diferencie
maiúsculas de minúsculas. Saída "sim" ou "não".
Olá SoftUni Macio

Olá sim softuni sim Ele
não
cerveja vodca
não
Diretrizes e dicas Antes

de comparar palavras, coloque-as em letras minúsculas para que o tamanho das letras
(maiúsculas/minúsculas) não seja afetado: String palavraPrimeira = scanner.
next().toLowerCase().

Tarefa: informações de velocidade

Escrever um programa que insere uma velocidade (número decimal) e imprime as informações
de velocidade.
• Para velocidades de até 10 (inclusive), imprima "lento". • Para
velocidade acima de 10 e até 50, imprima "média". • Para
velocidades acima de 50 e até 150, imprima "rápido". • Para
velocidades acima de 150 e até 1000, imprima "ultra rápido".
• Em uma velocidade mais alta, imprima "extremamente rápido".
8 lento 126 rápido 3500 extremamente rápido

49,5 média 160 ultra rápido
Tarefa: rostos em figuras

Escrever um programa que insira as dimensões de uma figura geométrica e calcule sua face.As figuras
são de quatro tipos: quadrado, retângulo, círculo e triângulo.
O tipo de figura (quadrado, retângulo, círculo, triângulo) é lido na primeira linha da entrada.
• Se a figura for um quadrado, um número é lido na próxima linha - comprimento de

O país dele.
• Se a figura for um retângulo, dois números são lidos nas próximas duas linhas –
os comprimentos de seus lados.
• Se a figura for um círculo, um número é lido na próxima linha - o raio de
o circulo.
• Se a figura for um triângulo, dois números são lidos nas próximas duas linhas –
o comprimento de seu lado e o comprimento de sua altura a ele.
Arredonde o resultado para 3 dígitos após a vírgula.
Entrada Saída Conecte-se Saída Conecte-se Saída Entrada Saída
retângulo triângulo
quadrado círculo
25 7 17.5 113.097 4.5 45
5 6
2.5 20
Tarefa: tempo + 15 minutos

Escrever um programa que insira a hora e os minutos de um dia de 24 horas e calcule qual será a hora
em 15 minutos. Imprima o resultado no formato hh:mm. As horas estão sempre entre 0 e 23 e os
minutos estão sempre entre 0 e 59. As horas são escritas como um ou dois dígitos. Os minutos são
sempre escritos com dois dígitos e um zero à esquerda quando necessário.
23 11
2:01 0:16 0:14 11:23
1 46 0 01 59 08
Diretrizes e dicas
Adicione 15 minutos e faça algumas verificações. Se os minutos excederem 59, aumente as horas em
1 e diminua os minutos em 60. Da mesma forma, considere o caso quando as horas excederem 23.
Ao imprimir os minutos, verifique se há um zero à esquerda.
Tarefa: os mesmos 3 números

Para escrever um programa no qual são inseridos 3 números e se são iguais (sim / não) é impresso.
5 5 1
5 sim 4 não 2 não
5 5 3
*
Tarefa: escreva um número de 0 a 100 em palavras
Escrever um programa que converta um número no intervalo [0 … 100] em texto.
25 vinte e cinco 42 quarenta e dois 6 seis
Diretrizes e dicas
Verifique primeiro os números de um dígito e, se o número for de um único dígito, imprima a palavra
correspondente a ele. Em seguida, verifique se há números de dois dígitos. Eles
imprima em duas partes: parte esquerda (dezenas = o número / 10) e parte direita
(unidades = o número % 10). Se o número tiver 3 dígitos, deve ser 100 e pode ser
considerado um caso especial.
Teste no sistema de juízes

Capítulo 3.2. Verificações simples - tarefas

de exame
No capítulo anterior, vimos as construções condicionais na linguagem Java, por meio das quais podemos
realizar diversas ações dependendo de alguma condição. Também mencionamos qual é o escopo de uma
variável (seu escopo), bem como como seguir passo a passo a execução de nosso programa (a chamada
depuração). Neste capítulo, praticaremos o trabalho com verificações lógicas observando alguns
problemas apresentados em exames. Para fazer isso, vamos primeiro relembrar a construção da
verificação lógica:
if (expressão booleana) { //
corpo de construção condicional; } else { // corpo
do else-
construct;
}
se os cheques consistirem em:
• cláusula if •
expressão booleana - variável de tipo booleano (boolean) ou expressão lógica booleana

(expressão que retorna um resultado verdadeiro/falso)
• corpo da estrutura - contém qualquer bloco de código-fonte • cláusula else e seu
bloco de código-fonte (opcional)
Tarefas de exame
Agora que lembramos como escrever instruções condicionais, vamos resolver alguns problemas para
obter experiência prática com a instrução if-else .
Tarefa: preço do transporte

Um estudante tem que percorrer n quilômetros. Ele pode escolher entre três tipos de transporte:
• Taxas. Taxa inicial: BGN 0,70 Tarifa diária: BGN 0,79/km. Tarifa noturna:
BGN 0,90/km.
• Ônibus. Tarifa diurna/noturna: BGN 0,09/km. Pode ser usado para espaçamento
pelo menos 20 km.
• Trem. Tarifa diurna/noturna: BGN 0,06/km. Pode ser usado para distâncias de pelo menos 100 km.
Escreva um programa que insira o número de quilômetros n e a hora do dia (dia ou noite) e calcule o custo
do transporte mais barato.
Dados de entrada
Duas linhas são lidas do console:
• A primeira linha contém o número n - número de quilômetros - um inteiro no intervalo

[1 … 5000].
• A segunda linha contém a palavra "dia" ou "noite" – viajar durante o dia ou através
a noite.
Dados de saída
Para imprimir no console o preço mais baixo para o número de quilômetros especificado.

25 180
4,65 7 2.25 10.8
5 dias 7 noites dias noites
Diretrizes e dicas
Faremos a leitura dos dados inseridos e dependendo da distância escolheremos o transporte mais
barato. Para isso, usaremos várias verificações.
Processamento de entrada Nossa primeira
etapa é criar um objeto do tipo java.util.Scanner, em cujo construtor passamos o "fluxo de

entrada" (System.in) do qual estamos lendo. Na condição da tarefa, são fornecidas informações sobre a
entrada e a saída. Assim, as duas primeiras linhas da solução conterão a declaração e inicialização das
duas variáveis nas quais armazenaremos os valores dos dados de entrada.
Para a primeira linha, é mencionado que contém um número inteiro, portanto a variável que será declarada
é do tipo int. Para a segunda linha, a indicação é que contém uma palavra, respectivamente, a variável é
do tipo String.
Antes de iniciarmos as verificações, precisamos declarar uma variável na qual armazenaremos o valor do
preço do transporte.
Realização de verificações e cálculos correspondentes

Agora que declaramos e inicializamos os dados de entrada e alteramos o wat em que armazenaremos o
valor do preço, precisamos decidir quais condições da tarefa serão verificadas primeiro.
Capítulo 3.2. Verificações simples - tarefas de exame 143
Fica claro pela condição que as tarifas de dois dos veículos não dependem de ser dia ou
noite, mas a tarifa do terceiro transporte (táxi) sim. neste
pois a primeira checagem será se é dia ou noite, para deixar claro qual tarifa de táxi será
utilizada. Para tanto, declaramos outra variável na qual armazenaremos o valor da tarifa
do táxi.
Para calcular a tarifa do táxi, usaremos uma verificação if-else e, por meio dela, será
atribuído um valor à variável da tarifa do táxi.
Feito isso, podemos agora proceder ao cálculo do preço real do transporte. As restrições
que estão presentes na condição da tarefa são sobre a distância que o aluno deseja
percorrer. Por esse motivo, construiremos uma construção if-else , com a ajuda da qual
encontraremos o preço
para o transporte em função dos quilómetros apresentados.
Primeiro, verificamos se os quilômetros estão abaixo de 20, pois fica claro na condição
que abaixo de 20 quilômetros o aluno só pode usar táxis. Se a condição de verificação
for verdadeira (devolve verdadeiro), será atribuído o valor correspondente à variável que
foi criada para conter o valor do preço de transporte (preço) . Esse valor é igual à taxa
inicial que cobramos com aquela tarifa multiplicada pela distância que o aluno tem que
percorrer.
Se a condição da variável não for verdadeira (ela retorna falso), o próximo passo é nosso
programa verificar se os quilômetros estão abaixo de 100. Fazemos isso porque fica claro
pela condição que nesta faixa um ônibus também pode ser utilizado como meio de
transporte. O preço por quilômetro do ônibus é menor que o do táxi. Portanto, se o
resultado da verificação for verdadeiro, então no corpo do bloco else if, devemos atribuir
um valor igual ao resultado da multiplicação da tarifa do ônibus pela distância até a
variável preço do transporte (preço) .
Se esta verificação não retornar true como resultado, ela permanecerá no outro corpo
da variável de preço para atribuir um valor igual ao resultado da multiplicação
a distância de acordo com a tarifa do trem. Isso é feito porque o trem é a opção de
transporte mais barata para determinada distância.
Imprimindo os dados de saída Depois de

fazermos as verificações de distância e calcularmos o custo do transporte mais barato,
devemos imprimi-lo. Não há requisitos na condição de atribuição sobre como o resultado
deve ser formatado, portanto, imprimiremos
apenas a variável.

Tarefa: canos em uma piscina

Uma piscina de volume V tem dois canos a partir dos quais é enchida. Cada cano tem uma
certa vazão (os litros de água que passam por um cano em uma hora). O trabalhador liga
os canos simultaneamente e sai em N horas. Escreva um programa que recupere o estado
do pool quando o trabalhador retornar.
Dados de entrada
Quatro linhas são lidas no console:
• A primeira linha contém o número V - volume da piscina em litros - um inteiro no intervalo [1
… 10000].
• A segunda linha contém o número P1 - vazão do primeiro tubo por hora - inteiro
número no intervalo [1 ... 5000].
• A terceira linha contém o número P2 - vazão do segundo tubo por hora - inteiro
• A quarta linha contém o número H - as horas em que o trabalhador está ausente
– um número de ponto flutuante no intervalo [1,0 … 24,00].
Dados de saída
Para imprimir no console um dos dois estados possíveis:
• Quanto a piscina encheu e qual tubo contribuiu com qual porcentagem. Para todas as
porcentagens, pegue apenas a parte inteira (isto é, arredonde para baixo).
o "O pool está [x]% cheio. Pipe 1: [y]%. Pipe 2: [z]%."

• Se a piscina transbordou - quantos litros ela transbordou no tempo determinado,
número de ponto flutuante.
* que devido à obtenção

o "Durante [x] horas a piscina transborda com [y] litros." Observe
da parte inteira de um número fracionário, os dados são perdidos e é normal que as
porcentagens somem 99% em vez de 100%.
1000 100
100 A piscina está 66% cheia. Tubo 100 Por 2,5 horas a piscina
120 1: 45%. Tubo2: 54%. 100 transborda com 400 litros.
3 2,5
Diretrizes e dicas
Para resolver o problema, vamos ler a entrada, realizar algumas verificações e cálculos e imprimir o
resultado.
Processando os dados de entrada Da
condição do problema, vemos que nosso programa deve ter quatro linhas das quais lemos os dados
de entrada. Através dos três primeiros estaremos inserindo números inteiros e por este motivo as
variáveis nas quais armazenaremos os valores serão do tipo int. Para a quarta linha, somos
informados de que será um número de ponto flutuante, portanto, a variável que usaremos também é
do tipo double.
Nosso próximo passo é declarar e inicializar uma variável na qual calcularemos quantos litros a
piscina encheu durante a ausência do trabalhador. Faremos os cálculos somando os valores da vazão
dos dois tubos e multiplicando-os pelas horas que nos foram dadas como entrada.
Efetuando verificações e processando os dados de saída Uma vez que já temos

o valor da quantidade de água que passou pelas tubulações, o próximo passo é comparar essa
quantidade com o volume da própria piscina.
Faremos isso com uma simples verificação if-else , na qual a condição será se a quantidade de água
é menor que o volume da piscina. Se a verificação retornar verdadeiro, então
precisamos imprimir uma linha que contenha a relação entre a quantidade de água que
passou pelos canos e o volume da piscina, e a relação entre a quantidade de água de
cada cano e o volume da piscina.
A proporção precisa ser expressa em porcentagem, portanto, todos os cálculos até

agora nesta linha serão multiplicados por 100. Os valores serão inseridos com strings de
formato e, como há uma condição para formatar o resultado da porcentagem para um
número inteiro, para esse fim, usaremos o método Math.floor(…).
No entanto, se a verificação retornar um resultado falso, significa que a quantidade de

água é maior que o volume da piscina, portanto ela transbordou. Novamente, a saída
deve ser em uma linha, mas desta vez contém apenas dois valores - o das horas que o
trabalhador esteve ausente, e a quantidade de água, que é a diferença entre a entrada
de água e o volume da piscina .

Tarefa: gato sonolento Tom

O gato Tom gosta de dormir o dia todo, infelizmente seu dono brinca com ele sempre
que tem tempo livre. Para ter uma boa noite de sono, a norma de jogo de Tom é de
30.000 minutos por ano. O tempo de jogo de Tom depende dos fins de semana
ao seu mestre:
• Quando está no trabalho, seu dono brinca com ele 63 minutos por dia.
• Quando ele está descansando, seu dono brinca com ele 127 minutos por dia.
Escreva um programa que insira o número de dias de folga e imprima se Tom consegue
ter uma boa noite de sono e a diferença da norma para o ano atual, supondo que o ano
tenha 365 dias.
Exemplo: 20 dias de folga ÿ dias úteis são 345 (365 – 20 = 345). O tempo real de reprodução é de
24.275 minutos (345 * 63 + 20 * 127). A diferença da norma é de 5.725 minutos (30.000 – 24.275 =
5.725) ou 95 horas e 25 minutos.
Dados de entrada
A entrada é lida no console e consiste em um único inteiro - o número de dias de folga no intervalo [0
… 365].
Dados de saída
Duas linhas devem ser impressas no console.
• Se o tempo de jogo de Tom estiver acima da norma para o ano atual:
o Na primeira linha, escreva: "Tom vai fugir". o Na segunda
linha, imprima a diferença da norma no formato: "{H} horas
e {M} minutos a mais para jogar".
• Se o tempo de jogo de Tom estiver abaixo do esperado para o ano atual:
o Na primeira linha, escreva: "Tom dorme bem". o Na
segunda linha, imprima a diferença da norma no formato: "{H} horas
e {M} minutos a menos para jogar".
Tom dorme bem

Tom vai fugir 3 horas
20 95 horas e 25 minutos a 113
e 47 minutos para jogar
menos para brincar
Diretrizes e dicas
resultado.
Processamento dos dados de entrada e cálculos adjacentes Da condição da
tarefa, vemos que os dados de entrada serão lidos de apenas uma linha, que conterá em si um número
inteiro no intervalo [0 … 365]. Por esse motivo, usaremos uma variável do tipo int.
Para resolver o problema, primeiro precisamos calcular quantos minutos totais o dono do Tom joga com
ele. Pela condição vemos que, além dos fins de semana, o gato cinza sonolento também deve brincar
nos dias úteis para seu dono. o número que
lemos no console, são os fins de semana.
Nosso próximo passo é usar esse número para calcular quantos dias úteis o proprietário tem, pois sem
eles não podemos chegar ao total de minutos de jogo. Se o número total de dias no ano for 365 e o
número de feriados for X, isso significa que o número de dias úteis é 365 - X. Vamos armazenar a
diferença em uma nova variável (workingDays) que usaremos apenas por este valor.
Agora que temos a quantidade de dias de jogo, podemos calcular o tempo de jogo de Tom em minutos.
O seu valor é igual ao resultado da multiplicação dos dias úteis por 63 minutos (na condição de que em
dias úteis o tempo de jogo seja de 63 minutos por dia) adicionado ao resultado da multiplicação dos fins-
de-semana por 127 minutos (na condição é definido que nos fins de semana, o tempo de jogo é de 127
minutos por dia).
Na condição da tarefa para a saída, vemos que precisaremos imprimir a diferença entre os dois valores
em horas e minutos. Para isso, subtrairemos a norma de 30.000 minutos do tempo total de jogo e
escreveremos a diferença resultante em uma nova variável. Em seguida, dividiremos essa variável inteira
por 60 para obter as horas e, para encontrar os minutos, usaremos a divisão modular com o operador % ,
dividindo a variável de diferença por 60 novamente.
Devemos observar aqui que, se o tempo de jogo resultante de Tom for menor que 30.000, subtrair a
norma resultará em um número com sinal negativo. Para neutralizar o sinal nas duas divisões depois,
vamos matemática.
nós usamos método
abs(…) ao encontrar a diferença.
Fazendo verificações
O tempo de brincadeira já foi calculado, o que nos leva ao próximo passo – comparar o tempo de
brincadeira de Tom com a norma que determina se o gato consegue dormir bem. Para fazer isso,
usaremos uma verificação if-else e, na cláusula if , verificaremos se o tempo de jogo é maior que 30.000
(a norma).
Processando a saída Seja qual for o

resultado que o cheque retornar, precisamos imprimir a diferença em horas e minutos.
Faremos isso com um especificador de formato e as variáveis nas quais calculamos os
valores de hora e minuto. Na saída de exemplo, vemos que as horas e os minutos são
formatados como um número inteiro arredondado para baixo. Isso nos diz que devemos
usar o método Math.floor(…) ao imprimir o resultado.

Tarefa: colheita
De uma vinha com uma área de X metros quadrados, 40% da colheita é destinada à
produção de vinho. A partir de 1 m2. vinha produz Y quilogramas de uvas. São necessários
2,5 kg para 1 litro de vinho. uvas. A quantidade desejada de
vinho a ser vendida é Z litros. Escreva um programa que calcule quanto vinho pode ser
produzido e se essa quantidade é suficiente. Se sobrar, o restante é dividido igualmente
entre os trabalhadores da vinha.
Dados de entrada
A entrada é lida do console e consiste em exatamente 4 linhas:
• 1ª linha: X m2 é a vinha - um inteiro no intervalo [10 … 5000]. • 2ª fila: Y uvas
para um m2. – um número real no intervalo [0,00 … 10,00]. • 3ª linha: Z litros de vinho
necessários – um inteiro no intervalo [1 … 600]. • 4ª linha: número de trabalhadores
– um inteiro no intervalo [1 … 20].
Dados de saída
O seguinte deve ser impresso no console:
• Se o vinho produzido for inferior ao necessário:
o "Será um inverno difícil! Mais {vinho insuficiente} litros de vinho necessários." O

* resultado deve ser arredondado para um número inteiro inferior.
• Se o vinho produzido for mais do que necessário:
o "Boa colheita este ano! Total de vinho: {total de vinho} litros."
*
O resultado deve ser arredondado para um número inteiro inferior.
o "{Vinho restante} litros restantes -> {vinho para 1 trabalhador} litros por pessoa."
*
Ambos os resultados devem ser arredondados para o inteiro superior
número.

650 Boa colheita este ano! Vinho total: 1020

208 litros. 33 litros 1,5 Será um inverno difícil! Mais 180
2 restantes -> 11 litros por 425 litros de vinho necessários.
175 3 pessoa. 4
Diretrizes e dicas
resultado.
Processamento de entrada e cálculos associados

Primeiro precisamos verificar quais serão os dados de entrada e escolher quais
variáveis que usaremos.
Para resolver a tarefa, precisamos calcular quantos litros de vinho obteremos com base nos dados de
entrada. Da condição do problema, vemos que para calcular a quantidade de vinho em litros, devemos
primeiro descobrir qual é a quantidade de uvas em quilogramas que se obterá dessa safra. Para o efeito,
declararemos uma variável à qual atribuiremos um valor igual a 40% do resultado da multiplicação da área
da vinha e da quantidade de uvas de 1 m2. Feitos estes cálculos, estão prontos para calcular a quantidade
de vinho também em litros que será obtida desta safra. Para este propósito dekla
criamos mais uma variável na qual iremos armazenar esta quantidade, e a partir da condição
chegamos à conclusão de que, para calculá-lo, precisamos dividir a quantidade de uvas em quilos por 2,5.
Realizando verificações e processando os dados de saída Já fizemos

os cálculos necessários, e o próximo passo é verificar se os litros de vinho recebidos são
suficientes. Para tanto, utilizaremos uma construção condicional simples do tipo if-else, e
na condição verificaremos se
os litros de vinho da vindima são superiores ou iguais aos litros necessários.
Se a verificação retornar true, vemos pela condição da tarefa que na primeira linha
precisamos imprimir o vinho que recebemos da colheita. Para impor a condição de que
esse valor seja arredondado para o menor número inteiro, usaremos o método
Math.floor(…) ao imprimi-lo por meio de um especificador de formato. Na segunda linha,
há a exigência
de imprimir os resultados arredondando-os para o maior inteiro, o que faremos com o
método Math.ceil(…). Os valores que precisamos imprimir são a quantidade restante
de vinho e a quantidade de vinho que cai por trabalhador. A quantidade restante de vinho
é igual à diferença entre os litros de vinho recebidos e os litros de vinho necessários.
Vamos calcular o valor dessa quantidade em uma nova variável que vamos declarar e
inicializar no bloco if body antes de imprimir a primeira linha. Calcularemos a quantidade
de vinho por trabalhador dividindo o vinho restante pelo número de trabalhadores.
Se a verificação retornar um resultado falso da condição da tarefa, veremos que devemos

imprimir a diferença entre os litros necessários e os litros de vinho obtidos nesta safra.
Existe a condição de que o resultado seja arredondado para o menor inteiro, o que
faremos com o método Math.floor(…).

Tarefa: empresa
Uma empresa recebe uma solicitação para o desenvolvimento de um projeto que requer um determinado número
de horas. A empresa tem um certo número de dias. Durante 10% dos dias, os funcionários estão em treinamento e
não podem trabalhar no projeto. Um dia normal de trabalho na empresa é de 8 horas. O projeto é importante para a
empresa e todo funcionário deve trabalhar no projeto fora do horário de trabalho por 2 horas por dia. As horas devem
ser arredondadas para um número inteiro inferior (por exemplo, ÿ 6,98 horas são arredondadas para 6
horas).
Escreva um programa que calcule se a empresa pode concluir o projeto no prazo e quantas horas faltam ou faltam.
Dados de entrada
A entrada é lida do console e contém exatamente 3 linhas:
• A primeira linha contém as horas necessárias – um número inteiro no intervalo [0 … 200

000].
• Na segunda linha estão os dias disponíveis para a empresa - um inteiro no intervalo

[0 … 20 000].
• Na terceira linha está o número de todos os funcionários - um inteiro no intervalo [0 ...

200].
Dados de saída
Para imprimir uma linha no console:
• Se o tempo for suficiente:
o "Sim!{remaining hours} horas restantes.".
• Se o tempo NÃO for suficiente:
o "Tempo insuficiente!{as horas que faltam} horas necessárias.".
90 99
7 Sim! 2 horas restantes. 3 Não há tempo suficiente! 72 horas necessárias.
3 1
Diretrizes e dicas
Para resolver o problema, vamos ler a entrada, realizar algumas verificações e cálculos
e imprimir o resultado.
Processamento de dados de entrada

Para resolver o problema, primeiro precisamos considerar quais tipos de variáveis
usaremos para os dados de entrada.
Cálculos auxiliares O
próximo passo é calcular a quantidade de horas de trabalho multiplicando os dias úteis
por 8 (todos os dias são trabalhados 8 horas) pelo número de trabalhadores e somando-
os ao tempo livre. Os dias úteis correspondem a 90% dos dias à disposição da empresa.
A hora extra é igual ao resultado da multiplicação do número de funcionários por 2 (as
horas extras possíveis), que também é multiplicado pelo número de dias à disposição da
empresa. A partir da condição de atribuição, vemos que existe a condição de que as
horas sejam arredondadas para um inteiro menor, o que faremos com o método
Math.floor(…).
Efectuar verificações Uma

vez efectuados os cálculos necessários para compreender o valor das horas de trabalho,
devemos verificar se essas horas
alcançar ou permanecer adicionais.
Se o tempo for suficiente, imprimimos o resultado exigido na condição da tarefa, que é a

diferença entre as horas de trabalho e as horas necessárias para concluir o projeto.
Se o tempo não for suficiente, imprimimos as horas adicionais que são

necessárias para concluir o projeto e são iguais à diferença entre horas de projeto e
horas de trabalho.

Capítulo 4.1. Verificações mais complexas

Neste capítulo, veremos as verificações aninhadas na linguagem Java que permitem que nosso
programa execute construções condicionais que tenham outras construções condicionais aninhadas
dentro delas. Nós as chamamos de "aninhadas" porque aninhamos uma construção if dentro de outra
construção if . Também consideraremos lógicas mais complexas
condições com exemplos adequados.
Vídeo
Assista a um tutorial em vídeo sobre este capítulo: https://youtube.com/watch?v=1ZXBO_fCZ4w.
Cheques aninhados
Muitas vezes, a lógica do programa requer o uso de construções if ou if-else que estão contidas umas
nas outras. Estes são chamados de instruções if ou if else aninhadas. Como o nome "aninhado"
indica, são instruções if ou if-else que são colocadas dentro de outras instruções if ou else .
if (condição1) { if
(condição2) { // corpo; }
else { //
corpo;
}
}
Aninhar mais de três construções condicionais uma dentro da outra não é considerado uma boa prática
e deve ser evitado, principalmente otimizando a estrutura/algoritmo do código e/ou usando outro tipo
de construção condicional, que discutiremos a seguir. .
Exemplo: endereço por idade e sexo

De acordo com a idade digitada (número decimal) e sexo (m / f) para imprimir o endereço: • "Sr." –
masculino
(gênero “m”) com 16 anos ou mais. • “Mestre” – menino
(gênero “m”) menor de 16 anos. • "Senhora." – feminino
(gênero “f”) com 16 anos ou mais. • "Miss" – menina (gênero
"f") menor de 16 anos.
12 17 25 13.5
Perder Senhor. EM. Mestre
f m f m
Responder
Podemos notar que a saída do programa depende de várias coisas. Primeiro, precisamos verificar o gênero inserido
e, em seguida, verificar a idade. Assim, usaremos vários blocos if-else . Esses blocos serão
aninhado, ou seja a partir do resultado da primeira determinaremos qual das outras executar.
Depois de ler a entrada do console, ela precisará ser executada

a seguinte lógica de programa de exemplo:
Testando a solução: Teste sua
Exemplo: loja de bairro

Um empreendedor búlgaro abre uma loja de bairro em várias cidades com preços diferentes para os seguintes
produtos:
Capítulo 4.1. Verificações mais complexas 157
produto / cidade Sofia Plovdiv Varna
café 0,50 0,40 0,45

água 0,80 0,70 0,70
1,20 1,15 1,10
cerveja 1,45 1,30 1,35
doces amendoim 1,60 1,50 1,55
Por cidade dada (string), produto (string) e quantidade (número decimal) sim
calcular o preço.
Conecte-se Saída Conecte-se Saída Entrada Saída Entrada Saída
café amendoim cerveja água

Varna 0,9 Plovdiv 1 1,5 Sofia 7.2 Plovdiv 2.1
2 6 3
Responder
Colocamos todas as letras em minúsculas com a função .toLowerCase() para comparar produtos e
cidades sem diferenciar maiúsculas de minúsculas.
Testando a solução: Teste sua
Verificações mais complexas

Vejamos como podemos fazer verificações lógicas mais complexas. Podemos usar AND lógico (&&), OU lógico
(||), negação lógica (!) e parênteses (()).
E Lógico
Como vimos, em algumas tarefas precisamos fazer muitas verificações ao mesmo tempo. Mas o que acontece
quando, para executar algum código, várias condições devem ser atendidas e não queremos fazer uma negação
(else) para cada uma delas? A opção com blocos if aninhados é válida, mas o código pareceria muito confuso e
certamente difícil de ler e manter.
Um "AND" lógico (operador && ) significa que várias condições são atendidas simultaneamente. A seguinte
tabela verdade se aplica:
a b a && b
verdadeiro
verdadeiro
falso
falso verdadeiro
verdadeiro falso verdadeiro falso
falso falso falso
Como funciona o operador &&?

O operador && usa várias expressões booleanas (condicionais) que têm o valor true ou false e nos retorna uma
única expressão booleana como resultado. Usá-lo em vez de uma série de blocos if aninhados torna o código
mais legível, organizado e fácil de manter. Mas como funciona quando colocamos várias condições uma após a
outra? Como vimos acima, o "AND" lógico retorna verdadeiro apenas quando aceita expressões com o valor
verdadeiro como argumentos. Da mesma forma, quando temos uma sequência de argumentos, o AND lógico
verifica até esgotar os argumentos ou até encontrar um argumento com o valor false.
Exemplo:
booleano a = verdadeiro;
booleano b = verdadeiro;
booleano c = falso; booleano
d = verdadeiro; resultado
booleano = a && b && c && d; // false (que d não verifica)
O programa será executado da seguinte maneira: começa a verificar a partir de a, lê e informa que é
verdadeiro e, em seguida, verifica b. Depois de determinar que a e b retornam verdadeiro, ele
verifica o próximo argumento. Ele atinge c e informa que a variável tem o valor false. Uma vez que o
programa detecta que o argumento c tem o valor false, ele avalia a expressão até c,
independentemente do valor de d. Para isso, a verificação de d é ignorada e toda a expressão é
avaliada como falsa.
Exemplo: um ponto em um retângulo

Verifique se o ponto {x, y} está dentro do retângulo {x1, y1} – {x2, y2}. Os dados de entrada são lidos
no console e consistem em 6 linhas: os números decimais x1, y1, x2, y2, x e y (garantindo que x1 <
x2 e y1 < y2).
Conecte-se Saída Visualização
2
-3
12
Dentro
3
8
-1
Responder
Um ponto é interior a um retângulo se ambos se encontram

quatro condições a seguir:
• O ponto está à direita do lado esquerdo do retângulo.

• O ponto está à esquerda do lado direito do retângulo. • O
ponto está abaixo do lado superior do retângulo. • O ponto está
acima da base do retângulo.
Aqui está a implementação:

Testando a solução Teste sua solução:
https://judge.softuni.bg/Contests/Practice/Index/653#2.
"OU" lógico
Um OR lógico (operador ||) significa que pelo menos uma das várias condições foi atendida. Como o operador &&, o OR
lógico aceita vários argumentos booleanos (condicionais) e retorna verdadeiro ou falso. Podemos adivinhar facilmente que
nos tornamos verdadeiros sempre que pelo menos um dos argumentos for verdadeiro. Um exemplo típico da lógica desse
operador é
a seguir:
Na escola, a professora diz: "Deixa o Ivan ou o Pedro lavar o quadro-negro". Para que esta condição seja cumprida (a tábua
ser lavada), é possível que apenas Ivan lave, apenas Peter lave, ou ambos o façam.
a b um || b
verdadeiro verdadeiro
verdadeiro falso falso verdadeiro falso verdadeiroverdadeiro

falso verdadeiro falso
Como o operador || funciona ?

Já aprendemos o que é OU lógico. Mas como isso é realmente implementado? Assim como no AND lógico, o programa
verifica da esquerda para a direita os argumentos definidos. Para obter true da expressão, é necessário que apenas um
argumento tenha o valor true, portanto, a verificação continua até que um argumento com esse valor seja encontrado ou até
que os argumentos se esgotem. Aqui está um exemplo do operador || em ação:
booleano a = falso; booleano b

= verdadeiro;
booleano c = falso;
booleano d = verdadeiro;
resultado booleano = a || b || c || d; // verdadeiro (já
que c e d não são verificados)
O programa verifica a, relata que tem um valor false e continua. Chegando em b, ele informa que tem
valor true e toda a expressão avalia true sem checar c e d pois seus valores não mudariam o resultado
de
expressões.
Exemplo: fruta ou legume

Vamos verificar se um produto é uma fruta ou um legume. As frutas são banana, maçã, kiwi, cereja,
limão e uva. Legumes são tomate, pepino, pimenta e cenoura. Todos os outros são "desconhecidos".
Conecte-se Saída
banana fruta
tomate vegetal
java desconhecido
Responder
Precisamos usar várias verificações condicionais com OU lógico (||):

Testando a solução Teste sua
negação lógica
Uma negação lógica (operador !) significa que uma determinada condição não foi cumprida.
a !a
verdadeiro falso
O operador ! recebe uma variável booleana como argumento e retorna seu valor.
Exemplo: número inválido

Um determinado número é válido se estiver no intervalo [100 … 200] ou for 0. Verifique se há um número inválido.
Entrada Saída
75 inválido
150 (Não há escapatória)
220 inválido
Responder
Testando a solução
O operador parênteses ()
Assim como os outros operadores na programação, os operadores && e || tem prioridade,

neste caso && tem prioridade maior que ||. O operador () é usado para alterar a
precedência dos operadores e é avaliado primeiro, assim como na matemática. O uso
de parênteses também torna o código mais legível e é considerado uma boa prática.
Condições lógicas mais complexas

Às vezes, as condições podem ser bastante complexas, exigindo uma longa expressão booleana ou uma
série de verificações. Vejamos alguns desses exemplos.
Exemplo: um ponto em um lado de um retângulo

Escreva um programa que verifique se um ponto {x, y} está em qualquer um dos lados de
um retângulo {x1, y1} - {x2, y2}. Os dados de entrada são lidos no console e consistem
em 6 linhas: os números decimais x1, y1, x2, y2, x e y (garantindo que x1 < x2 e y1 < y2).
Para imprimir "Border" (o ponto fica em um dos lados) ou "Inside / Outside" (caso
contrário).
2
2 -3
-3 12
Fronteira Dentro fora
3
12 8
3 12 -1 -1
Responder
Um ponto pertence a um dos lados de um retângulo se:

• x corresponde a x1 ou x2 e ao mesmo tempo y está entre y1 e y2 ou
• y corresponde a y1 ou y2 e ao mesmo tempo x está entre x1 e x2.
Aqui está um exemplo de implementação:
Exemplo: uma frutaria

Uma loja de frutas durante a semana vende
Os preços são mais elevados aos fins-de-semana:
pelos seguintes preços:
Fruta Preço
Fruta Preço
banana 2,70
banana 2,50
maça 1,25
maça 1,20
laranja 0,90
laranja 0,85
toranja kiwi 1,60
toranja kiwi 1,45
3,00
2,70
abacaxi 5,60
abacaxi 5,50
uvas 4,20
uvas 3,85
Escreva um programa que leia no console a fruta (banana/maçã/…), dia da semana (segunda/terça/…)
e quantidade (número decimal) e calcule o preço de acordo com os preços das tabelas acima. Imprima
o resultado arredondado para 2 casas decimais. Para um dia da semana inválido ou um nome de fruta
inválido, imprima "erro".
laranja kiwi uvas

tomate
Domingo 2,70 segunda- 6,75 sábado 0.5 2.10 erro
segunda
3 feira 2.5
0.5
Responder
Exemplo: comissões de negociação

Uma empresa dá as seguintes comissões aos seus vendedores de acordo com a cidade em que
trabalham e o volume de vendas:
Cidade 0 <= s <= 500 500 < s <= 1000 1000 < s <= 10000 s > 10000
Sofia 5% 7% 8% 12%
Varna 4,5% 7,5% 10% 13%
Plovdiv 5,5% 8% 12% 14,5%
Escreva um programa que leia o nome de uma cidade (uma string) e um volume de vendas (um número
decimal) e calcule o valor da comissão. O resultado deve ser arredondado para 2 casas decimais após
a vírgula. Cidade ou volume de vendas inválido (número negativo) para imprimir "erro".
Sófia Plovdiv Kaspichan-50

120,00 27,50 erro
1500 499,99
Responder
Ao ler a entrada, podemos converter a cidade para letras minúsculas (com a função .toLowerCase()).
Inicialmente definimos a comissão como -1. Ela vai ser
166 Noções básicas de programação Java
alterado se a cidade e a faixa de preço forem encontradas na tabela de comissões. Para calcular a
comissão com base na cidade e no volume de vendas, precisamos de algumas verificações if aninhadas ,
como no exemplo de código abaixo:
É uma boa prática usar blocos que cercamos com chaves { } depois de if e else. Além
disso, é recomendável recuar o código após if e else em uma tabulação ao escrever
para facilitar a leitura do código.
Caixa de comutação de construção condicional

A construção switch-case funciona como uma série de blocos if-else . Quando a operação do nosso
programa depende do valor de uma variável, em vez de fazer verificações sequenciais com blocos if-else ,
podemos usar a construção de switch condicional. É usado para selecionar em uma lista de opções. A
construção compara um determinado valor com certas constantes e, dependendo do resultado, executa
uma ação.
A variável que queremos comparar é colocada entre parênteses após a instrução switch e é chamada de
"seletor". Aqui, o tipo deve ser comparável (números, strings). Sequencialmente, a comparação começa
com cada valor que segue as marcas de caso. Se houver uma correspondência, a execução do código
começa no local correspondente e continua até que a instrução break seja alcançada. Em algumas
linguagens de programação (como C# por exemplo) a presença de uma quebra é obrigatória para todos
os casos,
que contém a implementação da lógica do programa. Em Java, a instrução break pode

ser omitido para executar o código de outra construção case até que a próxima instrução break
seja alcançada . Embora permitido pela linguagem Java, omitir uma instrução break após uma
tag case é extremamente raro e não é uma boa prática, pois leva aos chamados travamentos do
código do programa. Se não houver correspondência, a construção padrão será executada , se
houver.
interruptor (seletor) { caso

valor1:
construção;
quebrar
valor do caso2 :
construção;
quebrar
valor do caso3 :
construção;
quebrar
…
padrão:
construção;
quebrar
}
Exemplo: dia da semana

Vamos escrever um programa que imprima o dia da semana (em inglês) de acordo com o número
digitado (1 … 7) ou "Erro!" se for informado um dia inválido.
Conecte-se Saída
1 Segunda-
Feira
7 -1 Domingo Erro!
Responder
É uma boa prática colocar primeiro os casos que lidam com as situações que ocorrem com
mais frequência e deixar as construções de caso que lidam com situações que ocorrem
com menos frequência no final, antes da construção padrão . Outra boa prática é
organizar as tags de caso em ordem crescente, independentemente da importância
sejam eles inteiros ou caracteres.
Múltiplos rótulos em switch-case

Em Java, temos a capacidade de usar várias tags case quando elas precisam executar o mesmo código. Com
essa forma de escrever, quando nosso programa encontrar uma correspondência, ele executará o próximo
código encontrado, pois não há código de execução e instrução break após o rótulo case correspondente .
interruptor (seletor) {
caso valor1: caso valor2:

caso valor3:
construção; quebrar
valor do
caso4 :
valor do caso5 :
…
padrão:
}
Exemplo: um tipo de animal

Escreva um programa que imprima o tipo de animal de acordo com seu nome:
• cachorro -> mamífero
• crocodilo, tartaruga, cobra -> réptil

• outros -> desconhecido
tartaruga réptil cachorro mamífero elefante desconhecido
Responder
Podemos resolver o problema verificando o switch-case com vários rótulos da seguinte maneira:

Neste capítulo, aprendemos como podemos usar condições e verificações mais complexas,
operadores lógicos em condições e instruções if aninhadas .
Cheques aninhados
if (condição1) {
if (condição2) { //
corpo; } else
{ // corpo;
}
}
Verificações mais complexas com &&, ||, ! e ()
if ((x == esquerda || x == direita) && y <= superior && y >= inferior)

System.out.println (…);
Verificações de caso de comutação
valor do caso1 :
construção;
quebrar
caso valor2: caso valor3:
…
padrão:
Exercícios: verificações mais complexas

Vamos agora praticar o trabalho com verificações mais complexas. Vamos resolver alguns problemas práticos.
Tarefa: cinema
Em uma sala de cinema, as cadeiras são dispostas de forma retangular em r fileiras e c colunas.
Existem três tipos de sessões com bilhetes a preços diferentes:
• Estreia – exibição de estreia, ao preço de BGN 12,00. • Normal
– projeção padrão, ao preço de BGN 7,50. • Desconto – rastreio
de crianças, escolares e estudantes ao preço reduzido de 5,00
leva.
Escreva um programa que insira o tipo de triagem (string), o número de filas e o número de colunas no hall
(números inteiros) e calcule a receita total de ingressos na íntegra
salão. O resultado deve ser impresso no formato dos exemplos abaixo - com 2 dígitos após a
vírgula.
Estreia Normal
10 1440.00 leva 21 2047.50 leva
12 13
Diretrizes e dicas Ao ler a

entrada, podemos inverter o tipo de projeção para letras minúsculas (com a função .toLowerCase()).
Criamos e inicializamos uma variável que armazenará nossos ganhos calculados. Em outra
variável, calculamos a capacidade total do salão. Usamos uma construção condicional switch-
case para calcular a receita dependendo do tipo de projeção e imprimir o resultado no formato
especificado (procure a funcionalidade Java necessária na Internet). Exemplo de código (partes
do código estão obscurecidas para encorajar o pensamento independente e a tomada de
decisão):
Tarefa: vôlei
Vladi é estudante, mora em Sofia e vai para sua cidade natal de vez em quando. Ele é muito apaixonado
por vôlei, mas fica ocupado durante a semana e só joga vôlei nos finais de semana e feriados. Vladi
joga em Sofia todos os sábados, quando não está trabalhando e viajando para sua cidade natal, bem
como em 2/3 dos feriados. Ele viaja para sua cidade natal h vezes por ano, onde joga vôlei com seus
velhos amigos aos domingos. Vladi não está no trabalho 3/4 dos fins de semana em que está em Sofia.
Separadamente, durante os anos bissextos, Vladi joga 15% mais vôlei do que o normal. Assumimos
que há exatamente 48 fins de semana adequados para o voleibol no ano. Escreva um programa que
calcule quantas vezes Vlady jogou vôlei durante o ano. Arredonde o resultado para o número inteiro
mais próximo (por exemplo, 2,15 -> 2; 9,95 -> 9).
Os dados de entrada são lidos no console:

• A primeira linha contém a palavra "leap" (ano bissexto) ou "normal" (ano normal com 365
dias).
• A segunda linha contém o inteiro p - número de feriados do ano (que não são sábados nem
domingos).
• A terceira linha contém o inteiro h - número de finais de semana em que Vladi viaja para sua
cidade natal.
Entrada Saída Conecte-se Sair Entrar Sair Entrada Saída
salto normal normal salto

45 38 11 44 0 41
52 32 6 1
Diretrizes e dicas
Por padrão, lemos os dados de entrada do console e, para evitar erros de digitação, convertemos o
texto em letras minúsculas com a função .toLowerCase(). Calculamos consistentemente os fins de
semana passados em Sofia, o tempo de jogo em Sofia e o tempo total de jogo. Por fim, verificamos se
o ano é bissexto, fazemos cálculos adicionais se necessário e exibimos o resultado no console
arredondado para o inteiro mais próximo (procure uma classe Java com essa funcionalidade na Internet).
Exemplo de código (partes do código estão ocultas para que você mesmo possa pensar nos detalhes):
*
Tarefa: ponto na figura
*
Uma figura consiste em 6 blocos de tamanho hh, dispostos como na
figura. O canto inferior esquerdo do edifício está na posição {0, 0}. O
canto superior direito da figura está na posição {2*h, 4*h}. Na figura,
as coordenadas são dadas em h = 2.
Para escrever um programa que insere um inteiro h e as coordenadas

de um determinado ponto {x, y} (inteiros) e imprime se o ponto está
dentro da figura (dentro), fora da figura (fora) ou em uma das paredes
de a figura (borda).
Entrada Saída Entrada Saída Conecte-se Saída Conecte-se Saída
2 2 2
fora 3 dentro 2 fronteira 6 fronteira
2 3 10 1 2 0
2 15 15 15
0 fora 13 fora 29 dentro 37 fora
6 55 37 18
Diretrizes e dicas Exemplo
de lógica para resolver a tarefa (não a única correta):

• Podemos dividir a figura em duas linhas retas
o canto com uma parede comum.
• Um ponto está fora da figura quando
está simultaneamente fora dos dois retângulos. • Um ponto
está dentro da figura se estiver dentro de qualquer um dos
retângulos (excluindo seus lados) ou estiver em seu comum
parede.
• Caso contrário, o ponto fica na borda do retângulo.
Exemplo de código (partes do código estão obscurecidas para

encorajar o pensamento independente e a tomada de decisão):
Capítulo 4.2. Verificações mais complexas

- tarefas de exame
No capítulo anterior, aprendemos sobre construções condicionais aninhadas na linguagem
Java. Através deles, a lógica do programa em um determinado programa pode ser
representada por meio de construções if aninhadas . Também examinamos a construção
condicional switch-case , que permite uma escolha em uma lista de possibilidades. Devemos
praticar e reforçar o que aprendemos até agora examinando alguns dos problemas mais
difíceis apresentados nos exames. Antes de passar para as tarefas, vamos relembrar as
construções condicionais:
Cheques aninhados
if (condição1) { if
(condição2) { //
corpo; }
else { //
corpo;
}
}
Lembre-se de que não é uma boa prática escrever condicionais

profundamente aninhadas (com um nível de aninhamento superior a três).
Evite aninhar mais de três condicionais um dentro do outro. Isso complica
o código e torna-o difícil de ler e entender.
Verificações de caso de comutação
Quando a operação do programa depende do valor de uma variável, em vez de fazer

verificações sequenciais com vários blocos if-else , podemos usar a construção condicional
switch-case.
valor do caso1 :
construção;
quebrar
valor do caso2 :
projeto; quebrar;
padrão:
construção;
quebrar
}
A construção consiste em:
• Seletor - uma expressão que avalia algum valor específico. O tipo de seletor pode ser um número
inteiro, string ou enum.
• Múltiplas tags case com comandos depois delas terminando com break.
Tarefas de exame
Agora que lembramos como as construções condicionais são usadas e como as construções
condicionais são aninhadas para implementar verificações e lógica de programa mais complexas,
vamos resolver alguns problemas de exame.
Tarefa: a tempo para o exame

Um aluno deve ir a um exame em um horário específico (por exemplo, 9h30). Ele chega à sala de
exames em um determinado horário de chegada (por exemplo, 9h40). É considerado pontual o aluno
que chegou no horário do exame ou até meia hora antes. Se ele chegasse mais de 30 minutos antes,
estava atrasado. Se ele veio depois do horário do exame, ele está atrasado.
Escreva um programa que insira um horário de exame e um horário de chegada e imprima se o aluno
chegou no horário, adiantado ou atrasado e quantas horas ou minutos ele chegou adiantado ou
atrasado.
Dados de entrada
Quatro inteiros são lidos no console (um por linha):
• A primeira linha contém a hora do exame - um número inteiro de 0 a 23. • A
segunda linha contém o minuto do exame - um número inteiro de 0 a 59.
• A terceira linha contém a hora de chegada - um número inteiro de 0 a 23. • A quarta
linha contém o minuto de chegada - um número inteiro de 0 a 59.
Dados de saída
Na primeira linha, imprima:
• "Atrasado" se o aluno chegar depois do horário do exame. • "On time", se o
aluno chegar exatamente no horário do exame ou em 30 minutos

mais cedo.
• "Early" se o aluno chegar mais de 30 minutos antes do horário do exame.
Se o aluno chegar pelo menos um minuto depois do horário do exame, imprima na próxima linha:
• "mm minutos antes do início" para chegar com menos de uma hora de antecedência.
Capítulo 4.2. Verificações mais complexas - tarefas de exame 177
• "hh:mm horas antes do início" para avançar 1 hora ou mais. Os minutos

imprima sempre com 2 dígitos, por exemplo "1:05".
• "mm minutos após o início" para um atraso inferior a uma hora. •
"hh:mm horas após o início" para um atraso de 1 hora ou mais. Os minutos

imprima sempre com 2 dígitos, por exemplo, "1:03".

16
No horário 30
9 Atrasado 20 minutos 00 Cedo 1:00 horas 9
minutos antes do
após o início 15 antes do início
início
30 9 50 00 00 8 30
14 10
9 Atraso 1:30 horas 00 No horário 5 minutos 00
Na hora
00 após o início 13 antes do início 10
10 30 55 00
Diretrizes e dicas
É uma boa ideia ler a tarefa várias vezes, fazendo anotações e esboçando os exemplos
enquanto pensa sobre eles, antes de começar a escrever o código.
Processamento de entrada De acordo com a
atribuição, esperamos receber quatro linhas consecutivas de inteiros diferentes. Observando os parâmetros
fornecidos, podemos definir o tipo int , pois ele satisfaz nossos valores esperados. Lemos simultaneamente a
entrada e analisamos o valor da string para o tipo de dados inteiro escolhido.
Olhando para a saída esperada, podemos criar variáveis para armazenar os diferentes tipos de dados de saída,
a fim de evitar o uso dos chamados "cordas mágicas" no código.
cálculos
Depois de ler a entrada, podemos começar a escrever a lógica para calcular o resultado. Vamos primeiro calcular
a hora de início do exame em minutos
para uma comparação mais fácil e precisa.
Vamos calcular o horário de chegada do aluno usando a mesma lógica.
Resta-nos calcular a diferença nos dois tempos, para que possamos determinar
quando e a que horas em relação ao exame o aluno chegou.
Nosso próximo passo é fazer as verificações e cálculos necessários, finalmente gerando o resultado deles. Vamos
dividir a saída em duas partes:
• Primeiro, vamos mostrar quando o aluno chegou - se ele chegou adiantado, atrasado ou pontual. Para isso,
vamos nos concentrar na construção if-else .
• Em seguida, mostraremos a diferença de horário se o aluno chegar às

tempo pessoal a partir da hora de início do exame.
Para economizar uma verificação adicional (senão), podemos assumir como padrão que o aluno está atrasado.
Então, de acordo com a condição, verificamos se a diferença de horário é superior a 30 minutos. Se for esse o caso,
assumimos que ele está ferido. Se não entrarmos na primeira condição, então devemos apenas verificar se a
diferença é menor ou igual a zero (<= 0), com a qual verificamos a condição de que o aluno veio de 0 a 30 minutos
antes do exame.
Em todos os outros casos, assumimos que o aluno está atrasado, o que é nosso padrão. Portanto, nenhuma
verificação adicional é necessária.
Para a final, temos que descobrir e mostrar com que diferença da hora do exame
o aluno chegou e se essa diferença indica um horário de chegada
antes ou depois do exame.
Verificamos se nossa diferença é maior que uma hora para exibir horas e minutos
respectivamente no formato desejado pela tarefa, ou menor que uma hora para exibir
apenas minutos como formato e descrição. Resta
fazer mais uma verificação - se o horário de chegada do aluno é antes ou depois do
início do exame.
Imprimindo o resultado Por fim,

resta imprimir o resultado no console. Como tarefa, se o aluno chegou exatamente no
horário (sem um único minuto de diferença), não devemos deduzir um segundo resultado.
Portanto, realizamos a seguinte verificação:
De fato, para os propósitos da tarefa, a saída do resultado para o console pode ser feita
em um estágio anterior - já durante os próprios cálculos. Isso geralmente não é uma
prática muito boa. Por que?
Vamos considerar a ideia de que nosso código não tem 10 linhas, mas 100 ou 1000!
Algum dia, a saída do resultado precisará ser salva em um arquivo ou visualizada em
um aplicativo da Web, em vez de estar no console. Então, quantos lugares no código
terão que ser corrigidos por causa dessa mudança? E não vou perder um lugar?
Sempre pense no código de cálculo lógico como separado do processamento de

entrada e saída. Deve ser capaz de funcionar independentemente de como os
dados são alimentados a ele e onde o resultado precisará ser exibido.

Tarefa: jornada
Estranho, mas a maioria das pessoas planeja suas férias com antecedência. Um jovem programador
tem um determinado orçamento e tempo livre em uma determinada temporada.
Escreva um programa que aceite como entrada o orçamento e a temporada, e como saídas onde o
programador vai descansar e quanto vai gastar.
O orçamento determina o destino e a temporada determina quanto do orçamento será gasto. Se for
verão, estarei acampando e no inverno - em um hotel. Se estiver na Europa, independentemente da
época, vai descansar num hotel. Cada parque de campismo ou hotel, consoante o destino, tem um
preço próprio que corresponde a uma determinada percentagem do orçamento:
• Em BGN 100 ou menos - em algum lugar na Bulgária. o

Verão – 30% do orçamento.
o Inverno – 70% do orçamento.
• Em BGN 1000 ou menos - em algum lugar nos Bálcãs.
o Verão – 40% do orçamento.
o Inverno – 80% do orçamento.
• Em mais de BGN 1.000 - em algum lugar da Europa.
o Ao viajar pela Europa, independente da estação, gastará 90% do
seu orçamento.
Dados de entrada
A entrada é lida do console e consiste em duas linhas:
• Na primeira linha obtemos o orçamento - um número real no intervalo [10,00 …

5000,00].
• Na segunda linha – uma das duas estações possíveis: "verão" ou "inverno".
Dados de saída
Duas linhas devem ser impressas no console.
• Na primeira linha - "Somewhere in {destination}" entre "Bulgária", "Balcãs" e

"Europa".
• Na segunda linha – "{Tipo de férias} – {Valor gasto}":

o O descanso pode ser entre "Camp" e "Hotel".
o O valor deve ser arredondado para a segunda casa decimal
sinal de tique.

50 Algures na Bulgária 75 Hotel em algum lugar da

verão Acampamento – 15h00 inverno Bulgária – 52,50
312 Algures no Acampamento 1500 Hotel Algures na Europa

verão dos Bálcãs – 124,80 verão – 1350.00
Diretrizes e dicas
Normalmente, como em outras tarefas, podemos dividir a solução em várias partes: ler a entrada,
calcular, imprimir o resultado.
Processando os dados de entrada Ao ler
a condição cuidadosamente, entendemos que esperamos duas linhas de dados de entrada. O primeiro
parâmetro é um número real, para o qual é bom escolher um tipo de variável apropriado. Para maior
precisão nos cálculos, vamos nos concentrar em BigDecimal como o tipo para o orçamento e para a
temporada - string.
Sempre considere que tipo de valor é passado nos dados de entrada, bem como
em que tipo esses dados devem ser convertidos para que as construções do
programa que você cria funcionem corretamente!
Exemplo: quando a tarefa exigir que você faça cálculos monetários, use BigDecimal para maior
precisão.
cálculos
Vamos criar e inicializar a lógica e os cálculos
variáveis.
Semelhante ao exemplo do problema anterior, podemos inicializar as variáveis com

alguns dos resultados de saída - para economizar inicialização adicional.
Olhando novamente para a condição da tarefa, notamos que a distribuição básica de

onde vamos descansar é determinada pelo valor do orçamento apresentado, ou seja,
nossa lógica principal se divide em dois casos:
• Se o orçamento for inferior a um determinado valor. • Se
for menor que outro valor, ou for maior que um determinado limite
valor.
Dependendo de como organizamos nosso esquema lógico (em que ordem percorreremos
os valores de limite), teremos mais ou menos verificações nas condições. Pense no
porquê!
Em seguida, precisamos verificar o valor da temporada enviada. Com base nisso,
determinaremos qual percentual do orçamento será gasto, bem como
onde o programador descansará - em um hotel ou em um acampamento.
Vamos escolher e criar o formato necessário para os dados de saída, que usaremos
posteriormente no código:
Formatador DecimalFormat = new DecimalFormat("0.00");
Um exemplo de uma possível abordagem de solução é:
então continuamos com:

e completamos as verificações com:
Sempre podemos inicializar um determinado valor de parâmetro e fazer apenas uma verificação.
Isso nos poupa um passo lógico.
Por exemplo, o seguinte bloco:
pode ser abreviado para esta forma:

Imprimir o resultado
Resta-nos exibir o resultado calculado no console:

Tarefa: operações entre números

Escreva um programa que leia dois inteiros (N1 e N2) e um operador para realizar uma
dada operação matemática sobre eles. As operações possíveis são adição (+),
subtração (-), multiplicação (*), divisão (/) e divisão modular (%). Ao somar, subtrair e
multiplicar, o console deve imprimir o resultado e se é par ou ímpar. Na divisão simples
- apenas o resultado e na divisão modular - o restante. Deve-se notar que o divisor pode
ser igual a zero (= 0), e zero não é divisível. Neste caso, uma mensagem especial deve
ser impressa.
Dados de entrada
3 linhas são lidas no console:
• N1 – um inteiro no intervalo [0 … 40.000]. • N2 –
um número inteiro no intervalo [0 … 40.000]. •
Operador – um símbolo entre: "+", "-", "*", "/", "%".
Dados de saída
• Se a operação for adição, subtração ou multiplicação: o "{N1}
{operador} {N2} = {resultado} – {par/ímpar}". • Se a
operação for divisão:
o "{N1} / {N2} = {resultado}" – o resultado é formatado para o segundo caractere após o
ponto decimal.
• Se a operação for divisão modular:

o "{N1} % {N2} = {resto}".
• Em caso de divisão por 0 (zero): o "Não é

possível dividir {N1} por zero".
10 7
*
1 10 – 1 = 9 – ímpar 3 7 3 = 21 – ímpar
- *
10 7
*
12 10 + 12 = 22 – par 3 7 3 = 21 – ímpar
*
+
123 10
12 123/12 = 10,25 3 10 % 3 = 1
/ %
Diretrizes e dicas
A tarefa não é complicada, mas há algumas linhas de código para escrever.
Processando os dados de entrada Depois de ler
a condição, entendemos que esperamos três linhas de dados de entrada. Nas duas primeiras linhas, recebemos
números inteiros (no intervalo indicado pela tarefa) e na terceira - um símbolo aritmético.
cálculos
Vamos criar e inicializar as variáveis necessárias para a lógica e os cálculos. Em um armazenaremos o resultado dos
cálculos e no outro usaremos para a saída final do programa.
Ao ler atentamente a condição, entendemos que há casos em que não deve

para não fazer cálculos, apenas mostre um resultado.
Portanto, podemos primeiro verificar se o segundo número é 0 (zero), bem como

se a operação é divisão ou divisão modular, então para inicializar
resultados.
Vamos colocar o resultado como um valor ao inicializar o parâmetro de saída . Portanto, podemos fazer apenas
uma verificação - se precisamos recalcular e substituir esse resultado.
Dependendo de qual abordagem escolhermos, nossa próxima verificação será um simples else ou um único if.
No corpo desta verificação, com verificações adicionais sobre como o resultado é calculado em relação ao
operador passado, podemos separar a lógica da estrutura do resultado esperado.
A partir da condição, podemos ver que para adição (+), subtração (-) ou multiplicação (*), o resultado esperado
tem a mesma estrutura: "{N1} {operador} {N2} = {resultado} – {par /odd}", enquanto para divisão (/) e para divisão
modular (%) o resultado tem
estrutura diferente.
Terminamos com as verificações de adição, subtração e multiplicação:

Para verificações curtas e simples, como no exemplo acima para pares e ímpares, é
possível usar um operador ternário. Vamos considerar nossa possível verificação sem
um operador ternário.
Sem usar o operador ternário, o código é mais longo, mas fácil de ler:
Usando um operador ternário, o código fica bem mais curto, mas pode exigir um esforço
extra para ler e entender como lógica:

resta exibir o resultado calculado no console:

Tarefa: ingressos para uma partida
Um grupo de torcedores decidiu comprar ingressos para a Euro 2016. O preço do ingresso é
determinado de acordo com duas categorias:
• VIP – 499,99 BGN
• Normal – BGN 249,99
Os isqueiros têm um determinado orçamento, e o número de pessoas no grupo determina qual

porcentagem do orçamento deve ser destinada ao transporte:
• De 1 a 4 – 75% do orçamento • De 5
a 9 – 60% do orçamento • De 10 a 24 –
50% do orçamento • De 25 a 49 – 40% do
orçamento
• 50 ou mais – 25% do orçamento Escreva
um programa para calcular se eles podem comprar ingressos para a categoria selecionada com o dinheiro
restante do orçamento, bem como quanto dinheiro sobrará ou precisará.
Dados de entrada
• Na primeira linha está o orçamento – um número real no intervalo [1 000,00 … 1 000
000,00.
• Na segunda linha está a categoria - "VIP" ou "Normal". • Na
terceira linha está o número de pessoas no grupo - um inteiro no intervalo [1 … 200].
Dados de saída
• Se o orçamento for suficiente:
o "Sim! Você tem {N} sobrando." – onde N é o dinheiro restante do grupo.
• Se o orçamento NÃO FOR suficiente:
o "Não há dinheiro suficiente! Você precisa de {M} leva." – onde M é a quantidade que não
alcançar.
Os valores devem ser formatados com duas casas decimais.
Conecte-se Saída Explicações
1 pessoa: 75% do orçamento vai para o transporte.

1000
Sim! Você tem Restante: 1000 – 750 = 250.
Normal *
0,01 leva restante. Categoria Normal: o bilhete custa 249,99 249,99 < 1 = 249,99
1
250: resta 250 – 249,99 = 0,01
49 pessoas: 40% do orçamento vai para o transporte. Restante:

Dinheiro
30000 30000 – 12000 = 18000. Categoria VIP:
insuficiente!
VIP bilhete custa 499,99 49. 24499,510000000002 <
Você precisa de
49 18000. Insuficiente 24499,51 – 18000 =
6499,51 leva.
*6499,51
Diretrizes e dicas
Vamos ler os dados de entrada e realizar os cálculos descritos na condição
da tarefa para verificar se o dinheiro será suficiente.
Entrada de processamento Vamos ler a
condição cuidadosamente e ver o que se espera que seja recebido

chim como entrada, o que esperamos retornar como saída e quais são as principais etapas para quebrar o
circuito lógico.
Para começar, vamos processar e armazenar os dados de entrada nas variáveis apropriadas:
cálculos
Vamos criar e inicializar as variáveis necessárias para os cálculos:
Vamos revisar a condição novamente. Precisamos fazer dois blocos diferentes

cálculos.
Desde os primeiros cálculos, precisamos entender que parte do orçamento teremos que reservar para o
transporte. Pela lógica desses cálculos, notamos que só importa o número de pessoas do grupo. Portanto,
faremos a divisão lógica de acordo com o número de torcedores.
Usaremos uma construção condicional - uma série de blocos if-else :

A partir do segundo cálculo, precisamos descobrir qual valor precisaremos para comprar
ingressos para o grupo. De acordo com a condição, depende apenas do tipo de ingresso
que precisamos comprar.
Vamos usar uma construção condicional switch-case .
Calculados quais são os custos de transporte e de passagem, resta-nos calcular o

resultado final e saber se o grupo de adeptos poderá ou não ir ao Euro 2016 com os
parâmetros assim apresentados.
Para a saída do resultado, para nos salvar de outra verificação, assumimos que o grupo
padrão poderá ir para a Euro 2016.
Imprimindo o resultado
Finalmente, resta exibir o resultado calculado no console.

Tarefa: quarto de hotel

Hotel oferece dois tipos de quartos: estúdio e apartamento.
Escreva um programa que calcule o preço total da estadia de um estúdio e um apartamento.
Os preços dependem do mês de estadia:
maio e outubro junho e setembro julho e agosto
Estúdio - Estúdio - Estúdio -

BGN 50/noite BGN 75,20/noite BGN 76/noite
Apartamento - Apartamento – Apartamento -

BGN 65/noite BGN 68,70/noite BGN 77/noite
Os seguintes descontos também estão disponíveis:
• Para estúdio, para mais de 7 noites em Maio e Outubro: 5% de desconto.
• Para estúdio, para mais de 14 noites em maio e outubro: 30% de desconto. • Para estúdio, para
mais de 14 noites em junho e setembro: 20% de desconto. • Para apartamento, para mais de 14
noites, independentemente do mês: 10%

redução.
Dados de entrada
A entrada é lida no console e contém exatamente duas linhas:
• Na primeira linha está o mês - maio, junho, julho, agosto, setembro ou outubro. • Na
segunda linha está o número de dormidas - um inteiro no intervalo [0 ... 200].
Dados de saída
Para imprimir duas linhas no console:
• Na primeira linha: "Apartamento: { preço para toda a estadia } lv." •

Na segunda linha: "Estúdio: { preço para toda a estadia } lv."
O preço de toda a estadia deve ser formatado com duas casas decimais
sinal de tique.
14 de Apartamento: 961,80 lv. 20 de Apartamento: 1386,00 lv.

junho Estúdio: 1052,80 lv agosto Estúdio: 1520,00 lv.
Em maio, para mais de 14 noites, reduzimos o preço do

estúdio em 30% (50 – 15 = 35), e do apartamento – em 10%
15 de Apartamento: 877,50 lv.
(65 – 6,5 = 58,5). Toda a estadia em apartamento - BGN 877,50.
maio Estúdio: 525,00 lv.
Toda a estadia em estúdio - BGN 525,00.
Diretrizes e dicas
Vamos ler os dados de entrada e realizar os cálculos de acordo com a lista de preços descrita e as regras de desconto
e, finalmente, imprimir o resultado.
Processamento dos dados de entrada De acordo
com o estado da tarefa, esperamos receber duas linhas de dados de entrada - na primeira linha o mês em que a
estadia está prevista e na segunda - o número de noites. Vamos processar e salvar os dados de entrada nos
parâmetros apropriados:
cálculos
A seguir, vamos criar e inicializar as variáveis necessárias para os cálculos:
Olhando novamente para a condição, notamos que nossa lógica principal depende do
mês que nos é dado, bem como do número de noites.
Em geral, existem diferentes abordagens e maneiras de fazer as verificações em questão,
mas vamos nos concentrar em uma construção condicional switch-case básica e, nos
diferentes blocos de casos , usaremos construções condicionais if e if-
else. Vamos começar com o primeiro grupo de meses: maio e outubro. Durante estes
dois meses, o preço da estadia é o mesmo para os dois tipos de alojamento - estúdio e
apartamento. Portanto, precisamos fazer uma verificação interna do número de noites
para recalcular o preço relevante (se necessário).
Nos meses seguintes, a lógica e os cálculos serão relativamente idênticos.


Depois de calcularmos quais são os preços relevantes e o valor final da estadia - vamos
enviar o resultado de forma formatada, tendo previamente escrito nas nossas variáveis
de saída - studioInfo e apartmentInfo.
Para os cálculos dos parâmetros de saída, utilizamos o método java.math.

BigDecimal.setScale(int newScale, RoundingMode roundingMode). Este método
arredonda um número decimal para um número especificado de dígitos após o ponto
decimal e, portanto, também temos controle sobre o tipo de arredondamento -
RoundingMode. Para isso, passamos para o método um inteiro (int) com o qual
indicamos para qual sinal o arredondamento precisa ser e um valor de uma determinada
enumeração de RoundingMode (UP, DOWN, CEILING, FLOOR, HALF_UP,
HALF_DOWN, HALF_EVEN). No nosso caso, arredondaremos o número decimal para
dois dígitos após a vírgula com o tipo de arredondamento HALF_UP.

resta exibir os resultados calculados no console.

Capítulo 5.1. Repetições (loops)

Neste capítulo, aprenderemos sobre as construções para repetir um grupo de comandos,
conhecidos na programação como "loops". Escreveremos vários loops usando a instrução for
em sua forma mais simples. Por fim, resolveremos vários problemas práticos que exigem a
repetição de uma série de ações usando loops.
Vídeo
Assista a um tutorial em vídeo sobre este capítulo: https://youtube.com/watch?v=MMLI-dGB3Ms.
Repetições de bloco de código (for loop)

Na programação, geralmente precisamos executar um bloco de comandos várias vezes. Para
isso, os chamados ciclos. Vejamos um exemplo de loop for que percorre os números de 1 a 10
e os imprime:
Um loop começa com a instrução for e percorre todos os valores de uma determinada variável
em um determinado intervalo, por exemplo, todos os números de 1 a 10 inclusive, e para cada
valor executa uma série de comandos. Na declaração do
loop, um valor inicial e um valor final são definidos. O corpo do loop é colocado entre chaves { }
e é um bloco de um ou mais comandos. A figura abaixo mostra a estrutura de um loop for :
Na maioria dos casos, um loop for percorre de 1 a n (por exemplo, de 1 a 10). O objetivo do loop
é percorrer os números 1, 2, 3, … em sequência, cada um deles realizando alguma ação. n e para
No exemplo acima, a variável i assume valores de 1 a 10, e o valor atual é impresso no corpo do
loop. O loop é repetido 10 vezes e cada uma dessas repetições é chamada de "iteração".
Exemplo: números de 1 a 100

Escrever um programa que imprima os números de 1 a 100. O programa não recebe

entrada e imprime os números de 1 a 100 um após o outro, um por linha.
Diretrizes e dicas
Podemos resolver o problema com um loop for, com o qual passamos a variável i pelos
números de 1 a 100 e os imprimimos no corpo do loop:
Iniciamos o programa com [Shift+F10] e testamos:

Teste sua solução: https://judge.softuni.bg/Contests/Practice/Index/655#0. Você deve
obter 100 pontos (solução completamente correta).
Capítulo 5.1. Repetições (ciclos) 199
Trecho de código para um loop for no IntelliJ IDEA

Durante a programação, temos que escrever loops constantemente, dezenas de vezes todos os dias.
É por isso que a maioria dos ambientes de desenvolvimento (IDEs) possui trechos de código para
escrever loops. Um desses padrões é o padrão de loop for no IntelliJ IDEA. Digite fori no editor de
código Java no IntelliJ IDEA e pressione [Enter].
O IntelliJ IDEA desdobrará um modelo para você e escreverá um loop for completo , basta adicionar
o valor final:
Tente você mesmo dominar a arte de usar o padrão de código de loop for no IntelliJ IDEA.
Exemplo: números até 1000 terminados em 7

Escreva um programa que encontre todos os números no intervalo [1 … 1000] que terminem em 7.
Diretrizes e dicas
Podemos resolver o problema combinando um loop for para percorrer os números de 1 a 1000 e
verificando se cada número termina em 7. Existem outras soluções, é claro, mas vamos resolver o
problema fazendo um loop + verificando:
Exemplo: todas as letras latinas

Para escrever um programa que imprima as letras do alfabeto latino: a, b, ..., Com.
Diretrizes e dicas É útil
saber que os loops for não funcionam apenas com números. Podemos resolver o problema fazendo
um loop for que passa por todas as letras do alfabeto latino sequencialmente:
Exemplo: somando números

Escrever um programa que recebe n inteiros e os soma. • O número de números n é
inserido na primeira linha da entrada . • Um número é inserido nas

próximas n linhas. • Os números são somados e, finalmente, o
resultado é impresso.
Conecte-se Saída Entrada Saída Entrada Saída
4
45
3
2 30 -60 -20 43
-10
10 20
-20 -30
7 11
Conecte-se Saída Entrada Saída
999 0 0
1 999
Diretrizes e dicas
Podemos resolver o problema de somar números da seguinte maneira:
• Lemos o número de entrada n. •
Começamos inicialmente com sum sum = 0.
• Loop de 1 a n. A cada passo do loop, lemos um número num e ele

nós adicionamos à soma soma . •
Finalmente, imprimimos a soma do valor recebido.
Aqui está o código-fonte da solução:

Exemplo: maior número

Escreva um programa que receba n inteiros (n > 0) e encontre o maior deles. Na primeira linha da entrada,
o número de números n é inserido. Em seguida, os próprios números são inseridos, um por linha. Exemplos:
4
45
3
2 100 20 -20 99
-10
100 99
20 -30
7 99
Conecte-se Saída Entrada Saída
2
999 -1 -1
1 999
-2
Diretrizes e dicas Primeiro,
inserimos um único número n (o número de números a serem inseridos). Definimos o máximo atual máximo
para um valor neutro inicial, por exemplo -10000000000000 (ou Integer.MIN_VALUE). Usando um loop for ,
através do qual iteramos n-1 vezes, lemos um número inteiro num. Se o número lido num for maior que o
max atual , atribuímos o valor de num a
a variável máx. Por fim, o maior número deve ser armazenado em max . Imprimimos no console.
Exemplo: menor número

Escreva um programa que receba n inteiros (n > 0) e encontre o menor deles. Primeiro, o número de
números n é inserido, seguido por mais n números, um de cada vez
ordem.
4
45
3
2 99 -30 -20 -20
-10
100 99
20 -30
7 99
Diretrizes e dicas
A tarefa é absolutamente análoga à anterior, apenas começando com um valor inicial neutro diferente.
Exemplo: soma esquerda e direita

*
Escreva um programa que insira 2 dos primeiros n n inteiros e verifica se a soma
números (soma à esquerda) igual à soma dos segundos n números (soma à direita). Se houver empate, "Sim" +
a soma é impressa, caso contrário, "Não" + a diferença é impressa. A diferença é calculada como um número
positivo (em valor absoluto). O formato de saída deve ser como os exemplos abaixo.
2 2
10 Sim, soma = 100 Não, diferença = 1
90 90
60 40 9 50 50
Direções e dicas Primeiro,
inserimos o número n, depois os primeiros n números (a metade esquerda) e os somamos. Continuamos inserindo
mais n números (a metade direita) e descobrimos sua soma também. Calculamos a diferença entre as somas
encontradas por valor absoluto: Math.abs(leftSum - rightSum). Se a diferença for 0, imprimimos "Sim" + o valor,
caso contrário - imprimimos "Não" + a diferença.
Teste no sistema de juízes Teste sua solução:
https://judge.softuni.bg/Contests/Practice/Index/655#6.
Exemplo: quantidade par / ímpar

Escreva um programa que receba n números inteiros e verifique se a soma dos números nas posições pares é igual à soma dos
números nas posições ímpares. Se houver empate imprime "Sim" + a soma, caso contrário imprime "Não" + a diferença. A diferença é
calculada em valor absoluto. O formato de saída deve ser como em
os exemplos abaixo.
4 4
3
10 3
Sim Não 5 Não
50 5
Soma = 70 Diferença = 1 8 Diferença = 2
60 1
1
20 -2
Direções e dicas
Entramos nos números um a um e calculamos as duas somas (dos números em
posições pares e dos números em posições ímpares). Como na tarefa anterior,
calculamos o valor absoluto da diferença e imprimimos o resultado ("Sim" + a soma se
a diferença for 0 ou "Não" + a diferença caso contrário).
+= é um operador de atribuição composto comumente usado, ele adiciona o valor do operando direito ao operando
esquerdo e atribui o resultado final ao operando esquerdo. C += A é equivalente a C = C + A.
Exemplo: soma de vogais

Para escrever um programa que receba texto (string), calcule e imprima a soma dos valores das vogais conforme
a tabela abaixo:
a e eu o em
1 2 345

olá bambu
6 (e+o = 2+4 = 6) 9 (a+o+o = 1+4+4 = 9)
oi cerveja
3 (i = 3) 4 (e+e = 2+2 = 4)
Diretrizes e dicas Lemos o

texto de entrada s, redefinimos a soma para zero e repetimos de 0 a s.length() - 1 (o comprimento
do texto -1). Verificamos se cada letra s.charAt(i) é uma vogal e, consequentemente, adicionamos
seu valor à soma.


Podemos repetir um bloco de código com um loop for:
Podemos ler uma sequência de n números do console:

Exercícios: repetições (ciclos)

Agora que aprendemos sobre loops, é hora de colocar nosso conhecimento em prática e,
como você sabe, isso envolve escrever muito código. Vamos resolver alguns problemas
práticos.
Crie um novo projeto no IntelliJ IDEA

Criamos um novo projeto no IntelliJ IDEA para organizar melhor as soluções das tarefas do
exercício. Para cada tarefa, criaremos uma classe separada. Lançamos o IntelliJ IDEA,
selecione: [Criar novo projeto].
em seguida, no campo esquerdo, selecionamos Java, se não especificamos o PROJECT

SDK: selecionamos o caminho para o diretório Java JDK instalado e pressionamos [Avançar].
Na próxima janela, selecione [Avançar] novamente.
Nomeamos o projeto (Nome do projeto:) Loops e escolhemos um diretório onde salvá-lo

(Localização do projeto:). Em seguida, pressionamos [Concluir].
Na próxima janela, selecione [OK] para criar a localização do Projeto, caso não tenhamos
criado anteriormente.
Então criamos um novo projeto. Se pressionarmos o triângulo na frente de Loops na janela

da esquerda, a própria estrutura do projeto será aberta.
Para criar em nosso projeto um pacote que contenha todas as classes com as
soluções das tarefas do exercício, clicamos com o botão direito em [src], selecionamos
[Novo] -> [Pacote] e nomeamos as tarefas do pacote (com a primeira letra minúscula) .
Para criar uma nova classe para o primeiro exercício, clique com o botão direito nas
tarefas, selecione [New] -> [Java Class] e nomeie a classe Task_01 (com a primeira
letra maiúscula).
Após essas alterações, a estrutura do projeto ficará assim:
A cada exercício subseqüente, criamos uma nova aula, conforme descrito acima
maneira de criar uma classe.
Tarefa: um elemento igual à soma dos outros

Escreva um programa que receba n inteiros e verifique se há um número entre eles que seja igual
à soma de todos os outros. Se houver tal elemento, "Sim" + seu valor é impresso, caso contrário -
"Não" + a diferença entre o maior elemento e a soma dos outros (em valor absoluto).
Conecte-se Saída Comente Conecte-se Saída Comente
7
3
4 3
1 Sim 3+4+1+2 1 Não
1 Soma = 12 + 1 + 1 = 12 1 Diferença = 8
|10 – (1 + 1)| = 8
2 10
12 1
4
3 3
6
1 Não 5 Não Sim
1
1 Diferença = 1 5 Diferença = 1 Soma = 6
2
1 1
3
Diretrizes e dicas
Precisamos calcular a soma de todos os elementos, encontrar o maior deles e verificar a condição de busca.

Tarefa: posições pares/ímpares

Escreva um programa que leia n números e calcule a soma, mínimo e máximo dos números nas posições pares
e ímpares (contagem de 1). Quando não houver elemento mínimo/máximo, imprima "Não".
6
Soma Ímpar=9, OddSum=1,5, Soma Ímpar=1,
2
OddMin = 2, OddMin=1,5, OddMin = 1,
3 2
Máx=5, OddMax=1,5, 1 Máx=1,
5 1,5
EvenSum=8, EvenSum=-2,5, 1 EvenSum=0,
4 -2,5
EvenMin = 1, EvenMin=-2,5, EvenMin = Não,
2
EvenMax = 4 EvenMax=-2,5 EvenMax=Não
1
Soma Ímpar=-4, Soma Ímpar=-5, Soma Ímpar=8,

OddMin=-3, OddMin=-5, 5 OddMin=-3,
3 OddMax=-1, OddMax=-5, 3 Máx=8,
-1 EvenSum=-2, 1 -5 EvenSum=0, EvenSum=9,
-2 -3 EvenMin=-2, EvenMin = Não, -2 EvenMin=-2,
EvenMax=-2 EvenMax=Não 8 11 -3 EvenMax = 11
Diretrizes e dicas
A tarefa combina várias tarefas anteriores: encontrar o mínimo, o máximo e a soma, bem como processar os
elementos das posições pares e ímpares. Lembrar
você é eles.
Neste problema, é melhor trabalhar com números fracionários (não inteiros). A soma, o mínimo e o máximo
também são números fracionários. Devemos usar um valor inicial neutro ao encontrar o mínimo/máximo, por
exemplo 1000000000,0 e -1000000000,0. Se finalmente obtivermos o valor neutro, imprimimos “Não”.
Tarefa: pares correspondentes

*
2 também são n números. O primeiro e o segundo formam um par, o terceiro e o quarto
dados, etc. Cada par tem um valor - a soma dos números que o compõem. Escreva um programa que verifique
se todos os pares têm o mesmo valor. Caso seja igual, imprima "Sim, valor=..." + o valor, caso contrário
imprima a diferença máxima entre dois pares consecutivos no seguinte formato - "Não, maxdiff=..." + a diferença
máxima.
A entrada consiste em um número n seguido por 2*n inteiros, todos um por linha.
3
1 valores = {3, 4}
2 21
valores = {3, 3, 3} mesmos
0 Sim, valor = 3 2 Não, maxdiff=1 diferenças = {1} máx.
valores
3 2 diferença = 1
4 2
-1
2
valores = {10} um valor
-1 valores = {1, -1} 1
mesmos valores
2 Não, maxdiff=2 diferenças = {2} máx. 5 Sim, valor = 10
0 diferença = 2 5
-1
4
1
2 1
-1 3
0 Sim, valor=-1 1 Não, maxdif = 4

0 2
-1 2
Direções e dicas Lemos os
números de entrada em pares. Para cada par, calculamos sua soma. À medida que lemos os pares de entrada,
para cada par, exceto o primeiro, precisamos calcular a diferença com o anterior. Para isso, é necessário
armazenar em uma variável separada a soma do par anterior. Finalmente, encontramos a maior diferença entre
dois pares. Se for 0, imprimimos “Sim” + o valor, caso contrário - “Não” + a diferença.
Exercícios: Aplicações Gráficas e Web

Neste capítulo, fomos apresentados aos loops como uma construção de programação que nos permite repetir
uma ação ou grupo de ações repetidamente. Agora vamos brincar com eles. Para isso, vamos desenhar várias
figuras que consistem em um grande número de elementos gráficos repetidos, mas desta vez não no console,
mas em um ambiente gráfico usando "gráficos de tartaruga". Isso vai ser interessante. E não é nada complicado.
Tente!
Tarefa: Desenhar com Tartaruga - Um aplicativo GUI gráfico

O objetivo do próximo exercício é brincar com uma biblioteca de desenhos conhecida como gráficos de
tartaruga. Construiremos uma aplicação gráfica na qual iremos desenhar várias formas, movendo nosso
"grampo" na tela por operações como "avançar 100 posições", "virar 30 graus à direita", "avançar mais 50
posições". Vamos primeiro nos familiarizar com o conceito de desenho “Turtle Graphics”. Podemos considerar
as seguintes fontes:
• Definição do termo “gráficos de tartaruga”: http://c2.com/

cgi/wiki?TurtleGraphics
• Artigo da Wikipédia sobre “gráficos de tartaruga”:
https://en.wikipedia.org/wiki/Turtle_graphics
• Ferramenta interativa de desenho de tartaruga online: https://blockly-

games.appspot.com/turtle
O aplicativo ficará mais ou menos assim:
Começamos criando um novo projeto Java no IntelliJ IDEA. Em seguida, adicionamos um

novo aplicativo de pacote (como fazer isso é descrito anteriormente neste capítulo).
Baixamos MyTurtle.java e jturtle-0.1.1.jar no link abaixo:
• https://github.com/SoftUni/Programming-Basics-Book-Java BG/
tree/master/assets/chapter-5-1-assets.
MyTurtle.java é uma classe pré-escrita que nos ajudará a nos familiarizar rapidamente com
a biblioteca jturtle-0.1.1.jar que gerencia a tartaruga. Usando o navegador de arquivos, copie
MyTurtle.java no diretório app do projeto criado. Em seguida, precisamos adicionar a
biblioteca externa jturtle 0.1.1.jar ao nosso projeto. Isto se faz do seguinte modo:
• No menu Arquivo, selecione Estrutura do Projeto (CTRL + SHIFT + ALT + S). •

Pressionamos Selecionar Módulos no painel esquerdo.
• Pressione a guia Dependências. •
Pressione '+' ÿ JARs ou diretórios.
Na próxima tela, definimos o caminho para jturtle-0.1.1.jar e pressionamos [OK].
Na próxima tela, marque apenas a caixa de classes e pressione [OK].
Na próxima tela selecionamos [OK] e estamos prontos para abrir o MyTurtle.java.

Métodos básicos da classe Turtle

Estas são as principais ações na classe Turtle com as quais desenhamos:
Valor de
Método e sua descrição
retorno
Tartaruga back(double distance) – move a tartaruga para trás
Tartaruga bk(dupla distância) – funciona como back(dupla distância)
Tartaruga forward(double distance) – move a tartaruga para frente
Tartaruga fd(double distance) – funciona como forward(double distance)
Tartaruga hideTurtle() – esconde a tartaruga
Tartaruga ht() - a ação é a mesma que hideTurtle()
home() – move a tartaruga de volta para sua posição inicial, voltada para o
Tartaruga
norte
Tartaruga left(dois graus) – gira a tartaruga para a esquerda (em graus)
Tartaruga lt(graus duplos) – age como left(graus duplos)
penDown() - Anexa uma caneta à tartaruga que deixa uma linha quando a
Tartaruga
tartaruga se move
Tartaruga pd() – a ação é a mesma que penDown()
Tartaruga penUp() – separa a caneta da tartaruga

Valor de
retorno Método e sua descrição
Tartaruga penWidth(int newWidth) – define a largura da caneta
Tartaruga
direita (graus duplos) – gira a tartaruga para a direita (em graus)
Tartaruga rt(graus duplos) – funciona como right(graus duplos)
Tartaruga setColor(Color color) – define a cor da caneta
Tartaruga setLineWidth(double lineWidth) – define a largura da linha
Tartaruga setPenColor(Color color) - define a cor da caneta para desenho
setPos(double x, double y) – move a tartaruga para uma nova posição

Tartaruga
com coordenadas (x, y)
Tartaruga showTurtle() – mostra a tartaruga
Tartaruga st() - funciona como showTurtle()
Tartaruga speed(double newSpeed) - define a velocidade da tartaruga
Para criar um método que desenha um triângulo, em MyTurtle.java encontramos o método

drawTriangle() vazio e escrevemos o seguinte código:
Este código move e gira a tartaruga, que está inicialmente no centro da tela (no meio da
forma), e desenha um triângulo equilátero. você pode editá-lo
e brincar com ele.
Iniciamos o aplicativo com [Shift + F10]. Testamos para ver se funciona (pressione o botão [Draw] várias
vezes):
Agora podemos modificar e complicar o código da tartaruga adicionando o seguinte código ao nosso
método drawTriangle():
Iniciamos o aplicativo novamente com [Shift + F10]. Estamos testando se o novo funciona
programa tartaruga:
Agora nossa tartaruga desenha figuras mais complexas. Vamos escrever o código
para os outros dois botões também: o objetivo do botão [Reset] é deletar o gráfico
desenhado e posicionar a tartaruga em sua posição inicial, completamos o método
resetTurtle() com o seguinte código :
O objetivo do botão [Hide / Show Turtle] é mostrar ou ocultar a tartaruga, adicionamos

o método showTurtle() com o seguinte código::
Iniciamos o aplicativo novamente com [Shift + F10] e testamos se os dois botões

funcionam corretamente.
*
Tarefa: desenhando um hexágono com a tartaruga
Adicione um botão [Hexágono] que desenha um hexágono regular:
Dica: Repita
o seguinte 6 vezes em um loop:
• Rotação de 60 graus.
• Movimento para frente 100.
Adicionar um novo botão para desenhar uma forma

Para adicionar um novo botão para desenhar uma nova forma, podemos seguir a lógica em
MyTurtle.java para o botão [Draw] e criar um novo botão para desenhar um hexágono.
Primeiro, adicionamos a nova forma ao enum Shape:
Criamos um novo botão e adicionamos um ActionListener a ele, que atribui a forma o novo
valor de enum :
Em seguida, adicionamos o novo botão à bList:
Criamos um novo método drawHex() através do qual a tartaruga desenha um hexágono.

Obrigatório no final do método shape = "", esta linha impede que nosso método seja
executado várias vezes!
Em Thread t , adicionamos case "Hexagon" para chamar o método drawHex():
*
Tarefa: desenhando uma estrela com a tartaruga
Adicione um botão [Star] que desenha uma estrela de 5 pontas como na figura
abaixo:
Dica:
Altere a cor: turtle.setPenColor(Color.green);.
Em um loop, repita o seguinte 5 vezes:
• Movimento para a frente
200. • Rotação 144 graus.
Tarefa: *
desenhando uma espiral com a tartaruga
Adicionar um botão [Spiral] que desenha uma espiral com 20 vértices conforme a figura
abaixo:
Dica:
Desenhe em um loop movendo para frente e girando. A cada passo, aumente

gradualmente a duração do movimento para frente e gire 60 graus.
*
Tarefa: desenhando o sol com a tartaruga
Adicione um botão [Sun] que desenha um sol com 36 vértices como na figura abaixo:
*
Tarefa: desenhando um triângulo espiral com a tartaruga
Adicione um botão [Triângulo] que desenha três triângulos com 22 vértices cada como
na figura abaixo:
Dica:
Desenhe em um loop movendo para frente e girando. A cada passo, aumente o
comprimento do movimento para frente em 10 e gire 120 graus. Repetir 3
vezes para os três triângulos.
Se você tiver problemas com o projeto de amostra acima, pergunte no fórum SoftUni:
https://softuni.bg/forum.
Capítulo 5.2. Repetições (ciclos) – tarefas

de exame
No capítulo anterior, aprendemos como executar um bloco de comandos mais de uma vez. Assim,
apresentamos o loop for e examinamos algumas de suas aplicações básicas. O objetivo deste
capítulo é consolidar nossos conhecimentos resolvendo vários problemas mais complexos com
ciclos dados em vestibulares. Para alguns deles, mostraremos exemplos de soluções detalhadas
e, para outros, deixaremos apenas orientações. Antes de começarmos a trabalhar, é bom relembrar
a construção do loop for:
Os loops for consistem em:

• Bloco de inicialização, executado apenas uma vez no início antes que a condição de repetição
seja verificada pela primeira vez. Neste caso, a variável contadora (int i) é declarada e seu
valor inicial é definido
• Repita a condição (i <= 10) executada uma vez antes de cada i-ésimo
ração do ciclo.
• Atualização do contador (i++) – este código é executado após cada iteração.

• Corpo do loop - contém um bloco arbitrário de código-fonte.
Tarefas de exame
Vamos resolver alguns problemas com ciclos de exames no SoftUni.
Tarefa: histograma
Dados n inteiros no intervalo [1 … 1000]. Destes, algumas porcentagens p1 estão abaixo de 200,
as porcentagens p2 vão de 200 a 399, as porcentagens p3 vão de 400 a 599, as porcentagens p4
vão de 600 a 799 e as porcentagens p5 restantes vão de 800 e acima. Escrever um programa que
calcula e imprime as porcentagens p1, p2, p3, p4 e p5. Exemplo: temos
n = 20 e números: 53, 7, 56, 180, 450, 920, 12, 7, 150, 250, 680, 2, 600, 200, 800, 799, 199, 46,
128, 65. Obtemos a seguinte distribuição e visualização:
Número
Grupo Números Percentagem
números
53, 7, 56, 180, 12, 7, 150, 2, *

< 200 12 p1 = 12/20 100 = 60,00%
199, 46, 128, 65
*
200… 399 250, 200 2 p2 = 2/20 100 = 10,00%
*
400… 599 450 1 p3 = 1/20 100 = 5,00%
*
600… 799 680, 600, 799 3 p4 = 3/20 100 = 15,00%
*
ÿ 800 920, 800 2 p5 = 2/20 100 = 10,00%
Dados de entrada
A primeira linha da entrada contém o inteiro n (1 ÿ n ÿ 1000), que representa o número de linhas de
números que serão alimentados para nós. Nas próximas n linhas há um inteiro no intervalo [1 … 1000] -
os números nos quais o histograma deve ser calculado.
Dados de saída
Imprima no console um histograma de 5 linhas, cada uma contendo um número entre 0% e 100%,
formatado com duas casas decimais (por exemplo, 25,00%, 66,67%, 57,14%).
33,33% 14 57,14% 14,29%

9 33,33% 53 14,29% 7 28,57%
11,11% 7,14% 800 14,29%
367 11,11% 7 14,29% 801 14,29%
99 11,11% 56 7,14% 250 28,57%
200 180 199
799 450 399
999 333 555 920 12 599 799
111 7
9 150
250
680
2
600 200
Capítulo 5.2. Repetições (ciclos) - tarefas de exame 227
66,67% 4 75,00%
31 0,00% 53 0,00%
2 0,00% 7 0,00%
999 0,00% 56 0,00%
33,33% 999 25,00%
Diretrizes e dicas
Podemos dividir mentalmente o programa que resolve esse problema em três
peças:
• Ler os dados de entrada – no presente problema, isso envolve a leitura do número n

seguido por n números inteiros, cada um em uma linha separada.
• Processamento de dados de entrada - neste caso, isso significa alocação de número

lats por grupos e cálculo da divisão percentual por grupos.
• Resultado final de saída - imprima o histograma no console em

o formato especificado.
Antes de prosseguirmos, faremos uma pequena digressão da presente

tópico, ou seja, mencionaremos brevemente que, na programação, toda variável é de algum tipo de dados. Nesta
tarefa, usaremos os tipos de número int para números inteiros e double para números fracionários.
Passaremos agora à implementação de cada um dos pontos acima.
Lendo os dados de entrada Antes de
passarmos à leitura dos dados de entrada propriamente ditos, devemos declarar as variáveis nas quais iremos
armazená-los. Isso significa escolher um tipo de dados apropriado e nomes apropriados para eles.
Na variável n armazenaremos o número de números que leremos no console.

Escolhemos o tipo int porque a condição menciona que n é um inteiro no intervalo de 1
a 1000. Para as variáveis nas quais armazenaremos as porcentagens, escolhemos o
tipo double porque não se espera que sejam sempre inteiros. Adicionalmente,
declaramos as variáveis cntP1, cntP2 , etc., nas quais armazenaremos a quantidade de
números do grupo correspondente, escolhendo novamente o tipo int para eles.
Depois de declarar as variáveis necessárias, podemos ler o número n no console:
Processamento de dados de entrada

Para ler e atribuir cada número ao seu respectivo grupo, usaremos um loop for de 0 a
n (o número de números). Cada iteração do loop irá ler e alocar um único número
(currentNumber) para seu respectivo grupo. Para determinar se um número pertence a
um determinado grupo, verificamos seu intervalo correspondente. Se for esse o caso -
aumentamos o número de números neste grupo (cntP1, cntP2 , etc.) em 1.
Depois de determinar quantos números há em cada grupo, podemos passar para o

cálculo de porcentagens, que também é o objetivo principal da tarefa. Para isso usaremos
a seguinte fórmula:
(porcentagem do grupo) = (número de números no grupo) * 100 / (número de todos os números)
Esta fórmula no código do programa se parece com isto:
Se dividirmos por 100 (número, tipo int) ao invés de 100.0 (número, tipo double), será realizada a
chamada divisão inteira e somente a parte inteira da divisão será armazenada na variável, que não é o
resultado nós queremos. Por exemplo: 5/2 = 2 e 5/2,0 = 2,5. Com isso em mente, a fórmula para a
primeira variável
Isso parecerá assim:
Para deixar ainda mais claro o que está acontecendo, vejamos o seguinte exemplo:
Conecte-se Saída
66,67%
3
0,00%
0,00%
1
0,00%
2 999
33,33%
No caso n = 3. Para o ciclo temos:
• i = 0 - lemos o número 1, que é menor que 200 e cai na primeira

group (p1), incrementamos o contador de grupo (cntP1) em 1.
• i = 1 – lemos o número 2, que novamente cai no primeiro grupo (p1) e

aumentamos seu contador (cntP1) em 1 novamente.
• i = 2 – lemos o número 999, que cai no último grupo (p5) por ser maior que 800, e aumentamos o
contador do grupo (cntP5) em 1.
Depois de ler os números no grupo p1 temos 2 números e no p5 temos 1 número. Nos outros grupos
não temos números. Aplicando a fórmula acima, calculamos as porcentagens de cada grupo. Se na
fórmula multiplicarmos por 100, em vez de 100,0, obteremos 66% para o grupo p1 e 33% para o grupo
p5 (não haverá parte fracionária).
Saída do resultado final Resta apenas
imprimir os resultados obtidos. A condição diz que as porcentagens devem ter precisão de duas casas
decimais. Conseguiremos isso definindo o formato “%.2f%%” no método String.format(…) :

Tarefa: Lírio Inteligente

Lily agora tem N anos. Para cada aniversário ela ganha um presente. Para aniversários
ímpares (1, 3, 5, …, n) ele ganha brinquedos, e para cada par (2, 4, 6, …, n) ele ganha
dinheiro. Para o segundo aniversário, ele recebe BGN 10,00, e o valor aumenta em BGN 10,00
para cada aniversário par subsequente (2 -> 10, 4 -> 20, 6 -> 30, etc.). Ao longo dos anos, Lily
economizou o dinheiro secretamente. O irmão de Lily, nos anos em que ela recebe dinheiro,
recebe deles BGN 1,00. Lily vendeu os brinquedos recebidos ao longo dos anos por P leva
cada um e somou o valor ao dinheiro economizado. Com o dinheiro, ela queria comprar uma
máquina de lavar para BGN X. Escreva um programa para calcular quanto dinheiro ela juntou
e se ela tem o suficiente para comprar uma máquina de lavar.
Dados de entrada
3 números são lidos no console, cada um em uma linha separada:
• Idade de Lily - um número inteiro no intervalo [1 … 77]. • O preço
da máquina de lavar – um número no intervalo [1,00 … 10.000,00]. • Preço
unitário de um brinquedo – um número inteiro no intervalo [0 … 40].
Dados de saída
• Se o dinheiro de Lily for suficiente: o “Sim!
{N}” – onde N é o dinheiro restante após a compra.
• Se o dinheiro não for suficiente:
o “Não! {M}” – onde M é a quantidade que falta.
• Os números N e M devem ser formatados para a segunda casa decimal
apontar.

Conecte-se Saída Comentários
10 Sim! 5,00 Primeiro aniversário ganha um brinquedo; 2º -> BGN 10;

170,00 6 3º -> brinquedo; 4º -> 10 + 10 = BGN 20; 5º -> brinquedo; 6º -> 20 + 10
= BGN 30; 7º -> brinquedo; 8º -> 30 + 10 = 40 BGN; 9º -> brinquedo; 10º
-> 40 + 10 = 50 BGN. Ela economizou -> 10 + 20 + 30 + 40 +
50 = 150 BGN. Ela vendeu 5 brinquedos por 6 BGN cada =
30 BGN. O irmão dela pegou 5 vezes 1 BGN
cada = BGN 5 esquerda -> 150 + 30 – 5 = BGN 175. 175 >= 170 (o
preço da máquina de lavar) ela conseguiu comprar e tem 175-170
= BGN 5 restantes.
21 Não! 997,98 Ela economizou BGN 550. Ela vendeu 11 brinquedos a BGN 3 cada = 33
1570,98 3 BGN. O irmão dela pegou 1 BGN por 10 anos = BGN 10.
Restantes 550 + 33 – 10 = BGN 573. 573 <
1570,98 – ela não conseguiu comprar uma máquina de lavar.
1570,98–573 = BGN 997,98 não é suficiente para ela.
Diretrizes e dicas
A solução desta tarefa, como a anterior, também pode ser dividida mentalmente em três partes - ler os dados
de entrada, processá-los e exibir o resultado.
Novamente, começamos escolhendo os tipos de dados e nomes de variáveis apropriados. A idade de Lily
(age) e o preço unitário do brinquedo (presentPrice) são considerados números inteiros. Então vamos usar
o tipo int. Para o preço da máquina de lavar (priceOfWashingMachine) , sabemos que é um número
fracionário e escolhemos o dobro. No código acima, declaramos e inicializamos (atribuímos um valor) às
variáveis.
Para resolver o problema, precisaremos de várias variáveis auxiliares - para o número de brinquedos
(numberOfToys), para o dinheiro economizado (savedMoney) e para o dinheiro, semi-
dinheiro em cada aniversário (moneyForBirthday). Atribuindo a moneyForBirthday

um valor inicial de 10, já que é condicional que a primeira quantia que Lily receba seja
BGN 10.
Com um loop for , percorremos cada um dos aniversários de Lily. Quando o contador
em nosso loop (que corresponde aos anos de Lily) é um número par, isso significa que
Lily recebeu dinheiro e adicionamos esse dinheiro às suas economias totais de acordo.
Ao mesmo tempo, tiramos 1 BGN cada - o dinheiro que seu irmão leva. Em seguida,
incrementamos o valor da variável moneyForBirthday, ou seja , aumentamos em 10 o
valor que ela receberá em seu próximo aniversário. Por outro lado, quando o contador
(anos de Lily) é um número ímpar, incrementamos o número de brinquedos. Verificamos
a paridade dividindo com resto (%) por 2 – quando o resto é 0, o número é par, e com
resto 1, é ímpar.
Adicionamos o dinheiro dos brinquedos vendidos às economias de Lily:
Por fim, resta imprimir os resultados obtidos, levando em consideração a formatação

especificada na condição, ou seja, o valor deve ser arredondado para duas casas
decimais:
Neste caso, optamos por usar o operador condicional (?:) (também chamado de
operador ternário) porque o registro é mais curto. Sua sintaxe é a seguinte: operando1 ?
operando2 : operando3. O primeiro operando deve ser do tipo booleano (ou seja,
retornar verdadeiro/falso). Se o operando1 retornar verdadeiro, o operando2 será

executado , e se retornar falso , o operando3 será executado. No nosso caso,
verificamos se o dinheiro arrecadado por Lily é suficiente para uma máquina de lavar.
Se forem maiores ou iguais ao preço da máquina de lavar, o cheque saveMoney >=
priceOfWashingMachine retornará verdadeiro e imprimirá “Sim! ..." e se forem
menores - o resultado será falso e "Não! …”. Claro, em vez do operador ternário, também podemo
Capítulo 5.2. Repetições (ciclos) – tarefas de exame 233
para a inspeção. Mais informações sobre o operador ternário: https://www.programiz.com/java Programming/

ternary-operator.

Tarefa: voltar ao passado

Ivancho tem 18 anos e recebe uma herança que consiste em X quantia em dinheiro e uma máquina do
tempo. Ele decide voltar ao ano de 1800, mas não sabe se o dinheiro será suficiente para viver sem
trabalhar. Escreva um programa que calcule se Ivancho terá dinheiro suficiente para não ter que trabalhar
até um determinado ano, inclusive. Supondo que para cada ano par (1800, 1802 etc.), ele gastaria $ 12.000.
Para cada número ímpar (1801,1803, etc.) ele gastará 12 * [os anos que alcançou no ano dado]. 000 + 50
Dados de entrada
• Dinheiro herdado – um número real no intervalo [1,00 … 1 000 000,00]. • O ano de

vida até (inclusive) – um número inteiro no intervalo
[1801 … 1900].
Dados de saída
Para imprimir no console 1 linha. O valor deve ser formatado para dois caracteres
depois da vírgula:
• Se o dinheiro for suficiente: “Sim! Ele viverá uma vida despreocupada e terá {N} dólares
sobrando.” – onde N é o dinheiro que vai sobrar.
• Se o dinheiro NÃO for suficiente: “Ele vai precisar de {M} dólares para sobreviver.” – onde M é
a quantidade que NÃO atinge.
50000 Sim! Ele viverá uma vida 1800 ÿ par ÿ

1802 despreocupada e Gaste $ 12.000 ÿ Esquerda
terá 13.050,00 dólares sobrando. 50.000 - 12.000 = 38.000
1801 ÿ ímpar
ÿ Gaste 12.000 + 19*50 = 12.950 ÿ
Restante 38.000 - 12.950 = 25.050 1.802 ÿ
par
ÿ Gaste 12.000 ÿ
25.050 restantes - 12.000 = 13.050
100000,15 Ele precisará de 12.399,85 1800 ÿ mesmo

1808 dólares para sobreviver. ÿ 100000 restantes.15 - 12000 =
88000,15
1801 ÿ ímpar ÿ
Restante 88000,15 - 12950 = 75050,15
...
1808 ÿ par ÿ -399,85 - 12000 =
-12399,85
12399,85 insuficiente
Diretrizes e dicas
O método para resolver esta tarefa não é diferente dos anteriores, então começamos declarando e
inicializando as variáveis necessárias:
Na condição, diz-se que os anos de Ivancho são 18, por isso, ao declarar a variável anos , atribuímos a ela
um valor inicial de 18. As outras variáveis
lido no console.
Usando um loop for , percorreremos todos os anos. Partimos de 1800 - ano em que Ivancho retorna, e
chegamos ao ano que ele deve viver. No loop, verificamos se o ano atual é par ou ímpar. Verificamos a
paridade dividindo o restante (%) por 2. Se o ano for par, subtraímos 12.000 do patrimônio , e se for ímpar,
subtraímos 12.000 + 50 * (anos de Ivancho) do patrimônio .
Por fim, resta imprimir os resultados, para os quais verificamos se seu patrimônio era
suficiente para viver sem trabalhar ou não. Se o patrimônio for um número positivo,
imprimimos: “Sim! Ele viverá uma vida despreocupada e terá {N} dólares restantes.", e
se for um número negativo: "Ele precisará de {M} dólares para sobreviver.". Lembre-se de
formatar a soma com duas casas decimais.
Dica: Considere usar a função Math.abs(…) ao imprimir o

a saída quando a herança é insuficiente.

Tarefa: Hospital
Por um determinado período de tempo, todos os dias os pacientes chegam ao hospital para
exames. Inicialmente conta com 7 médicos. Cada médico só pode examinar
um paciente por dia, mas às vezes faltam médicos, então os demais pacientes são
encaminhados para outros hospitais. A cada três dias, o hospital faz cálculos e se o número
de pacientes não examinados for maior que o número de examinados, outro médico é
indicado. Como a consulta ocorre antes da admissão dos pacientes, o dia começa.
Escreva um programa que calcule para um determinado período o número de visualizações e

pacientes não examinados.
Dados de entrada
A entrada é lida no console e contém:
• Na primeira linha - o período para o qual você precisa fazer cálculos. Todo
• Nas próximas linhas (igual ao número de dias) – o número de pacientes que chegam para
exame no dia atual. Um número inteiro no intervalo [0 … 10.000].
Dados de saída
Para imprimir 2 linhas no console:
• Na primeira linha: “Pacientes atendidos: {número de pacientes examinados}.”
• Na segunda linha: “Pacientes não tratados: {número de pacientes não tratados}.”

Entrada Saída Explicações
4 Pacientes tratados: 23. 1 dia: 7 revisados e 0 não revisados

7 Pacientes não tratados: 21. o paciente para o dia 2
27 dia: 7 pacientes examinados e 20 não examinados para
o dia 3 dia: Até agora
91 os pacientes examinados são um total de 14 e
os não examinados – 20 –> Um novo médico é nomeado –
> 8 examinados e 1 não examinado paciente no
dia 4 dia: 1 paciente examinado e 0 não examinado no
dia
Total: 23 examinados e 21 não examinados
pacientes.
Pacientes tratados: 40. 3 Pacientes tratados: 21.

6 Pacientes não tratados: 87. 7 Pacientes não tratados: 0.
25 7
25 7
25
25
25 2
Diretrizes e dicas
Novamente, começamos declarando e inicializando as variáveis necessárias:
O período para o qual precisamos fazer os cálculos, lemos no console e salvamos na variável period. Também
precisaremos de algumas variáveis auxiliares: o número de pacientes tratados (treatedPatients), o número de
pacientes não tratados (untreatedPatients) e o número de médicos (countOfDoctors), que inicialmente é 7.
Com a ajuda de um loop for, percorremos todos os dias do período (período) especificado.
Para cada dia, lemos no console o número de pacientes (currentPatients). O aumento de
médicos por condição pode acontecer a cada três dias, MAS somente se o número de
pacientes não examinados for maior que o número de examinados. Para isso, verificamos
se o dia é o terceiro - usando o operador aritmético de divisão pelo resto (%): dia % 3 == 0.
Por exemplo:
• Se o dia for o terceiro, o restante da divisão por 3 será 0 (3 % 3 = 0) e
verificando o dia % 3 == 0 retornará verdadeiro.
• Se o dia for o segundo, o restante da divisão por 3 será 2 (2 % 3 = 2) e
check retornará falso.
• Se o dia for o quarto, o restante da divisão será 1 (4 % 3 = 1) e a verificação retornará
false novamente.
Se a verificação dia % 3 == 0 retornar verdadeiro, ele também verificará se o número de
pacientes não tratados é maior que o número de pacientes tratados: pacientes não
tratados > pacientes tratados. Se o resultado for verdadeiro novamente, o countOfDoctors
será incrementado .
Em seguida, verificamos se o número de pacientes do dia (currentPatients) é maior que o
número de médicos (countOfDoctors). Se o número de pacientes for superior a
grande:
• Incrementamos o valor da variável treatmentPatients pelo número de

os médicos (countOfDoctors).
• Aumentamos o valor da variável untreatedPatients com o número de pacientes
restantes, que calculamos subtraindo o número de médicos de todos os pacientes
(currentPatients - countOfDoctors).
Se o número de pacientes não for maior, apenas incrementamos a variável tratadosPacientes

pelo número de pacientes do dia (currentPatients).
Por fim, só precisamos imprimir o número de curados e o número de pacientes não curados.

Problema: divisão sem resto

Dados n inteiros no intervalo [1 … 1000]. Destes, algumas porcentagens p1 são divisíveis por
2 sem deixar resto, uma porcentagem p2 são divisíveis por 3 sem deixar resto, uma
porcentagem p3 são divisíveis por 4 sem deixar resto. Escreva um programa que calcule e
imprima as porcentagens p1, p2 e p3 . Exemplo: temos n = 10 números: 680, 2, 600, 200,
800, 799, 199, 46, 128, 65. Obtemos a seguinte distribuição e visualização:
divisão sem Números Número Percentagem

restante de:
2 680, 2, 600, 200, 800, 46, 128 7 p1 = (7/10) * 100 =

70,00%
3 600 1 p2 = (1/10) * 100 =

10,00%
4 680, 600, 200, 800, 128 5 p3 = (5/10) * 100 =

50,00%
Dados de entrada
A primeira linha da entrada contém o inteiro n (1 ÿ n ÿ 1000) - número de números. Nas
próximas n linhas há um inteiro no intervalo [1 … 1000] - os números a serem verificados por
quantos são divisíveis.
Dados de saída
Imprima no console 3 linhas, cada uma contendo uma porcentagem entre 0% e 100%, com
duas casas decimais, por exemplo, 25,00%, 66,67%, 57,14%.
• Na primeira linha – a porcentagem de números que são divisíveis por 2.

• Na segunda linha – a porcentagem de números que são divisíveis por
3. • Na terceira linha – a porcentagem de números que são divisíveis por 4.

10 70,00% 3 33,33% 100,00%

680 10,00% 3 100,00% 1 12 100,00%
2 50,00% 6 0,00% 100,00%
600 9
200
800
799
199
46
128
65
Diretrizes e dicas
Para esta e a próxima tarefa, você mesmo precisará escrever o código do programa, seguindo as instruções
fornecidas.
O programa que resolve o problema atual é análogo ao da tarefa Histograma que discutimos acima.
Portanto, podemos começar com a declaração das variáveis que precisamos: Os nomes das variáveis de
exemplo podem ser: n - número de números (que precisamos ler no console) e divisibleBy2, divisibleBy3,
divisibleBy4 - variáveis auxiliares mantendo o número de números de o grupo correspondente.
Para ler e atribuir cada número ao seu respectivo grupo, precisaremos executar um loop for de 0 a n ( o
número de números). Cada iteração do loop deve ler e alocar um único número. A diferença aqui é que um
número pode cair em vários grupos ao mesmo tempo, então precisamos fazer três verificações if separadas
para cada número - se é divisível por 2, 3 e 4 (a construção if-else neste caso não funcionam para nós ,
pois após encontrar uma correspondência, a verificação posterior das condições é interrompida) e para
aumentar o valor da variável que mantém o número de números no grupo correspondente.
Finalmente, você precisa imprimir os resultados obtidos seguindo o formato especificado na condição.

Tarefa: logística
Você é responsável pela logística de várias cargas. Dependendo do peso de cada carga, é necessário um
veículo diferente e custa um preço diferente por tonelada:
• Até 3 toneladas - microônibus (200 BGN por tonelada).
• Acima de 3 e até 11 toneladas - caminhão (BGN 175 por tonelada). •
Acima de 11 toneladas - trem (BGN 120 por tonelada).
Sua tarefa é calcular o custo médio por tonelada de carga transportada, bem como a porcentagem da
carga transportada por cada veículo.
Dados de entrada
Uma série de números são lidos no console, cada um em uma linha separada:
• Primeira linha: número de cargas a serem transportadas – um inteiro no intervalo [1 … 1000]. • Em cada
linha subseqüente, a tonelagem da próxima carga é inserida - um número inteiro no intervalo [1 … 1000].
Dados de saída
Para imprimir no console 4 linhas da seguinte forma:
• Linha #1 – preço médio por tonelada de carga transportada (arredondado para a segunda casa decimal).
• Linha #2 – a porcentagem de carga transportada por van (entre 0,00% e 100,00%, arredondado para a
segunda casa decimal).
• Linha #3 – a porcentagem de carga transportada por caminhão (entre 0,00% e 100,00%). • Linha #4 –
percentual de carga transportada por trem (entre 0,00% e 100,00%).
4 143,80 Duas das cargas 1 + 3, num total de 4 toneladas, são transportadas por van.
1 16,00% Uma das cargas é transportada por caminhão: 5 toneladas.
5 20,00% Uma das cargas é transportada por trem: 16 toneladas.
16 64,00%
A soma de todas as cargas é: 1 + 5 + 16 + 3 = 25 toneladas.
3
Porcentagem de carga de van: 4/25*100 = 16,00%
Porcentagem de carga de caminhão: 5/25*100 =
20,00% Porcentagem de carga de trem: 16/25*100 =
64,00% Preço médio por tonelada de carga
*
transportada: (4 *175
200++16
5 * 120) / 25 = 143,80
149,38 120,35
52 7,50% 4 53 0,00%
10 42,50% 0,63%
20 50,00% 7 56 99,37%
1 999
7
Diretrizes e dicas
Primeiro vamos ler o peso de cada carga e somar quantas toneladas são transportadas por van,
caminhão e trem respectivamente e calcular o total de toneladas de carga transportada. Calcularemos
os preços para cada tipo de transporte de acordo com as toneladas transportadas e o preço total. Por
fim, calcularemos e imprimiremos o custo médio total por tonelada e qual a porcentagem da carga
transportada por cada meio de transporte.
Declaramos as variáveis necessárias, por exemplo: countOfLoads – o número de cargas a transportar

(lemos no console), sumOfTons – a soma da tonelagem de todas as cargas, microbusTons,
truckTons, trainTons – variáveis mantendo a soma da tonelagem de cargas transportadas por
microônibus respectivamente, caminhão e trem. Vamos precisar de um loop for de 0 a countOfLoads-1
para percorrer todas as cargas. Para cada carga, lemos seu peso (em toneladas) no console e
armazenamos em uma variável, por exemplo, toneladas. Adicionamos o peso da carga atual (toneladas)
à soma da tonelagem de todas as cargas (sumOfTons ). Depois de ler o peso da carga atual,
precisamos determinar qual veículo será usado para isso (microônibus, caminhão ou trem). Para isso,
precisaremos de verificações if-else :
• Se o valor da variável toneladas for menor que 3, aumentamos o valor da variável microbusTons
pelo valor de toneladas: microbusTons += toneladas;
• Caso contrário, se o valor de toneladas for superior a 11, incrementamos truckTons por toneladas.
• Se toneladas for maior que 11, aumentamos trainTons em toneladas.
Antes de imprimir a saída, precisamos calcular a porcentagem de toneladas transportadas por cada
veículo e o preço médio por tonelada. Para o preço médio da tonelada, declararemos outra variável
auxiliar totalPrice, na qual somaremos o preço total de todas as mercadorias transportadas (de van,
caminhão e trem). Obteremos o preço médio dividindo totalPrice por sumOfTons. Resta você calcular
o percentual de toneladas transportadas por cada veículo e imprimir os resultados, seguindo o formato
na condição.

Capítulo 6.1. Loops aninhados

Neste capítulo, veremos loops aninhados e como usar loops for para desenhar
várias formas de console, que consistem em símbolos e caracteres organizados em
linhas e colunas do console. Usaremos loops simples e aninhados (loops um dentro
do outro), cálculos e verificações para imprimir figuras simples e não tão simples de
dimensões especificadas no console.
Vídeo
Assista a um tutorial em vídeo sobre este capítulo: https://youtube.com/watch?v=96SoFtFTPBc.
Exemplo: um retângulo de 10 x 10 estrelas
Para desenhar no console um retângulo de 10 x 10 estrelas.
Conecte-se Saída
**********
**********
**********
**********
**********
(não há) **********
**********
**********
**********
**********
Diretrizes e dicas
Para realizar a tarefa, vamos recorrer a um pequeno truque, vamos usar um método. No
Capítulo 10, entraremos em detalhes sobre o que são métodos e como eles são usados.
O método nos permitirá executar o mesmo código mais de uma vez e em mais de um
lugar em um determinado programa. Nesta fase não revelaremos mais do que o conceito
dos métodos.
Como funciona o exemplo? Uma variável de controle do loop i = 0 é inicializada e

incrementada a cada iteração até que seja menor que 10 (a verificação é realizada após
cada execução do corpo do loop e após a iteração). Portanto, o código no corpo do loop
é executado exatamente 10 vezes. O código no corpo do loop será chamado para cada
linha do retângulo. O método usará a classe StringBuffer, que cada vez que o loop for
(o do método) for loopado, ele "colará" um asterisco, criando assim uma linha de 10
asteriscos. Após o término da execução do loop, a string será retornada ao loop principal
e a linha resultante será exibida. Isso será repetido para todas as 10 iterações,
assim, em cada volta do loop, obteremos uma linha inteira.

Exemplo: um retângulo de N x N estrelas
Escreva um programa cuja entrada seja um inteiro positivo n e imprima no console um

retângulo de N x N estrelas.

****
***
** ****
2 3 *** 4
** ****
***
****
Diretrizes e dicas
Para resolver esta tarefa, usaremos a classe Scanner, que nos permitirá capturar o
tamanho da forma que está sendo passada.
Capítulo 6.1. Loops aninhados 245

Loops aninhados
Loops aninhados são uma construção onde outro loop (interno) é executado dentro
do corpo de um loop (externo). Para cada rotação do loop externo, o loop interno é
totalmente girado. Isso acontece da seguinte forma:
• Ao iniciar a execução de loops aninhados, o loop externo é iniciado primeiro: sua
variável de controle é inicializada e, após a verificação do fim do loop, o código em
seu corpo é executado.
• O loop interno é então executado. Sua variável de controle é inicializada com seu
valor inicial, uma verificação de fim de loop é feita e o código em seu corpo é
executado.
• Ao atingir o valor definido para o fim do ciclo interno, prog
a esteira é retornada um passo acima e a execução iniciada no ciclo anterior
(externo) é continuada. A variável de controle para o loop externo é alterada em
uma etapa, a condição de término é verificada e uma nova execução do loop
aninhado (interno) é iniciada.
• Isso é repetido até que a variável do loop externo atinja a condição de fim do loop.
Aqui está um exemplo para ilustrar loops aninhados. O objetivo é reimprimir um

retângulo de n estrelas, repetindo de 1 a n para cada linha e repetindo de 1 a *n para
cada coluna:
Vejamos o exemplo acima. Após a inicialização do loop externo (externo), seu corpo, que contém
o segundo loop (aninhado ou ainda interno), começa a ser executado. Ele gera numberOfstars
por número de estrelas em uma linha. Após o término da execução do loop interno, o controle do
programa é retornado para a primeira iteração do externo, e o externo continuará. Uma linha
(System.out.println()) foi adicionada ao corpo do loop externo , que se encarregará de passar
para a próxima linha no final da execução do loop interno. Sem esse código, todos os asteriscos
serão exibidos em uma linha. Se usarmos println () em vez de print() no loop interno, todos os
asteriscos serão exibidos em uma linha separada. Você pode tentar e ver por si mesmo. Isso é
seguido pelo incremento da variável esquerda (incrementando, em nosso caso, por 1) do loop
externo, e todo o loop interno será executado novamente. O loop interno será executado tantas
vezes quanto o corpo do loop externo for executado, neste caso, numberOfstars vezes.
Exemplo: um quadrado de estrelas

Para desenhar no console um quadrado de N x N estrelas:

****
***
** ****
***
2 ** 3 4 ****
***
****
Diretrizes e dicas
A tarefa é semelhante à anterior. No entanto, aqui é necessário considerar como deixar um
espaço após os asteriscos para que não haja espaços extras no início ou no final.

Exemplo: um triângulo de dólares

Escrever um programa que insira um número n e imprima um triângulo de dólares.
$$
3 $$ 4
$$$
$$$$
$$$$$
Diretrizes e dicas
A tarefa é semelhante à de desenhar um retângulo e um quadrado. Novamente, usaremos
loops aninhados, mas há um problema aqui. A diferença é que o número de colunas que
precisamos imprimir depende da linha em que estamos, não do número de entrada n. A
partir dos dados de entrada e saída da amostra, notamos que o número de dólares
depende de qual linha estamos no momento da impressão, ou seja, 1 cifrão significa
primeira linha, 2 cifrões significa segunda linha, etc. Vejamos o exemplo abaixo com mais
detalhes. Vemos que a variável do loop aninhado está vinculada à variável do externo.
Assim, nosso programa imprime o triângulo desejado.

Exemplo: moldura quadrada

Escreva um programa que insira um inteiro positivo n e desenhe um quadro quadrado de
*
tamanho n no console n.
+–-–-+
+–-–+
+–-+ |–-–-||–-
|–-–||–
4 |–-||– 5 6 –-||–-–-||
-–||–-–|
-| –-–-|
+–-+
+–-–+
+–-–-+
Diretrizes e dicas
Podemos resolver o problema da seguinte forma:
• Lemos o número n do console .
• Imprimimos a parte superior: primeiro + sinal, depois n-2 vezes - e finalmente + sinal. •
Imprimimos a parte do meio: imprimimos n-2 linhas imprimindo primeiro um sinal |, depois
n-2 vezes - e finalmente um sinal | novamente. Podemos conseguir isso com
loops aninhados.
• Imprimimos a parte inferior: primeiro +, depois n-2 vezes - e finalmente +.

Aqui está um exemplo de implementação da ideia descrita, com loops aninhados:
Exemplo: losango de estrelas

Escreva um programa que receba como entrada um inteiro positivo n e como saída para o
console um diamante de estrelas de tamanho n.

*
* **
* ** ***
1 * 2 **
3 ***
4 ****
* ** ***
* **
Diretrizes e dicas
Para resolver a tarefa dada, é necessário dividir mentalmente o losango em duas partes: superior
(incluindo a linha do meio) e inferior. Para exibir cada parte no console, usaremos dois loops, e o próprio
leitor deve encontrá-lo
a dependência entre n e as variáveis nos loops.
Para o primeiro ciclo, podemos usar as seguintes diretrizes:
• Imprimimos o intervalo de n linhas .

• Imprimimos *.
• Imprimimos a linha 1 vezes *.
Derivaremos a segunda parte (inferior) de maneira semelhante, que deixaremos novamente

o leitor a tentar fazê-lo sozinho.

Exemplo: árvore de natal
Escreva um programa que receba como entrada um número n (1 ÿ n ÿ 100) e como saída uma
"árvore de natal" de altura n+1.
Entrar Sair Sair Conecte-se Saída Conecte-se Saída
|*|*
1 2 3 |*|* 4
|*|* ** | ** ***
|*|* ** | ** ***
** | ** | *** **** |
| ***
****
Diretrizes e dicas
A partir dos exemplos, vemos que a árvore pode ser dividida em três partes lógicas. A
primeira parte são os asteriscos (*) e os espaços antes e depois deles, a parte do meio
é o | e a última parte são os asteriscos (*) novamente, desta vez apenas os espaços
antes deles. A impressão pode ser realizada em apenas um ciclo e voltaremos a recorrer
ao método que usamos no início.
Teste no sistema de juízes

Desenhar formas mais complexas

Vejamos como podemos desenhar nas figuras do console com uma lógica de construção
mais complexa, sobre a qual precisamos pensar mais antes de começar a escrever.
Exemplo: óculos de sol
Escreva um programa que receba um inteiro n (3 ÿ n ÿ 100) e imprima óculos de sol
de tamanho 5*nxn como nos exemplos:

******** ********
****** ******
3 4 */////*||||*//////* *//////* *//////

*////*|||*////* *
****** ******
******** ********
Conecte-se Saída
********** **********
*////////* *////////* *///////*|||||*////////*
5 *//// ////* *////////*
********** **********
Diretrizes e dicas
A partir dos exemplos, vemos que os óculos podem ser divididos em três partes - superior, médio e
inferior. Abaixo está um pedaço de código que pode resolver o problema.
Ao desenhar as linhas superior e inferior, 2 * n espaços e 2 * n asteriscos,

n asteriscos.
Ao imprimir a parte do meio, precisamos verificar se a linha é (n-1) / 2 - 1, pois fica claro pelos exemplos
que nesta linha devemos imprimir traços verticais em vez de espaços.
Exemplo: casa de campo
Escreva um programa que receba um número n (2 ÿ n ÿ 100) e imprima uma casa de tamanho nxn,
como nos exemplos:
Entrar Sair Sair Conecte-se Saída Conecte-se Saída

---*--
-**-
-*- -***-
** ****
2 3 *** 4 5 *****
|| |**| |
|*| |***| |
**|
***|
Diretrizes e dicas
Entendemos pela condição do problema que a casa tem dimensões n x n. O que
vemos no exemplo de entrada e saída é que:
• A casa é dividida em 2 partes: telhado e base.
• Quando n é um número par, o topo da casa é "rombo".

• Quando n é um número ímpar, o telhado é uma ordem maior que a base.
Um telhado
• É composto por asteriscos (*) e hífens (-). •
Em sua parte mais alta há uma ou duas estrelas, dependendo se ne

par ou ímpar, bem como traços.
• Em sua parte inferior, há muitas estrelas e poucos ou nenhum traço. • Com cada linha
abaixo, as estrelas aumentam em 2 e os traços
diminuir em 2.
Fundação
• É n em número de linhas de largura .
• É formado por asteriscos (*) e traços (|).
• As linhas representam 2 linhas verticais - uma no início e outra no final da linha, bem
como estrelas entre as linhas verticais com comprimento de corda n - 2.
Lemos n do console e escrevemos o valor em uma variável do tipo int.
É muito importante verificar se os dados de entrada são válidos! Nessas tarefas, não há
problema em converter diretamente o que é lido do console para um tipo int, pois é dito
explicitamente que receberemos inteiros válidos. No entanto, se estivermos fazendo
aplicações mais sérias, é uma boa prática verificar os dados de entrada. E se em vez
de um número o usuário digitar a letra "A"?
Para desenhar o telhado, registramos qual será o número inicial de estrelas na variável estrelas:
• Se n for um número par, haverá 2 números. •
Se for ímpar, será 1 número.
Calculamos o comprimento do telhado. É igual à metade de n. Salvamos o resultado na variável

roofLength.
É importante notar que quando n é um número ímpar, o comprimento do telhado é uma ordem maior que
o da base. Na linguagem Java, quando dois números inteiros são divididos e há resto, o resultado será
um número sem resto.
Exemplo:
int resultado = 3/2 ; // resultado 1
Se quisermos arredondar o resultado, temos que usar o método Math. teto(…):
int resultado = (int) Math.ceil(3 / 2f);
Neste exemplo, a divisão não é por 2 números inteiros. "f" após um número indica que o número fornecido
é do tipo float . O resultado de 3 / 2f é 1,5f. Math.ceil(…) arredonda a divisão para cima. Em nosso caso,
1,5f se tornará 2. (int) é usado para que possamos converter o tipo de volta para int.
Depois de calcular o comprimento do telhado, fazemos um loop de 0 para roofLength. A cada iteração
iremos:
• Calculamos o número de traços que precisamos desenhar. O número será igual a (n - estrelas) / 2.
Escrevemos no preenchimento variável.
Capítulo 6.1. 255 loops aninhados
• Imprimimos no console: "traços" ( número de preenchimentos) + "estrelas" ( tempos de estrelas)

+ "traços" (tempos de preenchimento ).
• Antes que a iteração do loop termine, adicionamos 2 a estrelas (o número de

as estrelas).
Não é uma boa ideia fazer concatenações de um grande número de

cadeias de caracteres da maneira mostrada acima, pois isso leva a
problemas de desempenho. Para mais informações, visite: https://
bg.wikipedia.org/wiki/Niz#String_Builder.
Agora que terminamos o telhado, é hora da fundação. É mais fácil para

impressão:
• Começamos fazendo um loop de 0 a n

(desligado). • Imprimimos no console: | + * (n - 2 número de vezes) + |.
Se escrevemos tudo corretamente, nossa tarefa está resolvida.

Exemplo: diamante
Escreva um programa que receba um inteiro n (1 ÿ n ÿ 100) e o imprima
diamante de tamanho n, como nos exemplos a seguir:
Entrar Sair Entrar Sair Entrar Sair Entrar Sair

---*--
-*- -**- -*-*-
1 * 2 ** 3 *-* 4 *--* 5 *---*
-*- -**- -*-*-
---*--
Diretrizes e dicas
O que sabemos da condição do problema é que o diamante tem tamanho n x n.
A partir da amostra de entrada e saída, podemos concluir que todas as linhas contêm exatamente n caracteres
cada e todas as linhas, exceto os vértices superiores, possuem 2 estrelas (*). Podemos dividir mentalmente o
diamante em 2 partes:
• Parte superior. Começa da ponta superior para o meio. •

Parte inferior. Começa na linha após o pico do meio até o pico inferior (incl
completamente).
Topo • Se n
for ímpar, começa com 1 estrela (*). • Se n for par, começa
com 2 estrelas (``**). • Com cada linha para baixo, as estrelas
se afastam mais. • O espaço antes, entre e depois dos asteriscos (*) é preenchido
com hífens (-).
Parte inferior •
Com cada linha para baixo, as estrelas convergem umas para as outras. Isso significa que o espaço (traços)
entre eles diminui e o espaço (traços)
esquerda e direita aumenta.
• Possui 1 ou 2 estrelas em sua parte inferior, dependendo se n é ímpar ou não

até.
Parte superior e inferior do diamante
• Em cada linha, as estrelas são cercadas por traços externos, exceto por
a linha do meio.
• Há um espaço entre as duas estrelas em cada linha, exceto a primeira
e a última linha (às vezes a estrela é 1).
Lemos o valor de n no console e o escrevemos em uma variável do tipo int.
Começamos a desenhar a parte superior do diamante. A primeira coisa que precisamos fazer é calcular o valor
inicial da contagem de traços externos leftRight (os traços do lado de fora das estrelas). É igual a (n - 1) / 2,
arredondado para baixo.
Depois de calcularmos leftRight, começamos a desenhar o topo do diamante. Podemos começar fazendo um
loop de 0 a n / 2 + 1 (arredondado para baixo). A cada iteração do loop, as seguintes etapas devem ser
executadas:
• Desenhamos no console os traços à esquerda (de comprimento leftRight) e imediatamente após

eles a primeira estrela.
• Calcularemos a distância entre as duas estrelas. Podemos fazer isso subtraindo de n o

comprimento dos traços externos, bem como o número 2 (o número de estrelas, ou seja, o
contorno do diamante). Registramos o resultado dessa diferença em uma variável mid.
• Se mid for menor que 0, então sabemos que deve haver 1 estrela na linha. Se for maior ou igual
a 0, devemos desenhar traços de comprimento no meio e uma estrela depois deles.
• Desenhamos os traços externos direitos de comprimento leftRight no console.
• No final do loop, decrementamos leftRight em 1 (as estrelas * se afastam).
Terminamos a parte superior.

Pintar o fundo é bastante semelhante a pintar o topo. As diferenças são que, em vez de diminuir
leftRight em 1 no final do loop, incrementaremos leftRight em 1 no início do loop. Além disso, o loop
será de 0 a (n - 1) / 2.
Repetir o mesmo trecho de código é considerado uma prática ruim, pois dificulta
a manutenção do código. Vamos imaginar que temos código (por exemplo, a
lógica para desenhar uma linha a partir do losango) em mais alguns locais do
programa e precisamos fazer alguma alteração. Para fazer isso, precisaríamos
corrigir o código em cada lugar onde colocamos esse código. E agora vamos
pensar no seguinte estudo de caso: O que aconteceria se o mesmo
o código deve ser usado não 1, 2 ou 3 vezes, mas dezenas de vezes.

Uma abordagem para lidar com esse problema é usar métodos. Você
pode procurar informações adicionais sobre eles na Internet ou consultar
o capítulo “10” (Métodos).


Aprendemos a desenhar formas com loops for aninhados :
for (int r = 1; r <= 5; r++) {
System.out.println("*"); for (int

c = 1; c < 5; c++)
System.out.println(" *");
System.out.println();
}
Também aprendemos como usar métodos para evitar a repetição do mesmo trecho de
código diversas vezes.
Capítulo 6.2. Loops aninhados - problemas de exame 259
Capítulo 6.2. Ciclos aninhados - tarefas

de exame
No capítulo anterior, examinamos loops aninhados e como usá-los para desenhar várias
formas no console. Aprendemos a imprimir figuras de tamanhos diferentes, criando uma lógica
de construção apropriada usando loops for simples e aninhados em combinação com vários
cálculos e lógica de programação:
for (int linha = 1; linha <= 5; linha++)

{ System.out.print("*"); for (int
col = 1; col < 5; col++) { System.out.print(" *");
}
System.out.println();
}
Também declaramos nosso próprio método repeatStr(…), que nos ajuda a imprimir um
determinado caractere (ou série de caracteres) um determinado número de vezes:
Tarefas de exame
Agora vamos resolver alguns problemas do exame juntos para consolidar o que aprendemos e
desenvolver ainda mais nosso pensamento algorítmico.
Tarefa: desenhar uma fortaleza

Para escrever um programa que lê do console um inteiro n e desenha um post cre com uma
*
largura de 2 e a n colunas e n linhas de altura como nos exemplos abaixo. o esquerdo
coluna da direita interna tem n / 2 de largura.
Dados de entrada
A entrada é um inteiro n no intervalo [3 … 1000].
Dados de saída
Para imprimir no console n linhas de texto representando a fortaleza, assim como nos exemplos.
/^^\__/^^\ | | | |
/^^\/^^\ | | |
/^\/^\ | | | __ | \__/ \__/
| \__/\__/
3 \_/\_/ 4 5
Diretrizes e dicas
Pela condição da tarefa, vemos que os dados de entrada consistirão em apenas uma linha, que
conterá um inteiro no intervalo [3 … 1000]. Por esse motivo, usaremos uma variável do tipo int.
Agora que declaramos e inicializamos as entradas, precisamos

divida a fortaleza em três partes:
• telhado
• corpo
• base
Pelos exemplos podemos entender que a cobertura é composta por duas torres e uma parte
^
intermediária. Cada torre consiste em início /, meio e finalize \.
\ é um caractere especial na linguagem Java, e usando apenas ele no método

System.out.println(…), o console não irá imprimi-lo, então com \\ indicamos ao
console que queremos imprimir exatamente este caractere sem interpretá-lo como
especial (nós o filtramos, em inglês se chama "character escape").
O meio é de tamanho n/ 2, então podemos separar esse valor em uma variável separada. Ele manterá
o tamanho do meio da torre.
Declaramos também uma segunda variável na qual armazenaremos o valor da parte entre as duas
torres. A parte do meio do telhado é de tamanho 2 * n - 2 * colSize - 4.
Capítulo 6.2. Loops Aninhados - Problemas de Exame 261
Para imprimir a capa no console, usaremos nosso método repeat Str(…), que recebe dois parâmetros
(string, int) e concatena um determinado caractere (ou série de caracteres) n vezes.
O corpo da fortaleza é constituído por um início |, um meio (espaço vazio) e um fim |. Os dados médios
de um local vazio são de tamanho 2 * n - 2. O número de linhas para paredes, podemos determinar a partir
de nossos exemplos fornecidos - n - 3.
Para desenhar a penúltima linha que faz parte da base, precisamos imprimir start |, middle (blank)_(blank)
e end |. Para fazer isso, podemos reutilizar as variáveis colSize e midSize que já declaramos, pois
vemos pelos exemplos que elas são iguais ao número
_ V
capas.
Somamos ao valor dos espaços em branco + 1 porque nos exemplos temos um

espaço vazio mais.
A estrutura da base da fortaleza é a mesma do telhado. É composto por duas torres e uma parte
intermediária. Cada torre tem um começo \, um meio _ e terminando /.

Tarefa: borboleta
Escreva um programa que leia um inteiro n do console e desenhe um 2 * (n - 2) + 1 largura
*
n - nos
de linha pepe ore como 1 colunas e altura
exemplos 2 Suas partes esquerda e direita têm n - 1 de
abaixo.
largura.
Dados de entrada
A entrada é um inteiro n no intervalo [3 … 1000].
Dados de saída
Para imprimir no console 2 borboletas, * (n - 2) + 1 linhas de texto representando
como nos exemplos.
*****\ /***** -----

\ /----- *****\ /*****
***\ /*** --- -----\ /----- ** ***\ /
\ /--- ***\ /*** ***** @ *****/
*\ /* @ @ ***/ \*** \***** -----/ \-----
3 5 7
*/ \* ---/ \--- ***/ *****/ \***** --- --/
\*** \----- *****/ \*****
Diretrizes e dicas
Pela condição da tarefa, vemos que os dados de entrada serão lidos de apenas uma linha,
que conterá um inteiro no intervalo [3 … 1000]. Por esse motivo, usaremos uma variável do
tipo int.
Podemos dividir a figura em 3 partes - asa superior, corpo e asa inferior. Para desenhar a asa
superior da borboleta, precisamos dividi-la em partes - início *, meio \ / e fim *. Depois de olhar
os exemplos, podemos dizer que a origem é de tamanho n - 2.
Também vemos que a asa superior da borboleta tem tamanho n - 2, então podemos
fazer um loop que repete meioRowSize vezes.
A partir dos exemplos podemos notar que em uma linha par temos start -, middle \ / e
end *, e em ímpar temos start *, middle \ / e end -. Portanto, precisamos fazer um if-
else para verificar se a linha é par ou ímpar, e sim de acordo
nós imprimimos um dos dois tipos de linhas.
Para fazer o corpo da borboleta, podemos novamente usar a variável halfRowSize e

imprimir exatamente uma linha no console. A estrutura do corpo tem início (em branco),
meio @ e fim (em branco).
Resta imprimir na consola e na asa inferior, que é idêntica à superior

asa.

Tarefa: placa de pare

Escreva um programa que leia um inteiro n do console e desenhe um sinal de alerta
STOP com dimensões como nos exemplos abaixo.
Dados de entrada
A entrada é um inteiro N no intervalo [3 … 1000].
Dados de saída
Para imprimir nas linhas de texto do console representando o sinal de aviso STOP, assim
como nos exemplos.
......................
......//___________\\...... .....//
_____________\\..... ....//
...._______.... _______________\\.... ...//
...//_____\\... ..// _________________\\... ..//
_______\\.. .// ___________________\\.. .//
3 _________\\. 6 _____________________\\.
//___PARAR!___\\ \ //_________PARAR!_________\\ \
\___________// .\ \_______________________// .\
\_________//. ..\ \_____________________//. ..\
\_______//.. \___________________//.. ...\
\_________________//... ....\
\_______________//.... .....\\
\___________//.....
Diretrizes e dicas
Pela condição da tarefa, vemos que os dados de entrada serão lidos de apenas uma
linha, que conterá um inteiro no intervalo [3 … 1000]. Por esse motivo, usaremos uma
variável do tipo int.
Podemos dividir a figura em 3 partes - superior, média e inferior. A parte superior é

consiste em duas subpartes - linha inicial e linhas nas quais o signo se expande.
A linha inicial é composta por start e end .. Depois

dizer
de que _ ., exemplos de ambiente, podemos
olhar para
start tem tamanho n + 1 e é bom separar esse valor em uma variável separada.
Também precisamos criar uma segunda variável na qual armazenaremos o valor do meio da linha inicial
e é de tamanho 2 * n + 1.
Agora que declaramos e inicializamos as duas variáveis, podemos imprimir a linha inicial no console.
Não vamos esquecer de passar uma nova linha de console com System.out.println(…).
Para plotar as linhas onde o caractere "expande", precisamos criar um loop que repita n vezes. A
estrutura de uma linha consiste em // + meio + \\ e fim .. Para poder reutilizar as variáveis criadas,
Começar ., precisamos diminuir
_ os pontos em 1 e os sublinhados em 2, porque já imprimimos a
primeira linha, e as linhas de pontos e sublinhados na próxima linha da figura diminuem.
Em cada iteração subsequente, o início e o fim são diminuídos em 1 e o meio é aumentado em 2.
A parte do meio da figura tem um começo // + _, meio ambiente PARE! e fim _ + \\. O número de
as linhas de fundo _ å (sublinhado - 5) / 2.
A parte inferior da figura, onde o sinal diminui, podemos criar novamente um loop para
loop n número de vezes. A estrutura de um + \\, ambiente .. O número de pontos na
subseqüente . primeira linha_ de e fim // + é o início do ciclo deve ser 0 e em cada
iteração
aumentar em um. Portanto, podemos dizer que a magnitude dos pontos na parte inferior
da figura é igual a i.
Para que nosso programa funcione corretamente, precisamos diminuir o número de a

cada iteração do loop _ com 2.

Tarefa: Flecha
Escreva um programa que leia um inteiro ímpar n do console e desenhe uma seta vertical
com dimensões como nos exemplos abaixo.
Dados de entrada
A entrada é um inteiro ímpar n no intervalo [3 … 79].
Saída Imprima uma

seta vertical no console, onde "#" (uma libra) contorna a seta e "." - o resto.

..#####..
..#...#..
.###. ..#...#..
.#.#. ..#...#..
3 ##.## 5 ###...###
.#.#. .#.....#.
..#.. ..#...#..
...#.#... ....#....
Diretrizes e dicas
Pela condição da tarefa, vemos que os dados de entrada serão lidos de apenas uma
linha, que conterá um inteiro no intervalo [3 … 1000]. Por esse motivo, usaremos uma
variável do tipo int.
Podemos dividir a figura em 3 partes - superior, média e inferior. A parte superior consiste
em duas subpartes - a linha de abertura e o corpo da flecha. A partir dos exemplos,
você pode ver que o número de pontos externos na linha inicial e no corpo da seta é (n -
1) / 2. Podemos escrever esse valor em uma variável outerDots.
O número de pontos internos no corpo da seta é (n - 2). Precisamos criar uma variável
chamada innerDots que manterá esse valor.
A partir dos exemplos podemos ver a estrutura da linha de abertura. Precisamos usar
nossas variáveis declaradas e inicializadas, outerDots e n, para imprimir a linha inicial.
Não devemos esquecer que devemos ir para uma nova linha com System.out.println();.
Para desenhar o corpo da seta no console, precisamos criar um loop que se repita n - 2
vezes.
O meio da figura é composto por start #, middle . e terminar #. A partir dos exemplos,
vemos que a contagem # é igual a outerDots aumentado em 1 e para isso podemos
usamos a mesma variável novamente.
Para desenhar a parte inferior da seta, precisamos definir novos valores para as duas
variáveis outerDots e innerDots.
O loop que vamos fazer deve ser repetido n - 2 vezes e imprimiremos separadamente a
última linha da figura. Em cada iteração, outerDots é incrementado em 1 e innerDots é
decrementado em 2.
A última linha da nossa figura é composta por start ., middle # e end .. O número
sobre
. é igual a outerDots.

Tarefa: machado
Escrever um programa que lê um inteiro n e desenha um eixo com as dimensões
mostradas abaixo. A largura do machado é de 5 * N colunas.
Dados de entrada
A entrada é um inteiro n no intervalo [2..42].
Dados de saída
Para imprimir o machado do console, como nos exemplos.
Conecte-se Saída
-------------------------**--------------
------------------------*-*-------------
--------------*--*------------
------------------------*---*-----------
------------------------*----*----------
------------------------*-----*---------
--------------*------*--------
--------------*-------*-------
8 *************************-------*-------
*************************-------*-------
*************************-------*-------
*************************-------*-------
--------------*-------*-------
-------------*---------*------
----------------------*-----------*-----
---------------------*****************----

---------------**--------
---------------*-*-------
---------------*--*------
---------
---------------*---*-----
------*-*-
2 5 ---------------*----*----
*******-*-
****----*----
------****-
****----*----
---------------*----*----
--------------********---
Diretrizes e dicas
Para resolver o problema, devemos primeiro calcular o tamanho dos traços à esquerda,
os traços centrais, os traços à direita e todo o comprimento da figura.
Depois de declarar e inicializar as variáveis, podemos começar a desenhar a forma

começando pela parte superior. A partir dos exemplos podemos entender qual é a
estrutura da primeira linha e criar um loop que se repete n vezes. Em cada iteração do
loop, os traços do meio são incrementados em 1 e os traços à direita são decrementados
em 1.
Para poder reutilizar as variáveis criadas ao desenhar o cabo do machado, precisamos

diminuir os traços do meio em 1 e aumentar os traços da direita em 1.
Podemos desenhar o cabo do machado executando um loop que se repete n - 2 vezes.

A partir dos exemplos podemos entender qual é a sua estrutura.
A parte inferior da figura deve ser dividida em duas partes - a cabeça do machado e a
última linha da figura. Vamos imprimir a cabeça do machado no console fazendo um loop
que se repete n/2 - 1 vezes. Em cada iteração, os traços à esquerda e à direita diminuem
em 1, e os traços do meio aumentam em 2.
Para a última linha da figura, podemos novamente usar as três variáveis já declaradas e
inicializadas leftDashes, middleDashes, rightDashes.

Capítulo 7.1. Ciclos mais complexos

Agora que aprendemos o que são loops for e para que servem , agora
estamos prestes a ser apresentados a outros tipos de loops, bem como a algumas construções de loop mais
complexas. Eles irão expandir nosso conhecimento e nos ajudar a resolver tarefas mais difíceis e desafiadoras.
Especificamente, veremos como as seguintes construções de programa são usadas:
• ciclos de passos
• loops while • loops
do-while • loops infinitos
Neste tópico, também entenderemos o que é o operador break e como utilizá-lo para quebrar um loop. Além
disso, usando a construção try-catch , aprenderemos a observar erros durante a execução de
nosso programa.
Vídeo
Assista a um tutorial em vídeo sobre este capítulo: https://youtube.com/watch?v=kaJSrGrvakQ.
Ciclos de passos
No capítulo "Repetições (loops)" aprendemos como funciona o loop for e agora sabemos quando e com que
propósito usá-lo. Neste tópico daremos atenção a uma determinada e muito importante parte da sua construção,
nomeadamente o degrau.
O que é um passo?
A etapa é a parte da construção do loop for que especifica quanto aumentar ou diminuir o valor de sua variável
principal. Ele é declarado por último no esqueleto do loop for . Geralmente é de tamanho 1 e, nesse caso, em
vez de escrever i += 1 ou i -= 1, podemos usar
os operadores i++ ou i--. Se quisermos que nosso passo seja diferente de 1, usamos o operador i += (o
tamanho do passo) para aumentar e i -= (o tamanho do passo) para diminuir. No passo 10, o loop ficaria
assim:
A seguir, uma série de problemas de exemplo, cuja solução nos ajudará a entender melhor o uso da etapa do
loop for .
Exemplo: os números de 1 a N a 3
Escreva um programa que imprima os números de 1 a n com um passo de 3. Por exemplo, se n
= 100, a saída será: 1, 4, 7, 10, …, 94, 97, 100.
Podemos resolver a tarefa através da seguinte sequência de ações (algoritmo):
• Lemos o número n da entrada do console.
• Executamos um loop for de 1 a n com um tamanho de passo de 3.
• No corpo do loop imprimimos o valor do passo atual.

Exemplo: os números N a 1 na ordem inversa

Escrever um programa que imprima os números n a 1 na ordem inversa (etapa -1). Por exemplo,
se n = 100, o resultado será: 100, 99, 98, …, 3, 2, 1. Podemos resolver o
problema da seguinte forma:
• Lemos o número n da entrada do console.
• Criamos um loop for atribuindo int i = n .
• Invertemos a condição do loop: i >= 1.
• Definimos o tamanho do passo: -1.

• No corpo do loop imprimimos o valor do passo atual.

Capítulo 7.1. Loops mais complexos 275
Exemplo: os números 1 a 2^n com um loop for

No próximo exemplo, veremos como usar a etapa usual de tamanho 1, mas com uma
lógica ligeiramente diferente no corpo do loop.
Escreva um programa que imprima os números de 1 a 2^n (dois elevado a n). Por
exemplo, se n = 10, o resultado será 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024.

Exemplo: potências pares de 2

Imprima as potências pares de 2 até 2^n: 2^0, 2^2, 2^4, 2^8, …, 2^n. Por exemplo, se n
= 10, o resultado será 1, 4, 16, 64, 256, 1024. Aqui está
uma ideia de como podemos resolver o problema:
• Criamos uma variável num para o número atual, ao qual atribuímos start
de valor 1.
• Para a etapa do loop, definimos o valor 2. •
No corpo do loop: imprimimos o valor do número atual e incrementamos o número
atual em 4 vezes (de acordo com a condição da tarefa).

loop while
O próximo tipo de loop que veremos são chamados while loops. A particularidade deles é
que eles repetem um bloco de comandos até que uma determinada condição seja verdadeira.
Como estrutura, eles diferem dos loops for , eles têm até um simplificado
sintaxe.
O que é um loop while?

Na programação , o loop while é usado quando queremos repetir a execução de determinada
lógica enquanto uma determinada condição é mantida. Por "condição", queremos dizer
qualquer expressão que retorne verdadeiro ou falso. Quando a condição se torna falsa, o
loop while para de executar e o programa continua executando o restante do código após o
loop. A construção de um loop while se parece com isso:
A seguir, uma série de problemas de exemplo, cuja solução nos ajudará a entender melhor o
uso do loop while .
Exemplo: uma matriz de números 2k+1

Escreva um programa que imprima todos os números ÿ n da sequência: 1, 3, 7, 15, 31, …,
*
assumindo que cada número subsequente = número anterior 2 + 1.
Aqui está como podemos resolver a tarefa:

• Criamos uma variável num para o número atual, ao qual atribuímos start
de valor 1.
• Para a condição do loop, colocamos o número atual <= n. • No

corpo do loop: imprimimos o valor do número atual e incrementamos o número atual usando
a fórmula da condição de atribuição.
Aqui está um exemplo de implementação da ideia descrita:

Exemplo: um número no intervalo [1 ... 100]

Insira um número inteiro no intervalo [1 … 100]. Se o número digitado for inválido, digite-
o novamente. Nesse caso, consideraremos inválido qualquer número que não esteja no
intervalo especificado.
Para resolver o problema, podemos usar o seguinte algoritmo:
• Criamos uma variável num à qual atribuímos o valor inteiro,
recebido da entrada do console.
• Para a condição do loop, colocamos uma expressão que é verdadeira se o número da entrada não for
dentro do intervalo especificado na condição.
• No corpo do loop: imprimimos uma mensagem com o conteúdo "Número inválido!"
no console, então atribuímos um novo valor para num de
entrada do console.
• Após já termos validado o número digitado, fora do corpo do loop imprimimos o valor
do número.
Aqui está um exemplo de implementação do algoritmo através de um loop while:

Máximo Divisor Comum (GCD)

Antes de passar para o próximo problema, é necessário nos familiarizarmos com a
definição do máximo divisor comum (MDC). Vamos começar com exemplos:
a b gcd a b gcd
24 16 8 15 9 3
67 18 1 10 10 10
12 24 12 100 88 4
Definição de NOD: o máximo divisor comum de dois números naturais a e b é o maior número que
divide a e b simultaneamente sem deixar resto.
algoritmo de euclides
Na próxima tarefa, usaremos um dos primeiros algoritmos publicados para encontrar o NOD - o
algoritmo de Euclides:
Até chegarmos ao resto 0:
• Dividimos o maior número pelo menor. • Pegamos

o restante da divisão.
Pseudo-código para o algoritmo de Euclides:
enquanto b ÿ 0
int velhoB = b; b =
a % b; a =
antigoB;
imprima um;
Exemplo: máximo divisor comum (GCD)

Insira os inteiros aeb e encontre OD(a, b).
Vamos resolver o problema usando o algoritmo de Euclides:
• Criamos as variáveis a e b às quais atribuímos valores inteiros,

retirado da entrada do console.
• Como condição do loop, colocamos uma expressão que é verdadeira se o número b ÿ 0.
• No corpo do loop, seguimos as instruções do pseudocódigo:

o Criamos uma variável temporária à qual atribuímos a posição atual
qualidade de b.
o Atribuímos um novo valor a b que é o resto da divisão de a por b. o Atribuímos à variável a
o valor anterior da variável b.
• Depois que o loop é concluído e estabelecemos o NOD, nós o imprimimos.


Loop faça-enquanto
O próximo loop que conheceremos é do-while . Na estrutura, assemelha-se ao tempo, mas
há uma diferença significativa entre eles. Consiste no fato de que o do-while executará seu
corpo pelo menos uma vez. Por que isso está acontecendo? Na construção do loop do-while ,
a condição é sempre verificada após
seu corpo, que por sua vez garante que na primeira iteração do loop, o código será executado
e a verificação de fim de loop será aplicada em cada iteração subsequente do do-while .
A seguir está a série usual de exemplos de problemas, cujas soluções nos ajudarão a entender
melhor o loop do-while .
Exemplo: calcular um fatorial

* * * *
Para um número natural n para calcular n! = 1 o 2 3 … n. Por exemplo, se n = 5, isso
* * * *
resultado será: 5! = 1 5 = 120. 2 3 4
Veja como podemos calcular um fatorial mais especificamente:

• Criamos a variável n à qual atribuímos um valor inteiro
retirado da entrada do console.
• Criamos outra variável - fato, cujo valor inicial é 1. Será
usamos para calcular e armazenar o fatorial.
• Para a condição do loop, usaremos n > 1, pois cada vez que realizarmos os cálculos no
corpo do loop, decrementaremos o valor de n em 1.
• No corpo do loop:
o Atribuímos um novo valor ao fato que é o resultado da multiplicação
do valor atual de fato com o valor atual de n.
o Reduzimos o valor de n em -1.
• Fora do corpo do loop, imprimimos o valor final do fatorial.


Exemplo: somar os dígitos de um número

Para somar os dígitos de um inteiro positivo n. Por exemplo, se n = 5634, o resultado será: 5 + 6 + 3 + 4 = 18.
Podemos usar a seguinte ideia para resolver o
problema:
• Criamos a variável n à qual atribuímos um valor igual a ve

o número fornecido pelo usuário.
• Criamos uma segunda variável - soma, cujo valor inicial é 0. Será

usamos para calcular e armazenar o resultado.
• Para a condição do loop, usaremos n > 0 porque, após cada cálculo do resultado no corpo do loop,
removeremos o último dígito de n.
o Atribuímos um novo valor a sum, que é o resultado da adição do
o valor atual de soma com o último dígito de n.
o Atribuímos um novo valor a n que é o resultado da remoção do

o último dígito de n.
• Fora do corpo do loop, imprimimos o valor final da soma.

n % 10: retorna o último dígito do número n. n / 10: exclui o último

dígito de n.
Loops infinitos e a instrução break

Até agora, fomos apresentados a diferentes tipos de loops, aprendendo quais construções eles têm e como são
implementados. Precisamos entender o que é um loop infinito, quando ele ocorre e como podemos interromper
sua execução usando o comando break.
Ciclo sem fim. O que é?

Um ciclo sem fim é o que chamamos de ciclo que repete indefinidamente a execução de seu corpo. Nos loops
while e do-while , a verificação final é uma expressão condicional que sempre retorna true. Um for infinito ocorre
quando não há condição final.
É assim que um loop while infinito se parece:
E é assim que um loop for infinito se parece:
declaração de quebra
Já sabemos que um loop infinito executa determinado código ad infinitum, mas
o que acontece se desejarmos, em um determinado momento, sob uma determinada condição, sair à força do
loop? A pausa do operador vem em socorro , na tradução - pare,
interromper.
A instrução break interrompe a execução do loop no momento em que é chamada e continua

a partir da primeira linha após o término do loop. Isso significa que a iteração atual do loop
não será concluída até o fim e, portanto, o restante do código no corpo do loop não será
executado.
Exemplo: Perdoe os Números

O próximo problema exige que verifiquemos um número primo. Antes
vamos passar a isso, vamos lembrar o que são números primos.
Definição: Um número inteiro é primo se for divisível sem deixar resto apenas por si mesmo e
por 1. Por definição, os números primos são positivos e maiores que 1. O menor número primo
é 2.
Podemos assumir que um inteiro n é primo se n > 1 e n não é divisível por um número entre 2
e n-1. Os
primeiros números primos são: 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, …
Em contraste, números não primos (compostos) são números cuja composição
zição é composta por um produto de números primos.
Aqui estão alguns exemplos de números não primos:

*
• 10 = 2 5
• 42 = 2 3 7
*
• 143 = 13 11
Algoritmo para verificar se um inteiro é primo: verificamos se n>1 n-1 sem resto. e n é divisível
por 2, 3, …,
• Se for dividido por qualquer um dos números, então é composto. •

Se não for divisível por nenhum dos números, então é primo.
Podemos otimizar o algoritmo verificando até ÿn divisores em vez de verificar

até n-1. Pense no porquê.
Exemplo: verificar um número simples. declaração de quebra

Para testar se um número n é primo. Faremos isso verificando se n é divisível pelos números
entre 2 e ÿn. Aqui está o algoritmo para
verificar um primo, escrito passo a passo:
• Criamos a variável n à qual atribuímos um inteiro digitado por
entrada do console.
• Criamos uma variável booleana isPrime inicializada como true se o número for maior
ou igual a dois (porque, por definição, números como 0, 1, -1 e -2 não são primos).
Assumimos que um número é primo até que se prove o contrário
a anotação.
• Criamos um loop for , para o qual definimos 2 como valor inicial para a variável do loop,
como condição seu valor atual <= ÿn. O passo do loop é 1.
• No corpo do loop, verificamos se n dividido pelo valor atual tem resto. Se não houver
resto da divisão, alteramos isPrime para false e forçamos a saída do loop usando a
instrução break. • Dependendo do valor de isPrime , imprimimos
se o número é primo
(verdadeiro) ou respectivamente composto (falso).
Aqui está um exemplo de implementação do algoritmo descrito:

Exemplo: instrução break em um loop infinito

Escreva um programa que verifique se um número n é par e imprima na tela se for.
Consideramos par um número que é divisível por 2 sem deixar resto. Se o número for inválido,
retorne para digitar novamente e imprima uma mensagem notificando que o número digitado
não é par. Aqui está uma ideia de como podemos resolver a tarefa:
• Criamos uma variável n à qual atribuímos um valor inicial de 0.

• Criamos um loop while infinito , definindo a condição como verdadeira. • No
corpo do loop:
o Pegamos um valor inteiro da entrada do console e o atribuímos
de n.
o Se o número for par, saímos do loop usando break.

o Caso contrário, geramos uma mensagem que diz que o número não é par. As
iterações continuam até que um número par seja inserido.
• Imprimimos o número par na tela.
Aqui está um exemplo de implementação da ideia:
Observação: embora o código acima esteja correto, ele não funcionará se ao invés de
números o usuário inserir texto, por exemplo “Número inválido”. Em seguida, a análise
do texto para um número será interrompida e o programa exibirá uma mensagem de erro
(exceção). Aprenderemos como lidar com esse problema e como capturar e tratar
exceções usando a construção try-catch em um momento.

Loops aninhados e a instrução break

Agora que aprendemos o que são loops aninhados e como a instrução break funciona,
é hora de entender como os dois funcionam juntos. Para melhor entendimento, vamos
passo a passo escrever um programa que deve fazer todas as combinações possíveis
de pares de números. O primeiro número na combinação está aumentando de 1 para 3
e o segundo está diminuindo de 3 para 1. A tarefa deve continuar executando até que i +
j seja igual a 2 (ou seja, i = 1 e j = 1).
O resultado desejado é:
Aqui está uma solução errada que parece certa à primeira vista:
Se deixarmos nosso programa assim, nosso resultado será o seguinte:

Por que isso acontece? Como podemos ver, o resultado está faltando "1 1". Quando o programa atinge o ponto em
que i = 1 ej = 1, ele entra na verificação if e executa a operação de interrupção. Dessa forma, o loop interno é
encerrado, mas a execução do loop externo continua. i aumenta, o programa entra no interno
o ciclo e imprime o resultado.
Quando usamos a instrução break em um loop aninhado , ela interrompe apenas a execução
do loop interno.
Qual é a solução correta? Uma maneira de resolver esse problema é declarando uma variável booleana que
monitora se preciso continuar executando o loop. Se for necessária uma saída (saída de todos os loops aninhados),
a variável é definida como true e o loop interno é encerrado com break e, após verificação subsequente, o loop
externo também é encerrado. Aqui está um exemplo de implementação dessa ideia:
Assim, quando i + j = 2, o programa tornará a variável hasToEnd = true e sairá do loop interno. Na próxima iteração
do loop externo, através do teste if , o programa não conseguirá alcançar o loop interno
loop e abortará sua execução.


Manipulando dados inválidos: try-catch

A última coisa que abordaremos neste capítulo é como "pegar" dados errados usando a construção
try-catch.
O que é try-catch?
A construção do programa try-catch serve para capturar e tratar exceções (erros) durante a execução
do programa.
Na programação, as exceções são notificações de um evento que interrompe a operação normal de

um programa. Tais eventos extraordinários interrompem a execução do nosso programa e ele procura
alguém para lidar com a situação. Se não o encontrar, a exceção é impressa no console (o programa
"rumble"). Se encontrada, a exceção é tratada e o programa continua sua execução normal sem
"bater". Veremos como em um momento
é exatamente isso que acontece.
Quando ocorre uma exceção, diz-se que a exceção foi "lançada" (lançar exceção). É daí que vem a
expressão "capturar exceção".
Uma construção try-catch

A construção try-catch tem várias variantes, mas por enquanto veremos apenas a mais básica, onde
o bloco catch detectará qualquer erro no
variável chamada ex:
Na próxima tarefa, veremos como lidar com uma situação em que o usuário insere uma entrada não
numérica (por exemplo, string em vez de int) usando try-catch.
Exemplo: lidar com números errados com try-catch

Escreva um programa que verifique se um número n é par e imprima na tela se for. Se um número
inválido for inserido, será exibida uma mensagem informando que a entrada inserida não é um número
válido e a entrada continuará novamente.
Aqui está como podemos resolver a tarefa:

• Criamos um loop while infinito , definindo a condição como verdadeira.

o Criamos uma construção try-catch . o

No bloco try , escrevemos a lógica do programa para ler o usuário
entrada, analisando-a em um número e verificando a paridade.
o Se o número for par, nós o imprimimos e saímos do loop (com break). Programa
o tapete fez seu trabalho e acabou.
o Para um número ímpar, imprimimos uma mensagem de que um número par é necessário
sem sair do loop (porque queremos que ele se repita novamente).
o Se detectarmos uma exceção durante a execução do bloco try, imprimiremos uma

mensagem de entrada de número inválido (e o loop se repetirá de acordo porque
não o interrompemos explicitamente).
Aqui está um exemplo de implementação da ideia descrita:

Agora a solução sempre deve funcionar: se inserirmos números inteiros, números inválidos
(por exemplo, muitos dígitos) ou textos que não contenham números.
Tarefas com ciclos

Neste capítulo, fomos apresentados a vários novos tipos de loops que podem ser usados
para iterar com lógica de programa mais complexa. Vamos resolver vários problemas
usando o novo conhecimento.
Problema: números de Fibonacci

Os números de Fibonacci na matemática formam uma série que se parece com isto: 1, 1, 2,
3, 5, 8, 13, 21, 34, … A fórmula para formar a
série é:
F0 = 1
F1 = 1
Fn = Fn-1 + Fn-2
Comentário de entrada (n) de saída Entrada (n) Saída
10 89 F(11) = F(9) + F(8) 0 1
5 8 F(5) = F(4) + F(3) 1 1
20 10946 F(20) = F(19) + F(18)
Digite um inteiro n e calcule o n-ésimo número de Fibonacci.
Diretrizes e dicas
Ideia para resolver a tarefa:
• Criamos uma variável n à qual atribuímos um valor inteiro de
entrada do console.
• Criamos as variáveis f0 e f1 às quais atribuímos o valor 1, pois é assim que a linha
começa.
• Criamos um loop for com a condição de que o valor atual i < n - 1.
o Criamos uma variável temporária fNext à qual atribuímos next
o número da sequência de Fibonacci.
o Para f0 atribuímos o valor atual de f1.
o Atribuímos o valor da variável temporária fNext a f1 .
• Fora do loop, imprimimos o enésimo número de Fibonacci.
Exemplo de implementação:

Tarefa: uma pirâmide de números

Para imprimir os números 1 … n em uma pirâmide como nos exemplos abaixo. no primeiro
linha imprimimos um número, na segunda linha imprimimos dois números, na terceira linha
imprimimos três números, etc. até acabarem os números. Na última linha, imprimimos quantos
números restam até chegarmos a n.
Entrada Saída Entrada Saída Entrada Saída
1 1
23 23
7 5 12 10
456 456
345
7 7 8 9 10
Diretrizes e dicas
Podemos resolver o problema com dois loops aninhados (por linhas e colunas)
imprimindo neles e saindo quando o último número for alcançado. Aqui está a ideia,
explicada com mais detalhes:
• Criamos uma variável n à qual atribuímos um valor inteiro de
entrada do console.
• Criamos uma variável num com valor inicial 1. Ela armazenará o número de números
impressos. A cada iteração iremos incrementá-lo em 1 e imprimi-lo. • Criamos um loop
for externo que será responsável pelas linhas da tabela. Chamamos a variável de loop de
linha e atribuímos a ela um valor inicial de 0. Como condição, colocamos linha < n. O
tamanho do passo é 1.
• No corpo do loop, criamos um loop for interno que será responsável pelas colunas da
tabela. Chamamos a variável de loop de col e atribuímos a ela um valor inicial de 0.
Como condição, colocamos col < linha (linha = número de dígitos por linha). O tamanho
do passo é 1.
• No corpo do loop aninhado:
o Verificamos se col > 1, se sim - distância de impressão. Se não

faça esta verificação e imprima diretamente a distância, haverá
me um desnecessário no início de cada linha.
o Imprimimos o número num na célula atual da tabela e incrementamos

divide por 1.
o Verificamos num > n. Se num for maior que n, abortamos

a rotação do loop interno.
• Imprimimos uma linha vazia para ir para a próxima. • Novamente verificamos se
num > n. Se for maior, interrompemos a execução do nosso programa usando break.
Aqui está um exemplo de implementação:
Tarefa: tabela com números

Para imprimir os números 1 … n em uma tabela como nos exemplos abaixo.
Entrada Saída Entrada Saída
1234
12
2343
3 323 4
3432
2321
4321
Diretrizes e dicas
Podemos resolver o problema com dois loops aninhados e alguns cálculos neles:
• Lemos no console o tamanho da tabela em uma variável inteira n. • Criamos um
loop for que será responsável pelas linhas da tabela. Chamamos a variável de loop de
linha e atribuímos a ela um valor inicial de 0. Como condição, colocamos linha < n.
O tamanho do passo é 1.
• No corpo do loop, criamos um loop for aninhado que será responsável pelas colunas
da tabela. Chamamos a variável de loop de col e atribuímos a ela um valor inicial de
0. Como condição, colocamos col < n. O tamanho do passo é 1.
• No corpo do loop aninhado: o
Criamos uma variável num à qual atribuímos o resultado da linha atual + a coluna
atual + 1 (+1 porque começamos a contar a partir de 0). o Verificamos num >
n. Se num for maior que n, atribuímos um novo valor a num igual a 2 n - o valor
atual de num. Fazemos isso para não *exceder n em nenhuma das células da
tabela.
ÿ Imprimimos o número da célula atual da tabela.
• Imprimimos uma linha em branco no loop externo para passar para o próximo
ordem.


Podemos usar loops for com um passo:
for (int i = 1; i <= n; i+=3)

{ System.out.println(i);
}
Os loops while / do-while se repetem até que uma determinada condição seja verdadeira:
int num = 1;
while (num <= n)
{ System.out.println(num++);
}
Se precisarmos interromper a execução de um loop, faremos isso com a instrução break:
int n = 0;
while (true) { n =
Integer.parseInt(scanner.nextLine()); if (n % 2 == 0)
{ quebrar; // número
par -> sai do loop
}
System.out.println("O número não é par.");
}
System.out.println(" Número par digitado: {0}", n);
Agora sabemos como capturar erros (exceções) durante a execução do nosso programa:
tente
{ System.out.println("Digite o número par: "); int n =
Integer.parseInt(scanner.nextLine());
} catch (Exceção ex)
{ System.out.println(" Número inválido.");
} // Se Integer.parseInt(…) explodir, o bloco catch { … } será executado

Capítulo 7.2. Ciclos mais complexos - tarefas

de exame
Já aprendemos como executar um bloco de comandos mais de uma vez usando um loop for. No capítulo anterior,
examinamos mais algumas construções de loop que nos ajudariam a resolver problemas mais complexos,
nomeadamente:
• ciclos de passos
• loops aninhados
• loops while
• loops faça-enquanto
• loops infinitos e saída de loop ( operador break )
• a construção try-catch
Tarefas de exame
Vamos consolidar nossos conhecimentos resolvendo alguns problemas mais complexos com ciclos dados em
vestibulares.
Tarefa: gerador de senha idiota

Escreva um programa que receba dois inteiros n e l e gere em ordem alfabética todas as senhas "burras" possíveis
que consistem nos 5 caracteres a seguir:
• Character 1: dígito de 1 a n.
• Character 2: dígito de 1 a n.
• Símbolo 3: uma letra minúscula entre as l primeiras letras do alfabeto latino.
• Símbolo 4: uma letra minúscula entre as l primeiras letras do alfabeto latino.
• Caractere 5: um dígito de 1 a n, maior que os 2 primeiros dígitos.
Dados de entrada
A entrada é lida do console e consiste em dois inteiros: n e l no intervalo [1 … 9], um por linha.
Dados de saída
Todas as senhas "burras" devem ser impressas no console em ordem alfabética,
separados por um espaço.

11aa2 11ab2 11ac2 11ad2 11ba2 11bb2 11bc2 11bd2

11aa2 11aa3 12aa3
11ca2 11cb2 11cc2 11cd2 11da2 11db2 11dc2 11dd2
24 31 21aa3 22aa3
2 1aa3 21aa4 21ab3 21ab4 21ba3 21ba4 21bb3 11aa2 11aa3

21bb4 22aa3 22aa4 22ab3 22ab4 22ba3 22ba4 22bb3 11ab2 11ab3
22bb4 23aa4 23ab4 23ba4 23bb4 31aa4 31ab4 31ba4 11ba2 11ba3
31bb4 32aa4 32ab4 32ba4 32bb4 33aa4 33ab4 33ba4 11bb2 11bb3
4 33bb4 3 12aa3 12ab3
2 2 12ba3 12bb3
21aa3 21ab3
21ba3 21bb3
22aa3 22ab3
22ba3 22bb3
Diretrizes e dicas
Podemos dividir mentalmente a solução da tarefa em três partes:
• Lendo os dados de entrada – na presente tarefa, isso envolve a leitura de dois números n e l, cada um em
uma linha separada.
• Processamento de entrada – usando loops aninhados para percorrer todos os caracteres

possíveis para cada um dos cinco caracteres da senha.
• Resultado da impressão - imprima qualquer senha "burra" que corresponda
das condições.
Lendo e processando os dados de entrada

Para ler os dados de entrada, declararemos duas variáveis do tipo inteiro int: n e l.
Vamos declarar e inicializar as variáveis que irão armazenar os caracteres da senha: para os caracteres digitais
- do tipo int - d1, d2, d3, e para as letras - do tipo char - l1, l2.
Gerando um resultado
Capítulo 7.2. Ciclos mais complexos - tarefas de exame 295
Precisamos aninhar cinco loops for um dentro do outro, um para cada variável. Para
garantir a condição de que o último dígito d3 seja maior que os dois primeiros, usaremos
a função interna Math.max(…).
Você sabia disso…?
• Podemos definir um loop for com uma variável char :
• Podemos ler uma variável char do console com o seguinte

construção:
• Podemos converter letras maiúsculas em minúsculas usando a função interna

ção em Java:
• Ao ler os caracteres do console, podemos converter diretamente letras maiúsculas em minúsculas

concatenando as duas linhas acima:

Desafio: Números Mágicos

Escreva um programa que receba como entrada um inteiro mágico e como saída todos
os números possíveis de 6 dígitos para os quais o produto de seus dígitos seja igual ao
número mágico.
Exemplo: "Número mágico" ÿ 2
*
• 111112 ÿ 1 1* 1* 1* 1*2=2
*
• 111121 ÿ 1 1* 1* 1*2* 1=2
*
• 111211 ÿ 1 1* 1*2* 1* 1=2
• 112111 ÿ 1 * * * * *
1 2 1 1 1=2
• 121111 ÿ 1 * * * * *
2 1 1 1 1=2
• 211111 ÿ 2 * * * * *
1 1 1 1 1=2
Dados de entrada
A entrada é lida do console e consiste em um número inteiro no intervalo [1 … 600.000].
Dados de saída
Todos os números mágicos divididos por devem ser impressos no console
intervalo.
Entrar Sair Entrar Saída Entrada Saída
111118 111124 111142 111181 111214

111222 111241 111412 111421 111811
112114 112122 112141 112212 112221
111112 112411 114112 11 4121 114211 118111 5
111121 121114 121122 121141 121212 121221 3
111211 121411 122112 122121 122211 124111 1
2 8 999999
112111 141112 141121 141211 142111 181111 4
121111 211114 211122 211141 211212 211221 4
211111 211411 212112 212121 212211 214111 1
221112 221121 221211 222111 241111
411112 411121 411211 412111 421111 811111
Diretrizes e dicas
A solução do problema do número mágico segue o mesmo conceito (novamente precisamos
gerar todas as combinações para n elementos). Seguindo estas etapas, tente resolver a tarefa
sozinho.
• Declarar e inicializar uma variável de tipo inteiro int e pro
leia a entrada do console.
• Aninhe seis loops for um dentro do outro, um para cada dígito dos números de 6 dígitos que
estão sendo procurados.
• No último loop, por meio de uma construção if , verifique se o produto de
os seis dígitos é igual ao número mágico.
No capítulo anterior, examinamos outras construções cíclicas. Vejamos um exemplo de solução para o mesmo
problema, no qual usamos o loop while. Primeiro, precisamos armazenar o número mágico de entrada em uma
variável adequada. Em seguida, inicializaremos 6 variáveis - uma para cada um dos seis dígitos
dos números procurados como resultado.
Em seguida, começaremos a escrever os loops while .
• Vamos inicializar o primeiro dígito: d1 = 0. • Vamos definir uma

condição para cada loop: o dígito deve ser menor ou igual a
9.
• No início de cada loop, definimos um valor para o próximo dígito, neste caso: d2 = 0. Nos loops for
aninhados , inicializamos as variáveis nos loops internos a cada incremento dos externos. queremos
alcançar
mesmo comportamento aqui.
• Ao final de cada loop, incrementaremos o número em um: d++. • No loop mais interno
faremos a checagem e se necessário iremos
nós imprimimos no console.
Vamos remover a verificação if do loop mais interno. Agora, vamos inicializar cada
variável fora dos loops e deletar as linhas dx = 0. Depois de executar o programa,
obtemos apenas 10 resultados. Por que? E se você usar um loop do-while ? Nesse
caso, esse ciclo não parece adequado, não é? Pense no porquê. Claro, você também
pode resolver o problema usando um loop infinito.
Como podemos ver, podemos resolver um problema com diferentes tipos de loops. Claro, há uma melhor
escolha para cada tarefa. Para praticar cada ciclo - tente resolver cada um dos seguintes problemas com
todos os ciclos estudados.

Tarefa: número de parada

Escreva um programa que imprima no console todos os números de N a M que são divisíveis por 2 e 3 sem
deixar resto, na ordem inversa. Outro número de "parada" S será lido do console. Se algum dos números
divisíveis por 2 e 3 for igual ao número de parada, ele não deve ser impresso e o programa deve ser
encerrado. Caso contrário, todos os números até N que atendem à condição são impressos.
Conecte-se
3 números são lidos no console, cada um em uma linha separada:

• N - inteiro: 0 ÿ N < M. • M -
inteiro: N < M ÿ 10000. • S - inteiro: N
ÿ S ÿ M.
Saída
Todos os números qualificados são impressos em uma única linha separada por espaços no console.

Os números de 30 a 1 que são divisíveis por 2 e 3 sem deixar resto são:

1 30 24 18 12 6 30, 24, 18, 12 e 6. O número 15 não é igual a nenhum, então a sequência
30 15 continua.
1 Os números de 36 a 1 que são divisíveis por 2 e 3 sem deixar resto são:

36 36 30 24 18 36, 30, 24, 18, 12 e 6. O número 12 é igual ao número de parada, então
12 paramos em 18.
Diretrizes e dicas
A tarefa pode ser dividida em quatro partes lógicas:

• Lendo os dados de entrada do console. • Verifique
todos os números no intervalo dado, gire de acordo

ciclo.
• Verificação das condições da tarefa em relação a cada número em questão
intervalo.
• Imprima os números.
A primeira parte é trivial - leremos três números inteiros do console, portanto, usaremos
o tipo int.
Também encontramos a segunda parte - inicializando o loop for . Há um pequeno
problema aqui - a condição menciona que os números devem ser impressos na ordem
inversa. Isso significa que o valor inicial da variável i será o maior número, o que vemos
nos exemplos é M. Assim, o valor final de i deve ser N. O fato de imprimirmos os
resultados na ordem inversa e os valores de eu sugiro que o passo seja decrementado
em 1.
Depois de inicializarmos o loop for , é hora da terceira parte da tarefa - verificar se o

número fornecido é divisível por 2 e 3 sem resto. Faremos isso com uma verificação if
simples , que deixaremos para o leitor construir.
O outro problema nesta tarefa é que, além da verificação acima, precisamos fazer mais
uma - se o número é igual ao número de "parada" fornecido pelo console na terceira
linha. Para chegar a esta verificação, o número que estamos verificando deve passar pelo
superior. Por esta razão, construiremos outro if construct, que iremos aninhar dentro do
anterior. Se a condição for verdadeira, a tarefa é impedir a impressão do programa, o que
neste caso específico podemos fazer com uma instrução break, que nos tirará do loop
for .
Assim, se a condição de verificar se o número corresponde ao número "parado" retornar
falso, por padrão, nosso programa deve continuar imprimindo. Na verdade, isso cobre a
quarta e última parte do nosso programa.

Tarefa: números especiais

Escreva um programa que receba um inteiro N e gere todos os números "especiais"
possíveis de 1111 a 9999. Para um número ser "especial", ele deve satisfazer a seguinte
condição:
• N a ser dividido por cada um de seus dígitos sem deixar resto.
Capítulo 7.2. Loops Mais Complexos - Problemas de Exame 301
Exemplo: para N = 16, 2418 é um número especial:

• 16/2 = 8 sem resto •
16/4 = 4 sem resto • 16/1
= 16 sem resto
• 16/8 = 2 sem resto
Dados de entrada
A entrada é lida do console e consiste em um número inteiro no intervalo [1 … 600.000].
Dados de saída
Imprima todos os números especiais separados por um espaço no console.
Entrada Saída Comentários
3/1 = 3 sem resto 3/3

1111 1113 1131 1133 1311 1313 1331 1333 3111 = 1 sem resto 3/3 = 1
3
3113 3131 3133 3311 3313 3331 3333 sem resto 3/3 = 1 sem
resto
Entrar Sair Sair
1111 1112 1114 1118 1121 1122 1124 1128 1141

1142 1144 1148 1181 1182 1184 1188 1211 1212 1214
1218 1221 1222 1224 1228 1241 1242 1244 1248 1281
1282 1284 1288 1411 1 412 1414 1418 1421 1422 1424
1428 1441 1442 1444 1448 1481 1482 1484 1488 1811
1812 1814 1818 1821 1822 1824 1828 1841 1842 1844
1848 1881 1882 1884 1888 2111 2112 2114 2118 2121
2122 2124 2128 2141 2142 2144 2148 2181 2182 2184
2188 2211 2212 2214 2 218 2221 2222 2224 2228 2241
11 1111 16 2242 2244 2248 2281 2282 2284 2288 2411 2412 2414
2418 2421 2422 2424 2428 2441 2442 2444 2448 2481
2482 2484 2488 2811 2812 2814 2818 2821 2822 2824
2828 2841 2842 2844 2848 2881 2882 2884 2888 4111
4112 4114 4118 4121 4 122 4124 4128 4141 4142 4144
4148 4181 4182 4184 4188 4211 4212 4214 4218 4221
4222 4224 4228 4241 4242 4244 4248 4281 4282 4284
4288 4411 4412 4414 4418 4421 4422 4424 4428 4441
4442 4444
Entrar Sair Sair
4448 4481 4482 4484 4488 4811 4812 4814 4818 4821
4822 4824 4828 4841 4842 4844 4848 4881 4882 4884
4888 8111 8112 8114 8 118 8121 8122 8124 8128
8141 8142 8144 8148 8181 8182 8184 8188 8211 8212
8214 8218 8221 8222 8224 8228 8241 8242 8244 8248
8281 8282 8284 8288 8411 8412 8414 8418 8421 8422
8424 8428 8441 8442 8444 8448 8481 8482 8484 8488
8811 8812 8814 8818 8821 8 822 8824 8828 8841
8842 8844 8848 8881 8882 8884 8888
Diretrizes e dicas
Resolva o problema de forma independente usando o que você aprendeu nos dois
anteriores. Lembre-se da diferença entre os operadores de divisão de número inteiro (/) e
divisão de resto (%) em Java.

Tarefa: números
Para escrever um programa que lê do console 1 inteiro no intervalo [100 … 999] e o
imprime um certo número de vezes - modificando-o
antes de cada impressão da seguinte forma:
• Se um número for divisível por 5 sem resto, subtraia seu primeiro dígito.
• Se um número for divisível por 3 sem resto, subtraia seu segundo dígito. • Se nenhuma
das condições acima for verdadeira, adicione a terceira a ela
sua figura.
Imprima no console N número de linhas, cada linha tendo M número de números que são
o resultado das ações acima. Deixar:
• N = a soma do primeiro e segundo dígitos do número. • M =
a soma do primeiro e terceiro dígitos do número.
Dados de entrada
A entrada é lida do console e é um número inteiro no intervalo [100 … 999].
Dados de saída
Para o console imprima todos os números inteiros resultantes dos cálculos dados acima
no número apropriado de linhas e colunas como nos exemplos.
Capítulo 7.2. Loops mais complexos - problemas de exame 303

382 388 394 400 397 403 409 415 412 418 424 10 linhas de 9 números por
430 427 433 439 445 442 448 454 460 457 463 todos.
469 475 472 478 484 490 487 493 4 99 505 502 O número de entrada 376:
508 514 520 517 523 529 535 532 538 544 550 376 ÿ nem 5 nem 3 ÿ 376 + 6 ÿ
547 553 559 565 562 568 574 580 577 583 589 = = 382 ÿ nem 5 nem 3 ÿ 382 +
376
595 592 598 604 610 607 613 619 625 622 628 6 = = 388 + 6 = 394 + 6 =
634 640 637 643 649 655 652 658 664 670 667 400 ÿ
673 679 685 6 82 688 694 700 697 703 709 divisão por 5 ÿ 400 - 3 = 397
715 712 718
(1 + 3) = 4 e (1 + 2) = 3 ÿ 4 linhas de 3 números em
todos.
O número de entrada 132:
129 126 123
132 ÿ divisão por 3 ÿ 132 - 3 = = 129 ÿ
120 119 121
132 divisão por 3 ÿ 129 - 3 = = 126 ÿ divisão
123 120 119
por 3 ÿ 126 - 3 = = 123 ÿ divisão por 3 ÿ
121 123 120
123 - 3 = = 120 ÿ divisão por 5 ÿ 120 - 1 =
121 ÿ nem por 5 nem por 3 ÿ 121 + 2 = 123
.....
Diretrizes e dicas
Resolva a tarefa de forma independente usando o que você aprendeu nas anteriores. Lembre-se de
que você precisará definir uma variável separada para cada dígito do número de entrada.

Capítulo 8.1. Preparação para Exames

Práticos - Parte I
Neste capítulo, veremos alguns problemas em um nível de dificuldade que você pode esperar
dos problemas do exame prático de Fundamentos da programação. Discutiremos e praticaremos
todo o conhecimento que você adquiriu neste livro e no curso Básico de Programação.
Vídeo
Assista a um tutorial em vídeo sobre este capítulo: https://youtube.com/watch?v=ljaZHRCyZW8 .
Exame prático sobre "Fundamentos de Programação"

O curso "Programming Basics" termina com um exame prático. São 6 tarefas incluídas e você
terá 4 horas para resolvê-las. Cada uma das tarefas do exame abordará um dos tópicos estudados
durante o curso. Os tópicos das tarefas são os seguintes:
• Tarefa com cálculos simples (sem verificações)
• Tarefa de verificação única
• Tarefa com verificações mais complexas
• Tarefa de loop único
• Tarefa com loops aninhados (desenhar um boneco no console)
• Tarefa com loops aninhados e lógica mais complexa
Sistema de Julgamento Online (Juiz)

Todos os exames e trabalhos de casa são testados automaticamente através do sistema online
do Juiz: https://judge.softuni.bg. Para cada uma das tarefas existem testes abertos (zero) que o
ajudarão a entender o que se espera da tarefa e corrigir erros
eles também são testes competitivos que estão ocultos e verificam se sua tarefa está funcionando
corretamente. O sistema de juízes é inserido com sua conta softuni.bg.
Como funciona o teste no sistema de juízes? Você carrega o código-fonte e, no menu abaixo,
escolhe compilá-lo como um programa Java. O programa é testado com uma série de testes e,
para cada teste bem-sucedido, você ganha pontos.
Problemas com cálculos simples

A primeira tarefa do exame prático de Fundamentos de Programação abrange cálculos simples
sem verificações e loops. Aqui estão alguns exemplos:
Problema: face de um triângulo no plano

Um triângulo no plano é definido pelas coordenadas

de seus três vértices. Primeiro, o vértice (x1, y1) é
definido. Em seguida, os dois vértices restantes são
definidos: (x2, y2) e (x3, y3), que se encontram em
uma linha horizontal comum (ou seja, têm as mesmas
coordenadas Y). Escreva um programa que calcule a
face de um triângulo por
as coordenadas de seus três vértices.
Entrada 6 inteiros são lidos do console (um por linha): x1, y1, x2, y2, x3, y3.
• Todos os números de entrada estão no intervalo [-1000 … 1000].
• É garantido que y2 = y3.
Saída
Para imprimir a face do triângulo no console.
Entrada Saída Desenho Explicações
5 O lado do triângulo: a = 6 – 1
-2 = 5 A altura
6 do triângulo: h = 1 – (-2) = 3 A
7.5
1 face do triângulo:
1 S = ah / 2 = 5 3 / 2 = 7,5
* *
1
Entrada Saída Desenho Explicações
4 O lado do triângulo: a = 3 –
1 (-1) = 4 A altura
-1 do triângulo: h = 1 – (-3) = 4 A
8
-3 face do triângulo:
* *
3 -3 S = um h/2=4 4/2 = 8
Capítulo 8.1. Preparação para Exames Práticos - Parte I 307
Orientações e dicas É
extremamente importante para este tipo de tarefas, onde são submetidas algumas coordenadas,
estar atento à ordem pela qual são submetidas, bem como ponderar corretamente qual das
coordenadas vamos utilizar e de que forma. Nesse caso, as entradas são x1, y1, x2, y2, x3, y3
nessa ordem. Se não seguirmos esta sequência, a decisão torna-se errada. Primeiro, escrevemos
o código que lê
dados enviados:
Precisamos calcular o lado e a altura do triângulo. Pelas figuras, assim como pela condição
y2 = y3 , notamos que um lado é sempre paralelo ao eixo horizontal. Isso significa que seu
comprimento é igual ao comprimento do segmento entre suas coordenadas x2 e x3, que é
igual à diferença entre as coordenadas maior e menor. Da mesma forma, podemos calcular
a altura. Será sempre igual à diferença entre y1 e y2 (ou y3 desde que sejam iguais). Como
não sabemos se x2 sempre será maior que x3, ou se y1 estará abaixo ou acima do lado do
triângulo, usaremos os valores absolutos da diferença para obter sempre números positivos,
pois um segmento não pode têm um comprimento negativo.
Usando a fórmula que conhecemos na escola para encontrar a face de um triângulo,

calcularemos a face. Uma coisa importante a considerar é que, embora obtenhamos apenas
números inteiros na entrada, a face nem sempre será um número inteiro. Portanto, usamos
uma variável do tipo double para a pessoa . Precisamos converter para a direita também
enésimo lado da equação, porque se passarmos números inteiros como parâmetros de
equação, nosso resultado também será um número inteiro.
A única coisa que resta é imprimir a cara do console.

Tarefa: carregar tijolos

Os trabalhadores da construção precisam mover um total de x tijolos. Os trabalhadores são w em número
e trabalham simultaneamente. Eles transportam os tijolos em carrinhos, cada um com capacidade para m
tijolos. Escreva um programa que leia os inteiros x, w e m e calcule o menor número de percursos que os
trabalhadores devem fazer para carregar os tijolos.
Entrada
3 inteiros são lidos do console (um por linha):
• O número de tijolos x é lido na primeira linha.

• O número de trabalhadores w é lido na segunda
linha. • A capacidade m do carrinho é lida a partir da terceira linha.
Todos os números de entrada são inteiros e estão no intervalo [1 … 1000].
Saída
Para imprimir no console o número mínimo de cursos necessários para o transporte
colocando os tijolos.
120 Temos 2 trabalhadores, cada um dirigindo 30 tijolos por curso. No total, os

2 trabalhadores dirigem 60 tijolos por curso. Para transportar 120 tijolos, são
2 30 necessários exatamente 2 cursos.
Explicações de entrada e saída
Temos 3 trabalhadores, cada um dirigindo 10 tijolos por curso. No total, os

355 trabalhadores dirigem 30 tijolos por curso. São necessários exatamente 12 cursos
12 para carregar 355 tijolos: 11 cursos completos carregam 330 tijolos e o 12º curso
3 10 final carrega os últimos 25
tijolos.
Explicações de entrada e saída
5 Temos 5 trabalhadores, cada um conduzindo 30 tijolos por curso. No total, os

12 1 trabalhadores conduzem 150 tijolos por curso. Para carregar 5 tijolos basta apenas
30 1 percurso (ainda que incompleto, com apenas 5 tijolos).
Diretrizes e dicas
A entrada é padrão, e só precisamos ter cuidado com a sequência em que lemos os dados.
Capítulo 8.1. Preparação para o Exame Prático - Parte I 309
Contamos quantos tijolos os trabalhadores carregam em um curso.
Dividindo o número total de tijolos transportados em 1 curso, obteremos o número de cursos

necessários para carregá-los. Devemos levar em conta que ao dividir números inteiros, o
resto é ignorado e sempre arredondado para baixo. Para evitar isso, converteremos o lado
direito da equação em um duplo e usaremos a função Math.ceil(…) para sempre arredondar
o resultado resultante para cima. Quando os tijolos puderem ser movidos por um número
exato de cursos, a divisão retornará um número exato e não haverá nada para arredondar.
Assim, quando não for o caso, o resultado da divisão será o número de cursos exatos, mas
com uma parte decimal. A parte decimal será arredondada e assim será obtida a taxa 1
necessária para os tijolos restantes.
Por fim, imprimimos o resultado no console.

Tarefas de verificação única

A segunda tarefa do exame prático de Fundamentos da Programação abrange a construção
condicional e as convoluções simples. Aqui estão alguns exemplos:
Problema: um ponto em um segmento

Um segmento horizontal está localizado em uma linha horizontal, definida com as coordenadas
x de suas duas extremidades: primeira e segunda. Um ponto está localizado na mesma linha
horizontal e recebe sua coordenada x. Escreva um programa que verifique se um ponto está
dentro ou fora do segmento e calcule a distância até a extremidade mais próxima do segmento.
Entrada 3 inteiros são lidos do console (um por linha):

• Na primeira linha está o primeiro número - uma extremidade do segmento.
• Na segunda linha está o segundo número - a outra extremidade do segmento.
• Na terceira linha está o ponto numérico - a localização do ponto.
Todos os números de entrada são inteiros e estão no intervalo [-1000 … 1000].
Saída
Para imprimir o resultado no console:
• Na primeira linha, imprima "in" ou "out" - se o ponto está no segmento
ou fora dela.
• Na segunda linha, imprima a distância do ponto até a extremidade mais próxima

na seção.
Pré-visualização de início de sessão
10
5
em 2
7
8
fora
10
3
5
fora
1
2
-2 3
Diretrizes e dicas
Lemos a entrada do console.
Como não sabemos qual ponto está à esquerda e qual está à direita, criaremos duas variáveis para nos dizer
isso. Como o ponto mais à esquerda é sempre aquele com a menor coordenada x, usaremos Math.min(…)
para encontrá-lo. Assim, o correto é sempre aquele com maior coordenada x e usamos Math.max(…).
Também encontraremos a distância do ponto x aos dois pontos. Como não sabemos a posição um em
relação ao outro, usaremos Math.abs(…) para obter
resultado positivo.
Encontraremos a menor das duas distâncias usando Math.min(…).
Resta descobrir se o ponto está dentro ou fora da linha. Um ponto estará na linha sempre
que coincidir com qualquer um dos outros dois pontos ou sua coordenada x estiver entre
eles. Caso contrário, o ponto está fora da linha. Após a verificação, enviamos uma de duas
mensagens, dependendo de qual verificação foi satisfeita.
Finalmente imprimimos a distância encontrada anteriormente.

Tarefa: apontar em uma figura

Escreva um programa que verifique se um determinado ponto (com coordenadas x e y) está
dentro ou fora da figura a seguir:
Entrada Dois inteiros (um por linha) são lidos no console: x e y.

Todos os números de entrada são inteiros e estão no intervalo [-1000 … 1000].
Saída
Para imprimir no console "dentro" ou "fora" – se o ponto está dentro ou fora da forma (no
contorno está dentro).
11 11
em em fora fora
8 -5 6 -3 -5 2
Diretrizes e dicas
Para descobrir se o ponto está na figura, vamos dividir a figura em 2 quatros
pescador:
Basta que o ponto esteja em um deles para que ele esteja na figura.
Lemos no console os dados de entrada:
Faremos duas verificações para saber se o ponto está dentro de um dos retângulos. Ao imprimir a mensagem,
verificaremos se alguma dessas verificações retornou true. Basta que apenas uma delas seja verdadeira
para localizar o ponto na figura.

Tarefas com verificações mais complexas

A terceira tarefa do exame prático de Fundamentos de Programação inclui várias verificações aninhadas
combinadas com cálculos simples. Aqui estão alguns exemplos:
Tarefa: data em 5 dias

Dois números d (dia) em (mês) são dados, os quais formam uma data. Escrever um programa que
imprima a data que será em 5 dias. Por exemplo, 5 dias após 28.03 é a data 2.04. Assumimos que os
meses: abril, junho, setembro e novembro têm 30 dias cada, fevereiro tem 28 dias e os outros têm 31
dias cada. Os meses devem ser impressos com um zero à esquerda quando forem de um dígito (por
exemplo, 01, 08).
Entrada
A entrada é lida no console e consiste em duas linhas:

• Na primeira linha existe um inteiro d no intervalo [1 … 31] - dia. O número do dia não excede
o número de dias do mês correspondente (por exemplo, 28 para fevereiro). • Na segunda
linha há um inteiro m no intervalo [1 … 12] – mês. O mês 1 é janeiro, o mês 2 é fevereiro, …, o
mês 12 é dezembro. O mês pode conter um zero à esquerda (por exemplo, abril pode ser
escrito como 4 ou 04).
Saída
Imprime no console uma única linha contendo uma data daqui a 5 dias no formato dia.mês. O mês
deve ser um número de dois dígitos com um zero à esquerda, se necessário. O dia deve estar sem
um zero à esquerda.
28 27 25 26
2.04 1.01 30.01 3.03
03 12 1 02
Diretrizes e dicas Aceitamos
informações do console.
Para facilitar nossas verificações, criaremos uma variável que conterá o número de dias do mês que
definimos.
Aumentamos o dia em 5.
Verificamos se o dia não ficou mais longo do que o número de dias do mês correspondente. Se for esse
o caso, precisamos subtrair os dias do mês do dia resultante para obter nosso dia a qual dia do próximo
mês corresponde.
Uma vez que passamos para o próximo mês, isso deve ser notado aumentando o conjunto inicial em 1.
Devemos verificar se ele se tornou maior que 12 e, em caso afirmativo, ajustar. Como não podemos pular
mais de um mês ao incrementar em 5 dias, a verificação inferior é bastante
gordo.
Resta apenas imprimir o resultado no console. É importante que formatemos a saída corretamente para
que o zero à esquerda apareça nos primeiros 9 meses. Isso é feito adicionando a string de formato %02d
ao segundo elemento. 0 indica com qual dígito preencher o espaço destinado a ele e 2 indica a quantidade
de espaços a serem preenchidos pelo dígito em questão.
Tarefa: somas de 3 números

Dados 3 números inteiros. Escreva um programa que verifique se a soma de dois dos números é igual ao
terceiro. Por exemplo, se os números forem 3, 5 e 2, a soma de dois dos números é igual ao terceiro: 2 +
3 = 5.
Conecte-se
Três inteiros são lidos no console, um por linha. Os números estão no intervalo [1 … 1000].
Saída
• Imprimir no console uma linha contendo a solução do problema no formato "a + b = c", onde
a, b e c estão entre os três números de entrada e a ÿ b.
• Se a tarefa não tiver solução, imprimir “Não” no console.
3 2 1 2
5 2+3=5 2 2+2=4 1 Não 6 Não
2 4 5 3
Diretrizes e dicas
Aceitamos informações do console.
Precisamos verificar se a soma de qualquer par de números é igual ao terceiro. Nós temos
três casos possíveis:
•a+b=c
•a+c=b
•b+c=a
Escreveremos um quadro, que adicionaremos com o código necessário. Se nenhuma das

três condições acima for atendida, diremos ao programa para imprimir "Não".
Agora temos que descobrir a ordem em que os dois adendos serão escritos na saída do
programa. Para fazer isso, faremos uma condição aninhada que verifica qual dos dois números
é maior. No primeiro caso, acontecerá assim:
Da mesma forma, completaremos os outros dois casos. O código completo das verificações
e a saída do programa ficarão assim:

Tarefas de loop único

A quarta tarefa do exame prático de Fundamentos de Programação envolve um único loop
com lógica simples. Aqui estão alguns exemplos:
Tarefa: soma em 3
Dados n inteiros a1, a2, …, an. Para calcular as somas: … (soma os
a7 + passo 3). números começando do primeiro com • soma1 = a1 + a4 +
• soma2 = a2 + a5 + a8 + … (os números são somados, começando do segundo com um passo

3).
• soma3 = a3 + a6 + a9 + … (soma os números do terceiro com o passo 3).
Entrada Os dados de entrada são lidos no console. A primeira linha contém um inteiro
n (0 ÿ n ÿ 1000). As próximas n linhas contêm n inteiros no intervalo [-1000 … 1000]:
a1, a2, …, an.
As 3
linhas de saída contendo as 3 somas pesquisadas devem ser impressas no console no
formato dos exemplos.
5
4
3
2 soma1 = 3 7 soma1 = 19 soma1 = 10
5
3 soma2 = 5 -2 soma2 = -2 soma2 = 13
2
5 soma3 = 0 6 soma3 = 6 soma3 = 2
7
12
8
Diretrizes e dicas
Pegaremos o número de números do console e declararemos os valores iniciais das
três somas.
Como não sabemos antecipadamente quantos números vamos processar, vamos pegá-los um a um em um loop que se
repetirá n vezes e processá-los no corpo do loop.
Para saber em qual das três somas devemos somar o número, vamos dividir seu número sequencial por três e usar o resto.
Usaremos a variável i, que controla o número de voltas do loop, para descobrir em qual número estamos. Quando o resto
de i/3 for zero, isso significa que vamos adicionar esse número à primeira soma, quando for 1 à segunda e quando for 2 à
terceira.
Por fim, imprimiremos o resultado no console no formato necessário.
Tarefa: uma sequência de elementos crescentes

Dado um array de n números: a1, a2, …, an. Para calcular o comprimento da maior sequência crescente
de elementos consecutivos na sequência de números.
Entrada
Os dados de entrada são lidos no console. Primeira linha: inteiro n (0 ÿ n ÿ 1000). Próximas n linhas: n
inteiros no intervalo [-1000 … 1000]: a1, a2, …, um.
Saída
Um único número deve ser impresso no console - o comprimento do maior

um número crescente.
4 4 4
3
2 1 5
5
2 8 2 2 3 6 4
2
7 4 7
4
6 4 8
Diretrizes e dicas
Para a solução desta tarefa, precisamos pensar um pouco mais algoritmicamente. Nos é dada uma sequência de
números e precisamos verificar se cada próximo será maior que o anterior e, em caso afirmativo, contar quanto
tempo dura a sequência em que essa condição é satisfeita. Então temos que descobrir qual linha de todas é a
mais longa. Para fazer isso, vamos fazer algumas variáveis que irão
usamos durante o curso da tarefa.
A variável n é o número de números que obteremos do console. Em countCurrent Longest, armazenaremos

o número de elementos no array crescente que estamos contando no momento. Por exemplo. na linha: 5, 6, 1, 2,
3 countCurrentLongest será 2 quando atingirmos o segundo elemento da contagem (5, 6, 1, 2, 3) e se tornará
3 quando atingirmos o último elemento (5, 6, 1, 2, 3), porque a sequência crescente 1, 2, 3 tem 3 elementos.
Usaremos countLongest para armazenar a linha crescente mais longa. As variáveis restantes são a - o número
em que estamos atualmente e aPrev - o número anterior que compararemos com a para ver se a linha está
crescendo.
Começamos a rolar os números e verificamos se o número a atual é maior que o aPrev anterior. Se isso for
cumprido, a linha está crescendo e precisamos aumentar seu número em 1. Salvamos isso na variável que
acompanha o comprimento da linha em que estamos atualmente, ou seja, - countCurrentLongest . Se o número
a não for maior que o anterior, significa que uma nova linha começa e devemos começar a contar a partir de 1.
Finalmente, após todas as verificações, aPrev se torna o número que estamos usando atualmente e iniciamos o
loop a partir do começando com a próxima entrada a. Aqui está um exemplo de implementação de
algoritmo descrito:
Resta descobrir qual de todas as linhas é a mais longa. Faremos isso verificando no
loop se a linha em que estamos atualmente se tornou mais longa do que o comprimento
da mais longa encontrada até agora. Todo o ciclo ficará assim:
Por fim, imprimimos o comprimento da linha mais longa encontrada.

Tarefas para desenhar figuras no console

A quinta tarefa do exame prático de Fundamentos de Programação requer o uso de um
ou mais loops aninhados para desenhar alguma figura no console. Pensamento lógico,
realizando cálculos e verificações simples podem ser necessários. A tarefa testa a
capacidade dos alunos de pensar logicamente e de criar algoritmos simples para resolver
problemas, ou seja, pensar algoritmicamente. Aqui estão alguns exemplos de tarefas de
exame:
Tarefa: um diamante perfeito

Escreva um programa que leia um inteiro n do console e desenhe um diamante perfeito
de tamanho n como nos exemplos abaixo.
Entrada
A entrada é um número inteiro n no intervalo [1 … 1000].
Saída
O console deve imprimir o diamante como nos exemplos.

*
*-* *
* *-*-* *-*
* *-* *-*-*-* *-*-*
2 *-* 3 *-*-* 5 *-*-*-*-* 4 *-*-*-*
* *-* *-*-*-* *-*-*
* *-*-* *-*
*-* *
*
Diretrizes e dicas Da
amostra de saída, podemos ver que precisaremos imprimir caracteres repetidos.
Portanto, escrevemos um método com antecedência através do qual repetiremos
mesmo símbolo quantas vezes forem necessárias.
Nas tarefas de desenho de figuras, o mais importante a considerar é a sequência em

que desenhamos. Quais elementos são repetidos e com quais etapas. Podemos notar
claramente que a parte superior e inferior do diamante são iguais. Resolveremos o
problema com mais facilidade fazendo um loop que desenha a parte superior e outro
que desenha a parte inferior (oposta à parte superior). Vamos ler o
número n do console.
Começamos a desenhar a metade superior do diamante. Podemos ver claramente que

cada linha começa com vários espaços e *. Se olharmos mais de perto, perceberemos
que os espaços vazios são sempre iguais a n - o número da linha (na primeira linha
há n-1, na segunda - n-2, etc.) Começaremos por desenhando os espaços numéricos,
bem como o primeiro asterisco. Lembre-se de usar System.out.print(…) ao invés de
System.out.println(…) para ficar na mesma linha. No final da linha escrevemos
System.out.println(…) para mover para uma nova linha. Observe que começamos a
contar a partir de 1, não 0. Depois é só adicionar -* algumas vezes para completar a
linha.
Aqui está um trecho de código para desenhar o topo do diamante:
Resta completar cada linha com o número necessário de -* elementos. Em cada linha,
precisamos adicionar i - 1 desses elementos (no primeiro 1-1 -> 0, no segundo -> 1, etc.)
Aqui está o código completo para desenhar o topo do diamante:
Para desenhar a parte inferior do diamante, precisamos virar a parte superior de cabeça
para baixo. Contaremos de n - 1, pois se começarmos em n desenharemos a linha do
meio duas vezes. Não se esqueça de alterar a etapa de ++ para --.
Aqui está o código para desenhar a parte inferior do diamante:
Resta montar todo o programa lendo primeiro a entrada, imprimindo a parte superior do
losango e depois a parte inferior do losango.

Tarefa: um retângulo com estrelas no centro

Escreva um programa que leia um inteiro n do console e desenhe um retângulo de tamanho
n com dois asteriscos no centro, como nos exemplos abaixo.
Entrada A entrada é um inteiro n no intervalo [2 … 1000].
Saída
O retângulo deve ser impresso no console como nos exemplos.
Entrar Sair Sair Entrada Saída Conecte-se Saída
%%%%%%%%%
%%%%%% %%%%%%% % % % % % ** %
%%% % % % ** % % % % ** % % % % %%%
2 % 3 % % % %% 4 % % % %%% 5 %%%%%%%
%**% %%%% %%%% %%%%%
Orientações e dicas
Nesta tarefa também notamos que teremos que imprimir o mesmo caractere várias vezes.
Para nossa conveniência, primeiro escrevemos um método que tornará a impressão do
mesmo símbolo rápida e fácil.
Lemos os dados de entrada da tarefa.
A primeira coisa que notamos facilmente é que a primeira e a última linhas contêm símbolos
2 * n % . Vamos começar com isso e, em seguida, desenhar o meio do
o quadrilátero.
A partir dos exemplos dados, vemos que o meio da figura sempre tem um número ímpar
de linhas. Notamos que quando um número par é definido, o número de linhas é igual
ao número ímpar anterior (2 -> 1, 4 -> 3, etc.). Criamos uma variável que representa o
número de linhas que nosso retângulo terá e ajustamos se o número n for par. Em
seguida, vamos desenhar o retângulo sem as estrelas. Cada linha começa e termina
com o símbolo % e entre eles 2 * n - 2 espaços (a largura é 2 * n e subtraímos 2 para
os dois percentuais no final). Não se esqueça de mover o código para a última linha
após o loop.
Podemos executar e testar o código até aqui. Tudo sem os dois asteriscos no meio deve
funcionar corretamente.
Agora resta adicionar os asteriscos no corpo do ciclo. Vamos verificar se estamos na fila
do meio. Se estivermos no meio, traçaremos a linha junto com os asteriscos, caso
contrário, traçaremos uma linha normal. A linha com os asteriscos tem n - 2 espaços em
branco (n é metade do comprimento e removemos o asterisco e a porcentagem), duas
estrelas e novamente n - 2 espaços em branco. Deixamos os dois por cento no início e
no final da linha fora do cheque.

Tarefas com loops aninhados com lógica mais complexa

A última (sexta) tarefa do exame prático "Fundamentos de Programação" requer o uso de vários
loops aninhados e lógica mais complexa neles. A tarefa testa a capacidade dos alunos de pensar
algoritmicamente e resolver problemas não triviais que requerem a construção de loops. A seguir
estão alguns exemplos de tarefas de exame.
Problema: quatro números crescentes

Dado um par de números a e b, gere todos os quadrantes n1, n2, n3, n4 para os quais a ÿ n1 < n2
< n3 < n4 ÿ b.
Entrada A entrada contém dois inteiros aeb no intervalo [0 … 1000], um por linha.
Saída
A saída contém todos os quads pesquisados, em ordem crescente, um por
ordem.
3456
3457
3 10
3467 Não 10 11 12 13
7 57 13
3567
4567
Diretrizes e dicas Vamos

ler a entrada do console. Também criamos a contagem de variável adicional, que acompanhará
se existe um intervalo de números existente.
Resolveremos a tarefa com mais facilidade se a dividirmos logicamente em partes. Se

formos obrigados a produzir todas as linhas de um único número entre a e b, faremos isso
com um loop que gera todos os números de a até b. Vamos considerar como isso seria
feito com linhas de dois números. A resposta é simples - usaremos loops aninhados.
Podemos testar o programa não escrito para ver se ele está correto até este ponto. Deve
imprimir todos os pares de números i, j para os quais i ÿ j.
Como cada número subsequente na sequência deve ser maior que o anterior, o segundo
loop girará de i + 1 (o próximo número maior). Assim, se não houver sequência de dois
números crescentes (a e b são iguais), o segundo ciclo
não será executado e nada será impresso no console.
Analogamente, resta implementar loops aninhados para quatro números da mesma

maneira. Também vamos incrementar o contador que inicializamos no início para saber se
tal linha existe.
Por fim, verificaremos se o contador é igual a 0 e, consequentemente, imprimiremos “Não”

no console, se for o caso.

Tarefa: gerar retângulos

Dado um número n e uma área mínima m, gere todos os retângulos com coordenadas inteiras no intervalo
[-n…n] com área de pelo menos m. Retângulos gerados para serem impressos no seguinte formato:
(esquerda, superior) (direita, inferior) -> área
Os retângulos são definidos por seus cantos superior esquerdo e inferior direito. As seguintes desigualdades
são válidas:
• -n ÿ esquerda < direita
ÿ n • -n ÿ superior < inferior ÿ n
Conecte-se
Dois números são inseridos no console, um por linha:

• Número inteiro n no intervalo [1 … 100] – define o mínimo e o máximo
coordenada do pico.
• Um inteiro m no intervalo [0 … 50000] – define a área mínima de
os retângulos gerados.
Saída
• Os retângulos descritos no formato devem ser impressos no console
como nos exemplos abaixo.
• Se não houver retângulo para os números n e m, exiba “No”. • A ordem em que os

retângulos são exibidos não importa.
Conecte-se Saída Entrada Saída Conecte-se Saída
(-1, -1) (0, 1) -> 2 (-1,

-1) (1, 0) -> 2 (-1, -1)
(1, 1) -> 4 (-1, 0) ) (1, Não (-3, -3) (3, 3) -> 36
12 2 17 3 36
1) -> 2 (0, -1) (1, 1)
-> 2
Diretrizes e dicas
Vamos ler a entrada do console. Também criaremos um contador no qual manteremos o número de
retângulos encontrados.
É extremamente importante poder visualizar a tarefa antes de começar a resolvê-la. No nosso caso,
somos obrigados a procurar retângulos em um sistema de coordenadas. O que sabemos é que o ponto
esquerdo sempre terá uma coordenada x menor que o ponto direito. Assim, o superior sempre terá uma
coordenada y menor que o inferior. Para encontrar todos os retângulos teremos que fazer um loop
semelhante ao do problema anterior, mas desta vez nem todos os loops subsequentes serão
começa no próximo número porque algumas das coordenadas podem ser iguais
(por exemplo, esquerda e superior).
Com as variáveis esquerda e direita seguiremos as coordenadas na horizontal, e com superior e

inferior - na vertical. O importante aqui é saber quais são as coordenadas para que possamos calcular
corretamente os lados do retângulo. Agora temos que ir
borda a face do retângulo e verifica se é maior ou igual a m. Um lado será a diferença entre esquerda
e direita e o outro - entre superior e inferior. Como as coordenadas podem ser trocadas, usaremos
valores absolutos. Novamente, também adicionamos o contador no loop, contando apenas os
quadriláteros que escrevemos. É importante notar que a ordem de escrita é esquerda, cima, direita,
baixo, pois é isso que está definido na condição.
Finalmente, imprimimos “Não” se tais retângulos não existirem.
Capítulo 8.2. Preparação para Exames

Práticos - Parte II
Neste capítulo, veremos um exame prático de programação realizado na SoftUni em 18 de
dezembro de 2016. As tarefas dão uma boa ideia do que esperar no vestibular de programação
da SoftUni. O exame abrange o material estudado deste livro e do curso "Fundamentos de
Programação" da SoftUni.
Vídeo
Assista a um tutorial em vídeo sobre este capítulo: https://youtube.com/watch?v=m9OscwPmZQE.
Tarefas de exame
Tradicionalmente, o vestibular SoftUni consiste em 6 tarefas práticas de programação:
• Tarefa com cálculos simples (sem verificações).

• Tarefa de verificação única. • Tarefa
com verificações mais complexas. •
Tarefa de loop único. • Tarefa
com loops aninhados (desenhar um boneco no console). • Tarefa com
loops aninhados e lógica mais complexa.
Vejamos um tópico de exame real, as tarefas nele contidas e suas soluções.
Tarefa: distância
Escreva um programa para calcular quantos quilômetros percorre um carro para o qual
conhecemos a velocidade inicial (km/h), o tempo em minutos após o qual ele aumenta a velocidade
em 10%, uma segunda vez após o qual diminui a velocidade em 5% , e o tempo até o final da
viagem. Para encontrar a distância, você precisa converter minutos em horas (por exemplo, 70
minutos = 1,1666 horas).
Dados de entrada
4 linhas são lidas no console:
• A velocidade inicial em km/h – um inteiro no intervalo [1 … 300]. • A primeira vez
em minutos – um número inteiro no intervalo [1 … 1000]. • A segunda vez
em minutos – um número inteiro no intervalo [1 … 1000]. • A terceira vez em
minutos – um número inteiro no intervalo [1 … 1000].
Dados de saída
Para imprimir um único número no console: os quilômetros percorridos, formatados com o segundo
caractere após a vírgula.
*
Distância com velocidade inicial: 90 km/h min) = 90 km 1 vez (60
Após o aumento:
90 *
90 + 10% = 99,00 km/h (70 min) = 115,50 km Após a 1.166 horas
60
330,90 diminuição: 99 - 5% =
70 *
94,05 km/h min) = 125,40 km Total percorrido: 330,9 1,33 horas (80
80
km
*
Distância com velocidade inicial: 140 km/h (112 min) = 1,86 horas
261,33 km Após a subida:
140 *
140 + 10% = 154,00 km/h (75 min) = 192,5 km Após a 1,25 horas
112
917.12 descida: 154,00 - 5% =
75 *
146,29 km/h ( 190 min) = 463,28 km Total percorrido: 3,16 horas
190
917,1166 km
Diretrizes e dicas
É provável que tal condição possa parecer à primeira vista confusa e incompleta, adicionando complexidade
adicional a uma tarefa simples. vamos dividir
definindo várias subtarefas e tentando resolver cada uma delas, o que nos levará ao resultado final:
• Deixe que a primeira subtarefa seja ler os dados de entrada necessários

o corpo entra e salvá-los em variáveis apropriadas.
• Execução da lógica principal do programa, que no nosso caso se resume a

a cálculos simples dos dados que já temos.
• Cálculo e modelagem do resultado final.
A parte essencial da lógica do programa é calcular qual será a distância percorrida após todas as mudanças
de velocidade. Como durante a execução do programa alguns dos dados à nossa disposição mudam,
poderíamos dividir o código do programa em várias partes logicamente distintas:
• Calcular a distância percorrida a uma velocidade inicial. • Alterar a velocidade

e calcular a distância percorrida.
Capítulo 8.2. Preparação para Exames Práticos - Parte II 331
• Última alteração e cálculo da velocidade. • Resumindo.
Para ler os dados do console, usamos o Scanner:
Por padrão, os dados de entrada são inseridos em quatro linhas separadas, portanto,
devemos executar o código anterior quatro vezes no total.
Para realizar os cálculos, optamos por utilizar o tipo double.

Você pode ler mais sobre os diferentes tipos de dados na linguagem Java aqui: http://
introprogramming.info/intro-java-book/read-online/glava2-primitivni-tipove-i promenlivi.
Dessa
forma, conseguimos lidar com sucesso com a primeira subtarefa. O próximo passo é
converter os dados de entrada para os tipos apropriados para que possamos realizar os
cálculos necessários. Optamos por usar o tipo Integer ou int porque a condição da tarefa
menciona que os dados de entrada estarão em um determinado intervalo para o qual
esse tipo de dados é perfeitamente suficiente. Realizamos a conversão da seguinte
forma:
Inicialmente, salvamos uma variável que usaremos repetidamente. Essa abordagem de

centralização nos dá flexibilidade e a capacidade de alterar o resultado geral do programa
com o mínimo de esforço. Caso precisemos alterar o valor, basta fazê-lo em um local do
código, que
nos economiza tempo e esforço.
Evitar código repetitivo (centralização da lógica do programa) nas tarefas

que consideramos neste livro,
parece redundante à primeira vista, mas essa abordagem é essencial
ao criar aplicativos de grande escala em um ambiente de trabalho real e
praticá-lo em um estágio inicial de aprendizado
só ajudará a dominar um estilo de qualidade de

programação.
Calculamos o tempo decorrido (em horas) dividindo o tempo por 60 (os minutos em uma hora). Encontramos a
distância percorrida multiplicando a velocidade inicial pelo tempo decorrido (em horas). Em seguida, alteramos a
velocidade aumentando-a em 10% por condição. Calculamos as porcentagens, bem como as seguintes distâncias,
da seguinte forma:
• O intervalo de tempo (em horas) é encontrado dividindo-se o intervalo definido em minutos

pelos minutos contidos em uma hora (60).
• Encontramos a distância percorrida multiplicando o intervalo (em horas) por
a velocidade que obtivemos após o aumento.
• O próximo passo é reduzir a velocidade em 5%, conforme definido por

doença.
• Encontramos a distância restante conforme descrito nos dois primeiros pontos.
Até este ponto, conseguimos concluir duas das subtarefas mais importantes, ou seja, receber os dados e processá-
los. Resta calcular o resultado final. Como a condição exige que seja formatado com 2 casas decimais, podemos
fazer assim:
Caso você tenha trabalhado corretamente e executado o programa com os dados de entrada
da condição da tarefa, você verificará se está funcionando corretamente.

Tarefa: troca de ladrilhos

Haralambi tem dinheiro arrecadado para substituir os ladrilhos do piso do banheiro. Como o piso é um
retângulo e os ladrilhos são triangulares. Escreva um programa para calcular se o dinheiro arrecadado será
suficiente para ele. Eles são amplamente lidos no console
o nível e o comprimento do piso, bem como um lado do triângulo com a altura. Você precisa calcular
quantos ladrilhos são necessários para cobrir o chão. O número de ladrilhos deve ser arredondado para um
número inteiro maior e mais 5 ladrilhos adicionados por turno. O console também lê - o preço de um
ladrilho e o valor do trabalho de um artesão.
Dados de entrada Dados de saída

7 linhas são lidas no console: No console deve ser impresso em uma linha:
• O dinheiro arrecadado
• A largura do piso • O • Se o dinheiro for suficiente:
comprimento do piso • O “{Remaining money} lv left.” • Se
lado do triângulo • A altura do o dinheiro NÃO for suficiente: “Você vai
precisar de {O dinheiro que falta}
triângulo • O preço de uma telha •
lv mais.”
O valor para o artesão
O resultado deve ser formatado para a segunda
casa decimal.
Todos os números são números reais no
intervalo [0,00 … 5000,00].
1000 *
Área do piso ÿ 5,55 Área do 8,95 = 49,67249
5,55 *
ladrilho ÿ 0,9 0,85 / 2 = 0,3825 Ladrilhos necessários ÿ
8,95 Você vai
49,67249 / 0,3825 = 129,86... = 130 + 5 fira = 135 Valor total ÿ 135
0,90 precisar de 1209,65 lv
13,99 + 321 (master) =
0,85 mais.
2209,65 2209,65 > 1000 ÿ sem alcance BGN 1209,65
13,99
321
500 *
Área do piso ÿ 3 Área 2,5 = 7,5
*
do ladrilho ÿ 0,5 Ladrilhos 0,7 / 2 = 0,175
3
25,60 lv necessários ÿ 7,5 / 0,175 = 42,857... = 43 + 5 fira = 48 Valor total ÿ 48
2,5
restante. 7,8 + 100
0,5
(mestre) = 474,4 474,4 *< 500 ÿ 25,60 BGN restantes
0,7
7,80 100
Diretrizes e dicas
A próxima tarefa exige que nosso programa aceite mais entradas e execute um número maior de cálculos,
mesmo que a solução seja idêntica. Aceitamos os dados do usuário da nossa maneira conhecida.
Observe que na seção de entrada da condição é mencionado que todas as entradas serão números reais
e, portanto, usaríamos o tipo double.
Agora que temos tudo o que precisamos para implementar a lógica do programa, podemos prosseguir
para a próxima parte. Como poderíamos calcular o número necessário de ladrilhos que seriam suficientes
para cobrir todo o piso? A condição de que as telhas tenham uma forma triangular pode levar a confusão,
mas na prática a tarefa se resume a cálculos muito simples. Poderíamos calcular qual é a área total do
piso pela fórmula para
encontrar a área de um retângulo e qual é a área de um ladrilho usando a fórmula de triângulo apropriada.
Para calcular quantos ladrilhos são necessários, dividimos a área do piso pela área de um ladrilho
(lembrando de adicionar 5 ladrilhos extras conforme a condição).
Observe que a condição diz para arredondar o número de ladrilhos resultantes da

divisão para um inteiro maior e, em seguida, adicionar 5. Procure mais informações
sobre a funcionalidade do sistema para isso: Math.ceil(…).
Podemos chegar ao resultado final calculando o valor total necessário para cobrir todo o piso adicionando
o custo das telhas ao custo do artesão que temos a partir dos dados de entrada. Podemos supor que o
custo total das telhas pode ser obtido multiplicando o número de telhas pelo preço por telha. Se o valor
que temos disponível será suficiente, dividimos comparando o dinheiro arrecadado até agora (a partir dos
dados de entrada) e o total
despesas.

Tarefa: loja de flores

Uma floricultura oferece 3 tipos de flores: crisântemos, rosas e tulipas. Os preços
depende da estação.
Temporada crisântemos rosas tulipas
Primavera Verão BGN 2,00/ BGN 4,10/un. BGN 2,50/un.

outono inverno peça BGN 3,75/un. BGN 4,50/un. BGN 4,15/un.
Nos feriados, os preços de todas as flores aumentam 15%. Estão disponíveis os seguintes
descontos:
• Na compra de mais de 7 tulipas na primavera - 5% do preço do buquê inteiro. • Na compra de
10 ou mais rosas no inverno - 10% do valor do buquê inteiro.
• Para compra de mais de 20 flores no total em todas as estações - 20% do preço de
todo o buquê.
Os descontos são feitos no pedido assim escrito e podem ser acumulados! Todos os descontos
se aplicam após o aumento do preço do feriado!
O preço para arrumar o buquê é sempre BGN 2. Escreva um programa que calcule o preço de
um buquê.
Dados de entrada
• A primeira linha é o número de crisântemos comprados - um inteiro [0 ... 200]. • Na
segunda linha está o número de rosas compradas - um inteiro [0 … 200]. • Na
terceira linha está o número de tulipas compradas - um inteiro [0 … 200]. • A quarta
linha mostra a estação - [Primavera, Verão, Outono, Inverno]. • A quinta linha indica se
o dia é feriado – [S - sim / N - não].
Dados de saída
Para imprimir no console 1 número - o preço das flores, formatado para o segundo caractere após
o ponto decimal.
2 Preço: 2*2,00 + 4*4,10 + 8*2,50 = BGN 40,40

4 Férias: 40,40 + 15% = BGN 46,46 5% de
8 46.14 desconto para mais de 7 tulipas na primavera: 44,14 Total de flores
Primavera são 20 ou menos: nenhum desconto 44,14 + 2 para arranjo =
E 46,14 BGN.
3 Preço: 3*3,75 + 10*4,50 + 9*4,15 = BGN 93,60 Não

10 é feriado: sem aumento 10% de desconto
9 69,39 para 10 ou mais rosas no inverno: 84,24 No total, mais de 20 flores:
Inverno com 20% de desconto = 67,392 67,392 + 2 para organizar = BGN
N 69.392.
Diretrizes e dicas
Depois de ler atentamente a condição, entendemos que teremos que realizar cálculos simples
novamente, mas com a diferença de que desta vez serão necessárias verificações mais
lógicas. Devemos prestar mais atenção quando as alterações finais de preço são feitas para
que possamos construir adequadamente nossa lógica de programa. Novamente, o texto em
negrito nos dá ampla orientação sobre como abordá-lo. Para começar, separamos os valores
já definidos em variáveis, como fizemos nas tarefas anteriores:
Fazemos o mesmo para o resto dos valores já definidos:
Nossa próxima subtarefa é ler corretamente a entrada do console. Abordamos da maneira

que já conhecemos bem, mas desta vez combinamos duas funções separadas - uma para ler
uma linha do console e outra para converter
convertendo-o em um tipo de dados numérico:
Vamos pensar na forma mais adequada de estruturar nosso programa de lógica. Fica
claro pela condição que o caminho do programa é basicamente dividido em duas partes:
primavera/verão e outono/inverno. Fazemos a divisão com uma condicional
construção atribuindo previamente variáveis aos preços das flores individuais, bem como
ao resultado final.
Resta-nos fazer várias verificações nas reduções dos diferentes tipos de flores, consoante
a época, e modificar o resultado final.

Desafio: Notas
Escreva um programa para calcular as estatísticas das notas do exame. No início, o
programa recebe o número de alunos que fizeram o exame e para cada aluno sua nota.
Ao final, o programa deverá imprimir a porcentagem de alunos com notas entre 2,00 e
2,99, entre 3,00 e 3,99, entre 4,00 e 4,99, 5,00 ou superior, e o GPA no exame.
Dados de entrada
Uma série de números são lidos no console, cada um em uma linha separada:
• Na primeira linha - o número de alunos que fizeram o exame - um número inteiro entre
eixo [1 … 1000].
• Para cada aluno em uma linha separada - a nota do exame - um número real
no intervalo [2,00 ... 6,00].
Dados de saída
Imprima no console 5 linhas que contêm as seguintes informações: • "Alunos
melhores: {porcentagem de alunos com GPA 5,00 ou superior}%". •
"Entre 4,00 e 4,99: {entre 4,00 e 4,99 inclusive}%".
• "Entre 3,00 e 3,99: {entre 3,00 e 3,99 inclusive}%". • "Falha: {menos de

3,00}%". • "Média: {sucesso
médio}".

10
3,00
2,99 5 e acima - três = 30% de 10 Entre
5,68 Melhores alunos: 30,00% 4,00 e 4,99 - três = 30% de 10 Entre 3,00 e 3,99
3,01 Entre 4,00 e 4,99: 30,00% Entre 3,00 - dois = 20% de 10 Abaixo de 3 - dois = 20% de
4 e 3,99: 20,00% Reprovação: 20,00% 10 O sucesso médio é: 3 + 2,99
Média: 4,06 + 5,68 + 3,01 + 4 + 4 + 6 + 4,50 + 2,44 + 5
4 = 40,62 / 10 = 4,062
6,00
4,50
2,44 5
Entrada Saída
6
2 Melhores alunos: 33,33%
3 Entre 4,00 e 4,99: 16,67% Entre 3,00
4 e 3,99: 16,67% Reprovação: 33,33%
Média: 3,70
5
6 2.2
Diretrizes e dicas
Da condição vemos que primeiro nos será dado o número de alunos e só depois suas notas. Por
esse motivo , primeiro leremos o número de alunos em uma variável int . Para ler e processar as
próprias notas, usaremos um loop for. O valor da variável int será o valor final da variável i do loop.
Dessa forma, todas as iterações do loop lerão todas as avaliações.
Antes de executar o código do loop for , separamos variáveis nas quais manteremos o
número de alunos de cada grupo: notas baixas (até 2,99), notas de 3 a 3,99, de 4 a 4,99
e notas acima de 5. precisaremos mais de uma variável para armazenar a soma de todas
as notas, com a ajuda da qual calcularemos a nota média de todos os alunos.
Viramos o loop e nele declaramos outra variável na qual armazenaremos o valor atual
inserido. A variável será do tipo double e a cada iteração verificamos qual é o seu valor.
De acordo com este valor, aumentamos em 1 o número de alunos do grupo correspondente,
não esquecendo de aumentar a soma total das notas, que também monitorizamos.
Podemos calcular a porcentagem de um determinado grupo de alunos do número total

multiplicando o número de alunos do respectivo grupo por 100 e dividindo pelo número
total de alunos.
Observe com qual tipo de dados numéricos você está trabalhando ao

realizar esses cálculos.
Moldamos o resultado final da nossa maneira bem conhecida até o segundo símbolo após
a vírgula.

Tarefa: chapéu de Natal

Escreva um programa que leia um inteiro n do console e desenhe um chapéu de Natal
* n +nos
com 4 n + 5 linhas de largura , como 1 colunas e altura
exemplos 2
abaixo. *
Dados de entrada
A entrada é lida do console - um único inteiro n no intervalo [3 … 100].
Dados de saída
Para imprimir um gorro de Natal na consola, tal como nos exemplos.

............./|\............. .............
\|/..... ........
......................................
......./|\....... ....... ............*-*-*............ ...........*--*--
*... ........ ..........*---*---*........ .........*---
-*----*......... ........*-----*-----
*........ ..... ..*------*------*..... ......*-------
*-------*... .....*--------*--------*.....
4 7
\|/....... .......***...... . ......*-*-*...... .....*--*--*..... ....*---*---*.. .. ...*----*----*... ..*-----*-
.*------*------*. ....*--------*-----*....
*-------*-------* ...*----------*----------*... ..*-----------
***************** *------ -----*..*------------*------------*.
*.*.*.*.*.*.*.*.*
***************** *-------------*-------------*
*****************************
*.*.*.*.*.*.*.*.*.*.*.*.*.*.*
*****************************
Diretrizes e dicas
Nas tarefas de desenho do console, na maioria das vezes o usuário insere um número
inteiro relacionado ao tamanho total da figura que precisamos desenhar. Como a
condição menciona como calcular o comprimento e a largura totais da figura, podemos
usá-los como pontos de partida. A partir dos exemplos, fica claro que não importa quais
sejam os dados de entrada, sempre temos as duas primeiras linhas que são quase
idênticas em conteúdo.
......./|\..... .......\|/.....
Também notamos que as últimas três linhas estão sempre presentes, duas das quais
são exatamente iguais.
*****************
*.*.*.*.*.*.*.*.*
*****************
A partir dessas observações podemos derivar a fórmula para a altura da parte variável
esquerda do chapéu de Natal. Usamos a fórmula condicional para a altura total
subtraindo a magnitude da parte constante. Obtemos (2 * n + 5) – 5 ou 2 *
n.
Usaremos um loop para desenhar a parte dinâmica ou variável da forma. O tamanho
do loop será de 0 até a largura que temos por condição, que é 4 * n + 1. Como usaremos
essa fórmula em vários lugares do código, é uma boa prática exportá-la para uma
variável separada . Antes de executar o loop, devemos separar variáveis para o número
de caracteres individuais que estão envolvidos na parte dinâmica: pontos e traços. Ao
estudar os exemplos, podemos derivar fórmulas para os valores iniciais dessas variáveis
também. Os traços são inicialmente 0, mas o número de pontos é claramente visto como
obtido subtraindo 3 da largura total (o número de caracteres que compõem o topo do
gorro de Natal) e depois dividindo por 2, pois o número
pontos em ambos os lados do chapéu é o mesmo.
.......***....... ......*-*-
*...... .....*--*--
*.... . ....*---*---*....
...*----*----*...
..*-----*-----*..*------
*------*.
*-------*-------*
Resta completar o corpo do loop, diminuindo o número de pontos em 1 após cada

desenho e aumentando os traços em 1. Não esqueçamos de desenhar um asterisco
entre eles. A sequência de desenho no corpo do loop é a seguinte:
• Cadeia de caracteres de pontos
• Estrela
• Uma sequência de caracteres com
travessões •
Estrela • Uma sequência de caracteres
com travessões • Estrela
• Cadeia de caracteres de pontos

Se trabalhamos corretamente, obtemos figuras idênticas às dos exemplos.

Tarefa: combinações de letras

Escreva um programa para imprimir no console todas as combinações de 3 letras em um intervalo especificado,
ignorando combinações contendo uma letra especificada pelo console. Finalmente, o número de combinações
impressas deve ser impresso.
Dados de entrada
A entrada é lida no console e contém exatamente 3 linhas: • Uma letra
minúscula do alfabeto inglês para iniciar o intervalo - de 'a' a 'z'. • Letra minúscula do alfabeto inglês para
terminar o espaço - da primeira letra
para 'z'.
• Uma letra minúscula do alfabeto inglês – de 'a' a 'z' – e as combinações que contêm essa
letra são ignoradas.
Dados de saída
Imprima em uma linha todas as combinações que atendem à condição, seguidas de seu número, separadas por
um espaço.
Todas as combinações possíveis das letras 'a', 'b' e 'c' são: aaa aab aac
aba abb abc aca acb acc baa bab bac bba bbb bbc bca bcb bcc caa
a
aa aac aca acc cab cac cba cbb cbc cca ccb ccc
c
caa cac cca ccc 8
b Combinações contendo 'b' não são válidas.
Restam 8 combinações válidas.
Conecte-se Saída
a
aaa aab aac aba abb abc aca acb acc baa bab bac bba bbb bbc bca bcb bcc caa cab cac
c
cba cbb cbc cca ccb ccc 27
Com
Conecte-se Saída
fff ffg ffi ffj ffk fgf fgg fgi fgj fgk fif fig fii fij fik fjf fjg fji fjj fjk fkf fkg fki fkj fkk gff gfg
gfi gfj gfk ggf ggg ggi ggj ggk gif gig gii gij gik gjf gjg gji gjj gjk gkf gkg gki gkj
gk k Iff ifg ifi ifg igf igf igk igk iii iig ijf ijg Ija ijk IKF IKJ IKJ IKJ IKJ IKJ IKJ IKJ
fk IKJ IKJ iKJ JFG JFG JFJ JFJ JFJ JGJ JGJ JGJ JGJ JGJ JF JIK JIK JJJF Jjjk
Jjjk J KG JKG JKG Jkj Jkj Jkjj kff kfg kfi kfj kfk kgf kgg kgi kgj kgk kif kig kii kij
kik kjf kjg kji kjj kjk kkf kkg kki kkj kkk
Diretrizes e dicas
Para a última tarefa, temos por padrão dados de entrada de 3 linhas, que são representadas
por um caractere cada da tabela ASCII (http://www.asciitable.com/). Poderíamos usar as
funções já definidas na linguagem Java para ler um único caractere do console e armazená-
lo em uma variável do tipo char:
Vamos pensar em como poderíamos chegar ao resultado final. Se a condição da tarefa for
imprimir todos os caracteres do início ao fim (omitindo uma determinada letra), como
faríamos? A maneira mais fácil e conveniente é usar um loop,
passando por todos os caracteres e imprimindo aqueles que são diferentes da letra que
precisamos pular. Uma das vantagens da linguagem Java é que temos a capacidade de
usamos um tipo de dados diferente para uma variável de loop:
O resultado da execução do código são todas as letras de a a z inclusive, impressas em

uma linha e separadas por um espaço. Isso parece o resultado final da nossa tarefa?
Precisamos descobrir uma maneira de imprimir 3 símbolos conforme a condição em vez de
1. A execução do programa é muito semelhante a uma máquina caça-níqueis. Lá, geralmente
ganhamos se conseguirmos alinhar vários símbolos idênticos. Digamos que temos slots para
três símbolos na máquina. Quando paramos em um determinado símbolo no primeiro lugar,
os dois lugares restantes continuam a alinhar símbolos de todos os possíveis. No nosso
caso, todas as letras possíveis são da inicial até a final especificada pelo usuário, e a solução
do nosso programa é idêntica à forma de jogar
a máquina.
Usamos um loop que percorre todos os caracteres desde o início até a letra final, inclusive.
A cada iteração do primeiro loop, executamos um segundo com os mesmos parâmetros
(mas somente se a letra do primeiro loop for válida, ou seja, não corresponder ao
que devemos excluir por condição). A cada iteração do segundo loop, executamos outro com os mesmos parâmetros e
a mesma verificação. Assim você vai
temos três loops aninhados, e no corpo do último vamos imprimir
os símbolos.
Não esqueçamos que também somos obrigados a imprimir o número total de combinações válidas que encontramos e
que devem ser impressas na mesma linha, separadas por um espaço.

Capítulo 9.1. Tarefas do Campeão - Parte I

Neste capítulo, ofereceremos ao leitor várias tarefas um pouco mais difíceis, que visam desenvolver habilidades
algorítmicas e dominar a programação
técnicas de resolução de tarefas de maior complexidade.
Tarefas mais complexas no material estudado

Resolveremos juntos vários problemas de programação que cobrem a matéria do curso estudada no livro, mas em
dificuldade superam os problemas usuais dos vestibulares do SoftUni. Se você quer se tornar um campeão no
básico da programação, recomendamos que pratique resolvendo problemas semelhantes mais complexos
tarefas para tornar mais fácil para você nos exames.
Problema: Linhas que se cruzam

Temos duas linhas:
• Série de Tribonacci (por analogia com a série de Fibonacci), onde cada

número é a soma dos três primeiros (dados os três números iniciais)
• uma matriz gerada por uma espiral numérica, definida como uma travessia espiral (direita, baixo, esquerda,
cima, direita, baixo, esquerda, cima, etc.) de uma matriz de números, começando de seu centro com um
determinado número de semente e passo em incrementos, com os números atuais na linha sendo
registrados cada vez que fazemos uma curva
Escrever um programa que encontre o primeiro número que aparece em ambas as linhas assim definidas.
Exemplo
Deixe a série Tribonacci começar com 1, 2 e 3. Isso significa que a primeira série conterá os números 1, 2, 3, 6,
11, 20, 37, 68, 125, 230, 423, 778, 1431, 2632, 4841, 8904, 16377, 30122, 55403, 101902, etc.
Ao mesmo tempo, deixe os números da espiral começarem com 5

e a espiral aumente 2 a cada passo. Em seguida, a segunda linha
conterá os números 5, 7, 9, 13, 17, 23, 29, 37, etc. Vejo que 37 é
o primeiro número que ocorre na série de Tribonacci e na espiral
e que é
a solução procurada da tarefa.
Dados de entrada
Os dados de entrada são 5 números inteiros,
que são lidos no console.
• As três primeiras linhas da entrada recebem três números inteiros representando

os três primeiros números da série Tribonacci.
• As próximas duas linhas contêm dois números inteiros representando o primeiro
número e o passo para cada célula da matriz para a espiral de números.
Os dados de entrada serão sempre válidos e estarão sempre no formato descrito. Não há necessidade
de verificá-los.
Dados de saída
O resultado deve ser impresso no console. Na única linha de saída
você deve imprimir o menor número que ocorre em ambas as sequências. Se não houver nenhum
número no intervalo [1 … 1.000.000] que ocorra em ambas as sequências, imprima "Não".
Limites
• Todos os números na entrada estarão no intervalo [1 … 1.000.000].
• Tempo de trabalho permitido para o programa: 0,25 segundos.

• Memória permitida: 16 MB.

1 13 99 1
2 25 99 4
3 37 99 13 99 Não 7 23
5 2 23
2 52 2 3
Diretrizes e dicas
A tarefa parece bastante complexa, então vamos dividi-la em subtarefas mais simples.
processamento de entrada
O primeiro passo para resolver o problema é ler e processar a entrada. A entrada consiste em 5 números
inteiros: 3 para a série de Tribonacci e 2 para a hélice numérica.
Uma vez que temos os dados de entrada, precisamos pensar em como vamos gerar números
assim em ambas as linhas.
Capítulo 9.1. Missões para Campeões - Parte I 347
Gerando a série de Tribonacci Para a

série de Tribonacci, vamos cada vez somar os três valores anteriores e depois
deslocar os valores desses números (os três anteriores) uma posição à frente na
série, ou seja, o valor do primeiro deve assumir o valor do segundo, e assim por
diante. Quando terminarmos com o número, armazenaremos seu valor em uma
matriz. Como a condição do problema diz que os números nas linhas não
excedem 1.000.000, podemos parar a geração dessa linha precisamente em
1.000.000.
Gerando uma espiral numérica

Precisamos criar uma relação entre os números na espiral numérica para que possamos gerar
facilmente cada número subsequente sem ter que olhar para as matrizes e seus percursos.
Se olharmos atentamente para a imagem da condição, podemos notar que para cada 2
"voltas" na espiral, os números que pulamos aumentam em 1, ou seja, de 5 a 7 e de 7 a 9
nenhum número é pulado, mas adicionamos diretamente com o passo da linha. De 9 a 13 e
de 13 a 17 pulamos um número, ou seja, adicionamos o dobro do passo. De 17 a 23 e de 23
a 29 pulamos dois números, ou seja, somamos três vezes o passo, etc.
*
Então vemos que para os dois primeiros temos o último número + 1 passo, para os próximos
*
dois somamos 2 passos e assim por diante. Toda vez que queremos que chegue
mudo para o próximo número da espiral, realizaremos tais cálculos.
O que precisamos cuidar é que a cada dois números nosso multiplicador (vamos chamá-lo de
"coeficiente") é incrementado em 1 (spiralStepMul++), o que pode
é obtido por uma verificação simples (spiralCount % 2 == 0). Todo o código de

a geração da hélice em uma matriz é dada abaixo.
Encontre o número total para ambas as linhas

Depois de gerar os números em ambas as linhas, podemos combiná-los e construir a
solução final. Como será? Para cada um dos números de uma linha (começando pelo
menor), verificaremos se existe na outra. O primeiro número que atender a esse critério
será a resposta do problema.
Faremos a busca no segundo array de forma linear, e para os mais curiosos, vamos deixar
que otimizem usando a técnica chamada busca binária, já que o segundo array é gerado
ordenado, ou seja, atende ao requisito para aplicar esse tipo de pesquisa. O código para
encontrar nossa solução será
parece que:
Capítulo 9.1. Tarefas do Campeão - Parte I 349
A solução do problema usa matrizes para armazenar os valores. Arrays não são
necessários para resolver o problema. Existe uma solução alternativa que gera os
números e trabalha com eles diretamente, em vez de armazená-los em uma matriz.
Podemos verificar a cada passo se os números nas duas linhas correspondem. Se for
esse o caso, imprimiremos o número no console e encerraremos a execução do nosso
programa. Caso contrário, veremos qual número atual da linha é menor e geraremos a
próxima, onde estamos "atrás". A ideia é que vamos gerar números a partir da linha que
está "atrás" até passarmos o número atual para a outra linha e depois para a outra linha
e, se encontrarmos uma correspondência nesse meio tempo, encerraremos a execução.

Tarefa: datas mágicas

Digamos que recebemos uma data no formato "dd-mm-aaaa", por exemplo 17-03-2007.
Calculamos o peso desta data tomando todos os seus dígitos, multiplicando cada dígito
pelos outros e por fim somando todos os resultados obtidos. No nosso caso temos 8
dígitos: 17032007, então o peso é 1*7 + 1*0 + 1*3 + 1*2 + 1*0 + 1*0 + 1*7 + 7*0 + 7*3 +
7*2 + 7*0 + 7*0 + 7*7 + 0*3 + 0*2 + 0*0 + 0*0 + 0*7 + 3*2 + 3*0 + 3*0 + 3* 7 + 2*0 + 2*0
+ 2*7 + 0*0 + 0*7 + 0*7 = 144.
Nossa tarefa é escrever um programa que encontre todas as datas mágicas - datas
entre dois anos especificados correspondentes a um determinado peso mágico. As datas
devem ser impressas em ordem crescente no formato "dd-mm-aaaa".
Usaremos um calendário tradicional (os anos têm 12 meses, cada mês tem 28, 29, 30 ou 31
dias).
2007 17-03-2007
2007 13-07-2007 01-09-2013
144 31-07-2007 17-01-2013
23-03-2013
07-11-2013
Conecte-se Saída
09-01-2013
2003 09-10-2013
2012
2004 Não 10-09-2013
2014
1500 17-10-2013
80
11-07-2013
24-11-2013
Conecte-se Saída 14-12-2013
01-01-2011 23-11-2014
2011 13-12-2014
01-10-2011
2012 31-12-2014
10-01-2011
14
10-10-2011
Dados de entrada
Os dados de entrada devem ser lidos no console. Eles consistem em 3 linhas:
• A primeira linha contém um número inteiro: ano inicial. • A segunda
linha contém um inteiro: ano final. • A terceira linha contém um
inteiro: peso mágico.
Os dados de entrada serão sempre válidos e estarão sempre no formato descrito.
Dados de saída
O resultado deve ser impresso no console como datas consecutivas no formato "dd-mm-aaaa",
organizadas em ordem alfabética. Cada string deve estar em uma linha separada. Caso não
existam datas mágicas, imprimimos "Não".
Limites
• Os anos inicial e final são números inteiros no intervalo [1900-2100]. • O peso mágico é um
número inteiro no intervalo [1 … 1000]. • Tempo de trabalho permitido para o
programa: 0,25 segundos.

Diretrizes e dicas
Começamos com os dados de entrada. Neste caso, temos 3 inteiros a serem lidos do
console, esgotando assim a digitação e o processamento da entrada para a tarefa.
Ao ter o ano de início e fim, é bom saber como vamos passar por cada data sem nos
confundirmos com quantos dias tem um mês e se é um ano bissexto, etc.
Procurar todas as datas

Para o rastreamento, aproveitaremos a funcionalidade fornecida pela classe Local
Date . Vamos definir uma variável para a data de início, o que podemos fazer usando o
construtor que aceita ano, mês e dia. Sabemos que o ano é o ano inicial que lemos no
console, e o mês e o dia devem ser janeiro e 1º, respectivamente.
Assim que tivermos a data de início, queremos fazer um loop que seja executado até
ultrapassarmos o ano final (ou até passarmos 31 de dezembro no ano final, se estivermos
comparando datas inteiras), incrementando 1 dia a cada etapa.
Para aumentar em 1 dia cada giro, usaremos o método de

LocalDate - plusDays(…) que adiciona um número de dias à data atual e retorna
o recém-recebido.
Atenção: como o método LocalDate.plusDays(…) retorna a "nova" data, é importante
ter uma atribuição do resultado, não apenas uma chamada ao método! O Metodo
cuidará de nós quando pular para o próximo mês, quantos dias há em um mês e tudo
mais.
No final, nosso loop pode ficar assim:
Nota: podemos obter o mesmo resultado com um loop for, a inicialização da data vai na
primeira parte do for, a condição é salva e o passo é incrementar o net em 1 dia. Além
disso, a condição pode ser substituída tornando a variável de data final, por exemplo. 31
de dezembro no último ano e ser comparado diretamente
ambas as datas.
cálculo de peso
Cada data consiste em exatamente 8 caracteres (dígitos): 2 para o dia (d1, d2), 2 para o mês
(d3, d4) e 4 para o ano (d5 a d8). Isso significa que teremos o mesmo cálculo todas as vezes
e podemos tirar vantagem disso para definir a fórmula estaticamente (ou seja, não fazer um
loop referenciando diferentes dígitos da data, mas escrever a fórmula inteira). Para poder
escrevê-la, precisaremos de todos os dígitos da data em variáveis separadas para fazer todas
as multiplicações necessárias. Usando as operações de divisão e resto nos componentes de
data individuais, via getDayOfMonth(), getMonthValue() e getYear(), podemos recuperar
cada dígito.
Vamos também explicar uma das linhas mais interessantes aqui. Vamos tomar como exemplo
o segundo dígito do ano (d6). Com ele, dividimos o ano por 100 e tiramos 10 de resto. O que
alcançamos? Primeiro, dividindo por 100, retiramos os 2 últimos dígitos do ano (exemplo:
2018 / 100 = 20). Com o resto da divisão por 10, pegamos o último dígito do número resultante
(20% 10 = 0) e assim obtemos 0, que é o segundo dígito de 2018.
Resta fazer o cálculo que nos dará o peso mágico de uma determinada data. Para evitar
escrever todas as multiplicações conforme mostrado no exemplo, aplicaremos um agrupamento
simples. O que precisamos fazer é multiplicar cada dígito pelos que o seguem.* Em vez de
* *
escrever d1 d2 + d1 * (d2 + d3 + + d8), seguindo a matemática d8, podemos d3 + … + d1
…
agrupamento tchecas quando temos abreviar essa expressão para d1 Regras de
multiplicação e adição. Aplicando a mesma simplificação às restantes multiplicações, obtemos
a seguinte fórmula:
Imprimindo a saída Uma vez

calculado o peso de uma determinada data, precisamos verificar se ela corresponde ao peso
mágico que procuramos para saber se deve ser impresso ou não. A verificação pode ser feita
com um bloco if padrão , certificando-se de que a data esteja no formato correto ao imprimir.
Para formatar uma data da forma solicitada, utilizaremos a classe DateTimeFormatter.
Observação: como estamos percorrendo as datas do ano inicial ao ano final, elas sempre
serão classificadas em ordem crescente, conforme a condição. Por fim, se
não encontrarmos nenhuma data que corresponda às condições, teremos um valor falso na
variável encontrada e poderemos imprimir No.

Tarefa: cinco letras especiais

Dois números são dados: início e fim. Escreva um programa que gere todas as combinações
de 5 letras cada uma do conjunto {'a', 'b', 'c', 'd', 'e'} tal que o peso dessas 5 letras seja um
número no intervalo [ início … fim] inclusive. Imprima-os em ordem alfabética, em uma única
linha, separados por um espaço.
O peso de uma carta é calculado da seguinte forma:
peso('à') = 5; peso('b')
= -12; peso('c') = 47;
peso('d') = 7; peso('e')
= -32;
O peso da sequência de letras c1c2…cn é calculado removendo todas as letras repetidas (da
direita para a esquerda) e calculando a fórmula:
… +n *
peso(c1c2…cn) = 1 * peso(c1) + 2 * peso(c2) + peso(cn)
Por exemplo, o peso de "bcddc" é calculado da seguinte forma:

Primeiro removemos as letras repetidas e obtemos "bcd". Em seguida, aplicamos a fórmula *
* *
peso('b') + 2 * peso('c') + 3 * peso('d') = 1 * (-12) + 2: 1 7 = 103. 47 + 3
* * * *
Outro exemplo: peso("cadea") = peso("cade") = 1 47 + 2 5+3 7-4 32 = -50.
Dados de entrada
Os dados de entrada são lidos no console. Eles consistem em duas linhas:
• O número inicial está na primeira linha. • O
número final está na segunda linha. Os
dados de entrada serão sempre válidos e estarão sempre no formato descrito. Não há
necessidade de verificá-los.
Dados de saída
O resultado deve ser impresso no console como uma série de strings em ordem alfabética.
Cada string deve ser separada da próxima por um único espaço. Se o peso de qualquer uma
das sequências de 5 letras não existir no intervalo especificado, imprima "Não".
Limites
• Os números inicial e final devem ser inteiros no intervalo [-10000 … 10000]. • Tempo de
trabalho permitido para o programa: 0,25 segundos. • Memória
permitida: 16 MB.
Conecte-se Saída Explicações Conecte-se Saída
40 peso("bcead") = 41 300
bcead bdcea Não
42 peso("bdcea") = 40 400
bcdea cebda eaaad eada

baadc babdc explorar badbc explorer
eadd eade eaed eadaa
badcb badcc badcd baddc bbadc bbdac
eadad eadae eadda eaddd
-1 200 bdaac bdabc bdaca bdacb bdacc bdacd
eadde eadea eaded eadee
1 300 bdadc bdbac bddac beadc sendo eabdc
eaead eaeda eedd eaede
ebadc ebdac edbac
eaeed eeaad eeada eeadd
eeade eeaed eeead
Diretrizes e dicas
Como qualquer tarefa, iniciamos a solução lendo e processando os dados de entrada. Neste
caso, temos dois inteiros que podemos processar com uma combinação dos métodos
Integer.parseInt(…) e Scanner.nextLine().
Na tarefa, temos vários pontos principais: a geração de todas as combinações de

comprimento 5 incluindo as 5 letras dadas, a remoção de letras repetidas e o cálculo do
peso para uma determinada palavra já simplificada. A resposta consistirá em qualquer
palavra cujo peso esteja no intervalo dado [firstNumber, secondNumber].
Gerar todas as combinações

Para gerar todas as combinações de comprimento 1 usando 5 caracteres, usaríamos um
loop de 0..4 e gostaríamos que cada número no loop correspondesse a um caractere.
Para gerar todas as combinações de comprimento 2 usando 5 caracteres (ou seja, "aa",
"ab", "ac", …, "ba", ...), faríamos dois loops aninhados, cada um passando pelos dígitos
0 a 4, novamente fazendo com que cada dígito corresponda a um símbolo específico.
Repetiremos esta etapa 5 vezes para que acabemos com 5 loops aninhados com índices
i1, i2, i3, i4 e i5.
Tendo todas as combinações de 5 dígitos, precisamos encontrar uma maneira de

"transformar" os cinco dígitos em uma palavra com as letras 'a' a 'e'. Uma maneira de
fazer isso é redefinir uma string simples contendo as letras que temos
e para cada dígito pegamos a letra da posição específica. Assim, o número 00000 se
tornará "aaaaa", o número 02423 se tornará "acecd". Podemos fazer a string de 5 letras
assim:
Outra maneira: podemos converter os números em letras usando sua disposição na

tabela ASCII. A expressão 'a' + i nos dará o resultado 'a' para i = 0, 'b' para i = 1, 'c' para
i = 2 e assim por diante.
Portanto, agora temos todas as combinações de 5 letras geradas e podemos continuar
com a próxima parte da tarefa.
Observação: como selecionamos um padrão que corresponde à ordem alfabética das
letras e os loops são girados adequadamente, o algoritmo gerará as palavras em ordem
alfabética e não há necessidade de classificação adicional antes da saída.
Remover letras repetidas

Assim que tivermos a string pronta, precisamos remover todos os caracteres repetidos.
Faremos esta operação adicionando as letras da esquerda para a direita em uma nova
string e cada vez antes de adicionar uma letra verificaremos se ela já existe - se estiver
lá vamos ignorá-la, se não estiver vamos adicioná-la. Para começar, adicionaremos a
primeira letra à string inicial.
Depois faremos o mesmo com os outros 4, verificando a cada vez se existem com a
seguinte condição e o método .indexOf(…). Isso pode ser feito com um loop fullWord
(deixamos isso para o leitor para um exercício) ou pode ser feito de maneira preguiçosa
com copiar e colar.
O método .indexOf(…) retorna o índice do elemento em particular se encontrado ou -1

se o elemento não for encontrado. Portanto, toda vez que obtivermos -1, isso significará
que ainda não temos essa letra na nova sequência de letras exclusivas e podemos
adicioná-la, e se obtivermos um valor diferente de -1, isso significará que já temos a letra
e nós não vamos adicionar.
Calculando o peso Calcular

o peso é simplesmente percorrer a única palavra (palavra) obtida na última etapa, e
para cada letra precisamos pegar seu peso e multiplicá-lo pela posição. Para cada letra
na travessia, precisamos calcular por qual valor multiplicaremos sua posição, por
exemplo, usando uma construção de switch .
Uma vez que tenhamos o valor da letra dada, devemos multiplicá-la por sua posição.
Como os índices na string diferem em 1 das posições reais, ou seja, índice 0 é a posição
1, índice 1 é a posição 2, etc., adicionaremos 1 a
os índices.
Quaisquer resultados intermediários obtidos devem ser adicionados a um total para cada
letra da combinação de 5 letras.
Formatando a saída
Se uma palavra deve ser impressa é determinado pelo seu peso. Precisamos de uma
condição que determine se o peso atual está no intervalo [start … end] que nos foi dado
na entrada no início do programa. Em caso afirmativo, imprima a palavra completa
(fullWord).
Tenha cuidado para não imprimir a palavra de letras únicas. Só precisávamos disso para
calcular o peso!
As palavras são separadas por um espaço e vamos acumulá-las em um resultado
variável intermediário, que é definido como uma string vazia no início.
Toques finais
A condição é satisfeita, exceto nos casos em que não temos nenhuma palavra no intervalo
dado. Para descobrir se encontramos tal palavra, podemos simplesmente verificar se a
string resultante tem seu valor inicial (ou seja, uma string vazia), se sim - imprimimos
Não, caso contrário, imprimimos a string inteira sem o último espaço usando o .trim ()
método.

Capítulo 9.2. Missões de Campeão - Parte II

Neste capítulo veremos mais três tarefas que classificamos como "para campeões", ou seja, mais difícil
do que os problemas padrão deste livro.
Tarefas mais complexas no material estudado

Antes de passar para as tarefas específicas, devemos esclarecer que elas podem ser resolvidas mais
facilmente com conhecimento adicional de programação e da linguagem C# (métodos, arrays, coleções,
recursão, etc.), mas cada solução que será dada agora usará apenas material abordado neste livro. O
objetivo é aprender a construir algoritmos mais complexos com base em seu conhecimento atual.
Tarefa: dias de compras apaixonadas

Lina tem uma verdadeira paixão por compras. Quando ela tem algum dinheiro, ela vai imediatamente ao
primeiro grande shopping center (shopping center) e tenta gastar o máximo possível em roupas, bolsas
e sapatos. Mas o que ela mais gosta são as liquidações de inverno. Nossa tarefa é analisar seu
comportamento estranho e calcular as compras que Lina faz ao entrar no shopping, assim como o
dinheiro que sobra ao finalizar as compras.
Na primeira linha da entrada, será inserido o valor que Lina tem antes de começar a fazer compras.
Então, ao receber o comando "mall.Enter", Lina entra no shopping e começa a fazer compras até
receber o comando "mall.Exit". Quando Lina começar a fazer compras, em cada linha da entrada você
obterá strings que representam ações que Lina realiza. Cada caractere na string representa uma compra
ou outra ação. Os comandos de string podem conter apenas caracteres da tabela ASCII. O código ASCII
de cada personagem tem relação com quanto Lina tem que pagar por cada item. Interprete os símbolos
por
da seguinte maneira:
• Se o símbolo for uma letra maiúscula, Lina obtém uma redução de 50%, ou seja, você deve reduzir
o dinheiro que ela possui em 50% da representação numérica do símbolo da tabela ASCII.
• Se o símbolo for uma letra minúscula, Lina obtém uma redução de 70%, ou seja, você deve reduzir
o dinheiro que ela possui em 30% da representação numérica do símbolo da tabela ASCII.
• Se o símbolo for "%", Lina faz uma compra que reduz seu dinheiro pela metade. • Se o símbolo for
"*", Lina saca dinheiro de seu cartão de débito e acrescenta

fundos disponíveis BGN 10.
• Caso o símbolo seja diferente dos citados acima, a Lina apenas efetua uma compra sem descontos
e nesse caso é só subtrair o valor do símbolo de
tabela ASCII de seus recursos disponíveis.
Se algum dos valores da compra for superior aos fundos disponíveis atualmente, a Lina NÃO efetua a
compra. O dinheiro de Lina não pode ser menor que 0.
As compras terminam quando o comando "mall.Exit" é recebido. Quando isso acontecer, você
deve imprimir o número de compras feitas e o dinheiro que está no saldo de Lina.
Dados de entrada
Os dados de entrada devem ser lidos no console. Na primeira linha da entrada, será inserido o
valor que Lina tem antes de começar a fazer compras. Cada linha subseqüente terá um comando
específico. Ao receber o comando "mall.Enter", em cada linha subsequente você receberá
strings contendo informações sobre as compras/ações que Lina deseja realizar. Essas strings
continuarão a ser enviadas até que o comando "mall.Exit" seja recebido.
Apenas um comando "mall.Enter" e apenas um comando "mall.Exit" sempre serão emitidos .
Dados de saída
A saída deve ser impressa no console. Quando a compra for concluída, determinada saída deve
ser impressa no console, dependendo de quais compras foram feitas.
• Se nenhuma compra foi feita – "Sem compras. Dinheiro restante: {dinheiro restante} lv." • Se
pelo menos uma
compra foi feita - "{número de compras} compras. Dinheiro restante: {dinheiro restante} lv."
O dinheiro deve ser impresso com 2 casas decimais.
Limites
• Dinheiro é um número de ponto flutuante no intervalo: [0 - 7,9 x 1028]. • O
número de strings entre "mall.Enter" e "mall.Exit" estará no intervalo: [1-20]. • O número de
caracteres em cada string que representa um comando será c
intervalo: [1-20]. •
Tempo de execução permitido: 0,1 segundos. • Memória
permitida: 16 MB.
Conecte-se Saída Comente
110 'd' tem código ASCII 100. 'd' é uma letra minúscula e
mall.Enter 1 compras.
por isso Lina ganha 70% de desconto e então ela
Dinheiro
restante: 80,00 lv.
gasta 30% 100* = BGN 30. Após a compra ela tem 110
d mall.Exit - 30 = BGN 80 sobrando.
Capítulo 9.2. Missões para Campeões - Parte II 361
100
110
1 compras. mall. Enter 2 compras.
shopping.Entrar
Dinheiro Ab Dinheiro
% **
restante: 55,00 lv. restante: 58,10 lv.
shopping.Sair
shopping
Diretrizes e dicas
Dividiremos a solução da tarefa em três partes principais:
• Processamento de
entrada • Algoritmo de solução
• Formatação de saída Vejamos
cada parte em detalhes.
Processamento de entrada A
entrada para nossa tarefa consiste em vários componentes:
• Na primeira fila temos todo o dinheiro que Lina usará para fazer compras.
• Em cada linha subseqüente teremos algum tipo de comando.
A primeira parte da leitura é trivial, a única coisa que precisamos prestar atenção é o uso do tipo
BigDecimal , ou seja, trabalhamos com dinheiro e precisamos de muita precisão:
Mas no segundo há um detalhe que temos que levar em conta. A condição é a seguinte:
Cada linha subseqüente terá um comando específico. Quando você receber o comando
"mall.Enter", em cada linha subsequente você obterá strings contendo informações sobre
as compras/ações que Lina deseja fazer.
Aqui é o ponto onde temos que considerar que a partir da segunda linha temos que começar a ler
os comandos, mas só depois de pegarmos o comando "mall.
Enter", precisamos começar a processá-los. Como fazer? Usar um loop while ou do-while é
uma boa escolha. Aqui está um exemplo de solução de como podemos pular todos os comandos
antes de obter o comando "mall.Enter":
Aqui devemos observar que a chamada scanner.nextLine() após o final do loop é usada
para pular para o primeiro comando de processamento.
Algoritmo para resolver a tarefa O algoritmo

para resolver a tarefa em si é direto - continuamos a ler os comandos do console até que
o comando "mall.Exit" seja emitido. Durante esse tempo, processamos cada char de
cada comando de acordo com as regras especificadas na condição e, simultaneamente,
modificamos o dinheiro que Lina possui e armazenamos o número de compras. Vamos
considerar os dois primeiros problemas que nosso
algoritmo enfrenta. O primeiro problema diz respeito a como podemos ler os comandos
até encontrarmos "mall.Exit". A solução, como vimos acima, é usar um loop while . O
segundo problema é a tarefa de acessar cada caractere do comando fornecido. Dado que
os dados de entrada que os comandos representam são do tipo String, a maneira mais
fácil de acessar cada caractere é por meio de um loop foreach .
Veja como seria usar dois desses loops:
A próxima parte do nosso algoritmo é processar os símbolos dos comandos contra as

seguintes regras da condição:
• Se o símbolo for uma letra maiúscula, Lina obtém uma redução de 50%, o que significa que
você deve reduzir o dinheiro que ela possui em 50% da representação numérica do
símbolo ASCII.
• Se o símbolo for uma letra minúscula, Lina obtém uma redução de 70%, o que significa que
você deve reduzir o dinheiro que ela possui em 30% da representação numérica ASCII do
símbolo.
• Se o símbolo for "%", Lina faz uma compra que reduz seu dinheiro à metade
sobre.
• Se o símbolo for "*", Lina saca dinheiro de seu cartão de débito e acrescenta
fundos disponíveis BGN 10.
• Caso o personagem seja diferente dos citados acima, Lina simplesmente faz uma compra
sem descontos, nesse caso basta subtrair o valor do personagem ASCII do seu saldo
disponível.
Capítulo 9.2. Tarefas do Campeão - Parte II 363
Consideremos os problemas da primeira condição diante de nós. Uma é como podemos saber se um caractere
é uma letra maiúscula. Pudermos
para usar uma das duas maneiras:
• Dado que as letras do alfabeto têm uma ordem, podemos usar a seguinte ação de verificação >= 'A' &&
ação <= 'Z' para verificar se nosso caractere está no intervalo de letras maiúsculas. • Podemos usar a
função Character.isUpperCase(…).
O outro problema é como podemos pular um símbolo se ele representa uma operação que requer mais dinheiro
do que Lina possui. Isso pode ser feito usando a construção continue . Um exemplo de verificação para a
primeira parte da condição se parece com isto:
Nota: as compras são uma variável do tipo compras int . , em que mantemos a contagem de todos
Acreditamos que o leitor não deve ter nenhum problema com a implementação
de todas as outras verificações porque são muito semelhantes à primeira.
Formatação de saída Ao final da
tarefa, precisamos imprimir determinada saída, sujeita à seguinte condição:
• Se nenhuma compra foi feita - "Nenhuma compra. Dinheiro sobrando: {osta

dinheiro certo} lv."
• Se pelo menos uma compra foi feita – "{número de compras} compras. Dinheiro restante:
{dinheiro restante} lv."
As operações de impressão são triviais, a única coisa a ter em conta é que o dinheiro deve ser impresso com
uma precisão de 2 casas decimais.
Como podemos fazer isso? Deixaremos a resposta a esta pergunta para o leitor.

Problema: expressão numérica

Bonnie é uma bruxa extremamente poderosa. Como o poder da natureza não era forte
o suficiente para lutar com sucesso contra vampiros e lobisomens, ela começou a
absorver o poder das Expressões. A expressão é muito difícil de dominar porque o feitiço
depende da capacidade de resolver rapidamente expressões matemáticas.
Para usar o "Feitiço de Expressão", a bruxa deve saber o resultado da expressão
matemática com antecedência. Uma expressão de feitiço consiste em algumas
expressões matemáticas simples. Cada expressão matemática pode conter operadores
de adição, subtração, multiplicação e/ou divisão.
A expressão é resolvida sem levar em conta as regras matemáticas para calcular
expressões numéricas. Isso significa que a sequência de operadores tem precedência,
não o tipo de cálculo que eles executam. Uma expressão pode conter parênteses e tudo
dentro dos parênteses é avaliado primeiro. Cada expressão pode conter vários
parênteses, mas não pode conter parênteses aninhados:
• Uma expressão contendo (…(…)…) é inválida.
• Uma expressão contendo (…)…(…) é válida.
Exemplo
A expressão
é resolvido da seguinte forma:
Bonnie é muito bonita, mas não tão inteligente, então ela precisa de nossa ajuda para
dominar o poder das Expressões.
Dados de entrada
Os dados de entrada consistem em uma única linha que é alimentada pelo console.
Contém a expressão matemática para o cálculo. A linha sempre termina com o caractere
"=". O símbolo "=" indica o fim de uma expressão matemática.
Os dados de entrada são sempre válidos e no formato descrito. Eles não precisam ser
validados.
Dados de saída A
saída deve ser impressa no console. A saída consiste em
uma linha – o resultado da expressão matemática calculada.
O resultado deve ser arredondado para o segundo dígito após a vírgula.
Limites
• As expressões terão no máximo 2.500 caracteres. • Os
números de cada expressão matemática estarão no intervalo [1 … 9]. •
Os operadores em expressões matemáticas serão sempre + (adição), - (subtração), /
(divisão) ou * (multiplicação). • O resultado da expressão
matemática estará no intervalo [-100000,00 …
100.000,00].
• Tempo de execução permitido: 0,1 segundos. • Memória
permitida: 16 MB.
4+6/5+(4*9–8)/7*2= 8,57 3+(6/5)+(2*3/7)*7/2*(9/4+4*1)= 110,63
Diretrizes e dicas
Como de costume, primeiro leremos e processaremos a entrada, depois resolveremos o
problema e, finalmente, imprimiremos o resultado, formatado conforme necessário.
Processamento de entrada
Os dados de entrada consistem em exatamente uma linha do console. Aqui temos duas
maneiras de processar a entrada. A primeira é lendo a linha inteira com o comando
bufferReader.readLine() (onde bufferReader é uma variável do tipo BufferedReader)
e acessando cada caractere (char) da linha através de um loop foreach. A segunda é
lendo a entrada caractere por caractere usando o comando bufferReader.read() e
processando cada caractere.
Para resolver o problema, usaremos a segunda opção.
Algoritmo para resolver a tarefa Para

os propósitos de nossa tarefa, precisaremos de duas variáveis:
• Uma variável na qual armazenaremos a pontuação atual.
• Mais uma variável onde iremos armazenar o operador atual da nossa expressão.
Em relação ao código acima, precisamos esclarecer o seguinte detalhe. O valor padrão do operador é +
para que o primeiro número encontrado seja igual ao nosso resultado.
Agora que temos nossas variáveis iniciais, precisamos pensar em qual será a estrutura básica do nosso
programa. Da condição entendemos que cada expressão termina com =, ou seja, teremos que ler e
processar símbolos até encontrar =. A seguir está a ortografia exata de um loop while .
O próximo passo é lidar com nossa variável de símbolo . Para ela, temos 3 casos possíveis:
• Se o caractere for o início de uma subexpressão entre parênteses, ou seja, o símbolo encontrado
é (.
• Se o caractere for um número entre 0 e 9. Mas como podemos verificar isso? Como podemos
verificar se nosso símbolo é um número? É aqui que entra o código ASCII do caractere, através
do qual podemos utilizar a seguinte fórmula: [código ASCII do nosso caractere] - [código ASCII
do caractere 0] = [dígito que representa o caractere]. Se o resultado desta verificação estiver
entre 0 e 9, então nosso símbolo é de fato um número.
• Se o símbolo for um operador, ou seja, é +, -, * ou /.
Vamos dar uma olhada nas ações que precisamos tomar nos casos relevantes que definimos:
• Se nosso símbolo for um operador, basta atribuir um novo valor à variável

expressionOperator.
• Se nosso símbolo for um dígito, precisamos alterar o resultado atual da expressão
dependendo do operador atual, ou seja. se expressionOperator for -, devemos
decrementar o resultado pela representação numérica do caractere atual.
Podemos obter a representação numérica do caractere atual usando a fórmula
que usamos ao verificar este caso ([código ASCII do nosso caractere] -
[código ASCII do caracter0] = [o dígito que representa o caractere]).
• Se o nosso símbolo for (, isso indica o início de uma subexpressão (uma expressão
entre parênteses). Por definição, a subexpressão deve ser avaliada antes de modificar
o resultado de toda a expressão (as ações entre parênteses são executadas primeiro).
Isso significa que teremos um resultado local para a subexpressão e o operador local.
Então, para avaliar o valor da subexpressão, usamos os mesmos métodos que usamos para avaliar a expressão
principal - usamos um loop while para ler os caracteres (até encontrarmos o caractere )). Dependendo se o
caractere lido é um dígito ou um operador, modificamos o resultado do subteste para . A implementação dessas
operações é análoga à implementação de avaliação da expressão descrita acima, portanto, acreditamos que o
leitor não deve ter problemas com isso. Após terminarmos de computar o resultado de nossa subexpressão,
modificamos o resultado de toda a expressão dependendo do valor de expressionOperator.
Formate a saída
A única saída que o programa deve imprimir no console é o resultado da resolução da expressão, com duas
casas decimais. Como podemos formatar a saída assim? Deixamos a resposta a esta questão
no leitor.

Tarefa: touros e vacas

Todos nós conhecemos o jogo Bulls and Cows (http://en.wikipedia.org/wiki/Bulls_and_cows). Dado um número
secreto de 4 dígitos e um número de palpite de 4 dígitos, use
temos as seguintes regras:
• Se tivermos um dígito do número palpite que corresponda a um dígito do número secreto e esteja na mesma
posição, temos um touro.
Capítulo 9.2. Missões para Campeões - Parte II 369
• Se tivermos um dígito do número presumido que corresponda a um dígito de

o número secreto, mas está em uma posição diferente, temos uma vaca.
numerar secretamente 1 4 8 1 Comente
Touros = 1
Número estimado 8 8 1 1
Vacas = 2
numerar secretamente 2 2 4 1 Comente
Touros = 0
Número estimado 9 9 24
Vacas = 2
Dado um número secreto e número de touros e vacas, nossa tarefa é encontrar

todos os números de palpites possíveis em ordem crescente.
Se não houver nenhum número de palpite que corresponda aos critérios definidos no
console, "Não" deve ser impresso.
Conecte-se Saída
1222 2122 2212 2232 2242 2252 2262 2272 2281 2283 2284 2285 2286
2228
2287 2289 2292 2322 2422 2522 2622 2722 2821 2823 2824
2825 2826 2827 2829 2922 3222 4222 5222 6222 7222 8221 8223
21
8224 8225 8226 8227 8229 9222
Entrada Saída
1234 1134 1214 1224 1231 1232 1233 1235 1236 1237 1238 1239 1244 1254
1264 1274 1284 1294 1334 1434 1534 1634 1734 1834 1934 2 234 3234
30 4234 5234 6234 7234 8234 9234
Dados de entrada
Os dados de entrada são lidos no console. A entrada consiste em 3 linhas:
• A primeira linha contém o número secreto.
• A segunda linha contém o número de touros.
• A terceira linha contém o número de vacas.
Os dados de entrada serão sempre válidos. Eles não precisam ser verificados.
Dados de saída
A saída deve ser impressa no console. A saída deve consistir em uma única linha - todos
os números adivinhados separados por um único espaço. Se não houver nenhum
número de palpite que corresponda aos critérios definidos no console, “Não” deve ser
impresso.
Limites
• O número secreto sempre consistirá em 4 dígitos no intervalo [1..9]. • O número de vacas e
touros sempre estará no intervalo [0..9]. • Tempo de execução permitido: 0,15
segundos.
Diretrizes e dicas
Resolveremos a tarefa em várias etapas:
• Vamos ler os dados de entrada. • Geraremos
todas as combinações possíveis de quatro dígitos (candidatos a

verificar).
• Para cada combinação gerada, calcularemos quantos touros e quantas vacas existem com base no número
secreto. Se houver correspondência entre os touros e as vacas que você procura, imprimiremos a
combinação.
Processamento de entrada
Para a entrada de nossa tarefa, temos 3 linhas:
• O número secreto. •
Número de touros desejados.
• O número de vacas desejado.
Ler esta entrada é trivial:
Algoritmo para resolver a tarefa

Antes de começarmos a escrever o algoritmo para resolver nosso problema, precisamos
declarar um sinalizador para indicar se uma solução foi encontrada:
Se após a conclusão do nosso algoritmo, esse sinalizador ainda for falso, imprimiremos
Não no console conforme especificado na condição.
Vamos começar a pensar no nosso problema. O que precisamos fazer é analisar todos os
números de 1111 a 9999 , excluindo aqueles que contêm zeros (por exemplo, 9011, 3401 ,
etc. são inválidos). Qual é a maneira mais fácil de gerar todos esses números? Com loops
aninhados. Como temos um número de 4 dígitos, teremos 4 loops aninhados, cada um dos
quais gerará um dígito separado de nosso número de teste.
Graças a esses loops, temos acesso a cada dígito de todos os números que precisamos
verificar. Nosso próximo passo é dividir o número secreto em dígitos. Isso pode ser
alcançado muito facilmente por uma combinação de divisão inteira e modular.
Faltam-nos os dois últimos passos antes de começarmos a analisar quantas vacas e touros
existem em um determinado número. Assim, a primeira é a declaração de variáveis de
contador em nossos loops aninhados para contar as vacas e touros para o número atual.
O segundo passo é fazer cópias dos dígitos do número atual que analisaremos para evitar
problemas com o funcionamento do
inserir loops se fizermos alterações neles.
Agora estamos prontos para começar a analisar os números gerados. Que lógica podemos
usar? A maneira mais básica de verificar quantas vacas e touros existem em um número é
por meio de uma série de verificações if-else . Sim, não é o máximo
da maneira ideal, mas para não usar o conhecimento além do escopo deste livro,
escolheremos essa abordagem.
Que verificações precisamos?
A verificação de touro é simples - verificamos se o primeiro dígito do número gerado é igual

ao mesmo dígito do número secreto. Retiramos as figuras marcadas para evitar a repetição
de touros e vacas.
Repetimos a ação para o segundo, terceiro e quarto dígitos.

Podemos verificar se há vacas da seguinte maneira - primeiro verificamos se o primeiro dígito
do número gerado corresponde ao segundo, terceiro ou quarto dígito do número secreto.
Exemplo de implementação:
Em seguida, verificamos sucessivamente se o segundo dígito do número gerado corresponde

ao primeiro, terceiro ou quarto dígito do número secreto, se o terceiro dígito do número gerado
corresponde ao primeiro, segundo ou quarto dígito do número secreto e, finalmente,
verificamos se o quarto dígito do número gerado corresponde ao primeiro, segundo ou terceiro
dígito do código secreto
número.
Imprimindo a saída Após

todas as verificações serem feitas, tudo o que resta é verificar se os touros e
vacas no número gerado atualmente correspondem aos touros e vacas desejados
lidos no console. Em caso afirmativo, imprimimos o número atual de
o console.

Capítulo 10. Métodos

Neste capítulo, vamos conhecer os métodos e aprender o que são, bem como quais são os conceitos básicos ao
trabalhar com eles. Aprenderemos por que é uma boa prática usá-los, como declará-los e chamá-los. Aprenderemos
sobre parâmetros e valor de retorno de um método e como usar esse valor de retorno. No final do capítulo, veremos
as práticas estabelecidas no uso dos métodos.
O que é um "método"?
Até agora, descobrimos que, ao escrever código para um programa que resolve uma tarefa, fica mais fácil dividir a
tarefa em partes. Cada parte é responsável por uma determinada ação e, dessa forma, não apenas facilita a
resolução da tarefa, mas também melhora muito a legibilidade do código e o rastreamento de erros.
Qualquer pedaço de código que execute uma determinada funcionalidade e que tenhamos separado logicamente
pode invocar a funcionalidade do método. Métodos são exatamente isso - pedaços de código que são nomeados
por nós de uma determinada maneira e que podem ser chamados quantas vezes precisarmos. Um método pode
ser chamado quantas vezes julgarmos necessário para resolver um determinado problema. Isso
nos poupa a repetição de um e
o mesmo código várias vezes, além de reduzir a possibilidade de perder um erro em

possível correção do código em questão.
métodos simples
Os métodos simples são responsáveis por realizar uma ação que ajuda a resolver um determinado problema. Tais
ações podem ser imprimir uma determinada string no console, realizar algum tipo de verificação, executar um
ciclo etc
Vejamos o exemplo a seguir para um método simples:
Este método é encarregado de imprimir um título que é uma string do caractere -. Por esta razão, seu nome é
printHeader. Parênteses ( e ) sempre seguem o nome, independentemente de como nomeamos o método.
Veremos como devemos nomear os métodos com os quais trabalhamos mais tarde, mas, por enquanto, apenas
observaremos que é importante que seu nome descreva a ação* que ele executa.
O corpo do método contém o código do programa que está entre as chaves { e }. Esses parênteses sempre seguem
sua declaração, e entre eles colocamos o código que resolve o problema descrito pelo nome do método.
Por que usar métodos?

Até agora, descobrimos que os métodos ajudam a dividir uma grande tarefa em partes menores, o que
leva a uma resolução mais fácil da tarefa em questão. Isso torna nosso programa não apenas melhor
estruturado e fácil de ler, mas também mais compreensível.
Através de métodos evitamos a repetição do código do programa. Código duplicado é uma prática ruim
porque torna o programa muito difícil de manter e leva a erros. Se uma determinada parte do nosso código
estiver presente várias vezes no programa e precisarmos alterar algo, então as alterações devem ser
feitas a cada iteração do código em questão. A probabilidade de perder um local onde precisamos fazer
uma correção é muito alta, o que levaria a um comportamento incorreto do programa. Esta é a razão pela
qual é uma boa prática usar um trecho de código mais de uma vez em nosso programa para defini-lo como
um método separado.
Os métodos nos dão a capacidade de usar um trecho de código várias vezes. À medida que você resolver
mais e mais tarefas, descobrirá que usar métodos já existentes economiza muito tempo e esforço.
Declarando métodos
Na linguagem Java, declaramos métodos dentro de uma classe, ou seja. entre as chaves de abertura { e
fechamento } da classe, mas não na declaração de outro método. Declarar é registrar o método no
programa para que seja reconhecido pelo restante do programa. Nosso exemplo mais conhecido de
método é o método main(…), que usamos em cada programa que escrevemos.
Com o próximo exemplo, veremos os elementos necessários em um dekla

a razão de um método.
• Tipo do valor de retorno. Nesse caso, o tipo é double, o que significa que o método de exemplo
retornará um resultado do tipo double. O valor de retorno pode ser int, double, String , etc. ou
void. Se o tipo for void, significa que o método não retorna um resultado, mas apenas executa uma
ação.
• Nome do método. O nome do método é definido por nós, lembrando que deve descrever a
função que é realizada pelo código em seu corpo. EM
Capítulo 10. Métodos 377
exemplo, o nome é GetSquare, o que nos diz que a tarefa desse método é
calcular a face de um quadrado.
• Lista de parâmetros. É declarado entre colchetes ( e ), que escrevemos após seu nome. Aqui listamos a
série de parâmetros que o método irá utilizar. Pode haver apenas um parâmetro, vários ou uma lista vazia.
Se não houver parâmetros, escreveremos apenas os parênteses (). No exemplo específico, declaramos
o lado do parâmetro do tipo double.
• Uma declaração estática na descrição do método. Por enquanto, podemos assumir que static é escrito
sempre que um método é declarado, e mais tarde, quando aprendermos sobre programação orientada a
objetos (OOP), entenderemos a diferença entre métodos estáticos (compartilhados para toda a classe) e
métodos de objeto que operam sobre os dados de uma instância específica da classe (objeto).
Ao declarar métodos, é importante seguir a sequência de seus elementos principais - primeiro a palavra-chave
static, seguida do tipo do valor de retorno, depois o nome do método e, finalmente, uma lista de parâmetros
entre chaves (). Após declararmos o método, segue-se sua implementação (corpo). No corpo do método,
descrevemos
o algoritmo pelo qual ele resolve um determinado problema, ou seja, o corpo contém o código (bloco de programa)
que implementa a lógica do método. No exemplo mostrado, calculamos a face de um quadrado, ou seja, lado *
lado.
Quando declaramos uma variável no corpo de um método, a chamamos de variável local para o método. O
escopo no qual essa variável existe e pode ser usada começa na linha em que a declaramos e termina com a
chave de fechamento } do corpo do método. Essa área é chamada de escopo variável.
Métodos de chamada
Chamar um método é o início da execução do código contido no corpo do método. Isso é feito escrevendo seu
nome, seguido dos parênteses () e do sinal ; para fim de linha. Se nosso método requer dados de entrada, eles
são passados entre parênteses (), e a sequência dos parâmetros reais deve corresponder à sequência daqueles
passados ao declarar o método. Aqui está um exemplo:
Um método pode ser chamado de vários lugares em nosso programa. Uma maneira é chamá-lo do método
principal.
Um método também pode ser chamado do corpo de outro método que não seja o método principal
no nosso programa.
Existe uma opção para o método ser chamado de seu próprio corpo. Isso é chamado de recursão, e você
pode encontrar mais informações sobre isso na Wikipédia ou pesquisar você mesmo na Internet.
É importante saber que se um método for declarado em uma determinada classe, ele poderá ser chamado
antes da linha em que for declarado.
Exemplo: um recibo em branco

Escrever um método que imprima um recibo em branco. O método deve chamar três outros métodos: um
para imprimir o título, um para o corpo da nota e um para o rodapé.
Parte do recibo Texto
RECIBO EM DINHEIRO
Parte de cima -------------------------
Carregado para____________________
Parte do meio
Recebido por___________________
-------------------------
parte inferior
(c) SoftUni
Conecte-se Saída
RECIBO EM DINHEIRO
(não há) -------------------------
Conecte-se Saída
Carregado para____________________
Recebido por___________________
-------------------------
(c) SoftUni
Diretrizes e dicas
Nosso primeiro passo é criar um método void para imprimir o cabeçalho do recibo. Vamos dar um
nome significativo que descreva de forma breve e clara sua tarefa, por exemplo printReceiptHeader.
Em seu corpo, escreveremos o código do exemplo abaixo:
Da mesma forma, criaremos mais dois métodos para imprimir a parte do meio da nota (corpo)
printReceiptBody e para imprimir a parte inferior da nota (rodapé) printReceiptFooter. A seguir,
também criaremos mais um método que chamará
os três métodos que

nós escrevemos até agora um após o outro:
Por fim, chamaremos o método printReceipt do corpo do método principal para

nosso programa:

O programa com um total de cinco métodos que são chamados um do outro está pronto e podemos
executá-lo e testá-lo, depois enviar para verificação no sistema de juízes: https://judge.softuni.bg/
Contests/Practice/Index/ 665#0.
Métodos com parâmetros

Muitas vezes, na prática, para resolver um determinado problema, o método pelo qual o alcançamos
precisa de informações adicionais que dependem de
sua tarefa. São essas informações que constituem os parâmetros do método, e seu comportamento depende
delas.
Usando parâmetros em métodos

Como observamos acima, os parâmetros, além de zero em número, também podem ser um ou mais. Ao declará-
los, os separamos com vírgulas. Eles podem ser de qualquer tipo (int, String , etc.), e abaixo está um exemplo
de como exatamente eles serão usados pelo método.
Declaramos o método e sua lista de parâmetros e, em seguida, escrevemos o código que ele executará.
Em seguida, chamamos o método e passamos valores específicos:
Ao declarar parâmetros, podemos usar diferentes tipos de variáveis, e devemos ter cuidado para que cada
parâmetro tenha um tipo e um nome. É importante observar que nas chamadas subsequentes ao método,
devemos passar valores para os parâmetros na ordem em que são declarados. Se tivermos parâmetros passados
na ordem int e depois String, ao chamá-lo não podemos passar um valor para String primeiro e depois para int.
Vejamos o exemplo de uma declaração de método que possui vários parâmetros

de um tipo diferente.
Exemplo: sinal inteiro

Para criar um método que imprima o sinal de um inteiro n.

Conecte-se Saída
2 O número 2 é positivo.
-5 O número -5 é negativo.
0 O número 0 é zero.
Diretrizes e dicas Nosso
primeiro passo é criar um método e dar a ele um nome descritivo, por exemplo printSign. Este
método terá apenas um parâmetro do tipo int.
Nosso próximo passo é implementar a lógica pela qual nosso programa verificará exatamente qual é
o sinal do número. A partir dos exemplos, vemos que existem três casos: o número é maior que zero,
igual a zero ou menor que zero,
o que significa que faremos três verificações no corpo do método.
Nosso próximo passo é ler o número de entrada e chamar o novo método do corpo do método
principal .
Exemplo: imprimir um triângulo

Crie um método que imprima um triângulo conforme mostrado nos exemplos.
1 11
12 212
3 123 4 3123
12 412
1 31
21
Diretrizes e dicas Antes

de criarmos um método para imprimir uma única linha com um determinado início e fim, lemos
o número de entrada do console. Em seguida, escolhemos um nome significativo para o
método que descreva sua finalidade, como printLine, e o implementamos.
Das tarefas de desenho em balanço, lembramos que é uma boa prática dividir a figura em
várias partes. Para nossa conveniência, vamos dividir o triângulo em
três partes - superior, linha média e inferior.
Nosso próximo passo é imprimir em loop a metade superior de um triângulo

Nika:
Em seguida, imprimimos a linha do meio:
Por fim, imprimimos a parte inferior do triângulo, desta vez diminuindo o passo do loop.

Exemplo: desenhar um quadrado preenchido

Desenhar no console um quadrado preenchido de lado n, como nos exemplos.
Conecte-se Saída Conecte-se Saída Entrada Saída

-------- ------
-\/\/\/- -\/\/ -\/\/- -\/ ----
4 3 2 ----
\/- \/-
-------- ------

primeiro passo é ler a entrada do console. Então preciso criar um método dem que
imprima a primeira e a última linha, pois são iguais. Não vamos esquecer que temos que
dar um nome descritivo e definir o comprimento do lado como parâmetro. Usaremos o
novo construtor String.
Nosso próximo passo é criar um método que irá desenhar as linhas do meio no console.
Novamente, definimos um nome descritivo, por exemplo printMiddleRow.
Por fim, chamamos os métodos criados no método principal main() do programa, para
para desenhar o quadrado inteiro:

Retornar um resultado de um método

Até agora, vimos métodos que executam uma ação, como imprimir um texto, número ou
figura no console. Além desse tipo de método, também existem métodos que podem
retornar algum resultado. São esses métodos que consideraremos nas linhas a seguir.
Tipos do valor de retorno do método

Até agora, vimos exemplos em que usamos a palavra-chave void ao declarar métodos , o que indica que
o método não retorna um resultado, mas executa uma determinada ação.
Se substituirmos void por um tipo de variável, isso dirá ao programa que o método deve retornar algum
valor do tipo especificado. Esse valor de retorno pode ser de qualquer tipo – int, String, double , etc.
Para que um método retorne um resultado, precisamos ter o cuidado de escrever o

tipo esperado do resultado na declaração do método em vez de void.
É importante observar que o resultado retornado pelo método pode ser de um tipo compatível com o tipo
do valor de retorno do método. Por exemplo, se o tipo declarado do valor de retorno for double, podemos
retornar um resultado do tipo int.
declaração de retorno
Para obter o resultado do método, o operador return vem em socorro. Ele deve ser usado no corpo do
método e diz ao programa para parar sua execução e retornar ao chamador do método um valor
especificado, que é determinado pela instrução após a instrução de retorno em questão .
No exemplo abaixo, temos um método que pega um nome e um sobrenome, os concatena e os retorna
como resultado. O valor de retorno é do tipo String:
O operador return também pode ser usado em métodos void . Então o próprio método irá parar de
executar sem retornar nenhum valor, e não deve haver nenhuma expressão depois dele para ser
retornado. Neste caso, o uso de return é apenas para sair do método.
Há casos em que return pode ser chamado de vários lugares em um método, mas somente se houver
certas condições de entrada.
No exemplo abaixo, temos um método que compara dois números e retorna um resultado de -1, 0 ou 1,
respectivamente , baseado em se o primeiro argumento é menor, igual ou maior que o segundo argumento passado
para o função. O método usa a palavra-chave return em três locais diferentes para retornar três valores diferentes
de acordo com a lógica das comparações numéricas:
O código após o retorno não está acessível Após
a instrução return, no bloco atual, não deve haver outras linhas de código, porque o IntelliJ IDEA lançará um erro
que encontrou um código que não pode ser acessado:
Na programação, não pode haver uma declaração de retorno duas vezes

após o outro porque a execução do primeiro não permitirá a execução do segundo. Às vezes,
os programadores brincam com a frase “escrever retorno; retornar; e vamos" para explicar
que a lógica do programa está confusa.
Uso do valor de retorno do método

Depois que um método é executado e retorna um valor, esse valor pode
é usado de várias maneiras.
A primeira é atribuir o resultado como o valor de uma variável de tipo compatível:
int max = getMax(5, 10);
A segunda é usar o resultado em uma expressão:

total duplo = getPreço() * quantidade * 1.2;
A terceira é passar o resultado da operação do método para outro método:
Scanner scanner = new Scanner(System.in); int idade

= Integer.parseInt(scanner.nextLine());
Exemplo: calcular a face de um triângulo

Escreva um método que calcule a face de um triângulo com base e altura fornecidas e
retorne seu valor.
Entrada Saída
3
6
4

primeiro passo é ler a entrada. Em seguida, criamos um método, mas desta vez
temos o cuidado de passar o tipo correto de dados que queremos que o método retorne,
ou seja, double.
Nosso próximo passo é chamar o novo método de nosso método main() e armazenar o
valor de retorno em uma variável apropriada.

Exemplo: potência de um número
Escrever um método que calcula e retorna o resultado da elevação de um número a uma

determinada potência.
2
256 81
8 34
Direções e dicas Nosso

primeiro passo será novamente ler a entrada do console. Seu próximo passo é criar um
método que receberá dois parâmetros (o número e a potência) e retornará um número do
tipo double como resultado.
Depois de fazermos os cálculos necessários, resta imprimir o resultado no método principal

main() do programa.

Variantes de métodos
Em muitas linguagens de programação, o mesmo método pode ser declarado em diversas
variantes com o mesmo nome e parâmetros diferentes. Isso é conhecido como “sobrecarga
de método”. Agora vamos ver como escrever esses métodos sobrecarregados.
Assinatura do método
Na programação, a forma como um método é identificado é pelo par de elementos de sua

declaração - um nome de método e uma lista de seus parâmetros. Esses dois elementos
definem sua especificação, a chamada assinatura de método.
Neste exemplo, a assinatura do método é seu nome (print) e também seu parâmetro (String text).
Se em nosso programa existem métodos com os mesmos nomes, mas com assinaturas diferentes,
dizemos que temos variantes de método (sobrecarga de método).
Variantes de métodos
Conforme mencionado, se usarmos o mesmo nome para vários métodos com assinaturas diferentes,
isso significa que temos variantes de método. O código abaixo mostra como três métodos diferentes
podem ter o mesmo nome, mas têm assinaturas diferentes e executam ações diferentes.
Assinatura e tipo do valor de retorno

É importante observar que o tipo de retorno do método não faz parte de sua assinatura. Se o valor de
retorno fizer parte da assinatura do método, o compilador não terá como saber exatamente qual método
chamar.
Vamos considerar o seguinte exemplo - temos dois métodos com tipos de retorno diferentes. No entanto,
o IntelliJ IDEA nos mostra que há um erro porque as naturezas de assinatura de ambos são as mesmas.
Da mesma forma, ao tentar chamar um método chamado print(), o compilador não seria capaz de decidir
qual dos dois métodos executar.
Exemplo: maior de dois valores

Dois valores do mesmo tipo são fornecidos como entrada. Os valores podem ser do tipo int, char ou
String. Crie um método getMax() que retorne o maior dos dois valores.
int Caracteres corda

16 a Com Ivan todor
2 16 Com todor
Diretrizes e dicas
Para criar este método, primeiro precisamos criar três outros métodos com o mesmo nome e assinaturas
diferentes. Primeiro criamos um método que irá comparar alvos
números
Seguindo a lógica do método anterior, criamos um com o mesmo nome, que irá, no entanto, comparar símbolos.
O próximo método que precisamos criar irá comparar strings. Aqui a lógica será um pouco diferente, pois valores
do tipo String não permitem ser comparados usando os operadores < e >. Usaremos o método compareTo(…),
que retorna um valor numérico: maior que 0 (o objeto comparado é maior), menor que 0 (o objeto comparado é
menor) e 0 (para dois objetos idênticos).
A etapa final é ler os dados de entrada, usar as variáveis apropriadas e chamar o método getMax() do corpo do
método main().

Nomeação de métodos e boas práticas

Nesta seção, veremos algumas práticas recomendadas ao trabalhar com métodos
relacionados a nomenclatura, layout de código e estrutura de código.
Métodos de nomenclatura
Ao nomear um método, é recomendável usar nomes significativos. Como cada método é
responsável por alguma parte do nosso problema, ao nomeá-lo, devemos considerar sua
função, ou seja, bom
é prática comum que o nome descreva seu propósito.
O nome deve começar com letra minúscula e deve ser composto por um verbo ou um
par: verbo + substantivo. O nome é formatado de acordo com a convenção Camel
Minúsculas, ou seja, a primeira palavra começa com uma letra minúscula e cada palavra
subseqüente começa com uma letra maiúscula. Parênteses ( e ) sempre seguem seu
nome.
Cada método deve executar uma tarefa independente e o nome do método deve
descrever qual é sua função.
Alguns exemplos de nomes de métodos corretos:
• encontrarEstudante
• relatório de carga
• deles
Alguns exemplos de nomes de métodos incorretos:
• Método1
• FaçaAlgo
• Handle Stuff
• SampleMethod
• DirtyHack
Se não conseguirmos encontrar um nome adequado, provavelmente o método resolve mais
de uma tarefa ou não tem um propósito claramente definido e, então, precisamos pensar
em como dividi-lo em vários métodos separados.
Parâmetros do método de nomeação

Praticamente as mesmas regras se aplicam à nomenclatura dos parâmetros do método e
aos próprios métodos. As diferenças aqui são que não há problema em usar um substantivo
ou um par adjetivo-substantivo para nomes de parâmetros, e essa nomenclatura de
parâmetro também segue a convenção lowerCamelCase . Devemos observar que é uma
boa prática que o nome do parâmetro indique a unidade de medida usada ao trabalhar com
ele.
Alguns exemplos de como nomear Alguns exemplos de nomes de parâmetros
corretamente os parâmetros do método: incorretos:
• primeiroNome •p
• relatório • p1
• velocidadeKmH p2_ _
• lista de usuários • povoar
• fontSizeInPixels • Sobrenome
• fonte • sobrenome
Boas práticas ao trabalhar com métodos

Lembremos novamente que um método deve executar apenas uma tarefa bem definida. Se
isso não puder ser alcançado, precisamos pensar em como dividir o método em vários
métodos separados. Como dissemos, o nome do método deve descrever com precisão e
clareza sua finalidade. Outra boa prática de programação é evitar métodos maiores que
nossa tela (aproximadamente). Se, no entanto, o código ficar muito volumoso, é
recomendável usar o método yes
dividida em várias outras mais curtas, como no exemplo abaixo.
Estrutura e formatação do código

Ao escrever métodos, devemos ter cuidado para observar a indentação correta (mudança
de blocos de código mais adiante).
Exemplo de código Java formatado corretamente:
Exemplo de código Java formatado incorretamente:
Quando a linha do título do método for muito longa, recomenda-se dividi-la em várias linhas, com cada linha após
a primeira deslocada duas abas para a direita (para melhor legibilidade):
Outra boa prática ao escrever código é deixar uma linha em branco entre métodos, loops posteriores e condicionais.
Além disso, tente evitar escrever linhas longas e expressões complexas. Com o tempo, você descobrirá que isso
melhora a legibilidade do código e economiza tempo.
Recomendamos sempre usar chaves para o corpo de verificações e loops. Os parênteses não apenas melhoram a
legibilidade, mas também reduzem a possibilidade de cometer um erro e fazer com que nosso programa se
comporte mal.

Neste capítulo, fomos apresentados aos conceitos básicos de trabalhar com métodos:
• Aprendemos que o propósito dos métodos é dividir grandes programas por muitos
linhas de código em tarefas menores e mais curtas.
• Conhecemos a estrutura dos métodos, como declará-los e chamá-los

temos o nome deles.
• Vimos exemplos de métodos com parâmetros e como usá-los em nosso programa.
• Aprendemos o que são a assinatura e o valor de retorno de um método,

bem como qual é a função da declaração de retorno em métodos.
• Aprendemos sobre as melhores práticas ao trabalhar com métodos, como nomear métodos
e seus parâmetros, como formatar código e muito mais.
exercícios
Para consolidar o trabalho com métodos, resolveremos várias tarefas. Eles exigem que
você escreva um método com determinada funcionalidade e, em seguida, chame-o como
alimente-o com os dados lidos do console, conforme mostrado no exemplo
entrada e saída.
Tarefa: "Olá, nome!"

Escreva um método que receba um nome como parâmetro e imprima "Olá, <nome>!" no
console.
Conecte-se Saída
Peter Olá Peter!
Diretrizes e dicas Defina

um método printName(string name) e implemente-o, em seguida, no programa principal,
leia o nome de uma pessoa no console e chame
método passando-lhe o nome de leitura.

Tarefa: número menor

Crie um método getMin(int a, int b) que retorne o menor de dois números. Escrever um
programa que lê como dados de entrada do console três números e imprime o menor deles.
Para usar o método getMin(…) que é
já criado.
1 -100
2 1 -101 -102
3 -102
Diretrizes e dicas Defina

um método getMin(int a, int b) e implemente-o, então chame-o do programa principal como
mostrado abaixo. Encontrar
o mínimo de três números, primeiro encontre o mínimo dos dois primeiros deles e depois
este é o mínimo do resultado e o terceiro número:
int min = getMin(getMin(num1, num2), num3);

Tarefa: repetir uma string
Escreva um método repeatString(str, count) que receba como parâmetros uma variável
do tipo String e um inteiro n e retorne a string repetida n vezes. Depois
isso para imprimir o resultado no console.
str prazos
strstr armazenamento armazenamento armazenamento
2 6
Diretrizes e dicas
Reescreva o método abaixo adicionando a concatenação da string de entrada ao resultado
tata no ciclo:
Observe que na linguagem Java, concatenar strings em um loop resulta em baixo

desempenho e não é recomendado. Pesquise e experimente soluções mais eficientes aqui:
https://stackoverflow.com/questions/1235179.

Problema: o enésimo dígito
Escreva um método findNthDigit(number, index) que receba um número e um índice N

como parâmetros e imprima o enésimo dígito do número (contando da direita para a
esquerda, começando em 1). Em seguida, imprima o resultado no console.

Conecte-se Saída Conecte-se Saída Entrada Saída
83746 2 93847837 6 2435

4 8 2
4
Diretrizes e dicas
Para executar o algoritmo, usaremos um loop while até que um número se torne 0. A cada iteração do
loop while , verificaremos se o índice atual do número não corresponde ao índice que estamos procurando.
Se corresponder, retornaremos o número do índice (número % 10) como resultado. Se não corresponder,
removeremos o último dígito do número (número = número / 10). Precisamos acompanhar qual dígito
estamos verificando pelo índice (da direita para a esquerda, começando em 1). Quando encontrarmos o
dígito, retornaremos o índice.

Tarefa: sistema de número para número

Escreva um método integerToBase(number, toBase) que receba como parâmetros um inteiro e a base
de um sistema numérico e retorne o número de entrada convertido no sistema numérico especificado. Em
seguida, imprima o resultado no console. O número de entrada sempre estará no sistema numérico 10 e
o parâmetro base estará entre 2 e 10.
Entrada Saída Entrada Saída Entrada Saída
3 4 9
11 10 12
2 4 7
Diretrizes e dicas
Para resolver o problema, declararemos uma variável string na qual armazenaremos o resultado. Em
seguida, precisamos realizar os seguintes cálculos necessários para converter o número.
• Calculamos o restante do número dividido pela base.

• Inserimos o restante do número no início da string que representa o resultado. • Dividimos
o número pela base. • Repetimos o
algoritmo até que o número de entrada se torne 0.
Preencha a lógica que falta no método abaixo:

static String integerToBase(int number, int toBase) { String resultado = "";

while (number != 0) { //
Implementa a lógica de
conversão ausente
} retorna resultado;
}

Tarefa: notícias
Escreva um programa que leia um inteiro n e insira n mensagens nas seguintes linhas (várias
linhas são lidas para cada mensagem). Cada mensagem começa com messageType: sucesso,
aviso ou erro:
• Quando messageType for bem-sucedido na operação de leitura + mensagem (cada um em

linha separada).
• Quando messageType é uma mensagem somente de leitura de aviso .
• Quando messageType for error , leia operação + mensagem + errorCode (cada um em

uma linha separada).
Imprima cada mensagem lida no console, formatada de acordo com seu messageType. Assim
como após a linha de cabeçalho de cada mensagem, imprima tantos símbolos = quantos forem os
comprimentos da linha de cabeçalho correspondente e coloque uma linha em branco após cada
mensagem (para uma compreensão mais detalhada, veja os exemplos).
Resolva a tarefa definindo quatro métodos: showSuccessMessage(), showWarningMessage(),

showErrorMessage() e readAndProcessMessage(), com apenas o último método sendo chamado
do método main() principal:

Conecte-se Saída
erro Erro: Falha ao executar a compra com cartão de crédito.

==============================================
compra com cartão de crédito
Endereço de cliente Motivo: Endereço de cliente inválido.
inválido Código de erro: 500.
500
Aviso: E-mail não confirmado.
aviso ===============================
E-mail não confirmado
sucesso
Cadastro de usuário executado com sucesso.
registro de usuário ========================================
Usuário cadastrado Utilizador registado com sucesso.
com sucesso
aviso Aviso: o cliente não tem e-mail atribuído.

===========================================
O cliente não tem e-
mail atribuído
Diretrizes e dicas
Definir e implementar os quatro métodos indicados.
Em readAndProcessMessage() , leia o tipo de mensagem do console e, de acordo com o tipo lido, leia o
restante dos dados (mais duas ou três linhas). Em seguida, chame o método apropriado para imprimir o tipo
de mensagem apropriado. Se você estiver lendo do console a partir de vários métodos separados,
observe que você só precisa criar um objeto Scanner uma vez (por exemplo, no método main) e passá-lo
para os outros métodos como um parâmetro. A criação de vários objetos Scanner que são lidos no console
pode não funcionar conforme o esperado.
Tarefa: números em palavras

Escreva um método letterize(number) que leia um inteiro e o imprima em palavras em inglês de acordo
com as condições abaixo:
• Para imprimir as centenas, dezenas e unidades (e possivelmente

menos) de acordo com as regras da língua inglesa.
• Se o número for maior que 999, deve ser impresso "muito grande". • Se o
número for menor que -999, "muito pequeno" deve ser impresso.
• Se o número for negativo, "menos" deve ser impresso antes dele. • Se o número não
tiver três dígitos, não deve ser impresso.
novecentos e noventa e nove

3 quinze
menos quatrocentos e vinte 2
999 trezentos e cinquenta
15 350
-420 1020 muito grande
trezentos e onze
4 quinhentos
quatrocentos e dezoito 3
311 123
quinhentos e nove 500
418 nove
123 9
509 -9945muito pequeno
Diretrizes e dicas
Podemos imprimir as centenas como texto primeiro - (o número / 100) % 10, depois as
dezenas - (o número / 10) % 10 e finalmente as unidades - (o número % 10).
O primeiro caso especial é quando o número é exatamente arredondado para 100 (por
exemplo, 100, 200, 300, etc.). Nesse caso, imprimimos "cem", "duzentos", "trezentos"
etc.
O segundo caso especial é quando o número formado pelos dois últimos dígitos do
número de entrada é menor que 10 (por exemplo, 101, 305, 609, etc.). Nesse caso,
imprimimos "cento e um", "trezentos e cinco", "seiscentos e nove", etc.
O terceiro caso especial é quando o número formado pelos dois últimos dígitos do
número de entrada é maior que 10 e menor que 20 (por exemplo, 111, 814, 919, etc.).
Neste caso, imprimimos "cento e onze", "oitocentos e quatorze", "novecentos e
dezenove", etc.

Tarefa: criptografar uma string

Para escrever um método encrypt(char letter) que criptografa uma determinada letra por
da seguinte maneira:
• O primeiro e o último dígito do código ASCII da letra são retirados e colados

um para o outro em uma string que representará o resultado.
• Ao início do valor da string que representa o resultado é colado

o símbolo que atende à seguinte condição:
o Código ASCII da letra + o último dígito do código ASCII da letra.

• Então, ao final do valor da string que representa o resultado, se
cole o símbolo que atende a seguinte condição:
o Código ASCII da letra - o primeiro dígito do código ASCII da letra.

• O método deve retornar a string criptografada como resultado.
Exemplo:
• j ÿ p16i
o O código ASCII de je 106 ÿ Primeiro dígito - 1, último dígito - 6. o Colamos
o primeiro e o último dígito ÿ 16. o No início do valor da
string que representa o resultado, colamos o símbolo que é obtido da soma do código
ASCII + último dígito ÿ 106 + 6 ÿ 112 ÿ p.
o Ao final do valor da string que representa o resultado, colamos o símbolo obtido da

diferença do código ASCII - o primeiro dígito ÿ 106 - 1 ÿ 105 ÿ i.
Usando o método descrito acima, escreva um programa que leia um poro

sequência de caracteres, criptografa-os e imprime o resultado em uma única linha.
Assumimos que os dados de entrada serão sempre válidos. O método principal deve ler os dados de entrada
fornecidos pelo usuário - um inteiro n, seguido por
de um símbolo em cada uma das próximas n linhas.
Para criptografar os caracteres e anexá-los à string criptografada. Por fim, como resultado, uma cadeia de
caracteres criptografada deve ser impressa como no exemplo a seguir.
Exemplo:
• S, o, f, t, U, n, i ÿ V83Kp11nh12ez16sZ85Mn10mn15h
4 7
s S
eu o
a f
x15rt18kh97Xr12o V83Kp11nh12ez16sZ85Mn10mn15h
p t
EM
n
eu
Diretrizes e Dicas A
variável String na qual o valor do resultado será armazenado será "" (String Vazia).
= Devemos fazer um loop n vezes, e a cada iteração atribuir um valor inicial String str
adicionaremos o símbolo criptografado à variável na qual armazenamos o valor do
resultado.
Para encontrar o primeiro e o último dígito do código ASCII, usaremos o ritmo de
algoritmo que usamos para resolver o problema "Number to Number System".

Capítulo 11. Truques e hacks

Neste capítulo, veremos alguns truques, macetes e técnicas que facilitarão o trabalho
com a linguagem Java no ambiente de desenvolvimento IntelliJ IDEA. mais especial
mas vamos nos encontrar:
• Como formatar código corretamente •

Com convenções de nomenclatura para elementos
de código • Com alguns atalhos de teclado • Com
alguns trechos de código • Com técnicas
de depuração de código
Formatação de código
A formatação adequada do nosso código o tornará mais legível e compreensível se outra
pessoa precisar trabalhar com ele. Isso é importante porque, na prática, precisaremos
trabalhar em equipe com outras pessoas, e é muito importante escrever nosso código de
maneira que nossos colegas possam navegar rapidamente. Existem certas regras para
a formatação adequada do código, que são chamadas de convenções. As convenções
são um conjunto de regras geralmente aceitas pelos programadores de uma determinada
linguagem e são amplamente utilizadas. Essas convenções ajudam a construir normas
em determinados idiomas - a melhor forma de escrever e quais são as boas práticas.
Supõe-se que, se um programador os seguir, seu código será fácil de ler e entender.
A linguagem de programação Java foi criada pela Sun Microsystems (empresa de

tecnologia posteriormente absorvida pela Oracle) e foi a Sun quem criou uma das
primeiras convenções para Java. Você deve saber que, mesmo que não siga as
convenções geralmente aceitas, seu código funcionará (desde que seja escrito
corretamente), mas não será facilmente compreendido por outros programadores.
Obviamente, isso não é fatal em um nível básico, mas quanto mais cedo você se
acostumar a escrever código de qualidade, melhor.
A convenção de código Java moderna mais amplamente aceita é chamada de "Guia de
Estilo Java do Google" (https://google.github.io/styleguide/javaguide.html) e este livro irá
somos guiados principalmente por ela.
Para formatação de código no mundo Java, é recomendável que as chaves {} estejam

na seguinte disposição - a chave de abertura está na mesma linha e a chave de
fechamento logo abaixo da construção a que se referem, como no exemplo abaixo.
if (someCondition)
{ System.out.println("Dentro da instrução if");
}
Você pode ver que o comando System.out.println(…) no exemplo tem 4 espaços para
dentro (uma tabulação), que é o padrão Java. Não importa quantas guias em
inicia uma construção particular com chaves (ou seja, não importa quantos operadores
aninhados tenhamos), a chave de fechamento deve estar abaixo do início
da construção como no exemplo abaixo:
if (alguma condição) { if
(outra condição) {
System.out.println("Dentro da instrução if");
}
}
Aqui está um exemplo de código mal formatado contra as convenções geralmente aceitas para
escrever código na linguagem Java:
if(someCondition)
{ System.out.println("Dentro da instrução if");}
A primeira coisa a notar são as chaves {}. O primeiro parêntese (abertura) deve estar
após a condição if , e o segundo parêntese (fechamento) - sob o comando
System.out.println(…), em uma linha vazia separada. Além disso, o comando dentro
da construção if deve ter 4 espaços dentro (uma tabulação). Um espaço é deixado
imediatamente após a palavra-chave if e antes da condição de verificação e
imediatamente antes de { .
A mesma regra se aplica a loops for e quaisquer outras construções com chaves {}.
Aqui estão mais alguns exemplos:
Correto:
for (int i = 0; i < 5; i++)

}
Errado:
for(int i=0;i<5;i++)
{ System.out.println(i); }
Para sua conveniência, existem atalhos de teclado no IntelliJ IDEA, que explicaremos
mais adiante neste capítulo, mas, por enquanto, estamos interessados em duas
combinações específicas. Uma combinação é para formatar o código em todo o
documento e a outra combinação é para formatar uma parte do código. Se quisermos
formatar todo o código, devemos pressionar [CTRL + ALT + L]. Caso queiramos
formatar apenas parte do código, então devemos destacar a parte que queremos
formatar e pressionar [Ctrl + Shift + Alt + L].
Capítulo 11. Truques e Hacks 403
Vamos usar o exemplo errado de um tempo atrás:
for(int i=0;i<5;i++)
{ System.out.println(i); }
Se pressionarmos [CTRL + ALT + L], que é nossa combinação para formatar o documento
inteiro, obteremos o código formatado de acordo com as convenções Java geralmente
aceitas, que ficará assim:
for (int i = 0; i < 5; i++)

}
Essa combinação pode nos ajudar se encontrarmos um código mal formatado.
Nomeando os elementos do código

Nesta seção, vamos nos concentrar nas convenções geralmente aceitas para nomear
projetos, arquivos e variáveis no mundo Java.
Nomeando projetos e classes

Para nomear projetos e classes, recomenda-se um nome descritivo que sugira o papel
da classe/projeto em questão, enquanto a convenção PascalCase é recomendada. Esta
é uma convenção de nomenclatura de elemento em que cada palavra, incluindo a primeira,
começa com letra maiúscula, por exemplo Expressão
Calculadora.
Exemplo: este curso começa com uma palestra chamada First steps in coding, então um
exemplo de nome de projeto para esta palestra pode ser FirstSteps InCoding. A mesma
convenção se aplica às classes em um projeto. Se tomarmos a primeira tarefa da palestra
Primeiros passos na codificação como exemplo, ela se chama Hello World e, portanto,
nosso arquivo de projeto será chamado HelloWorld.
Variáveis de nomeação
Na programação, as variáveis contêm alguns dados e, para tornar o código mais
compreensível, o nome de uma variável deve sugerir sua finalidade. Aqui estão mais
algumas recomendações para nomes de variáveis ao programar com a linguagem Java:
• O nome deve ser curto e descritivo e explicar para que serve a variável.
• O nome deve conter apenas as letras az, AZ, os números 0-9 e os símbolos '$' e '_'.
• Em Java, aceita-se que as variáveis sempre comecem com uma letra minúscula e contenham
letras minúsculas, com cada palavra subseqüente nelas começando com uma letra maiúscula
(essa nomenclatura também é conhecida como convenção camelCase ) .
• Deve-se tomar cuidado com letras maiúsculas e minúsculas, pois o Java diferencia maiúsculas de
minúsculas. Por exemplo , age e Age são variáveis diferentes.
• Os nomes de variáveis não podem corresponder a uma palavra-chave Java, por exemplo, int é
um nome de variável inválido.
Embora o uso de caracteres vi seja permitido, _ em nomes de variáveis

não é recomendado em Java e é considerado um estilo de nomenclatura ruim.
Aqui estão alguns exemplos de variáveis bem nomeadas:

• primeiroNome
• idade
• startIndex
• lastNegativeNumberIndex
Aqui estão alguns exemplos de variáveis mal nomeadas, mesmo que os nomes estejam corretos do
ponto de vista do compilador Java:
• _firstName (começa com '_') •
last_name (contém '_') • AGE
(em letras maiúsculas, que é o nome errado para uma variável, mas é
nome próprio para uma constante)
• Start_Index (começa com uma letra maiúscula e contém '_') •
lastNegativeNumber_Index (contém '_')
A princípio, todas essas regras podem nos parecer inúteis e desnecessárias, mas com o passar do
tempo e o acúmulo de experiência, você verá a necessidade de normas para escrever código de
qualidade para poder trabalhar com mais facilidade e rapidez em equipe. Você achará extremamente
tedioso trabalhar com código escrito sem
seguir quaisquer regras de qualidade de código.
Teclas de atalho no IntelliJ IDEA

Na seção anterior, mencionamos duas das combinações que se aplicam à formatação do código. Uma
combinação [Ctrl + Alt + L] servia para formatar todo o código em um determinado arquivo, e a segunda
[Ctrl + Shift + Alt + L] nos servia caso quiséssemos formatar apenas uma determinada parte do código.
Essas combinações são chamadas de teclas de atalho e agora daremos informações mais detalhadas
sobre elas.
As teclas de atalho são combinações que nos permitem realizar algumas ações de maneira mais fácil
e rápida, como qualquer ambiente de desenvolvimento de software
tem suas teclas de atalho, embora a maioria seja repetitiva. Agora veremos alguns dos atalhos
de teclado no IntelliJ IDEA.
Combinação Ação
A combinação abre um mecanismo de busca que podemos usar para

[CTRL + F]
pesquisar nosso código.
[CTRL + K + C] Comentou parte do código.
[CTRL + K + U] Descomente o código que já está comentado.
[CTRL + Z] Retorna uma alteração (chamada Desfazer).
A combinação tem o efeito oposto de [CTRL + Z] (o chamado

[CTRL+S]
Refazer).
[CTRL + K + D] Formata o código de acordo com as convenções padrão.
[CTRL + Backspace] Exclui a palavra à esquerda do cursor.
[CTRL + Del] Exclui a palavra à direita do cursor.
[CTRL + Shift + S] Salva todos os arquivos do projeto.
[CTRL + S] Salva o arquivo atual.
Mais informações sobre atalhos de teclado no IntelliJ IDEA podem ser encontradas no site da
JetBrains: https://jetbrains.com/help/idea/keyboard-shortcuts-by-category.html.
Modelos com código (trechos de código)

No IntelliJ IDEA existem os chamados templates com código (snippets de código), quando
escrito, algum bloco de código é escrito de acordo com um template. Por exemplo, digitar sout
+ [Enter] imprime o código System.out.println();:
Vamos fazer nosso próprio modelo de código

Nesta seção, mostraremos como criar seu próprio modelo. Veremos como fazer um trecho de
código para scanner.nextLine();. Para começar, vamos criar um novo projeto vazio e ir para
[Arquivo ÿ Configurações ÿ Editor ÿ Live
Templates] selecionando [+ ÿ Live Template] conforme mostrado na figura abaixo.
Aparece uma nova janela que se parece com a imagem a seguir.
Aqui preenchemos as seguintes informações:

• [Abreviação] - insira o trecho de código que usaremos aqui. Neste caso particular, é scnl. •
[Descrição] - preencha uma
descrição para o snippet aqui. No nosso caso, isso é scanner.nextLine().
• [Texto modelo] - aqui inserimos o código que será gerado ao escrever a abreviação. Neste
caso, este é o código abaixo:
Scanner scanner = novo scanner(Sysrtem.in); String s =

scanner.nextLine();
Em seguida, marcamos [Reformatar de acordo com o estilo] e, em [Definir], selecione [Java] e

pressione [OK], conforme mostrado na figura abaixo.
Agora, quando digitamos scnl no IntelliJ IDEA, nosso novo trecho aparece:
Técnicas de depuração de código

A depuração desempenha um papel importante no processo de desenvolvimento de
software, permitindo-nos rastrear passo a passo a execução do nosso programa. Usando
esta técnica, podemos monitorar os valores das variáveis locais à medida que mudam
durante a execução do programa e corrigir eventuais erros (bugs). O processo de depuração
inclui:
• Percebendo os problemas (bugs). • Encontrar o
código que está causando os problemas.
• Corrigindo o código que está causando os problemas para que o programa funcione
corretamente.
• Teste para garantir que o programa funcione corretamente depois de aplicado

correções.
O IntelliJ IDEA nos fornece um depurador integrado, por meio do qual podemos definir
pontos de interrupção em locais de nossa escolha. Quando uma parada (breakpoint) é
encontrada, o programa interrompe sua execução e permite a execução passo a passo das
linhas restantes. A depuração nos permite entrar nos detalhes de um programa e ver
exatamente onde ocorrem os erros, bem como
Qual é a razão para isto.
Para demonstrar como funciona o depurador, usaremos o seguinte programa:
public static void main(String[] args) { for (int i = 0; i <

100; i++) { System.out.println(i);
}
}
Vamos colocar um stop (breakpoint) na função System.out.println(…). Para fazer

isso, precisamos mover o cursor para a linha que imprime no console e pressionar
[Ctrl + F8] ou clique com o botão esquerdo do mouse à direita do número da linha.
Um ponto de interrupção aparece onde o programa irá parar de executar.
Para executar o programa no modo de depuração, selecione [Executar] ÿ [Depurar

<nome da classe>] ou pressione [SHIFT + F9].
Após iniciar o programa, vemos que ele para sua execução na linha 8, onde colocamos
o stopper (breakpoint). O código da linha atual é destacado em uma cor adicional e
podemos executá-lo passo a passo. Para mover para a próxima linha, use a tecla
[F8]. Notamos que o código da linha atual ainda não foi executado. Executado quando
passamos para a próxima linha. Em verde é mostrado o valor atual da variável, na
figura abaixo i = 0.
Na janela [Variáveis], podemos monitorar as alterações nas variáveis locais.
Manual com truques

Nesta seção, relembraremos brevemente os truques e técnicas de programação Java
abordados anteriormente neste livro que serão muito úteis se você
você faz o exame de programação para iniciantes:
Saída formatada com printf()

Para imprimir matrizes longas e complexas de elementos, podemos usar o método
printf(…). Este método significa "Imprimir formatado". A ideia principal de printf(…) é
aceitar uma string especial formatada com caracteres de formatação especial e uma lista
de valores para substituir no lugar dos "especificadores de formato".
printf(<string formatada>, <param1>, <param2>, <param3>, …)
Exemplo:
String str = "algum texto";

System.out.printf("%s", str); // Isso
imprimirá no console "algum texto"
O primeiro argumento do método printf(…) é a string de formato. Neste caso , %s significa

que a string str deve ser impressa , no lugar de %s.
String str1 = "algum texto"; int

número = 5; String
str2 = "mais algum texto";
System.out.printf("%s %d %s \n", str1, numero, str2); // Isso imprimirá
no console "some text 5 some more text"
Neste exemplo, notamos que podemos passar mais do que apenas variáveis de texto. O
primeiro argumento é a string de formato. Segue uma série de argumentos, substituindo
onde houver uma porcentagem seguida por uma letra (%s ou %d). O primeiro %s significa
colocar em seu lugar o primeiro argumento passado após a string de formato, no caso
str1. Isso é seguido por %d, que significa substituir pelo primeiro inteiro passado nos
argumentos. O último caractere especial é novamente %s, o que significa substituí-lo
pela próxima sequência de caracteres str2. Isso é seguido por \n, que é um caractere
especial que indica uma nova quebra de linha. Podemos usar uma determinada variável
várias vezes.
String str = "algum texto"; int

número = 5;
System.out.printf("%s %d %s \n", str, número, str); // Isso imprimirá
no console "some text 5 some text"
Arredondando números de ponto flutuante

Os tipos reais de ponto flutuante que usamos em Java são float e double.
número duplo = 5,432432;

System.out.println(Math.round(número)); // Isso
imprimirá "5" no console
Se o primeiro dígito após a vírgula for menor que 5, como no exemplo acima, o
arredondamento é para baixo, mas se for 5 ou maior, o arredondamento é para cima.
como no exemplo abaixo:

System.out.println(Math.round(número)); // Isso
imprimirá "6" no console
Outros métodos de arredondamento

Caso queiramos sempre arredondar para baixo, podemos ao invés de Math.round(…)
usar outro método - Math.floor(…), que sempre arredonda para baixo. Por exemplo, se
tivermos o número 5,99 e usarmos Math.floor(5,99), obteremos o número 5,0.
Também podemos fazer exatamente o oposto - sempre arredonde usando o método

Math.ceil(…). Novamente, se tivermos um número como 5,11 e usarmos Math.ceil(5,11),
obteremos 6,0. aqui estão alguns exemplos:
double numberToFloor = 5,99;

System.out.println(Math.floor(numberToFloor)); // Isso
imprimirá no console 5.0
double numberToCeiling = 5.11;

System.out.println(Math.ceil(numberToCeiling)); // Isso
Formato com dois dígitos após o ponto decimal

System.out.printf("%.2f%n", número); // Isso
Neste caso, usamos a string de formato %.2f, que limitará a variável numérica a 2 dígitos
após a vírgula. Devemos ter em mente que o número antes da letra f significa quantas
casas decimais o resultado é arredondado (ou seja, pode ser %.3f ou %.5f). Recomenda-
se que com printf() usemos %n em vez de /n como caractere de nova linha .
Como você escreve uma construção condicional?

A construção if condicional consiste nos seguintes elementos:
• palavra-chave if •
expressão booleana
(condição) • corpo da condição •
opcional: cláusula else
if (condição) { //
corpo }
else (condição) { //
corpo
}
Por conveniência, podemos usar um trecho de código para uma construção if :

• se + [Enter]
Como você escreve um loop for?

Para um loop for, precisamos de algumas coisas:
• Bloco de inicialização, executa apenas uma vez antes que a condição de repetição seja
verificada. Na maioria das vezes, a variável do contador (int i) é declarada e inicializada.
• Repita a condição (i <= 10).
• Atualizar contador (i++).
• Corpo de loop.
for (int i = 0; i <= 10; i++) { // corpo
É importante saber que todas as três partes do loop for são opcionais e podem ser omitidas. for(; ; )
{ … } é um exemplo válido de loop for .
Por conveniência, podemos usar um trecho de código para um loop for:

• fori + [Enter]

Neste capítulo, aprendemos como formatar e nomear corretamente nossos elementos de código,
alguns atalhos para trabalhar no IntelliJ IDEA, trechos de código e vimos como depurar código.
Conclusão
Se você leu o livro inteiro, resolveu todos os exercícios e chegou a essa conclusão, você está
de parabéns! Você já deu o primeiro passo para aprender a se tornar um programador, mas
ainda tem um longo caminho a percorrer antes de se tornar realmente bom em fazer da criação
de software sua profissão. Lembre-se dos quatro principais conjuntos de habilidades que todo
programador deve possuir para exercer
sua profissão:
• Habilidade nº 1 – escrever código de programação (20% das habilidades do programador)

– amplamente abordada neste livro, mas você também deve aprender estruturas básicas
de dados, classes, objetos, funções, strings e outros elementos de escrita de código.
• Habilidade #2 – Pensamento Algorítmico (30% das Habilidades do Programador) –

parcialmente coberta por este livro e desenvolvida principalmente pela resolução de um
grande número de diferentes problemas algorítmicos.
• Habilidade #3 - conhecimento fundamental da profissão (25% das habilidades do
programador) - adquirida ao longo de vários anos com uma combinação de aprendizado
e prática (ler livros, assistir a tutoriais em vídeo, frequentar cursos e principalmente
escrever vários projetos de diferentes áreas tecnológicas) .
• Habilidade #4 – linguagens de programação e tecnologias de software (25% das habilidades

de um programador) – adquirida ao longo de um longo período de tempo, com muita
prática, leitura sólida e redação de projetos. Esses conhecimentos e habilidades
rapidamente se tornam obsoletos e devem ser constantemente atualizados. Os bons programado
aprender novas tecnologias todos os dias.
Este livro é apenas o primeiro passo!

Este livro sobre fundamentos de programação é apenas o primeiro passo na construção das
habilidades de um programador. Se você conseguiu resolver todos
tarefas, significa que você adquiriu um conhecimento valioso sobre os princípios de programação
com a linguagem C# em um nível básico. Você ainda tem que estudar programação a fundo,
bem como desenvolver seu pensamento algorítmico, então agregar conhecimento tecnológico
da linguagem C# e do ecossistema .NET (.NET Framework, .NET Core, Entity Framework,
ASP.NET e outros), frente -end tecnologias (HTML, CSS, JavaScript) e uma série de outros
conceitos, tecnologias e ferramentas para desenvolvimento de software.
Se você não conseguiu resolver todas ou a maioria das tarefas, volte e resolva-as! Lembre-se
que se tornar um programador requer muito trabalho e esforço. Essa profissão não é para
preguiçosos. Sem uma prática séria de programação por anos, não há como aprender!
Como já explicamos, a primeira e mais básica habilidade de um programador é aprender a

escrever código com facilidade e prazer. Essa é exatamente a missão deste livro: ensinar você
a programar. Recomendamos que, além do livro, você também faça o curso prático de
"Fundamentos da programação" para iniciantes da SoftUni (https://softuni.bg/apply), que é
oferecido de forma totalmente gratuita na modalidade presencial. forma presencial ou online de
treinamento.
Para onde vamos depois deste livro?

Com este livro, você estabeleceu uma base sólida que facilitará seu desenvolvimento como
programador. Se você está se perguntando como continuar seu desenvolvimento, considere as
várias opções a seguir:
• estudar para ser engenheiro de software na SoftUni e fazer a programação
sua profissão;
• para continuar seu desenvolvimento como programador à sua maneira,
por exemplo, através do auto-estudo ou com alguns tutoriais online;
• ficar no nível do codificador sem programação
seriamente.
Profissão "engenheiro de software" na SoftUni

A primeira e, portanto, recomendada oportunidade de dominar totalmente a profissão de
"engenheiro de software" é iniciar seus estudos no programa completo de treinamento de
engenheiro de software da SoftUni: https://softuni.bg/curriculum . O currículo SoftUni foi
cuidadosamente desenvolvido pelo Dr. Svetlin Nakov e sua equipe para apresentar a você de
forma consistente e com complexidade gradual todas as habilidades que um engenheiro de
software precisa ter para iniciar uma carreira como desenvolvedor de software em uma empresa
de TI.
Duração do treinamento na SoftUni O treinamento na

SoftUni dura de 2 a 3 anos (dependendo da profissão e das especializações escolhidas) e
durante esse tempo é normal atingir um bom nível de entrada (desenvolvedor júnior), mas
somente se você estudar seriamente e escrever muito código diariamente. Com bom sucesso,
um aluno típico começa a trabalhar na metade de seus estudos (após cerca de 1,5 anos).
Graças a uma rede de parceiros bem desenvolvida, o Centro de Carreiras SoftUni oferece vaga
em empresa de software ou TI para todos os alunos SoftUni que obtiverem resultados muito
bons ou excelentes.
Torne-se um programador em pelo menos um ano de sólida escrita de código

Avisamos que se tornar um programador exige muito esforço, escrever dezenas de milhares
de linhas de código e resolver centenas, até milhares de problemas práticos, e leva anos! Se
alguém lhe oferece um "programa mais leve" e promete que você se tornará um programador e
começará a trabalhar em 3-4 meses, então
Conclusão 415
ou ele está mentindo para você ou vai te dar um nível tão baixo que nem vão te contratar como
estagiário, mesmo que você esteja pagando a empresa que está perdendo seu tempo. Há
exceções, é claro, como se você não estiver começando do zero ou se tiver
pensamento de engenharia extremamente desenvolvido ou se você está se candidatando a um nível muito baixo
posição (por exemplo, suporte técnico), mas, em geral, um programador com menos de 1 ano
de aprendizado árduo e código de escrita não é possível!
Exame de admissão no SoftUni

Para se inscrever no SoftUni, você precisa fazer o vestibular "Fundamentos de Programação"
com base no material deste livro. Se você resolver facilmente os problemas dos exercícios do
livro, estará pronto para o exame. Também dê uma olhada nos poucos capítulos para se preparar
para o exame prático de programação. Eles vão te dar uma boa ideia da dificuldade do exame e
dos tipos de problemas que você precisa aprender a resolver.
Se os problemas do livro e os exemplos de exames preparatórios forem difíceis para você, você
precisará de mais preparação. Inscreva-se no curso gratuito "Fundamentos da programação" (https://
softuni.bg/apply) ou releia o livro com atenção desde o início, sem deixar de resolver as tarefas
de cada tópico de estudo! Você deve aprender a resolvê-los com facilidade, sem se ajudar com
as diretrizes e exemplos de soluções.
Currículo de Engenheiro de Software Após o

exame, um currículo sério espera por você no programa de treinamento de engenheiros de
software da SoftUni. É uma série de módulos com vários cursos de programação e tecnologias
de software, totalmente voltados para a aquisição de conhecimentos fundamentais de
desenvolvimento de software e aquisição de habilidades práticas para trabalhar como
programador com as mais recentes tecnologias de software. Os alunos podem escolher entre
várias carreiras e especializações com foco em C#, Java, JavaScript, PHP e outras linguagens
e tecnologias. Cada profissão é estudada em vários módulos com duração de 4 meses e cada
módulo contém 2 ou 3 cursos. As aulas são divididas em preparação teórica (30%) e exercícios
práticos, projetos e atividades (70%), e cada curso termina com um exame prático ou um projeto
de curso prático.
Quantas horas por dia dura o treinamento? Estudar

como engenheiro de software na SoftUni é um empreendimento muito sério e você precisa
dedicar pelo menos 4-5 horas a ele todos os dias, e é recomendável que você dedique todo o
seu tempo a isso. A combinação de trabalho e estudo nem sempre dá certo, mas se você faz
algo leve com muito tempo livre, é uma boa opção. O SoftUni é uma opção adequada para
alunos, estudantes e que trabalham em outras profissões, mas é melhor dedicar todo o seu tempo
à sua educação e ao domínio da profissão. Não funciona com 2 ou 4 horas por semana!
As formas de aprendizado na SoftUni são presenciais (melhor escolha) e online (caso não tenha outra opção).
Em ambas as formas, para ter sucesso no aprendizado do currículo (que é exigido pelas empresas de software
para começar), é necessário um aprendizado difícil. Você apenas tem que encontrar o tempo! O motivo número
1 para escorregar no caminho da profissão na SoftUni é não dedicar tempo suficiente para estudar: no mínimo
20-30 horas semanais.
SoftUni por trabalhar e estudar em outro lugar

A todos aqueles que obtiveram excelente resultado no vestibular da SoftUni e são realmente apaixonados por
programação e sonham em fazer disso sua profissão, recomendamos que se libertem de seus outros
compromissos e dediquem todo o seu tempo ao aprendizado da profissão de "software engenheiro" e começar a
ganhar a vida com isso.
• Para as pessoas que trabalham, isso significa deixar o emprego (e fazer um empréstimo ou
reduzir seus custos financeiros para sobreviver com uma renda menor por 1 a 2 anos até
que comecem a trabalhar em sua nova profissão).
• Para alunos de uma universidade tradicional, isso significa mudar seu foco fortemente para
programação e cursos práticos no SoftUni,
minimizando o tempo que eles gastam na universidade tradicional
versity.
• Para os desempregados, esta é uma excelente oportunidade de investir todo o seu tempo,
força e energia para adquirir uma profissão promissora, bem remunerada e muito
procurada, que lhes proporcione alta qualidade de vida e uma vida longa
termo prosperidade.
• Para alunos do ensino fundamental e médio, isso significa priorizar o que é mais importante
para o seu desenvolvimento: aprender programação prática no SoftUni que lhes dará uma
profissão e um emprego, ou dedicar toda a atenção ao sistema tradicional de ensino, ou
combinar habilmente ambos os esforços. Infelizmente muitas vezes as prioridades são
definidas pelos pais e para esses casos não temos solução.
A todos aqueles que não conseguem um excelente resultado no vestibular do SoftUni, recomendamos que se
dediquem a estudar melhor, entender e principalmente praticar o material de estudo deste livro. Se você não
conseguir lidar com as tarefas deste livro com facilidade, não será capaz de avançar no aprendizado de
programação e desenvolvimento de software. Não perca o básico da programação! Em hipótese alguma você
deve tomar decisões ousadas de deixar seu emprego ou universidade tradicional e fazer
grandes planos para sua futura profissão como engenheiro de software se não tiver uma nota excelente no
vestibular da SoftUni! É uma medida de quanto você gosta de programar, quanto gosta e quanto
Conclusão 417
você está realmente motivado a estudá-lo seriamente e depois trabalhar nele por anos,
todos os dias, com desejo e prazer.
Carreira "engenheiro de software" em seu próprio caminho

A outra opção de desenvolvimento após este livro é continuar estudando programação
fora do SoftUni. Você pode gravar ou assistir a videoaulas que se aprofundam na
programação com C# ou outras linguagens e plataformas de desenvolvimento. Você
pode ler livros sobre programação e tecnologia de software, seguir tutoriais online e
outros recursos online - há uma quantidade infinita de material gratuito na Internet.
Lembre-se, porém, que o mais importante no caminho para a profissão de programador
é fazer projetos práticos!
Sem escrever muito e muito código e praticar muito, você não se torna um programador.
Dê a si mesmo tempo suficiente. Você não se torna um programador em um ou dois
meses. Na Internet, você encontra uma grande quantidade de recursos gratuitos como
livros, apostilas, videoaulas, cursos online e presenciais de programação e
desenvolvimento de software. No entanto, você precisará investir pelo menos um ou dois
anos para obter um nível básico de entrada.
Depois de progredir, encontre uma maneira de conseguir um estágio em uma empresa
(o que será quase impossível sem pelo menos um ano de codificação sólida antes) ou
crie seu próprio projeto prático para trabalhar por alguns meses , mesmo um ano, para
você aprender por tentativa e erro.
Lembre-se de que existem muitas maneiras de se tornar um programador,

mas todas têm uma interseção comum: escrita sólida de código e anos
de prática!
Comunidades online para iniciantes em programação

Independentemente do caminho que você seguir, se quiser levar a sério a programação,
é uma boa ideia ficar de olho em fóruns on-line especializados, grupos de notícias e
comunidades onde você pode obter ajuda de seus colegas e acompanhar as últimas
novidades em a indústria de software.
Se você vai aprender a programar seriamente, cerque-se de pessoas que levam a sério
a programação. Junte-se a comunidades de desenvolvedores de software, vá a
conferências de software, vá a eventos de desenvolvedores,
encontre amigos para conversar sobre programação e discutir seus problemas e bugs,
encontre um ambiente para ajudá-lo. Em Sófia e nas grandes cidades existem eventos
gratuitos para programadores, vários por semana. Em cidades menores você tem Internet
e acesso a toda a comunidade online. Aqui estão alguns recursos recomendados para o
seu
desenvolvimento como desenvolvedor:
• softuni.bg – site oficial da SoftUni. Nele você encontra cursos, seminários, videoaulas e treinamentos
gratuitos (e não só) em programação, tecnologias de software e competências digitais.
• softuni.bg/forum – fórum oficial do SoftUni. O fórum de discussão da SoftUni é extremamente positivo e

cheio de colegas prestativos. Se você fizer uma pergunta significativa relacionada à programação e
estudar as tecnologias SoftUni, quase certamente receberá uma resposta significativa em minutos.
Experimente, você não tem nada a perder.
• fb.com/SoftwareUniversity – página oficial da SoftUni no Facebook. Nele você conhecerá novos cursos,
seminários e eventos relacionados à programação e desenvolvimento de software.
• introprogramming.info – site oficial dos livros "Introduction to Programming" com C# e Java do Dr. Svetlin
Nakov e equipe. Os livros cobrem fundamentos de programação, estruturas básicas de dados e
algoritmos, OOP e outras habilidades básicas em profundidade e são uma excelente leitura de
acompanhamento após este livro. Porém, além da leitura, você também precisa de uma escrita sólida,
não se esqueça disso!
• stackoverflow.com - O Stack Overflow é um dos maiores fóruns de discussão do mundo para programadores,
onde você obterá ajuda sobre qualquer questão possível no mundo da programação. Se você fala inglês,
procure no StackOverflow e tire suas dúvidas por lá.
• fb.com/groups/bg.developers – o grupo "Programação da Bulgária" é uma das maiores comunidades online

de programadores do Facebook para discussões sobre os tópicos de desenvolvimento de software em
búlgaro.
• meetup.com/find/tech/ – procure encontros tecnológicos perto de você e junte-se às comunidades que você
gosta. A maioria dos encontros de tecnologia é gratuita e os recém-chegados são bem-vindos.
• Se você estiver interessado em eventos de TI, conferências de tecnologia, treinamentos e estágios, confira
os maiores sites de eventos de TI como dev.bg e iteventz.bg.
Boa sorte a todos!

Em nome de toda a equipe de autores, desejamos sucesso contínuo em sua profissão e na vida! Ficaremos
extremamente felizes se, com a nossa ajuda, você se apaixonar por programação e nós o inspirarmos a assumir
com ousadia a profissão de "engenheiro de software", o que lhe trará um bom trabalho que funcionará para
você com prazer, uma vida de qualidade e prosperidade, bem como grande perspectiva
objetivos para o desenvolvimento e oportunidades para fazer projetos significativos com inspiração e
paixão.
Sófia, 5 de dezembro de 2017

Livro "Fundamentos de programação com

Java" Autor: Svetlin Nakov e equipe
ISBN: 978-619-00-0636-7
Páginas: 420
Idioma: Búlgaro
Sófia, 2017
Livro básico de programação C#
Livro "Fundamentos da Programação Java"
Livro Fundamentos da Programação JavaScript
Livro básico de programação em Python
Livro "Fundamentos de Programação com C++"
Livro "Fundamentos de Programação com PHP"
Livro Básico de Programação Ruby
Livros "Introdução à Programação C# e Java"
Fundação da Universidade de Software (Fundação SoftUni)
SoftUni (Universidade de Software)
Curso gratuito com videoaulas sobre "Fundamentos de programação com a linguagem C#"
Svetlin Nakov – site oficial, cursos de programação e aulas
Etiquetas: programação; programação de livros; livro de programação; um livro; livro grátis; grátis; livro eletrônico; livro
eletrônico; Java; Livro Java; livro Java; código do programa; livro Java; livro Java; Java; Livro básico de Java; Noções
básicas de programação Java; livro de programação Java; livro básico de programação; livro básico de programação Java;
programação de computadores; conceitos de programação; noções básicas de programação; livro didático;
autodidata; Introdução ao Java; Introdução Java; livro java; aulas de programação; aulas de programação; aprender
Java; tutoriais Java; tutoriais Java; aprender programação; como programar; programador; programação prática; técnicas
de programação; pensamento lógico; pensamento algorítmico; codificador; codificador; codificação; codificação; habilidades
de codificação; habilidades de programação; linguagem de programação; linguagem de programação; noções básicas de
programação; primeiros passos da programação; aulas; Código fonte; Código fonte; Código aberto; Código fonte; Código
aberto; compilador; compilador; depuração; depurador; Eclipse; IntelliJ IDEA; IDE; ambiente de desenvolvimento; Java;
JVM; JavaSE; dados; variáveis; operadores; expressões; console; console; entrada do console; saída do console;
Aplicação de console; Construções condicionais; se declaração; se construir; se; if-else; switch-caixa; ciclos; enquanto; fazer enquanto
ciclo; laços aninhados; métodos; métodos de chamada; parâmetros; tarefas de programação, resolução de problemas;
tarefas e decisões; escrever código; teste de código; exercícios; tarefas; decisões; instruções de programação; tarefas de
programação; exercícios de programação; bom programador; programador pessoal; Nakov; Nakov; Svetlin Nakov;
Svetlin Nakov; universidade de software; SoftUni; academia de software; ISBN 978-619-00-0636-7; ISBN9786190006367;
ISBN 9786190006367
Livro de Fundamentos de Java - Contracapa

Java Svetlin Nakov

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

Java Svetlin Nakov

Enviado por

Direitos autorais:

Formatos disponíveis

Machine Translated by Google

Livro "Fundamentos de programação com

Livro básico de programação C#

Livro "Fundamentos da Programação Java"

Livro Fundamentos da Programação JavaScript

Livro básico de programação em Python

Livro "Fundamentos de Programação com C++"

Livro "Fundamentos de Programação com PHP"

Livros "Introdução à Programação C# e Java"

Fundação da Universidade de Software (Fundação SoftUni)

SoftUni (Universidade de Software)

Svetlin Nakov – site oficial, cursos de programação e aulas

Livro Java Basics - Capa frontal

Svetlin Nakov e equipe

Asya Dikova-Kirova Milena Georgieva

Vencislav Petrov Peter Ivanov

Noções básicas de programação Java

Primeira edição: dezembro de 2017

• Compartilhamento - Você pode copiar e distribuir o livro livremente em

• Compartilhamento similar – se você criar material misturando, modificando e copiando

Editora: Faber, Veliko Tarnovo

Canela: Marina Shiderova - http://shideroff.com

Site oficial: https://java-book.softuni.bg

Página oficial do Facebook: https://fb.com/IntroProgrammingBooks

8 Fundamentos da Programação Java

Tarefa: mercado de hortaliças.............................................. ..................................................... ....................

10 Fundamentos da Programação Java

Problemas com cálculos simples.............................................. ..................................................... ... ...........

Este livro fornece apenas os primeiros passos para a programação.

Para quem é este livro?

12 Fundamentos da Programação Java

conhecimento técnico e descobrir se eles gostam de programação e levam a sério o

Por que escolhemos a linguagem Java?

Como explicaremos mais tarde, a linguagem de programação com a qual começamos

O livro em outras linguagens de programação: C#, Java, JavaScript, Python,

A programação é aprendida escrevendo muito, não lendo!

Sobre a Universidade de Software (SoftUni)

14 Fundamentos da Programação Java

Os cursos gratuitos de programação da SoftUni

Os cursos básicos de programação gratuitos da SoftUni visam apresentá-lo às construções básicas de

Julgue o sistema para verificar tarefas

Observe também algumas características do juiz SoftUni:

• O uso do sistema é gratuito e não está vinculado à participação em cursos da

Como se tornar um programador?

Habilidade #1 - Codene (20%)

16 Fundamentos da Programação Java

• trabalhar com variáveis, verificações, loops •

Habilidade #2 – Pensamento algorítmico (30%)

• O pensamento algorítmico é desenvolvido resolvendo muitos (1000+) problemas de

Habilidade #3 – Fundamentos da Profissão (25%)

• conceitos matemáticos básicos relacionados à programação: sistemas de coordenadas,

18 Fundamentos da Programação Java

• programação de rede - protocolos de rede, comunicação de rede, TCP /

• programação paralela e assíncrona - gerenciamento de thread, assíncrono

Habilidade #4 - Linguagens de Programação e Tecnologias de Software

Para essas habilidades puramente tecnológicas, a linguagem de programação já importa.

• Atenção: só para esses 25% da profissão a linguagem de programação importa!

20 Fundamentos da Programação Java

A linguagem de programação não importa

Realmente, a linguagem de programação é quase irrelevante, você só precisa aprender a

Finalmente, quando você colocar tecnologias específicas em um projeto de software, precisará

O livro para ajudar os professores

• Apresentações educativas (slides em PowerPoint) para cada tema educacional, de