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()