Curso de Algoritmos e Lógica de Programação

Entenda o que são algoritmos e lógica de programação e a importância deles para o seu estudo e desenvolvimento como programador.

Ao longo deste curso, você aprenderá o que é um algoritmo e como funciona a lógica de programação, com exemplos práticos de como passar por cada uma dessas etapas e como elas podem te auxiliar na programação.

Aulas Disponíveis:

• Aula 1 – Algoritmos e Lógica de Programação – O que é e Como Funciona?
• Aula 2 – Algoritmos e Lógica de Programação – Variáveis, Tipos de Dados e Operadores
• Aula 3 – Algoritmos e Lógica de Programação – Estruturas Condicionais If Else
• Aula 4 – Algoritmos e Lógica de Programação – Estruturas de Repetição – For e While

Aula 1 – Algoritmos e Lógica de Programação – O que é e Como Funciona?

Vamos dar início ao Curso de Algoritmos e Lógica de Programação para que você entenda, de uma vez por todas, a importância deles para o seu estudo e desenvolvimento como programador.

Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!

Na primeira aula do nosso curso sobre algoritmos e lógica de programação, veremos o que são algoritmos e lógica de programação e a sua importância na programação.

Vou mostrar exemplos práticos de criação de algoritmos, utilizando texto, fluxogramas e pseudocódigos. Com isso, você entenderá as diferenças entre esses métodos e como cada um pode te ajudar a compreender a lógica por trás de cada processo.

Você aprenderá como construir uma lógica coerente e passo a passo, que poderá ser usada com qualquer linguagem de programação.

Então, venha comigo e saia do zero em algoritmos e lógica de programação!

O que é Algoritmo?

Sempre que realizamos uma atividade em nosso dia a dia, seguimos, mesmo que sem perceber, uma sequência de passos lógicos até alcançar nosso objetivo.

Na maioria das vezes, isso é tão natural que nem nos damos conta, mas, se você prestar atenção, verá que esse passo a passo está presente em tudo que você faz.

Vamos começar vendo o exemplo mais clássico de todos, a receita de um bolo.

Observe que, para fazer um bolo, é preciso seguir uma receita que possui um passo a passo, com a ordem e a lógica em que cada etapa precisa ser realizada.

Quando vamos para o mundo da programação, definir as etapas e a lógica de execução é fundamental.

Ao programar, estamos definindo uma série de comandos que devem ser executados pelo computador e em qual ordem devem ser executados para atingir o resultado esperado.

Essa sequência de passos definida para realizar uma tarefa é o que chamamos de algoritmo na programação.

Voltando ao nosso exemplo da receita de bolo, ela poderia ser traduzida como um algoritmo para criar um bolo.

Em resumo, um algoritmo é a sequência de passos necessária para realizar uma tarefa em programação. E, assim como uma receita, as etapas são importantes porque um passo depende da execução correta do procedimento anterior.

O que é Lógica de Programação?

É muito comum vermos o termo lógica de programação ser usado quase como um sinônimo de algoritmo. Porém, existe uma diferença entre eles.

A lógica de programação envolve uma série de regras e comandos que orientam a criação do algoritmo para garantir que o computador entenda e execute os comandos corretamente.

Ou seja, o algoritmo é o passo a passo executado pelo computador, enquanto a lógica de programação é a escrita desse algoritmo em uma linguagem compreensível pela máquina.

Você não precisa se preocupar tanto com a diferença entre algoritmo e lógica de programação, porque na prática veremos eles sempre juntos. Construiremos um algoritmo para o nosso computador executar (criando uma lógica de programação).

Como Criar um Algoritmo? – Texto

Antes de escrever qualquer código, é essencial definir com clareza o passo a passo que precisa ser feito para atingir o resultado esperado. Ou seja, criar o algoritmo que deverá ser executado.

Os algoritmos podem ser escritos de diferentes formas. A primeira delas é similar ao exemplo da receita de bolo que vimos no início da aula, com um texto descritivo, detalhando passo a passo as ações e procedimentos que devem ser executados.

Para mostrar as diferentes formas de representar um algoritmo, vamos ver alguns exemplos. Começando com um algoritmo para a automação de envio de e-mails.

Ao criar os passos do algoritmo, é importante pensar no objetivo que desejamos alcançar e em como realizaríamos essa ação se ela fosse feita manualmente. Isso nos ajudará a orientar e pensar a lógica do código com maior clareza.

Envio de E-mail:

1º Passo: Abrir o navegador

2º Passo: Entrar no Gmail

3º Passo: Se o e-mail não estiver logado:

Fazer o login no e-mail.

Caso contrário:

Passar para o próximo passo

4º Passo: Clicar na opção para criar o e-mail

5º Passo: Escrever o e-mail

6º Passo: Clicar no botão de enviar

Esses são os 6 passos necessários para enviar um e-mail. Então, se criarmos um programa que execute esses 6 passos, ele também enviará o e-mail corretamente.

