GABRIEL BELEM DE ARAUJO MARQUES – ENGENHARIA ELÉTRICA – INTRODUÇÃO A PROGRAMAÇÃO

1- Para resolver um problema, primeiramente, deve-se saber qual é o problema

a ser resolvido. E em seguida pensar maneiras de como pode ser resolvido.
2- Erro de sintaxe (Falha na tradução do algoritmo para Python, o compilador
vai detectar e dar dicas; mais fáceis de corrigir) Erro de lógica (Resultados
diferentes do esperado, erro de projeto do algoritmo, mais difíceis de
corrigir)
3-
1. Fluxograma: O fluxograma é uma representação gráfica de um algoritmo que
utiliza diferentes formas geométricas para representar diferentes partes
do algoritmo, como decisões, operações e pontos de início e fim. As
formas são conectadas por setas que indicam a sequência das instruções.
O fluxograma é útil para visualizar a estrutura do algoritmo e o fluxo
de execução de maneira clara e intuitiva.

2. Pseudocódigo: O pseudocódigo é uma forma de representação de algoritmos

que utiliza uma mistura de linguagem natural e estruturas de programação
simples. Ele se assemelha a um código de programação, mas não segue uma
sintaxe específica. O pseudocódigo é usado para descrever as etapas do
algoritmo de forma mais detalhada e compreensível, sem se preocupar com
a sintaxe específica de uma linguagem de programação real. É uma forma
flexível e legível de representar um algoritmo.

3. Linguagem de programação: A representação de um algoritmo em uma

linguagem de programação real envolve escrever o código seguindo as
regras de sintaxe e estrutura da linguagem escolhida. Isso envolve a
utilização de palavras-chave, operadores, estruturas de controle e
outras construções específicas da linguagem. Representar um algoritmo
em uma linguagem de programação permite que ele seja executado em um
ambiente de desenvolvimento e produza resultados reais. Essa forma de
representação é mais adequada quando se pretende implementar o algoritmo
em um programa funcional.
4- O compilador gera um arquivo “executável”. Compilador: o compilador serve
para transformar o código escrito em uma linguagem legível para execução em
computadores. (LINGUAGEM DESEJADA). O interpretador Python vai lendo o código
fonte, traduzindo para linguagem de máquina e executando ao mesmo tempo.
5- Os IDEs conseguem ajudar os desenvolvedores a programar de forma rápida,
já que muitos recursos não precisam ser ajustados ou integrados manualmente.
Criação rápida Maior produtividade Padronização Aprendizado contínuo
6- Comentários são trechos do programa voltados para a leitura por humanos, e
ignorados pelo interpretador. Use comentários para documentar seu código e
fazer com que ele seja fácil de entender por outras pessoas. Sequência dos
comandos é importante. Blocos devem ser criados usando endentação (com
espaços ou tab).
7- Tipos numéricos (inteiro, float, ...) Tipos textuais (caractere e string)
Tipo lógico (booleano)

