Projeto de Algoritmos - Exercícios
Vamos começar a desenvolver os exercícios.
Resposta:Entender o problema: O primeiro passo é entender o problema que o algoritmo deve resolver. É importante entender os requisitos e as limitações do problema para criar um algoritmo eficaz.
Definir a entrada e a saída: Em seguida, é preciso definir quais serão os dados de entrada e saída do algoritmo. É importante definir claramente os tipos de dados, como eles serão fornecidos e como serão exibidos.
Identificar os passos: A próxima etapa é identificar os passos necessários para resolver o problema. É importante criar uma lista clara de passos que o algoritmo deve seguir para atingir o resultado esperado.
Organizar os passos: Após identificar os passos, é preciso organizar a sequência dos mesmos em uma ordem lógica e coerente, levando em consideração a eficiência do algoritmo.
Testar e ajustar: Após criar o algoritmo, é importante testá-lo para garantir que ele resolva o problema de maneira correta e eficiente. Caso necessário, é preciso fazer ajustes no algoritmo para melhorar seu desempenho.
Documentar: Por fim, é importante documentar o algoritmo, para que outras pessoas possam entendê-lo e usá-lo no futuro.
Resposta:Entender o problema: O primeiro passo é entender claramente o problema que o algoritmo deve resolver. Isso envolve identificar os requisitos e as limitações do problema, bem como as informações necessárias para resolvê-lo.
Identificar as entradas e saídas: Em seguida, é preciso identificar quais são os dados de entrada necessários para o algoritmo e o que ele deve produzir como saída. Isso pode incluir informações como números, texto, imagens, entre outros.
Projetar a solução: Com base nas informações identificadas nas etapas anteriores, é preciso projetar a solução para o problema. Isso envolve identificar os passos específicos que o algoritmo deve seguir para chegar à solução, bem como os métodos e estruturas de dados que serão usados.
Escrever o algoritmo: Com a solução projetada, é possível escrever o algoritmo usando uma linguagem de programação. Isso envolve codificar os passos identificados na etapa anterior de maneira clara e precisa.
Testar e depurar: Depois de escrever o algoritmo, é importante testá-lo para garantir que ele funcione corretamente. Isso envolve executar o algoritmo com diferentes entradas e verificar se a saída está correta. Se houver erros, é necessário depurá-los para corrigi-los.
Otimizar: Se o algoritmo estiver funcionando corretamente, é possível otimizá-lo para melhorar sua eficiência e desempenho. Isso envolve fazer mudanças no algoritmo para torná-lo mais rápido ou usar menos recursos.
Documentar: Por fim, é importante documentar o algoritmo para que outras pessoas possam entendê-lo e usá-lo no futuro. Isso pode envolver escrever comentários no código, criar documentação técnica ou fornecer exemplos de uso.
4.Faça um algoritmo, apresentado cada passo, para ao seguinte problema: um homem precisa atravessar um rio com um barco que possui capacidade somente para carregar ele mesmo e mais uma de suas três cargas, que são um lobo, uma cabra e um repolho. O que o homem deve fazer para conseguir atravessar o rio sem perder suas cargas? Escreva os passos necessários mostrando a resposta, ou seja, indicando todas as ações necessárias para efetuar uma travessia segura.
atravessar homem e cabra
voltar homem
atravessar homem e lobo
voltar homem e cabra
atravessar homem e repolho
voltar homem
atravessar homem e cabra
5.Faça um algoritmo, apresentado cada passo, para ao seguinte problema: três jesuítas e três canibais precisam atravessar um rio; para tal dispõem de um barco com capacidade para duas pessoas. Por medidas de segurança, não se deve permitir que em alguma margem a quantidade de jesuítas seja inferior a de canibais. Qual a solução para efetuar a travessia com segurança? Elabore os passos de forma a mostrar a resposta, indicando as ações que concretizam a resolução deste problema
Embarcar um jesuita e um canibal
atravessar um jesuíta e um canibal
desembarcar um jesuíta ao outro lado da margem
voltar ao inicio com um canibal
embarcar mais um canibal
atravessar com dois canibais ao outro lado da margem
desembarcar um canibal
voltar ao inicio com um canibal
embarcar um jesuita
atravessar um jesuíta e um canibal ao outro lado da margem
desembarcar um jesuita
voltar ao inicio com um canibal
embarcar um canibal
atravessar dois canibais ao outro lado da margem
desembarcar um canibal
voltar um canibal
embarcar um jesuita
atravessar um jesuíta e um canibal ao outro lado da margem
desembarcar um jesuita e um canibal
M <- 10
N <- 20
O<- 30
M## [1] 10N## [1] 20O## [1] 30M+ N## [1] 30M+ O## [1] 40N+ O## [1] 50A <- 6
B <- 8
trocador <- A
A <- B
B <- trocador
print(A)## [1] 8print(B)## [1] 6A <- 6
B <- 8
trocador <- A
A <- B
B <- trocador
print(A)## [1] 8print(B)## [1] 6Fa <- 50
(Fa - 32) * (5/9)## [1] 103 * 3 - 4## [1] 5sqrt (3*3)## [1] 3x1 <- 3
x2 <- 5
x3 <- 7
x4 <- 4
x5 <- 3
x6 <- 2
x7 <- 1
x8 <- 9
x9 <- 12
x10 <-15
x11 <-9
media <- (x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11)/11
cat ("Média é =", media)## Média é = 6.363636Faça um programa em RStudio que calcule o fatorial de um número.
factorial(4)## [1] 24Crie uma matriz 4x4. Uma matriz no R comporta somente um tipo de dado (número, texto ou boleano). O comando para criar a matriz é “x <- matrix(data = 1, nrow = 4, ncol = 4, byrow = TRUE)”
x <- matrix(data = 1:4, nrow = 2, ncol = 2, byrow = TRUE)Agora, crie uma matriz com a sequência de 1 a 16.
mat <- matrix(data = 1:16, nrow = 4, ncol =4, byrow = TRUE)Transforme essa matriz em um data.frame Um data.frame é uma estrutura de dados similar a matriz que pode conter dados diferentes em suas variáveis. Lembre-se que também chamamos as colunas de variáveis e as linhas de registros. Uma variável (coluna) não pode conter dados de formas diferentes (textos e números, por exemplo). Ou todas as linhas dessa variável são números, ou todas são texto, ou ainda,boleanos. Utilize o comando “df <- as.data.frame(x)”
df <- as.data.frame(mat)Utilizando os comandos de repetição e decisão (se for necessário), calcule: a. a média de uma coluna da matriz do exercício “13)”.
soma <- 0
for (i in 1:4){
soma <- soma + mat[1,2]
}
media <- soma/i
media## [1] 2for(ypsolon in 1:4) {
soma <- 0
for(i in 1:4){
soma <- soma + mat[i, ypsolon]
}
media <- soma/i
print(media)
}## [1] 7
## [1] 8
## [1] 9
## [1] 10for (i in 1:4){
soma <- 0
for(j in 1:4){
soma <- soma + mat[i,j]
}
media <- soma/j
print(media)
}## [1] 2.5
## [1] 6.5
## [1] 10.5
## [1] 14.5for(coluna in 1:4){
soma <- 0
contador <- 0
for(linha in 1:4){
if(mat[linha,coluna]%%2 == 0){
soma <- soma + mat[linha,coluna]
contador <- contador + 1
}
}
if (contador != 0){
media <- soma/contador
cat("a média da coluna", coluna, "é", media, "\n")
} else {
cat("não existe número par na coluna", coluna, "\n")
}
}## não existe número par na coluna 1
## a média da coluna 2 é 8
## não existe número par na coluna 3
## a média da coluna 4 é 10for(coluna in 1:4){
contador <- 0
soma <- 0
for(linha in 1:4){
if(mat[coluna,linha]%%2 != 0){
soma <- soma + mat[coluna,linha]
contador <- contador + 1
}
}
if(contador != 0){
media <- soma/contador
cat("a média da linha", linha, "é", media, "\n")
} else {
cat("não existe número impar na linha", linha, "\n")
}
}## a média da linha 4 é 2
## a média da linha 4 é 6
## a média da linha 4 é 10
## a média da linha 4 é 14soma <- 0
for(coluna in 1:4){
for(linha in 1:4){
if(linha == coluna){
soma <- soma + mat[linha,coluna]
}
}
}
cat("a soma da diagonal principal", linha, "é", soma, "\n")## a soma da diagonal principal 4 é 34for(linha in 1:4){
soma <- 0
for(coluna in 1:4){
if(coluna != linha){
soma <- soma + mat[linha,coluna]
}
}
}
cat("a soma da diagonal principal", coluna, "é", soma, "\n")## a soma da diagonal principal 4 é 42Repita o exercício “15)” com os dados do data.frame do exercício “14)”
matriz <- matrix(data = 1:16, nrow = 4, ncol = 4, byrow = TRUE)
# a)a média de uma coluna da matriz do exercício “13)”.
soma_coluna <- 0
for(linha in 1:4){
for(coluna in 1:4){
if(coluna == 2){ # serão somados somente os valores da coluna 2
soma_coluna <- soma_coluna + matriz[linha, coluna]
}
}
}
# A média da coluna é a soma da coluna dividido pela quantidade de linhas dessa coluna
media_coluna <- soma_coluna/linha
media_coluna## [1] 8# b) A média de todas as colunas da matriz do exercício “13)”.
v_soma_colunas <- rep(0,4)
for(linha in 1:4){
for(coluna in 1:4){
v_soma_colunas[coluna] <- v_soma_colunas[coluna] + matriz[linha, coluna]
}
}
v_soma_colunas## [1] 28 32 36 40media_colunas <- v_soma_colunas/linha
media_colunas## [1] 7 8 9 10# c) A média de todas as linhas da matriz do exercício “13)”.
v_soma_linhas <- rep(0,4)
for(linha in 1:4){
for(coluna in 1:4){
v_soma_linhas[linha] <- v_soma_linhas[linha] + matriz[linha, coluna]
}
}
v_soma_linhas## [1] 10 26 42 58media_linhas <- v_soma_linhas/coluna
media_linhas## [1] 2.5 6.5 10.5 14.5# d) A média dos números pares de todas as colunas da matriz do exercício “13)”.
v_soma_npar_colunas <- rep(0,4) # repete 4 vezes o valor 0
for(linha in 1:4){
for(coluna in 1:4){
if(matriz[linha, coluna]%%2 == 0){
v_soma_npar_colunas[coluna] <- v_soma_npar_colunas[coluna] + matriz[linha, coluna]}
}
}
v_soma_npar_colunas## [1] 0 32 0 40Faça um programa em RStudio que crie uma matriz VALOR 6x6 e calcule a soma de cada uma das linhas da matriz. Os valores das somas calculadas devem ser armazenados em um vetor RESULTADO de tamanho 6. Ao final do programa o vetor deve ser impresso.
# Criando uma matriz VALOR 6x6 com números aleatórios entre 1 e 10
VALOR <- matrix(data = 1:36, nrow = 6, ncol = 6, byrow = TRUE)
# Calculando a soma de cada uma das linhas e armazenando em um vetor RESULTADO
RESULTADO <- rowSums(VALOR)
# Imprimindo o vetor RESULTADO
print(RESULTADO)## [1] 21 57 93 129 165 201Faça um programa em RStudio que crie um data.frame D 5x5 e calcule a média dos valores armazenados na diagonal principal e a soma dos valores armazenados na diagonal secundária
df <- as.data.frame(matrix(data = 1:25, nrow = 5, ncol = 5, byrow = TRUE))
# MÉDIA DOS VALORES ARMAZENADOS NA DIAGONAL PRINCIPAL
dfaa1.1 <- 1
dfaa2.2 <- 7
dfaa3.3 <- 13
dfaa4.4 <- 19
dfaa5.5 <- 25
SOMA <- dfaa1.1 + dfaa2.2 + dfaa3.3 + dfaa4.4 + dfaa5.5
MEDIA <- SOMA/5
# VALORES ARMAZENADOS NA DIAGONAL SECUNDÁRIA
dfaa5.5 <- 5
dfaa4.4 <- 9
dfaa3.2 <- 13
dfaa2.1 <- 17
dfaa1.4 <- 21
SOMA3<- dfaa5.5 + dfaa4.4 + dfaa3.2 + dfaa2.1 + dfaa1.4Faça um programa em RStudio que crie um data.frame D 4x4, que contenha números entre 0 e 100, e calcule e imprima: a) A média dos valores pares armazenados no data.frame; b) A quantidade de elementos com valor maior que 50; c) A média dos valores ímpares menores que 30 armazenados no data.frame; d) A soma dos valores das colunas ímpares. e) O maior e o menor valor armazenado.
# criando um data.frame D 4x4 com valores aleatórios entre 0 e 100
set.seed(123)
D <- data.frame(matrix(sample(0:100, 16, replace = TRUE), nrow = 4))
colnames(D) <- c("A", "B", "C", "D")
# calculando a média dos valores pares
media_pares <- mean(D[D %% 2 == 0])
# calculando a quantidade de elementos maiores que 50
maiores_50 <- sum(D > 50)
# calculando a média dos valores ímpares menores que 30
media_impares <- mean(D[D %% 2 != 0 & D < 30])
# calculando a soma dos valores das colunas ímpares
soma_colunas_impares <- sum(D[, c(TRUE, FALSE)])
# encontrando o maior e o menor valor
maior_valor <- max(D)
menor_valor <- min(D)
# imprimindo os resultados
cat("Média dos valores pares: ", media_pares, "\n")## Média dos valores pares: 63.09091cat("Quantidade de elementos maiores que 50: ", maiores_50, "\n")## Quantidade de elementos maiores que 50: 8cat("Média dos valores ímpares menores que 30: ", media_impares, "\n")## Média dos valores ímpares menores que 30: 13cat("Soma dos valores das colunas ímpares: ", soma_colunas_impares, "\n")## Soma dos valores das colunas ímpares: 397cat("Maior valor armazenado: ", maior_valor, "\n")## Maior valor armazenado: 100cat("Menor valor armazenado: ", menor_valor, "\n")## Menor valor armazenado: 13Faça um programa em RStudio que com base no salário de um funcionário (criado por vocês), calcule e mostre o seu salário a receber, sabendo-se que esse funcionário tem gratificação de 5% sobre seu salário base e paga 10% de imposto sobre o salário base.
salário_base<- 2000
gratificação <- salário_base * 0.05
imposto <- salário_base * 0.1
salário <- salário_base + gratificação - imposto
salário## [1] 1900Faça um programa em RStudio para calcular o salário mensal final de um vendedor. As seguintes informações determinam esse valor: a) salário fixo: R$ 3.000,00 b) total de vendas por ele efetuadas: R$ 25.000,00 c) percentual que ele recebe sobre o total de vendas (5%) d) IRPF de 7,5% sobre o salário fixo e) INSS de 11% sobre o salário fixo mais a comissão de vendas
salario_fixo <- 3000
total_de_vendas <- 25000
grat_vendas <- total_de_vendas * 0.05
IRPF <- salario_fixo * 0.075
INSS <- (salario_fixo + grat_vendas) * 0.11
salario <- salario_fixo + grat_vendas - IRPF - INSS
cat(" BILHETE DE PAGAMENTO \n",
"-------------------------------------", "\n" ,
"salario base ", salario_fixo, "\n" ,
"Gratificação de vendas ", grat_vendas, "\n" ,
"Imposto de Renda ", IRPF, "\n",
"INSS ", INSS, "\n",
"-------------------------------------", "\n",
"Líquido a receber ", salario)## BILHETE DE PAGAMENTO
## -------------------------------------
## salario base 3000
## Gratificação de vendas 1250
## Imposto de Renda 225
## INSS 467.5
## -------------------------------------
## Líquido a receber 3557.5Faça um programa em RStudio para efetuar a estimativa da quantidade de litros de cerveja consumida por um determinado bloco durante o carnaval. Outras informações: • o bloco tem 1000 pessoas; • cada pessoa consome em média 3 latões; • considerar que uma caixa de cerveja tem 12 latões; • sabe-se que cada latão tem 473 ml e que 1 litro tem 1000 ml; • considerar que o carnaval são quatro dias; Qual a quantidade de caixas de cerveja consumidas durante um dia? E durante os cinco dias? Supondo que cada caixa custa R$ 42,00 e é vendida a R$ 84,00 (R$ 7,00 cada lata), informar o o consumo em litros do bloco e o lucro auferido.
# Definindo variáveis
n_pessoas <- 1000
media_consumo <- 3
latoes_por_caixa <- 12
ml_por_latao <- 473
ml_por_litro <- 1000
dias_carnaval <- 5
preco_custo_caixa <- 42
preco_venda_caixa <- 84
# Calcular o consumo total em litros
litros_total <- n_pessoas * media_consumo * ml_por_latao / ml_por_litro * dias_carnaval
# Calcular a quantidade de caixas de cerveja consumidas em um dia
caixas_por_dia <- (n_pessoas * media_consumo) / latoes_por_caixa
# Calcular a quantidade de caixas de cerveja consumidas em cinco dias
caixas_cinco_dias <- caixas_por_dia * dias_carnaval
# Calcular o lucro auferido
lucro_por_caixa <- preco_venda_caixa - preco_custo_caixa
lucro_total <- lucro_por_caixa * caixas_cinco_dias
# Imprimir resultados
cat("Quantidade de caixas de cerveja consumidas por dia:", round(caixas_por_dia, 2), "\n")## Quantidade de caixas de cerveja consumidas por dia: 250cat("Quantidade de caixas de cerveja consumidas em cinco dias:", round(caixas_cinco_dias, 2), "\n")## Quantidade de caixas de cerveja consumidas em cinco dias: 1250cat("Consumo total de cerveja em litros:", round(litros_total, 2), "\n")## Consumo total de cerveja em litros: 7095cat("Lucro auferido em cinco dias:", round(lucro_total, 2))## Lucro auferido em cinco dias: 52500Dois times de futebol fizeram uma disputa entre eles e jogaram 10 partidas. Os resultados de cada jogo foram armazenados em uma matriz JOGO 10x2, onde cada linha representa um jogo e cada coluna um time. Faça um programa em RStudio que calcule a média de gols realizados por cada time.
jogo <- matrix(data = c(4,2,2,3,5,2,1,3,2,1,1,1,1,1,1,1,1,1,1,1), ncol = 2)
soma_fla <- 0
soma_flu <- 0
for(i in 1:10){
soma_flu <- soma_flu + jogo [i,2]
soma_fla <- soma_fla + jogo [i,1]
}
media_fla <- soma_fla/10
media_flu <- soma_flu/10
cat(" A média de gols do Fla foi", media_fla, "\n")## A média de gols do Fla foi 2.5cat(" A média de gols do Flu foi", media_flu, "\n")## A média de gols do Flu foi 1