Algoritmo com Fluxograma

A segunda forma que temos de construir um algoritmo é através de um fluxograma, onde os passos do algoritmo são representados visualmente com caixas interligadas.

Esse modelo proporciona uma visão clara dos processos que estão sendo executados e da ordem deles.

Algoritmo com Pseudocódigo

A terceira forma que quero te mostrar, e que é muito popular para criar algoritmos, é o pseudocódigo.

Nele, escrevemos frases em português semelhantes a estruturas utilizadas em uma linguagem de programação, em que os verbos são utilizados para ações e representam funcionalidades dentro do seu código, e os substantivos são os objetos dele.

Pseudocódigo para enviar e-mail:

abrir(chrome)
digitar(gmail.com)
apertar(enter)
se a tela de login apareceu:
    fazer_login()
caso contrário:
    passe para o próximo passo
clicar(botão_criar_email)
digitar([email protected])
digitar(assunto)
digitar(corpo_do_email)
clicar(botão_enviar)

Perceba que, apesar de não existir uma regra fixa para você escrever seu pseudocódigo, é importante que você determine um padrão, para que fique claro para você e para quem mais for ler, compreender o que o programa deve fazer.

É importante que o pseudocódigo deixe os procedimentos claros e sem ambiguidade, para facilitar o momento de transformá-lo em um código de fato.

Essas são as três formas que temos de escrever algoritmos. Você não precisa usar todas sempre que estiver desenvolvendo um código, apenas aquela que julgar melhor para você.

Voltar ao índice

Aula 2 – Algoritmos e Lógica de Programação – Variáveis, Tipos de Dados e Operadores

Na segunda aula do nosso curso de Algoritmos e Lógica de Programação, vou te mostrar o que são variáveis, tipos de dados e operadores em programação.

Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!

Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:

Nesta aula do curso de Algoritmos e Lógica de Programação, veremos o que são e como usar variáveis, tipos de dados e operadores em programação.

Vou explicar as diferenças entre variáveis e constantes, e discutir os principais tipos de dados: inteiros, decimais, textos e booleanos.

Você perceberá que esses conceitos são fundamentais ao construir seus códigos, independentemente da linguagem de programação utilizada.

Outro conceito muito importante são as estruturas de dados e coleções, onde apresentarei as listas e dicionários em programação.

Também falaremos sobre os operadores matemáticos e como eles são aplicados dentro da programação.

Para finalizar, preparei 3 exercícios práticos para que você possa entender, praticando, como transformar o enunciado de um problema em um algoritmo e depois em um pseudocódigo.

Então, faça o download do material disponível nesta aula e vem comigo!

O que são Variáveis e Constantes

Variáveis e constantes são conceitos fundamentais em programação. Eles são utilizados para armazenar informações que você deseja utilizar ou manipular ao longo do seu código.

De forma simples, podemos imaginar uma variável (ou constante) como uma caixa onde guardamos uma determinada informação. Essa caixa recebe um nome, uma “etiqueta“, que nos permite acessar essa informação quando necessário.

Por exemplo, imagine que você trabalha para uma empresa e precisa calcular o imposto sobre o faturamento dela. O faturamento da empresa foi de R$10.000,00 e o imposto é de 15%.

Para calcular o imposto sobre esse valor, bastaria multiplicar 10000 por 0.15, que equivale a 15%, dessa forma:

10000 * 0.15

Perceba que apenas essa linha de código não seria intuitiva, pois não há nenhuma informação identificando a que se refere cada valor.

Ao usar variáveis, tornamos nosso código mais intuitivo e facilitamos futuras manutenções e alterações. Vamos ver um exemplo:

faturamento = 10000
imposto_percentual = 0.15

imposto_faturamento = faturamento * imposto_percentual

Note como o uso de variáveis torna o código mais claro e intuitivo, permitindo identificar facilmente cada informação presente.

Além disso, ao utilizar variáveis, você pode referenciar o nome delas para realizar operações, ao invés de declarar os valores diretamente no código. Isso é especialmente útil para manutenção dele.

Por exemplo, no mês seguinte, a empresa pode ter um faturamento de R$12.000,00. Em vez de percorrer todo o código alterando os valores de 10000 para 12000, você pode simplesmente modificar a variável.

faturamento = 12000
imposto_percentual = 0.15

imposto_faturamento = faturamento * imposto_percentual

Assim como usamos variáveis para armazenar dados, também podemos utilizar constantes. A principal diferença entre elas é que, enquanto o valor atribuído a uma variável pode ser modificado, o valor de uma constante será fixo durante todo o código.

No nosso exemplo, o faturamento pode ser considerado uma variável, pois ele pode ser alterado de acordo com as vendas da empresa.

Por outro lado, o imposto_percentual pode ser um valor fixo definido, que não pode ser alterado, e nesse caso, ele seria considerado uma constante.