8-
Dinâmica: gerada automaticamente.
Forte: Uma vez que uma variável tenha um valor de um tipo, ele não pode ser
usado como se fosse de outro tipo.
9- São sensíveis a caixa. Podem ter tamanho ilimitado (mas evite abusos).
Devem começar com letra ou underline. Outros caracteres podem ser letras,
números ou underline . Não podem ter espaço nem acentos. Não podem ser uma
palavra reservada da linguagem.
10- Para entrada de dados, usamos input. Ex: nacionalidade = ( input (“Digite
sua nacionalidade: “)) idade = int(input(“Digite sua idade: “))
11-
b = 5
y = float(b)
print (y)
-----------------------------------------------------------------------------
12- valor = int (input ("Digite o valor de um número: ")) print (valor)
-----------------------------------------------------------------------------
13-
nome = input ("Digite seu primeiro nome: ")
idade = int (input ("Digite sua idade: "))
peso = float ( input ("Digite seu peso: "))
altura = float (input( "Digite sua altura: "))
nacionalidade = input ("Digite sua nacionalidade: ")
print ("Olá, " , nome , "sua idade é," , idade ," anos, e seu peso é " ,
peso, "quilos")
-----------------------------------------------------------------------------
14-
r = float (input("Digite o valor do raio: "))
p = 2*3.14*r
print(p)
-----------------------------------------------------------------------------
15-
x1 = int(input("Entre com a coordenada x do 1o. ponto:"))
y1 = int(input("Entre com a coordenada y do 1o. ponto:"))
x2 = int(input("Entre com a coordenada x do 2o. ponto:"))
y2 = int(input("Entre com a coordenada y do 2o. ponto:"))
cateto1 = math.fabs(y2-y1)
cateto2 = math.fabs(x2-x1)
hipotenusa = math.sqrt(cateto1 ** 2 + cateto2 ** 2)
print("A distancia entre os dois pontos é", hipotenusa)
-----------------------------------------------------------------------------
16-
valor = int(input("Digite o valor em centavos: "))
moedas_1_real = valor // 100 valor = valor % 100
moedas_50_centavos = valor // 50 valor = valor % 50
moedas_25_centavos = valor // 25 valor = valor % 25
moedas_10_centavos = valor // 10 valor = valor % 10
moedas_5_centavos = valor // 5 valor = valor % 5
moedas_1_centavo = valor
print("A menor quantidade de moedas é:")
print("{} moeda(s) de 1 real".format(moedas_1_real))
print("{} moeda(s) de 50 centavos".format(moedas_50_centavos))
print("{} moeda(s) de 25 centavos".format(moedas_25_centavos))
print("{} moeda(s) de 10 centavos".format(moedas_10_centavos))
print("{} moeda(s) de 5 centavos".format(moedas_5_centavos))
print("{} moeda(s) de 1 centavo".format(moedas_1_centavo))
-----------------------------------------------------------------------------
17-
(𝑥) : função
∗∗ : potência
+𝑥 : número positivo
−𝑥 : número negativo
∗ : multiplicação
/ : divisão
// : divisão de inteiros
% : resto de divisão, porcentagem
+ : soma
− : subtração
18-
𝑥 = 320
𝑦 = 7.1 – (𝑥 // 5 – 22 / 3) + 21 ∗ 0.8 + 5
Y = 7.1 – (320//5 – 22/3) + 21*0.8 + 5
Y = 7.1 – (64 – 22/3) + 21*0.8 + 5
Y = 7.1 – (64 – 7.3) + 21*0.8 + 5
Y = 7.1 – 56.7 + 21*0.8 + 5
Y = 7.1 – 56.7 + 16.8 + 5
Y = -49.6 + 16.8 + 5
Y = -49.6 + 21.8
Y = -27.8
19-
import math
def calcular_distancia(x1, y1, x2, y2):
distancia = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
return distancia
# Teste de mesa
x1 = 9
y1 = 1
x2 = -5
y2 = 7
distancia = calcular_distancia(x1, y1, x2, y2)
print("A distância entre os pontos ({}, {}) e ({}, {}) é
{:.2f}".format(x1, y1, x2, y2, distancia))
-----------------------------------------------------------------------------
20-
num = int(input("Digite o primeiro número do intervalo: "))
num2 = int(input("Digite o segundo número do intervalo: "))
import random
y = random.random()
print(num + random.random() * num2)
-----------------------------------------------------------------------------
21 - Em Python, os operadores relacionais são usados para comparar valores e
expressões, retornando um valor booleano (verdadeiro ou falso) como
resultado. Aqui estão os operadores relacionais em Python:
1- Igual a (==): Verifica se dois valores são iguais.
a = 5
b = 10
resultado = (a == b)
print(resultado) # Saída: False
2- Diferente de (!=): Verifica se dois valores são diferentes.
a = 5
b = 10
resultado = (a != b)
 print(resultado) # Saída: True
3- Maior que (>): Verifica se o valor da esquerda é maior que o valor da
direita.
a = 5
b = 10
resultado = (b > a)
print(resultado) # Saída: True

4- Menor que (<): Verifica se o valor da esquerda é menor que o valor da

direita.
a = 5
b = 10
resultado = (a < b)
print(resultado) # Saída: True

5- Maior ou igual a (>=): Verifica se o valor da esquerda é maior ou

igual ao valor da direita.
a = 5
b = 10
resultado = (b >= a)
print(resultado) # Saída: True
6- Menor ou igual a (<=): Verifica se o valor da esquerda é menor ou
igual ao valor da direita.

a = 5
b = 10
resultado = (a <= b)
print(resultado) # Saída: True
-----------------------------------------------------------------------------
22 - Em Python, existem três operadores lógicos: "and" (e), "or" (ou) e "not"
(não). Os operadores lógicos são usados para combinar ou modificar expressões
booleanas. Aqui estão os detalhes sobre cada um deles:
1- Operador "and" (e): Retorna True se todas as expressões forem
verdadeiras, caso contrário, retorna False.
a = 5
b = 10
c = 3

resultado = (a < b) and (b > c)

print(resultado) # Saída: True
 resultado = (a < b) and (b < c)
print(resultado) # Saída: False
2- Operador "or" (ou): Retorna True se pelo menos uma das expressões for
verdadeira, caso contrário, retorna False.
a = 5
b = 10
c = 3

resultado = (a < b) or (b < c)

print(resultado) # Saída: True

resultado = (a > b) or (b > c)

print(resultado) # Saída: False

3- Operador "not" (não): Inverte o valor de uma expressão booleana. Se a

expressão for verdadeira, retorna False. Se a expressão for falsa,
retorna True.

a = 5
b = 10

resultado = not (a > b)

print(resultado) # Saída: True

resultado = not (a < b)

print(resultado) # Saída: False

-----------------------------------------------------------------------------
-------------------------------------------------
24 - Em Python, "if", "else" e "elif" são palavras-chave usadas para
implementar estruturas condicionais, permitindo que o programa tome decisões
com base em determinadas condições. Aqui está o significado de cada uma
dessas palavras-chave:
1- "if" (se):
A palavra-chave "if" é usada para iniciar uma condição. Ela avalia uma
expressão ou uma condição booleana e executa um bloco de código se a
condição for avaliada como verdadeira (True). Se a condição for falsa
(False), o bloco de código do "if" não será executado.
idade = 20
 if idade >= 18:
print("Você é maior de idade.")

2- "else" (senão):
A palavra-chave "else" é usada em conjunto com um "if" e permite
definir um bloco de código a ser executado caso a condição do "if"
seja falsa. O bloco de código do "else" é executado somente se a
condição do "if" for avaliada como falsa.
idade = 15
if idade >= 18:
print("Você é maior de idade.")
else:
print("Você é menor de idade.")
3- "elif" (senão, se):
A palavra-chave "elif" é usada para adicionar mais condições em uma
estrutura condicional. Ela é usada entre um "if" e um "else" e permite
testar múltiplas condições sequencialmente. O bloco de código
associado a um "elif" será executado somente se a condição do "elif"
for verdadeira e as condições anteriores (if ou elif) forem avaliadas
como falsas.

idade = 25
if idade < 18:
print("Você é menor de idade.")
elif idade >= 18 and idade < 65:
print("Você é adulto.")
else:
print("Você é idoso.")
-----------------------------------------------------------------------------
-------------------------------------------------
25 –
numero = int(input("Digite um número: "))
if numero % 2 != 0:
print("O número é ímpar.")
else:
print("O número não é ímpar.")
-----------------------------------------------------------------------------
-------------------------------------------------
26 –
valor1 = float(input("Digite o primeiro valor: "))
valor2 = float(input("Digite o segundo valor: "))
valor3 = float(input("Digite o terceiro valor: "))
valor4 = float(input("Digite o quarto valor: "))
menor = valor1 # Assume-se inicialmente que o primeiro valor é o menor
if valor2 < menor:
menor = valor2
if valor3 < menor:
menor = valor3
if valor4 < menor:
menor = valor4
print("O menor valor é:", menor)
-----------------------------------------------------------------------------
-------------------------------------------------
27 –
idade_dias = int(input("Digite a idade em dias: "))

anos = idade_dias // 365 # Divide a quantidade de dias por 365 para obter a
quantidade de anos
meses = (idade_dias % 365) // 30 # Divide o resto dos dias por 365 e depois
divide por 30 para obter a quantidade de meses
dias = (idade_dias % 365) % 30 # O resto dos dias que não formam anos e
meses

print("Idade: {} anos, {} meses e {} dias".format(anos, meses, dias))

-----------------------------------------------------------------------------

28 –
valor_pago = float(input("Digite o valor pago: "))
preco_produto = float(input("Digite o preço do produto: "))

troco = valor_pago - preco_produto

if troco >= 0:
print("Troco a ser dado:", troco)
else:
print("Valor insuficiente. Pagamento incompleto.")
-----------------------------------------------------------------------------
29 –
a = int(input("Digite o valor de a: "))
b = int(input("Digite o valor de b: "))
c = int(input("Digite o valor de c: "))

if a != 0 and b != 0 and c != 0 and (a + b) > c and (a + c) > b and (b + c) >

a:
if a == b == c:
print("Triângulo Equilátero")
elif a == b or a == c or b == c:
print("Triângulo Isósceles")
else:
print("Triângulo Escaleno")
else:
print("Os valores não formam um triângulo.")
-----------------------------------------------------------------------------
30 –
texto = input("Digite um texto: ")
quantidade_caracteres = len(texto)

print("O texto digitado possui", quantidade_caracteres, "caracteres.")

-----------------------------------------------------------------------------
31 –
texto_maiusculo = input("Digite um texto em letras maiúsculas: ")
texto_minusculo = texto_maiusculo.lower()

print("Texto em letras minúsculas:", texto_minusculo)

texto_minusculo = input("Digite um texto em letras minúsculas: ")

texto_maiusculo = texto_minusculo.upper()

print("Texto em letras maiúsculas:", texto_maiusculo)

32 –
frase = input("Digite uma frase: ")
palavra_atual = input("Digite a palavra que deseja substituir: ")
nova_palavra = input("Digite a nova palavra: ")
nova_frase = frase.replace(palavra_atual, nova_palavra)

print("Frase original:", frase)

print("Frase modificada:", nova_frase)
-----------------------------------------------------------------------------
33 –
dicionario = {
1: 'a',
3: 'c',
4: 'd',
12: 'm',
14: 'o',
15: 'p',
17: 'r',
19: 't',
20: 'u'
}

codigo = [3, 14, 12, 15, 20, 19, 1, 4, 14, 17]

palavra = ""

for valor in codigo:

if valor in dicionario:
letra = dicionario[valor]
palavra += letra
print("Palavra gerada:", palavra)
COMPUTADOR

34 –
num = int(input("Digite um número: "))

# Dicionário para mapear os dígitos por extenso

digitos_extenso = {
"0": "zero",
"1": "um",
"2": "dois",
"3": "três",
"4": "quatro",
"5": "cinco",
"6": "seis",
"7": "sete",
"8": "oito",
"9": "nove"
}

# Converte o número em uma string

num_str = str(num)

# Percorre cada dígito e imprime por extenso

for digito in num_str:
if digito in digitos_extenso:
extenso = digitos_extenso[digito]
print(extenso)
-----------------------------------------------------------------------------

35 –
numeros = []
for i in range(5):
numero = float(input("Digite um número: "))
 numeros.append(numero)

soma = sum(numeros)

print("Somatório dos números:", soma)

print("Números digitados:")
for numero in numeros:
print(numero)
-----------------------------------------------------------------------------
36 –
numeros = []
for i in range(10):
numero = float(input("Digite um número: "))
numeros.append(numero)
numeros_multiplicados = [num * 5 for num in numeros]

print("Números originais\tNúmeros multiplicados por 5")

for num1, num2 in zip(numeros, numeros_multiplicados):
print(f"{num1}\t\t\t{num2}")
-----------------------------------------------------------------------------
37 –