Departamento de Ciência da
Computação - IME - USP
Escreva um programa que lê um inteiro k, k ≥ 0, e imprime uma aproximação do valor de π que pode ser calculada usando os primeiros k+1 termos da expansão de Gregory-Leibniz, isto é :
π ~ 4/1 - 4/3 + 4/5 - 4/7 + 4/9 - 4/11 + ··· +(-1)k 4/(2k+1)
As mensagens emitidas pelo seu programa devem ser idênticas as mensagens mostradas nos exemplos abaixo.
Exemplos de execuções do programa:Digite k: 0 A aproximação calculada é 4.000000 Digite k: 1 A aproximação calculada é 2.666667 Digite k: 200000 A aproximação calculada é 3.141598
#---------------------------------------------
# Solução 1: usa variável booleana para alternar o sinal
#
def main():
k = int(input("k = "))
pi = 0
den = 1 # denominador
soma = True # para o controle do sinal
while den <= 2*k+1:
if soma:
pi = pi + 4/den
soma = False
else:
pi = pi - 4/den
soma = True
den = den + 2
print("A aproximação calculada é %f" %pi)
#---------------------------------------------
main()
#---------------------------------------------
# Solução 2.
#
def main():
k = int(input("Digite k: "))
pi = 0
den = 1 # denominador
i = 0 # contador de termos e controle do sinal
while i <= k:
if i%2 == 0:
pi += 4/den
else:
pi -= 4/den
den += 2
i += 1
print("A aproximação calculada é %f" %pi)
#---------------------------------------------
main()
#---------------------------------------------
# Solução 3: versão com o comando for
#
def main():
k = int(input("Digite k: "))
pi = 0
sinal = -1 # controle do sinal
for den in range(1,2*k+2,2): # range(inicio,fim,passo)
sinal = -sinal
pi += sinal/den
print("A aproximação calculada é %f" %(4*pi))
#---------------------------------------------
main()
Suponha que pacotes de diferentes alturas precisam ser empilhados e que há espaço para três pilhas. Para que uma pilha não desmorone, uma estratégia é sempre empilhar os pacotes de forma que as alturas das três pilhas permaneçam aproximadamente iguais. Para tanto, decidiu-se usar a estratégia de sempre escolher uma pilha com a menor altura para empilhar um pacote.
Neste questão, o objetivo é escrever um programa que simula o empilhamento de uma dada quantidade de pacotes.
Item (a)
Escreva uma função que recebe três inteiros
a1, a2 e a3, todos maiores ou iguais a zero, e
retorna o índice i (1, 2 ou 3)
do menor desses inteiros.
Em caso de empate, deve devolver o menor i.
Exemplos de execuções da função:
>>> indice(11,22,33) 1 >>> indice(33,11,22) 2 >>> indice(22,33,11) 3 >>> indice(22,11,11) 2
#
# Solução 1: versão com apenas um return no final
#
def minimo(a1, a2, a3) :
if a1 <= a2 and a1 <= a3:
i = 1
elif a2 <= a3:
i = 2
else:
i = 3
return i
#
# Solução 2: versão com vários returns
#
def minimo(a1, a2, a3) :
if a1 <= a2 and a1 <= a3:
return 1
if a2 <= a3:
return 2
return 3
#
# Solução 3.
#
def minimo(a1, a2, a3) :
i = 1
if a2 < a1 and a2 <= a3:
i = 2
elif a3 < a1:
i = 3
return i
#
# Solução 4.
#
def minimo(a1, a2, a3) :
i = 1
if a2 < a1:
i = 2
if a3 < a1 and a3 < a2:
i = 3
return i
Item (b)
Escreva um programa em Python que dado um inteiro positivo n
(correspondendo ao número de pacotes) e uma sequência de n inteiros
positivos (correspondendo às alturas dos n pacotes), simula o
empilhamento sucessivo desses pacotes nas três pilhas. Inicialmente
todas as pilhas estão vazias e a cada iteração um pacote deve ser
empilhado na pilha que está com a menor altura no momento. Se duas
pilhas estiverem em tal situação, o pacote deve ser empilhado na
pilha de menor índice.
A cada iteração o programa deve imprimir a altura do pacote e em qual pilha ele foi empilhado. Ao final da simulação, o programa deve imprimir a altura de cada pilha.
Use, obrigatoriamente, a função do item (a) em sua solução mesmo que você não a tenha escrito.
As mensagens emitidas pelo seu programa devem ser idênticas às mensagens mostradas nos exemplos abaixo (as partes em vermelho e itálico são dados de entrada ou dependem dos dados de entrada).
Digite n: 5 Digite a altura do pacote: 2 Pacote de altura 2 empilhado na pilha 1 Digite a altura do pacote: 3 Pacote de altura 3 empilhado na pilha 2 Digite a altura do pacote: 7 Pacote de altura 7 empilhado na pilha 3 Digite a altura do pacote: 1 Pacote de altura 1 empilhado na pilha 1 Digite a altura do pacote: 1 Pacote de altura 1 empilhado na pilha 1 Altura da pilha 1: 4 Altura da pilha 2: 3 Altura da pilha 3: 7 Digite n: 4 Digite a altura do pacote: 3 Pacote de altura 3 empilhado na pilha 1 Digite a altura do pacote: 1 Pacote de altura 1 empilhado na pilha 2 Digite a altura do pacote: 2 Pacote de altura 2 empilhado na pilha 3 Digite a altura do pacote: 4 Pacote de altura 4 empilhado na pilha 2 Altura da pilha 1: 3 Altura da pilha 2: 5 Altura da pilha 3: 2
#---------------------------------------------
# Solução 1: usando while
#
def main():
n = int(input("n="))
p1 = 0
p2 = 0
p3 = 0
i = 0
while i < n:
altura = int(input("Altura do próximo pacote: "))
prox = minimo(p1, p2, p3)
if prox==1:
p1 = p1 + altura
elif prox==2:
p2 = p2 + altura
else:
p3 = p3 + altura
print("Pacote de altura %d empilhado na pilha %d" %(altura,prox))
i = i + 1
print("Altura da pilha 1: %d" %p1)
print("Altura da pilha 2: %d" %p2)
print("Altura da pilha 3: %d" %p3)
#---------------------------------------------
# Solução 2: usando for
#
def main():
n = int(input("n="))
p1 = p2 = p3 = 0
for i in range(n): # i = 0,1,2,...,n-1
altura = int(input("Altura do próximo pacote: "))
prox = minimo(p1, p2, p3)
if prox==1:
p1 = p1 + altura
elif prox==2:
p2 = p2 + altura
else:
p3 = p3 + altura
print("Pacote de altura %d empilhado na pilha %d" %(altura,prox))
print("Altura da pilha 1: %d" %p1)
print("Altura da pilha 2: %d" %p2)
print("Altura da pilha 3: %d" %p3)
Sejam a, b e c números inteiros, todos maiores que zero.
Suponha que a e b representam valores de moedas disponíveis e que c é o valor de uma cédula. Suponha ainda que existem infinitas moedas de valor a e b.
Escreva um programa em Python que lê a, b e c, e verifica se é possível trocar uma cédula de valor c por um punhado de moedas de valor a e b. Imprimir UMA (e apenas uma) forma de se fazer a troca (quantidade de moedas de valor a e de valor b) caso a troca seja possível, ou uma mensagem de que a troca não é possível em caso contrário.
As mensagens emitidas pelo seu programa devem ser idênticas às mensagens mostradas nos exemplos abaixo (as partes em vermelho e itálico são dados de entrada ou dependem dos dados de entrada).
Digite o valor de uma moeda: 5 Digite o valor da outra moeda: 3 Digite o valor da cédula: 11 1 moeda(s) de 5 e 2 moeda(s) de 3 Digite o valor de uma moeda: 5 Digite o valor da outra moeda: 3 Digite o valor da cédula: 7 Não é possível trocar a cédula Digite o valor de uma moeda: 3 Digite o valor da outra moeda: 5 Digite o valor da cédula: 30 0 moeda(s) de 3 e 6 moeda(s) de 5 Digite o valor de uma moeda: 4 Digite o valor da outra moeda: 6 Digite o valor da cédula: 121 Não é possível trocar a cédula Digite o valor de uma moeda: 4 Digite o valor da outra moeda: 7 Digite o valor da cédula: 17 Não é possível trocar a cédula
#---------------------------------------------
# Solução 1
#
def main():
a = int(input("Digite o valor de uma moeda: "))
b = int(input("Digite o valor da outra moeda: "))
c = int(input("Digite o valor da cédula: "))
possível = False
na = 0 # numero de moedas de a
while na <= c//a and not possível:
nb = 0 # numero de moedas de b
while nb <= c//b and not possível:
if na*a + nb*b == c:
possível = True
nb += 1
na += 1
if possível:
print("%d moeda(s) de %d e %d moeda(s) de %d" %(na-1,a,nb-1,b))
else:
print("Não é possível trocar a cédula")
#----------------------------------------------
main()
#---------------------------------------------
# Solução 2
#
def main():
a = int(input("Digite o valor de uma moeda: "))
b = int(input("Digite o valor da outra moeda: "))
c = int(input("Digite o valor da cédula: "))
achou = False
na = 0 # numero de moedas de a
while na*a <= c and not achou:
nb = 0 # numero de moedas de b
while na*a + nb*b < c:
nb = nb + 1
if na*a + nb*b == c:
achou = True
else:
na = na + 1
if achou:
print("%d moeda(s) de %d e %d moeda(s) de %d" %(na,a,nb,b))
else:
print("Não é possível trocar a cédula")
#---------------------------------------------
main()
#---------------------------------------------
# Solução 3
#
def main():
a = int(input("Digite o valor de uma moeda: "))
b = int(input("Digite o valor da outra moeda: "))
c = int(input("Digite o valor da cédula: "))
possível = False
na = 0 # numero de moedas de a
while na <= c//a and not possível:
nb = (c - na*a)//b # numero de moedas de b
if na*a + nb*b == c:
possível = True
else:
na += 1
if possível:
print("%d moeda(s) de %d e %d moeda(s) de %d" %(na,a,nb,b))
else:
print("Não é possível trocar a cédula")
#----------------------------------------------
main()