Na prática, cada linguagem de programação terá uma forma de distinguir a declaração de uma variável de uma constante, mas a função delas é bastante semelhante: armazenar uma informação.

Tipos de Dados

Em programação, existem diferentes tipos de dados com os quais podemos trabalhar, sendo os principais: inteiros (números inteiros), floats (números com casas decimais), strings (texto) e booleanos (verdadeiro ou falso).

No exemplo anterior, o faturamento está armazenando um valor do tipo inteiro, enquanto o imposto_percentual é do tipo float.

O float é o termo técnico para números com casas decimais, a expressão vem de ponto flutuante. Na maioria das linguagens de programação, utilizamos o ponto ao invés da vírgula como separador decimal, seguindo o padrão americano.

Além dos inteiros e dos floats, temos também as strings, que são dados do tipo texto. Por padrão, as strings são delimitadas por aspas para diferenciá-las dos valores numéricos. Um e-mail, por exemplo, é um dado do tipo string.

email = "[email protected]"

Por fim, temos o tipo booleano (boolean), que pode ser verdadeiro ou falso. Esse tipo de dado é muito útil para situações binárias, onde queremos verificar uma condição.

Por exemplo, podemos ter uma variável para controlar se o vendedor da empresa bateu a meta de vendas. Essa variável será True (verdadeira) se a meta tiver sido atingida, e False (falsa) caso contrário).

bateu_meta = True

Esses são os quatro tipos de dados mais utilizados em linguagens de programação, e é muito importante compreendê-los corretamente.

Em algumas linguagens, é essencial especificar o tipo de dado no momento da criação de uma variável ou constante.

Estruturas de Dados e Coleções

Além dos tipos de dados que acabamos de ver, existem também as estruturas de dados e coleções. Essas estruturas permitem armazenar múltiplas informações em um único conjunto.

Se pensarmos na variável como uma caixa, as estruturas podem ser compreendidas como a prateleira de uma loja que comporta diversos itens (informações).

Os tipos mais comuns de estruturas de dados e coleções que temos são as listas e os dicionários.

As listas são sequências ordenadas de informações em que cada elemento ocupa uma posição específica. Assim como as variáveis, podemos atribuir um nome à nossa lista. Por exemplo, em uma loja, podemos ter uma lista de produtos e uma lista de preços:

produtos = ("iphone", "ipad", "airpod", "macbook")
precos = (5000, 7000, 2000, 10000)

A forma como uma lista é declarada varia de uma linguagem de programação para outra, podendo ser definida entre chaves {}, colchetes [] ou parênteses ().

Os dicionários, por sua vez, são uma estrutura de dados que nos permite armazenar pares chave-valor, onde cada chave é única e está associada a apenas um valor.

Por exemplo, a mesma loja poderia ter, ao invés de duas listas (uma para os produtos e outra para os preços), um único dicionário em que a chave será o produto e o valor será o preço.

dic_produtos = ("iphone": 5000, "ipad": 7000, "airpod": 2000, "macbook": 10000)

Operadores Matemáticos em Programação

Dentro da programação, trabalhamos com operadores matemáticos e operadores lógicos. Nesta aula, veremos os operadores matemáticos, e na próxima abordaremos os operadores lógicos.

Como vimos no exemplo no início da aula, é possível realizar operações matemáticas dentro dos nossos códigos, e para isso utilizamos os operadores matemáticos básicos: soma, subtração, multiplicação e divisão.

Além desses, em algumas linguagens de programação, teremos um operador específico para potência, raiz, mod (resto da divisão), entre outros.

Assim como acontece em outros aspectos, os símbolos dos operadores matemáticos também podem variar de uma linguagem para outra, mas geralmente são: + (soma), – (subtração), * (multiplicação) e / (divisão).

Exercícios Práticos

Utilizando os conceitos aprendidos nessa aula e na aula anterior, vamos resolver 3 exercícios práticos que te ajudarão a fixar e melhorar a compreensão deles.

O objetivo de cada exercício será transformar o enunciado do problema em um algoritmo e depois em um pseudocódigo.

Você pode tentar resolver primeiro sozinho e depois comparar a sua resolução com a minha. Lembre-se que o importante não é a sua solução estar idêntica a que eu fiz, mas sim que a lógica dela faça sentido para o resultado final.

Além disso, para cada exercício eu vou te mostrar como seria a solução dele em Python, para que você possa compreender como fazemos a transformação de um algoritmo e pseudocódigo, para um código em si.

Primeiro Exercício:

Uma empresa precisa pagar 10% de imposto sobre seu faturamento como ISS. Além disso, sobre o lucro da empresa, ela precisa pagar 20% de IR e 5% de CSLL. Qual o total de imposto a ser pago em um mês que a empresa tenha 5000 de faturamento e 1000 de lucro?

Solução – Algoritmo de Texto:

• 1º Passo: Declarar as Variáveis – Definir as informações essenciais para o funcionamento do código.
  • iss = 0.1
  • ir = 0.2
  • csll = 0.05
  • faturamento = 5000
  • lucro = 1000
• 2º Passo: Calcular o Imposto ISS sobre o Faturamento
• 3º Passo: Calcular o Imposto sobre o Lucro
  • Calcular o IR sobre o Lucro
  • Calcular o CSLL sobre o Lucro
  • Somar os dois Impostos
• 4º Passo: Somar o Imposto sobre o Faturamento com o Imposto sobre o Lucro.

Solução – Pseudocódigo:

iss = 0.1
ir = 0.2
csll = 0.05
faturamento = 5000
lucro = 1000

- Calcular o imposto sobre o faturamento
imposto_fat = iss * faturamento

- Calcular o imposto sobre o lucro
imposto_lucro = ir * lucro + csll * lucro

- Calcular o imposto total
imposto_total = imposto_fat + imposto_lucro

Código em Python:

iss = 0.1
ir = 0.2
csll = 0.05
faturamento = 5000
lucro = 1000

imposto_fat = iss * faturamento
imposto_lucro = ir * lucro + csll * lucro
imposto_total = imposto_fat + imposto_lucro

print(imposto_total)

Resultado do Código:

Segundo Exercício:

Sua empresa vende 5 produtos, Iphone, Ipad, Airpod, Macbook e Apple Watch. Mês passado ela vendeu, 1000, 300, 200, 50, 250 unidades de cada respectivamente. Qual foi o total de produtos vendidos e quantas unidades vendeu o produto mais vendido?

Solução – Algoritmo de Texto:

• 1º Passo: Definir as informações essenciais: produtos e quantidades vendidas.
• 2º Passo: Calcular o total vendido: Somar todas as quantidades vendidas.
• 3º Passo: Encontrar o produto mais vendido: Verificar qual produto tem a maior quantidade vendida.

Solução – Pseudocódigo:

vendas_produtos = ("iphone": 1000, "ipad": 300, "airpod": 200, "macbook": 50, "apple watch": 250)

- Calcular o total vendido: Somar os valores de vendas_produtos
total = somar(vendas_produtos.valores)

- Calcular o produto mais vendido: Encontrar o valor máximo em vendas_produtos
mais_vendido = maximo(vendas_produtos.valores)

Código em Python:

vendas_produtos = {"iphone": 1000, "ipad": 300,
                   "airpod": 200, "macbook": 50,
                   "apple watch": 250}

total_sum = sum(vendas_produtos.values())
maximo = max(vendas_produtos.values())

print(total_sum)
print(maximo)

Resultado do Código:

Terceiro Exercício:

Todo dia você recebe e-mails nesse formato, um para cada loja que sua empresa tem:

“Prezado,

Segue total de vendas de ontem:

Total: R$1.530,00″

Você quer conseguir compilar esses e-mails automaticamente e precisa ser capaz de extrair o total de vendas de cada e-mail. Como você faria para pegar o total de vendas desse e-mail?

Solução – Algoritmo de Texto:

• 1º Passo: Pegar o texto do e-mail
• 2º Passo: Identificar um padrão em todos os e-mails.
  • O valor total sempre virá após o R$
• 3º Passo: Encontrar a posição do R$
• 4 º Passo: Pegar todo o texto que começa na posição do R$ até o final da linha.

Solução – Pseudocódigo:

texto_email = "Prezado,
Segue total de vendas de ontem:
Total: R$1.530,00"

- Encontrar a posição do R$
posicao_inicial = texto_email.encontrar("R$")

- Pegar todo o texto começando em R$ até o final
posicao_final = texto_email.fim
faturamento = extrair(posicao_inicial : posicao_final)

Código em Python:

texto_email = """Prezado,
Segue total de vendas de ontem:
Total: R$1.530,00"""

posicao_inicial = texto_email.find("R$")
faturamento = texto_email[posicao_inicial:]

print(faturamento)

Resultado do Código:

Voltar ao índice

Aula 3 – Algoritmos e Lógica de Programação – Estruturas Condicionais If Else

Vamos para a terceira aula do nosso curso de Algoritmos e Lógica de Programação. Nela, vou te mostrar o que são as estruturas condicionais if else, muito utilizadas em qualquer linguagem de programação.

Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!

Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:

Na terceira aula de Algoritmos e Lógica de Programação, veremos o que são as estruturas condicionais if else, que você vai utilizar bastante em qualquer linguagem de programação.

Vou te ensinar como utilizar os operadores lógicos e os operadores comparativos para construir as nossas condições. Com eles, verificaremos se as condições são verdadeiras ou falsas e definiremos o que ocorre em cada caso.

Para finalizar, separei dois exercícios para que você possa entender, na prática, como utilizar as estruturas condicionais e os operadores lógicos.

Então, faça o download do material disponível nesta aula e vem comigo!

Estruturas Condicionais – If Else

As estruturas condicionais são outro importante conceito dentro da lógica de programação. Elas permitem que o programa tome decisões e execute diferentes ações de acordo com as condições estabelecidas.

Essas condições são baseadas em expressões booleanas, que podem retornar True (Verdadeiro) ou False (Falso).

Dessa forma, podemos definir o que o programa deve executar se o resultado for verdadeiro e o que ele deve fazer se for falso.

Por exemplo, ao construir uma automação para o envio de e-mails, você pode utilizar uma estrutura condicional para verificar se o login foi realizado.

Caso o login esteja feito, a automação deve seguir para o envio de e-mail. Caso contrário, deverá fazer o login primeiro.

Perceba como essa condição cria dois caminhos possíveis dentro da estrutura de um código. É possível dividir e estabelecer quantos caminhos forem necessários.

As estruturas condicionais mais comuns são o if (se), que executa um bloco de código se a condição for verdadeira, e o else (senão), que executa um bloco de código alternativo se a condição for falsa.

Além disso, para comparar essas estruturas condicionais, utilizamos os operadores lógicos e comparativos.

Operadores Comparativos

Os operadores comparativos são usados para comparar valores e determinar a relação entre eles, funcionando de forma semelhante à lógica matemática. O resultado de um operador comparativo sempre será verdadeiro (True) ou falso (False).

Os principais operadores comparativos são: “igual a“, “diferente de“, “maior que“, “menor que“, “maior ou igual a“, “menor ou igual a“. Os símbolos desses operadores podem variar de uma linguagem de programação para outra.

Nas operações de “maior que”, “menor que”, “maior ou igual a” e “menor ou igual a”, a maioria das linguagens adotam os mesmos símbolos: > (maior que), < (menor que), >= (maior ou igual a) e <= (menor ou igual a).

Já os operadores de “igual” e “diferente” costumam variar mais. Podemos encontrar == ou = para representar igual e != ou <> para diferente.

O foco aqui não é se preocupar muito com a sintaxe específica desses operadores, pois ela pode variar entre as linguagens. O importante é entender o funcionamento deles.

Operadores Lógicos

Os operadores lógicos são usados para combinar duas ou mais condições lógicas e retornam um valor booleano (verdadeiro ou falso) de acordo com a veracidade da combinação. Os principais operadores lógicos são: and (e) e or (ou).

As formas mais comuns de encontrarmos esses operadores representados são:

• And (e): && ou and
• Or (ou): || ou or

O operador and retornará True sempre que ambas as condições avaliadas forem verdadeiras, enquanto o or retornará True se pelo menos uma das condições for verdadeira.

Exercícios Práticos

Para que você possa entender melhor a aplicação das estruturas condicionais e dos operadores condicionais e lógico, vamos resolver 2 exercícios práticos que te ajudarão a fixar o conteúdo dessa aula.

Assim como fizemos na aula anterior do curso, o objetivo de cada exercício será transformar o enunciado do problema em um algoritmo de texto e depois em um pseudocódigo.

Você pode tentar solucionar sozinho e depois comparar a sua resolução com a minha, ou então fazer acompanhando a resolução.

Lembre-se que o foco principal não é a sua solução ser idêntica a que eu fiz, mas sim que a lógica construída faça sentido para o resultado. Cada etapa precisa ser clara e estar condizente com os conceitos vistos até agora.

Além disso, ao final de cada exercício eu deixarei um exemplo de como seria a solução dele em um código Python.

Primeiro Exercício:

Você precisa criar um programa que calcula o bônus dos funcionários da sua empresa. A meta de vendas é de 500 reais, se um funcionário vendeu igual ou mais do que a meta, ele ganha 50 reais de bônus. Se não, ele não ganha bônus.

Solução – Algoritmo de Texto:

• 1º Passo: Definir as informações essenciais – Declarar as variáveis.
  • meta = 500
• 2º Passo: Comparar as vendas do vendedor com a meta.
  • Se as vendas forem maiores ou iguais à meta: o bônus é de 50.
  • Caso contrário: não ganha bônus, então o bônus será de 0.

Solução – Pseudocódigo:

meta = 500

if vendas >= meta:
    bonus = 50
else:
    bonus = 0

Código em Python:

Para exemplificar a execução do código em Python, vamos considerar que o vendedor atingiu o valor de 700 para suas vendas.

meta = 500
vendas = 700

if vendas >= meta:
    bonus = 50
else:
    bonus = 0

print(bonus)

Resultado do Código:

Explicação:

Perceba que na solução desse primeiro exercício empregamos a estrutura do if/else para determinar se o funcionário receberá ou não o bônus com base no desempenho das vendas.

Para verificar se as vendas atingiram ou superaram a meta, utilizamos o operador comparativo >= (maior ou igual a).

Dessa forma, se as vendas do funcionário forem maiores ou iguais à meta, o resultado dessa comparação será verdadeiro (True) e o bônus será 50. Caso contrário, se o resultado for falso (False), o bônus será 0

Segundo Exercício:

Sua empresa resolveu valorizar funcionários que vendem MUITO. Agora, existe uma super meta de vendas, que é de 1500 reais. Se um funcionário vendeu igual ou mais que a super meta, ele ganha 100 reais de bônus. Se ele vendeu igual ou mais que a meta (500 reais), ele ganha 50 de bônus. Se não bateu nenhuma meta, ele não ganha bônus.

Solução – Algoritmo de Texto:

• 1º Passo: Definir as informações essenciais – Declarar as variáveis.
  • meta = 500
  • supermeta = 1500
• 2º Passo: Comparar as vendas do vendedor com a supermeta.
  • Se as vendas forem maiores ou iguais à supermeta: o bônus é de 100.
  • Caso contrário: Comparar as vendas do vendedor com a meta.
• 3º Passo: Comparar as vendas do vendedor com a meta.
  • Se as vendas forem maiores ou iguais à meta: o bônus é de 50.
  • Caso contrário: não ganha bônus, então o bônus será de 0.

Solução – Pseudocódigo:

supermeta = 1500
meta = 500

if vendas >= supermeta:
    bonus = 100
else:
    if vendas >= meta:
        bonus = 50
    else:
        bonus = 0

Código em Python:

Para esse exercício vamos considerar dois cenários: o primeiro em que o vendedor vendeu acima da média (700) e o segundo em que ele vendeu acima da super meta (1600).

1º cenário:

supermeta = 1500
meta = 500
vendas = 700

if vendas >= supermeta:
    bonus = 100
else:
    if vendas >= meta:
        bonus = 50
    else:
        bonus = 0

print(bonus)

Resultado do Código:

2º Cenário:

supermeta = 1500
meta = 500
vendas = 1600

if vendas >= supermeta:
    bonus = 100
else:
    if vendas >= meta:
        bonus = 50
    else:
        bonus = 0

print(bonus)

Resultado do Código:

Explicação:

Neste exercício, empregamos uma estrutura aninhada de if/else para determinar o valor do bônus com base no desempenho das vendas dos funcionários.

Primeiramente, verificamos se as vendas atingiram ou superaram a supermeta utilizando o operador comparativo >= (maior ou igual a). Se essa condição for verdadeira (True), o bônus será de 100 reais.

Caso contrário (False), o programa verifica se as vendas atingiram ou superaram a meta regular. Se as vendas forem maiores ou iguais à meta, o bônus será de 50 reais.

Se nenhuma das condições anteriores for satisfeita, significa que o funcionário não atingiu nenhuma das metas e, portanto, o bônus será de 0 reais.

Essa estrutura permite que o programa avalie e atribua o bônus de forma correta, visto que a lógica é executada de cima para baixo.

Voltar ao índice

Aula 4 – Algoritmos e Lógica de Programação – Estruturas de Repetição – For e While

Na quarta e última aula do nosso curso de Algoritmos e Lógica de Programação, você aprenderá o que são estruturas de repetição, os famosos loops.

Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!

Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:

Nesta aula do curso de Algoritmos e Lógica de Programação, veremos o que são e como funcionam as estruturas de repetição, os famosos loops, que permitem com que você repita um código várias e várias vezes.

As estruturas de repetição são extremamente úteis, principalmente quando temos que percorrer uma lista ou até mesmo fazer uma verificação com vários itens diferentes.

Vou te mostrar como funciona as estruturas de repetição For e While. Elas são muito parecidas, mas tem uma pequena diferença entre elas.

Por fim, vamos fazer alguns exercícios de lógica de programação para que você consiga praticar os conteúdos dessa aula e de todo o curso. E vou te deixar uma recomendação de site para treinar lógica de programação.

Estruturas de Repetição – For e While

As estruturas de repetição, também conhecidas como laços ou loops, permitem que um bloco de código seja executado diversas vezes até que uma determinada condição seja atendida. As mais comuns são o while e o for.

O while executa um conjunto de códigos enquanto uma condição for verdadeira, continuando indefinidamente até que essa condição não seja mais satisfeita.

Já a estrutura do for é utilizada para executar um bloco de código um número fixo de vezes ou para iterar sobre uma sequência, como uma lista, tupla, dicionário, string ou algum outro conjunto.

Com o for, conseguimos determinar o número de vezes que desejamos que um determinado código seja executado, proporcionando maior controle sobre a iteração.

Essas estruturas são essenciais para automatizar tarefas repetitivas, iterar sobre coleções de dados e realizar ações que precisam ser repetidas até atingir uma certa condição.

Exercícios Práticos

Utilizando os conceitos aprendidos nessa aula e nas demais aulas desse curso, vamos resolver 3 exercícios práticos que te ajudarão a fixar e melhorar a compreensão dos conteúdos aprendidos.

Assim como fizemos nas aulas anteriores, o objetivo de cada exercício será transformar o enunciado do problema em um algoritmo de texto e depois em um pseudocódigo.

Você pode tentar resolver sozinho primeiro e depois comparar a sua resolução com a minha. O importante é que a lógica da resolução faça sentido e atinja o objetivo do exercício proposto.

Além disso, ao final de cada exercício eu deixarei um exemplo de como seria a solução dele em um código Python.

Primeiro Exercício:

Você trabalha em uma loja com 10 produtos, cada um com um preço diferente: 1000, 500, 300, 700, 1000, 50, 65, 80, 900, 440. Recentemente, a empresa decidiu aumentar em 5% o preço de todos os produtos. Como ficam os preços a serem cobrados?

Solução – Algoritmo de Texto:

• 1º Passo: Definir as informações essenciais – Lista com os preços dos produtos e taxa de aumento.
  • precos_produtos = (1000, 500, 300, 700, 1000, 50, 65, 80, 900, 440)
  • aumento = 0.05
• 2º Passo: Percorrer a lista de preços dos produtos
  • Para cada produto aumentar o preço em 5%
    • Novo Preço = Preço Antigo * (1 + aumento)

Solução – Pseudocódigo:

precos_produtos = (1000, 500, 300, 700, 1000, 50, 65, 80, 900, 440)
aumento = 0.05

for preco in precos_produtos:
    novo_preco = preco * (1 + aumento)

Código em Python:

precos_produtos = [1000, 500, 300, 700, 1000, 50, 65, 80, 900, 440]
aumento = 0.05

for preco in precos_produtos:
    novo_preco = preco * (1 + aumento)
    print(novo_preco)

Resultado do Código:

Explicação:

Neste exercício, utilizamos a estrutura de repetição for para percorrer a lista de preços dos produtos e calcular o novo preço de cada um, aplicando o aumento de 5%.

Dentro do laço for iteramos sobre cada preço na lista preços_produtos e calculamos o novo preço multiplicando o preço original por (1 + aumento).

A lógica é executada de forma sequencial, ou seja, o código dentro do laço for é aplicado a cada item da lista, começando com o primeiro item e continuando até o último.

Segundo Exercício:

Mantendo o mesmo exemplo do exercício anterior, como ficariam os preços a serem cobrados se o acréscimo de preço for apenas para os produtos que custam menos de 500 reais?

Solução – Algoritmo de Texto:

• 1º Passo: Definir as informações essenciais – Lista com os preços dos produtos, taxa de aumento e o limite de preço.
  • precos_produtos = (1000, 500, 300, 700, 1000, 50, 65, 80, 900, 440)
  • aumento = 0.05
  • limite_preco = 500
• 2º Passo: Percorrer a lista de preços dos produtos
  • Para cada produto, comparar o preço com o limite de preço:
    • Se o preço for menor que o limite de preço: aumentar o preço em 5%.
    • Caso contrário: manter o preço original.

Solução – Pseudocódigo:

precos_produtos = (1000, 500, 300, 700, 1000, 50, 65, 80, 900, 440)
aumento = 0.05
limite_preco = 500

for preco in precos_produtos:
    if preco < limite_preco:
        novo_preco = preco * (1 + aumento)
    else:
        novo_preco = preco

Código em Python:

precos_produtos = [1000, 500, 300, 700, 1000, 50, 65, 80, 900, 440]
aumento = 0.05
limite_preco = 500

for preco in precos_produtos:
    if preco < limite_preco:
        novo_preco = preco * (1 + aumento)
    else:
        novo_preco = preco
    print(novo_preco)

Resultado do Código:

Explicação:

Esse exercício tem uma resolução semelhante ao primeiro, mas nele combinamos a estrutura de repetição for com a condição if para aplicar o aumento de 5% apenas aos produtos cujo preço é menor que 500 reais.

Utilizamos o laço for para iterar sobre cada preço na lista precos_produtos. Em seguida, utilizamos a estrutura if para verificar se o preço do produto é menor que (>) o limite_preco.

Se essa condição for verdadeira (True) o novo preço será o preço original multiplicado por (1 + aumento). Caso contrário (False), mantemos o preço original.

Terceiro Exercício:

Sua empresa conseguiu bater sua meta de vendas de 50.000 unidades vendidas no mês. Ela tem 40 lojas. Seu chefe gostaria de analisar se mesmo com menos lojas (38 lojas por exemplos) ainda assim ele teria conseguido bater a meta. E com 35? E com 30 lojas? No fim do dia, seu chefe quer saber: qual o menor número de lojas (olhando as lojas das melhores para as piores) seria possível ainda bater a meta de vendas?

Solução – Algoritmo de Texto:

1º Passo: Definir as informações essenciais – Lista com as vendas das lojas e

• 1º Passo: Definir as informações essenciais – Lista com os preços dos produtos e a meta das vendas.
  • lista_vendas = (Lista com as Vendas de Cada Loja)
  • meta = 50000
• 2º Passo: Ordenar a lista de vendas em ordem decrescente, para começar pelas lojas com mais vendas.
• 3º Passo: Criar variáveis para somar as vendas e outra para contar o número de lojas.
  • soma_vendas = 0
  • num_lojas = 0
• 4º Passo: Percorrer a lista de vendas:
  • Enquanto o total das vendas (soma_vendas) for menor que a meta, vamos somar o valor da próxima venda e incrementar o contador de lojas.

Solução – Pseudocódigo:

lista_vendas = (lista de vendas)
meta = 50000

- Ordenar a lista de vendas em ordem decrescente
lista_vendas.ordenar(drescente)

- Criar variáveis de controle e contagem
soma_vendas = 0
num_lojas = 0

- Utilizar o while para somar as vendas até atingir a meta
while soma_vendas < meta:
    soma_vendas = soma_vendas + lista_vendas[num_lojas]
    num_lojas = num_lojas + 1

Código em Python:

Para exemplificar a execução do código em Python, vamos considerar alguns valores para as vendas das lojas.

# Lista de vendas de cada loja (exemplo)

lista_vendas = [5000, 4000, 3900, 3900, 3800, 3200, 3000, 2100, 3000, 3000,
          2950, 2950, 2900, 5000, 2900, 2900, 2900, 2900, 2900, 2900,
          2800, 2800, 2750, 2750, 2700, 2700, 3300, 2600, 2600, 2600,
          2500, 2500 ,2500, 2400, 2400, 2300, 2300, 2000,2300, 4200]

meta = 50000

# Ordenar a lista de vendas em ordem decrescente
lista_vendas.sort(reverse=True)

# Criar variáveis de controle e contagem
soma_vendas = 0
num_lojas = 0

# Utilizar o while para somar as vendas até atingir a meta
while soma_vendas < meta:
    soma_vendas += lista_vendas[num_lojas]
    num_lojas += 1

# Exibir o número de lojas necessárias
print(num_lojas)

Resultado do Código:

Explicação:

Perceba que na solução desse exercício empregamos a estrutura do while para determinar o número mínimo de lojas necessárias para atingir a meta de vendas de 50.000.

Isso porque, com o while, conseguimos fazer com que o código continue sendo executado até que a soma das vendas das lojas seja suficiente para atingir a meta. Dessa forma, a condição soma_vendas < meta passa a ser False e o loop é encerrado.

Para construção dessa lógia, primeiro ordenamos a lista de vendas das lojas em ordem decrescente, já que precisamos priorizar as lojas com as maiores vendas.

Em seguida, utilizamos duas variáveis de controle soma_vendas, que acumula as vendas das lojas, e num_lojas, que conta quantas lojas foram necessárias para atingir a meta.

Dentro do loop while, somamos as vendas de cada loja (lista_vendas[num_lojas]) à soma_vendas, até que soma_vendas atinja ou supere a meta de 50.000. A cada iteração incrementamos o valor de num_lojas em 1, para contar quantas lojas foram necessárias.

Recomendação para Treinar Lógica de Programação

Com isso, encerramos nosso Curso de Algoritmos e Lógica de Programação. Com o conteúdo abordado aqui, você já terá uma boa base para aprender a utilizar uma linguagem de programação e compreender como construir a lógica dos seus códigos.

Caso você queira continuar exercitando lógica de programação antes de iniciar o aprendizado de uma linguagem específica, eu recomendo o site do blockly.

Esse site oferece diversos jogos interativos que utilizam comandos de programação para resolver desafios. Esses jogos exigem a criação e execução de sequências lógicas para alcançar objetivos específicos.

E caso você queira partir para o estudo de uma linguagem de programação, eu vou deixar aqui o link para o nosso Curso Básico de Python.

Começar a estudar uma linguagem de programação não significa abandonar o estudo da lógica de programação. Afinal, para toda solução de exercício e desafio dentro da programação, você desenvolverá antes a lógica que deve ser executada para solucioná-lo.

Estudar uma linguagem de programação é a evolução natural do aprendizado e envolve traduzir os conceitos em instruções compreensíveis pelo computador, mantendo a prática contínua da lógica.

Voltar ao índice

Conclusão – Curso de Algoritmos e Lógica de Programação

Ao longo do Curso de Algoritmos e Lógica de Programação, você aprendeu o que são esses conceitos tão importantes para se tornar um programador.

Vimos a definição de algoritmos e lógica de programação, as diferentes maneiras de escrevermos algoritmos e estruturarmos nossa lógica para posteriormente transformar isso em um código.

Estudar algoritmos e lógica de programação é a base fundamental para quem deseja se tornar um programador. Com a compreensão desses conceitos, você estará mais preparado e pronto para trabalhar e se desenvolver como programador.

Hashtag Treinamentos

Para acessar outras publicações de Python, clique aqui!

Diego Monutti

Expert em conteúdos da Hashtag Treinamentos. Auxilia na criação de conteúdos de variados temas voltados para aqueles que acompanham nossos canais.