|
|
| Línia 1: |
Línia 1: |
| − | <!--
| |
| − | == A2.1 Exercicis estructura alternativa ==
| |
| | | | |
| − | '''Exercicis preliminars'''
| |
| − |
| |
| − | 1. Escriure un programa que demani una nota d'una prova i ens digui si ha aprovat (>=5).
| |
| − |
| |
| − | <source lang="python">
| |
| − | print("Programa per determinar si una prova està aprovada")
| |
| − |
| |
| − | # Constant nota aprovat
| |
| − |
| |
| − | NOTA_APROVAT = 5.0
| |
| − |
| |
| − | # Entrada nota prova
| |
| − |
| |
| − | nota = float(input("Introdueix la nota de la prova: "))
| |
| − |
| |
| − | # Determinar si la prova està aprovada
| |
| − |
| |
| − | if (nota >= NOTA_APROVAT):
| |
| − | print("L'alumne ha aprovat!")
| |
| − |
| |
| − | </source>
| |
| − |
| |
| − |
| |
| − | 2. Escriure un programa que demani una nota d'una prova i ens digui si ha aprovat o ha suspès.
| |
| − |
| |
| − | <source lang="python">
| |
| − | print("Programa per determinar si una prova està aprovada o suspesa")
| |
| − |
| |
| − | # Constant nota aprovat
| |
| − |
| |
| − | NOTA_APROVAT = 5.0
| |
| − |
| |
| − | # Entrada nota prova
| |
| − |
| |
| − | nota = float(input("Introdueix la nota de la prova: "))
| |
| − |
| |
| − | # Determinar si la prova està aprovada
| |
| − |
| |
| − | if (nota >= NOTA_APROVAT):
| |
| − | print("L'alumne ha aprovat!")
| |
| − | else:
| |
| − | print("L'alumne ha suspès!")
| |
| − | </source>
| |
| − |
| |
| − |
| |
| − | 3. Escriure un programa que demani dos números i digui si són iguals o diferents.
| |
| − |
| |
| − | <source lang="python">
| |
| − | print("Programa per deternimar si dos números són iguals o no")
| |
| − |
| |
| − | # Entrada de números
| |
| − |
| |
| − | numero_1 = float(input("Introdueix un número: "))
| |
| − | numero_2 = float(input("Introdueix un altre número: "))
| |
| − |
| |
| − | # Determinar si dos números són iguals o no
| |
| − |
| |
| − | if (numero_1 == numero_2):
| |
| − | print("Els números són iguals!")
| |
| − | else:
| |
| − | print("Els números són diferents!")
| |
| − | </source>
| |
| − |
| |
| − |
| |
| − | 4. Escriure un programa que provi d'endevinar un número secret (poseu el número secret com a constant).
| |
| − |
| |
| − | <source lang="python">
| |
| − | print("Programa per endevinar un número secret (0, )")
| |
| − |
| |
| − | # Constant número secret
| |
| − |
| |
| − | NUM_SECRET = 9
| |
| − |
| |
| − | # Entrada del número
| |
| − |
| |
| − | numero = int(input("Endivina el número secret: "))
| |
| − |
| |
| − | # Determinar encert del número secret
| |
| − |
| |
| − | if (numero == NUM_SECRET):
| |
| − | print("Enhorabona!")
| |
| − | else:
| |
| − | print("Ho sento! Torna-ho a intentar...")
| |
| − | </source>
| |
| − |
| |
| − |
| |
| − | '''Exercicis sentencia if'''
| |
| − |
| |
| − | 1. Els treballadors d’una fàbrica treballen en dos torns: diürn i nocturn. Es vol calcular el salari d’un dia d’acord amb els següents punts:
| |
| − | :a. La tarifa de les hores diürnes és de 4€
| |
| − | :b. La tarifa de les hores nocturnes és de 6€
| |
| − | :c. En cas de ser diumenge, la tarifa s’incrementa en 2€ el torn diari i en 3€ el torn nocturn.
| |
| − |
| |
| − | El programa ha de llegir les hores treballades, el torn i el dia de la setmana i dir quin serà el salari.
| |
| − |
| |
| − | <source lang="phyton">
| |
| − | print("Programa per calcular el salari d'un dia de treball")
| |
| − |
| |
| − | # Constants tarifes
| |
| − |
| |
| − | DIA = 4
| |
| − | DIAFESTIU = 6
| |
| − | NIT = 6
| |
| − | NITFESTIU = 9
| |
| − |
| |
| − | # Entrada hores, torn i dies
| |
| − |
| |
| − | hores = int(input("Introdueix el nombre d'hores treballades: "))
| |
| − | torn = input("Introdueix el torn (diari ->d/nocturn->n): ")
| |
| − | dia = input("Introdueix el dia (diumenge->d/feiner->f): ")
| |
| − |
| |
| − | # Determinar salari
| |
| − |
| |
| − | if dia == 'f':
| |
| − | if torn == 'd':
| |
| − | salari = hores * DIA
| |
| − | else:
| |
| − | salari = hores * NIT
| |
| − | elif torn == 'd':
| |
| − | salari = hores * DIAFESTIU
| |
| − | else:
| |
| − | salari = hores * NITFESTIU
| |
| − |
| |
| − | # Resultat: salari del dia
| |
| − |
| |
| − | print("El salari és: %d €" %salari);
| |
| − | </source>
| |
| − |
| |
| − | 2. Escriviu un programa que simuli una calculadora simple. El programa llegeix dos enters i un caràcter. Si el caràcter és un '+' s’imprimeix la suma, si és un '–' la resta, si és un '*' el producte, si és un '/' la divisió real, si és '//' la divisió entera i si és un '%', el mòdul.
| |
| − |
| |
| − | <source lang="phyton">
| |
| − | print("Programa calculadora simple")
| |
| − |
| |
| − | # Entrada números i operació
| |
| − |
| |
| − | num1 = int(input("Introdueix un valor enter: "))
| |
| − | num2 = int(input("Introdueix un altre valor enter: "))
| |
| − | operacio = input("Introdueix l'operació ('+' , '-' , '*' , '/' , '//' , '%': ")
| |
| − |
| |
| − | # Operació
| |
| − |
| |
| − | if operacio == '+':
| |
| − | resultat = num1 + num2
| |
| − | elif operacio == '-':
| |
| − | resultat = num1 - num2
| |
| − | elif operacio == '*':
| |
| − | resultat = num1 * num2
| |
| − | elif operacio == '/':
| |
| − | resultat = num1 / num2
| |
| − | elif operacio == '//':
| |
| − | resultat = num1 // num2
| |
| − | else:
| |
| − | resultat = num1 % num2
| |
| − |
| |
| − | # Resultat de l'operació
| |
| − |
| |
| − | if isinstance(resultat,float):
| |
| − | print("El resultat de l'operació és: %3.2f " %resultat)
| |
| − | else:
| |
| − | print("El resultat de l'operació és: %d " %resultat)
| |
| − | </source>
| |
| − |
| |
| − | 3. Escriviu un programa que llegeixi del teclat un enter comprès entre 0 i 63 (inclosos) i ens digui el nombre de bits que necessitem per escriure’l en binari. No s’ha de fer servir cap funció calcular-ho, sinó simplement a base de '''if .. elif .. else''', recordant que a cada potència de 2 necessitem un bit més.
| |
| − |
| |
| − | <source lang="phyton">
| |
| − | print("Programa bits per representar en binari un número")
| |
| − |
| |
| − | # Entrada número
| |
| − |
| |
| − | valor = int(input("Introdueix un valor enter: "))
| |
| − |
| |
| − | # Validació del número entrat
| |
| − |
| |
| − | if valor < 0 or valor > 63:
| |
| − | print("El número ha d'estar comprès en el rang [0:63]")
| |
| − | else:
| |
| − |
| |
| − | # Obtenció del nombre de bits
| |
| − |
| |
| − | if (valor < 2):
| |
| − | bits = 1
| |
| − | elif (valor < 4):
| |
| − | bits = 2
| |
| − | elif (valor < 8):
| |
| − | bits = 3
| |
| − | elif (valor < 16):
| |
| − | bits = 4
| |
| − | elif (valor < 32):
| |
| − | bits = 5
| |
| − | else:
| |
| − | bits = 6;
| |
| − |
| |
| − | # Número de bits del número
| |
| − |
| |
| − | print("Necessitem %d bits " %bits)
| |
| − | </source>
| |
| − |
| |
| − | 4. Volem saber si una persona és major d’edat, per això llegirem la data de naixement(dia_neix, mes_neix i any_neix).
| |
| − |
| |
| − | : Utilitzeu el següent codi per obtenir dia, mes i any actual
| |
| − | <source lang="python">
| |
| − | from datetime import date
| |
| − |
| |
| − | #Dia, mes i any actual
| |
| − |
| |
| − | AVUI = date.today()
| |
| − | DIA_ACTUAL = AVUI.day
| |
| − | MES_ACTUAL = AVUI.month
| |
| − | ANY_ACTUAL = AVUI.year
| |
| − | </source>
| |
| − |
| |
| − | <source lang="phyton">
| |
| − | from datetime import date
| |
| − |
| |
| − | print("Programa major d'edat")
| |
| − |
| |
| − | # Constants dia, mes i any actual
| |
| − |
| |
| − | AVUI = date.today()
| |
| − | DIA_ACTUAL = AVUI.day
| |
| − | MES_ACTUAL = AVUI.month
| |
| − | ANY_ACTUAL = AVUI.year
| |
| − |
| |
| − | # Entrada dia, mes i any de neixement
| |
| − |
| |
| − | dia_neix = int(input("Introdueix el dia de naixement: "))
| |
| − | mes_neix = int(input("Introdueix el mes de naixement: "))
| |
| − | any_neix = int(input("Introdueix el any de naixement: "))
| |
| − |
| |
| − | # Determinar majoria d'edat
| |
| − |
| |
| − | if (ANY_ACTUAL - any_neix < 18):
| |
| − | print("Ets menor d'edat!")
| |
| − | elif (ANY_ACTUAL - any_neix > 18):
| |
| − | print("Ets major d'edat!")
| |
| − | elif (MES_ACTUAL > mes_neix):
| |
| − | print("Ets major d'edat!")
| |
| − | elif (MES_ACTUAL < mes_neix):
| |
| − | print("Ets menor d'edat!")
| |
| − | elif (DIA_ACTUAL >= dia_neix):
| |
| − | print("Ets major d'edat!")
| |
| − | else:
| |
| − | print("Ets menor d'edat!")
| |
| − | </source>
| |
| − |
| |
| − |
| |
| − | 5. Escriu un programa que llegeixi un número enter positiu i determini si es un número de 1, 2,3 o 4 xifres.
| |
| − |
| |
| − | Control d'errors: Escriu els missatges pertinents si han introduït un valor fora del rang o si no han introduït un número enter.
| |
| − |
| |
| − | <source lang="phyton">
| |
| − | print("Programa xifres d'un número")
| |
| − |
| |
| − | # Entrada de dades
| |
| − |
| |
| − | numero = input("Introdueix un número: ")
| |
| − |
| |
| − | try:
| |
| − | numero = int(numero) # En el cas de que no sigui un enter saltarà a la zona de excepcions
| |
| − | if numero >= 0 and numero <10000:
| |
| − |
| |
| − | # Determinar les xifres del número
| |
| − |
| |
| − | if numero <10:
| |
| − | xifres = 1
| |
| − | elif numero <100:
| |
| − | xifres = 2
| |
| − | elif numero <1000:
| |
| − | xifres = 3
| |
| − | else:
| |
| − | xifres = 4
| |
| − | print("El número %d és de %d xifres" %(numero,xifres)) # Xifres del número
| |
| − | else:
| |
| − | print("El número %d no és dins del rang [0..9999]" %numero) # Número fora del rang
| |
| − | except ValueError:
| |
| − | print("La entrada és incorrecte: escriu un número enter!") # No és un enter
| |
| − | </source>
| |
| − |
| |
| − | 6. En un casino de jocs es desitja mostrar els missatges respectius per els punts obtinguts en el llançament de tres daus d'un client, d'acord als següents resultats:
| |
| − |
| |
| − | :a) Si els tres daus són sis, mostrar el missatge "Excel·lent"
| |
| − | :b) Si dos daus són sis, mostrar el missatge "Molt bé"
| |
| − | :c) Si un dau és sis, mostrar el missatge "Regular"
| |
| − | :d) Si cap dau és sis, mostrar el missatge "Pèssim"
| |
| − |
| |
| − | : Utilitzeu el següent codi per simular el llançament d'un dau
| |
| − | <source lang="python">
| |
| − | from random import randint
| |
| − |
| |
| − | # Simulació del llançament d'un dau
| |
| − |
| |
| − | dau = randint(1,6)
| |
| − | </source>
| |
| − |
| |
| − | <source lang="phyton">
| |
| − | from random import randint
| |
| − |
| |
| − | print("Programa joc de daus")
| |
| − |
| |
| − | # Simulació del llançament de 3 daus
| |
| − |
| |
| − | dau1 = randint(1,6)
| |
| − | dau2 = randint(1,6)
| |
| − | dau3 = randint(1,6)
| |
| − |
| |
| − | print("Has tret: %d %d %d " %(dau1,dau2,dau3))
| |
| − |
| |
| − | # Determinar quants sisos s'han obtingut en el llançament
| |
| − |
| |
| − | if (dau1 == 6) and (dau2 ==6) and (dau3 ==6):
| |
| − | print("Excel·lent!")
| |
| − | elif ((dau1 == 6) and (dau2 ==6)) or ((dau1 == 6) and (dau3 == 6)) or ((dau2 == 6) and (dau3 == 6)):
| |
| − | print("Molt bé!")
| |
| − | elif (dau1 == 6) or (dau2 ==6) or (dau3 == 6):
| |
| − | print("Regular")
| |
| − | else:
| |
| − | print("Pèssim")
| |
| − | </source>
| |
| − |
| |
| − |
| |
| − | 7. Demaneu tres números enters positius i mostreu-los en ordre descendent.
| |
| − |
| |
| − | Control d'errors: Escriu els missatges pertinents si han introduït un valor negatiu, si no han introduït un enter o si han introduït números iguals.
| |
| − |
| |
| − | <source lang="phyton">
| |
| − | print("Ordenació de tres números enters positius")
| |
| − |
| |
| − | # Entrada dels 3 números
| |
| − |
| |
| − | num1 = input("Introdueix un número: ")
| |
| − | num2 = input("Introdueix un segon número: ")
| |
| − | num3 = input("Introdueix un tercer número: ")
| |
| − |
| |
| − | try:
| |
| − | num1 = int(num1) # En el cas de que no siguin enters saltarà a la zona de excepcions
| |
| − | num2 = int(num2)
| |
| − | num3 = int(num3)
| |
| − |
| |
| − | if num1 >= 0 and num2 >= 0 and num3 >= 0: # Comprovació números positius
| |
| − |
| |
| − | if not (num1 == num2 or num1 == num3 or num2 == num3): # Comprovació números diferents
| |
| − |
| |
| − | if num1 > num2 and num1 > num3:
| |
| − | if num2 > num3:
| |
| − | print(" %d %d %d" %(num1,num2,num3))
| |
| − | else:
| |
| − | print(" %d %d %d" %(num1,num3,num2))
| |
| − |
| |
| − | elif num2 > num3:
| |
| − | if num1 > num3:
| |
| − | print(" %d %d %d" %(num2,num1,num3))
| |
| − | else:
| |
| − | print(" %d %d %d" %(num2,num3,num1))
| |
| − |
| |
| − | elif num1 > num2:
| |
| − | print(" %d %d %d" %(num3,num1,num2))
| |
| − | else:
| |
| − | print(" %d %d %d" %(num3,num2,num1))
| |
| − |
| |
| − | else:
| |
| − | print("Els números no són diferents!")
| |
| − | else:
| |
| − | print("Els números no són enters positius!")
| |
| − |
| |
| − | except ValueError:
| |
| − | print("La entrada és incorrecte: escriu només números enters positius!") # No són números enters
| |
| − | </source>
| |
| − |
| |
| − |
| |
| − | 8. Tres persones les edats de les quals s’han de llegir per teclat, van a un parc d’atraccions. El cost de l’entrada normal és de 20€. Però tenen els següents descomptes:
| |
| − |
| |
| − | :A. Els menors de 5 anys no paguen però han d’anar acompanyats d’algun més gran de 12 anys, sinó no poden entrar
| |
| − | :B. Entre els 5 i els 12 anys paguen el 25 % de l’entrada
| |
| − | :C. Entre els 12 anys i els 16 anys paguen el 50 % de l’entrada
| |
| − | :D. Els més grans de 16 anys paguen l’entrada normal, excepte que els tres estiguin entre els 16 i els 18 anys, que aquest cas com hi ha una oferta, només pagaran dues entrades normals entre els tres.
| |
| − | :E. Els més grans de 65 anys no paguen
| |
| − |
| |
| − | Quan costaran les tres entrades?
| |
| − |
| |
| − | <source lang="phyton">
| |
| − | print("Import entrades parc d'atraccions")
| |
| − |
| |
| − | # Entrada edats de les tres persones
| |
| − |
| |
| − | edat_P1 = int(input("Introdueix l'edat de la primera persona: "))
| |
| − | edat_P2 = int(input("Introdueix l'edat de la segona persona: "))
| |
| − | edat_P3 = int(input("Introdueix l'edat de la tercera persona: "))
| |
| − |
| |
| − | # Comprovem si poden entrar...
| |
| − |
| |
| − | if (((edat_P1 < 5) or (edat_P2 < 5) or (edat_P3 < 5)) and (edat_P1 < 12) and (edat_P2 < 12) and (edat_P3 < 12)):
| |
| − | print("NO ENTREN!!!");
| |
| − | else:
| |
| − |
| |
| − | # Comprovem si tenen dret a l'oferta...
| |
| − |
| |
| − | if ((edat_P1 >= 16) and (edat_P1 < 18) and (edat_P2 >= 16) and (edat_P2 < 18) and (edat_P3 >= 16) and (edat_P3 < 18)):
| |
| − | total = 40
| |
| − | else:
| |
| − | # Fem el calcul per la primera persona
| |
| − |
| |
| − | if ((edat_P1 >= 5) and (edat_P1 < 12)):
| |
| − | ent_P1 = 5
| |
| − | elif ((edat_P1 >= 12) and (edat_P1 < 16)):
| |
| − | ent_P1 = 10
| |
| − | elif ((edat_P1 >= 16) and (edat_P1 < 65)):
| |
| − | ent_P1 = 20
| |
| − | else:
| |
| − | ent_P1 = 0
| |
| − |
| |
| − | # Ho repetim per a la segona persona
| |
| − |
| |
| − | if ((edat_P2 >= 5) and (edat_P2 < 12)):
| |
| − | ent_P2 = 5
| |
| − | elif ((edat_P2 >= 12) and (edat_P2 < 16)):
| |
| − | ent_P2 = 10
| |
| − | elif ((edat_P2 >= 16) and (edat_P2 < 65)):
| |
| − | ent_P2 = 20
| |
| − | else:
| |
| − | ent_P2 = 0
| |
| − |
| |
| − | # Ho repetim per a la tercera persona
| |
| − |
| |
| − | if ((edat_P3 >= 5) and (edat_P3 < 12)):
| |
| − | ent_P3 = 5
| |
| − | elif ((edat_P3 >= 12) and (edat_P3 < 16)):
| |
| − | ent_P3 = 10
| |
| − | elif ((edat_P3 >= 16) and (edat_P3 < 65)):
| |
| − | ent_P3 = 20
| |
| − | else:
| |
| − | ent_P3 = 0
| |
| − |
| |
| − | # Calculem el total de les entrades
| |
| − |
| |
| − | total = ent_P1 + ent_P2 + ent_P3
| |
| − |
| |
| − |
| |
| − | print("El cost de les entrades es de %d €" %total)
| |
| − | </source>
| |
| − |
| |
| − |
| |
| − | == A2.2 Exercicis avaluar expressions lògiques ==
| |
| − |
| |
| − | Avalueu les següents condicions en funció dels valors corresponents de les variables
| |
| − |
| |
| − | 1. ((y<x) or ((y>1) and (x>1)))
| |
| − | <pre>
| |
| − | a) x=1 y=1
| |
| − | b) x=1 y=2
| |
| − | c) x=2 y=1
| |
| − | d) x=2 y=2
| |
| − | e) x=0 y=0
| |
| − | f) x=1 y=0
| |
| − | </pre>
| |
| − | <!--
| |
| − | <pre>
| |
| − | a) x=1 y=1 False
| |
| − | b) x=1 y=2 False
| |
| − | c) x=2 y=1 True
| |
| − | d) x=2 y=2 True
| |
| − | e) x=0 y=0 False
| |
| − | f) x=1 y=0 True
| |
| − | </pre>
| |
| − | -->
| |
| − | 2. (((x>3) and (x<6)) or not((y>3) and (y<6))) <==> (3<x<6) or not (3<y<6)
| |
| − | <pre>
| |
| − | a) x=3 y=3
| |
| − | b) x=3 y=4
| |
| − | c) x=4 y=3
| |
| − | d) x=4 y=4
| |
| − | </pre>
| |
| − | <!--
| |
| − | <pre>
| |
| − | a) x=3 y=3 True
| |
| − | b) x=3 y=4 False
| |
| − | c) x=4 y=3 True
| |
| − | d) x=4 y=4 True
| |
| − | </pre>
| |
| − | -->
| |
| − | 3. (z>x and z>y or x>=y)
| |
| − | <pre>
| |
| − | a) x=1 y=1 z=1
| |
| − | b) x=1 y=2 z=3
| |
| − | c) x=1 y=3 z=2
| |
| − | d) x=2 y=1 z=3
| |
| − | e) x=2 y=3 z=1
| |
| − | f) x=3 y=2 z=1
| |
| − | g) x=3 y=1 z=2
| |
| − | </pre>
| |
| − | <!--
| |
| − | <pre>
| |
| − | a) x=1 y=1 z=1 True
| |
| − | b) x=1 y=2 z=3 True
| |
| − | c) x=1 y=3 z=2 False
| |
| − | d) x=2 y=1 z=3 True
| |
| − | e) x=2 y=3 z=1 False
| |
| − | f) x=3 y=2 z=1 True
| |
| − | g) x=3 y=1 z=2 True
| |
| − | </pre>
| |
| − | -->
| |
| − |
| |
| − | == A2.3 Exercicis trobar expressions lògiques ==
| |
| − |
| |
| − | :*Sent num1, num2, num3, num4 variables numèriques, escriviu l'expressió lògica corresponent a:
| |
| − | <pre>
| |
| − | a) Els valors de num2 i num3 són tots dos superiors al valor de num4.
| |
| − | b) Els valors de num1, num2 i num3 són idèntics.
| |
| − | c) Els valors de num1, num2 i num3 són idèntics però diferents del valor de num4.
| |
| − | d) El valor de num2 està comprès, '''estrictament (<, >)''', entre els valors de num3 i num4, i el valor de num3 és més petit que el valor de num4.
| |
| − | </pre>
| |
| − | <!--
| |
| − | <pre>
| |
| − | a) Els valors de num2 i num3 són tots dos superiors al valor de num4.
| |
| − |
| |
| − | (num2 > num4 and num3 > num4)
| |
| − |
| |
| − | b) Els valors de num1, num2 i num3 són idèntics.
| |
| − |
| |
| − | (num1 == num2 and num1 == num3) <==> num1==num2==num3
| |
| − |
| |
| − | c) Els valors de num1, num2 i num3 són idèntics però diferents del valor de num4.
| |
| − |
| |
| − | (num1 == num2 and num1 == num3 and num1 !=num4) <==> num1==num2==num3!=num4
| |
| − |
| |
| − | d) El valor de num2 està comprès, '''estrictament (<, >)''', entre els valors de num3 i num4, i el valor de num3 és més petit que el valor de num4.
| |
| − |
| |
| − | (num2 > num3 and num2 < num4) <==> num3<num2<num4
| |
| − | </pre>
| |
| − | -->
| |
| − |
| |
| − | :*En un algorisme que analitza els resultats d'exàmens, hi ha 3 variables definides: les variables notaLit, notaCat, notaMat que indiquen respectivament (per a un alumne en particular) les notes de literatura, català i matemàtiques. Totes les notes estan calculades sobre 10 i totes tenen el mateix pes. Escriviu les expressions lògiques corresponents a:
| |
| − | <pre>
| |
| − | a) La mitjana de les tres notes és superior a 5.
| |
| − | b) Les notes de matemàtiques i català són superiors a la mitjana de les tres notes.
| |
| − | c) Hi ha, com a mínim, una nota superior a 5.
| |
| − | d) Totes les notes són superiors a 5.
| |
| − | </pre>
| |
| − | <!--
| |
| − | <pre>
| |
| − | a) La mitjana de les tres notes és superior a 5.
| |
| − |
| |
| − | ((notaLit + notaCat + notaMat) / 3) > 5
| |
| − |
| |
| − | b) Les notes de matemàtiques i català són superiors a la mitjana de les tres notes.
| |
| − |
| |
| − | ((notaMat > (notaLit + notaCat * notaMat) / 3) and (notaCat > (notaLit + notaCat * notaMat) / 3))
| |
| − |
| |
| − | c) Hi ha, com a mínim, una nota superior a 5.
| |
| − |
| |
| − | (notaLit > 5 or notaCat > 5 or notaMat > 5)
| |
| − |
| |
| − | d) Totes les notes són superiors a 5.
| |
| − |
| |
| − | (notaLit > 5 and notaCat > 5 and notaMat > 5)
| |
| − | </pre>
| |
| − | -->
| |
| − | :*Siguin vendesP1, vendesP2 i vendesP3 tres variables enteres que representen les vendes de tres productes.
| |
| − |
| |
| − | :Utilitzant aquestes variables, escriu les expressions que representin les següents afirmacions:
| |
| − | <pre>
| |
| − | a) Les vendes del producte P1 són les més elevades.
| |
| − | b) Cap producte té unes vendes inferiors a 200.
| |
| − | c) Algun producte té unes vendes superiors a 400.
| |
| − | d) La mitjana de vendes és superior a 500.
| |
| − | e) El producte P2 no és el més venut.
| |
| − | f) El total de vendes està entre 500 i 1000.
| |
| − | </pre>
| |
| − | <!--
| |
| − | <pre>
| |
| − | a) Les vendes del producte P1 són les més elevades.
| |
| − |
| |
| − | (vendesP1 > vendesP2 and vendesP1 > vendesP3)
| |
| − |
| |
| − | b) Cap producte té unes vendes inferiors a 200.
| |
| − |
| |
| − | (vendesP1 >= 200 and vendesP2>= 200 and vendesP3 >= 200) ERROR!! A and B and C >= 200 Només analitza el valor C
| |
| − |
| |
| − | c) Algun producte té unes vendes superiors a 400.
| |
| − |
| |
| − | (vendesP1 > 400 or vendesP2 > 400 or vendesP3 > 400)
| |
| − |
| |
| − | d) La mitjana de vendes és superior a 500.
| |
| − |
| |
| − | ((vendesP1 + vendesP2 + vendesP3) / 3) > 500
| |
| − |
| |
| − | e) El producte P2 no és el més venut.
| |
| − |
| |
| − | (vendesP2 < vendesP1 or vendesP2 < vendesP3)
| |
| − |
| |
| − | f) El total de vendes està entre 500 i 1000.
| |
| − |
| |
| − | ((vendesP1 + vendesP2 + vendesP3 >= 500) and (vendesP1 + vendesP2 + vendesP3 <= 1000))
| |
| − | <==> 500 <= vendesP1+vendesP2+vendesP3 <= 1000
| |
| − | </pre>
| |
| − | -->
| |
| − |
| |
| − | == A2.4 Exercicis estructura iterativa ==
| |
| − |
| |
| − | 1. Imprimir els números del 1 al 100.
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | print("Imprimir els números del 1 al 100")
| |
| − |
| |
| − | for i in range(1,101):
| |
| − | print(i ,end= " ")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 2. Imprimir els números parells del 0 al 98.
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | print("Imprimir els números parells del 0 al 98")
| |
| − |
| |
| − | for i in range(0,100,2):
| |
| − | print(i ,end= " ")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 3. Imprimir els números del 100 al 1.
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | print("Imprimir els números del 100 al 1")
| |
| − |
| |
| − | for i in range(100,0,-1):
| |
| − | print(i ,end= " ")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 4. Demanar cinc números i mostrar la suma.
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | print("Demanar cinc números i mostrar la suma")
| |
| − |
| |
| − | suma = 0
| |
| − | for _ in range(5):
| |
| − | valor = int(input("Introdueix un valor: "))
| |
| − | suma += valor
| |
| − | print("La suma és: %d" %suma)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 5. Igual que l'anterior però només sumant els valors més grans de 10.
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | print("Demanar cinc números i sumar els valors que siguin més grans de 10")
| |
| − |
| |
| − | suma = 0
| |
| − | for _ in range(5):
| |
| − | valor = int(input("Introdueix un valor: "))
| |
| − | if valor > 10:
| |
| − | suma += valor
| |
| − | print("La suma és: %d" %suma)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 6. Calcular el producte dels números del 1 al 10.
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | print("Calcular el producte dels números del 1 al 10")
| |
| − |
| |
| − | mult =1
| |
| − | for i in range(1,11):
| |
| − | mult=mult*i
| |
| − | print("EL resultat és: ", mult)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 7. Demanar cinc números enters positius i mostrar el valor més gran.
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | print("Demanar cinc números enters positius i mostrar el valor més gran")
| |
| − |
| |
| − | max = 0
| |
| − | for _ in range(5):
| |
| − | num = int(input("Introdueix un enter positiu: "))
| |
| − | if num > max:
| |
| − | max = num
| |
| − | print("El màxim és: ", max)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 8. Fer un quadrat d'asteriscos. Per exemple si l'usuari introdueix el valor 5, imprimirà:
| |
| − | <pre>
| |
| − | * * * * *
| |
| − | * * * * *
| |
| − | * * * * *
| |
| − | * * * * *
| |
| − | * * * * *
| |
| − | </pre>
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | print("Quadrat n x n d'asteriscos")
| |
| − |
| |
| − | num = int(input("Introdueix número d'asteriscos: "))
| |
| − | for _ in range(num):
| |
| − | print("* "*num)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 9. Com l'anterior però fent un quadrat buit. Per exemple si l'usuari introdueix el valor 5, imprimirà:
| |
| − | <pre>
| |
| − | * * * * *
| |
| − | * *
| |
| − | * *
| |
| − | * *
| |
| − | * * * * *
| |
| − | </pre>
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | print("Quadrat n x n d'asteriscos buit")
| |
| − |
| |
| − | num = int(input("Introdueix número d'asteriscos: "))
| |
| − | for i in range(1, num+1):
| |
| − | if (i == 1 or i == num):
| |
| − | print("* "*num)
| |
| − | else:
| |
| − | print("* ",end='')
| |
| − | print(" "*(num-2), end='')
| |
| − | print("*")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 10. Realitzar un programa que mostri el següent dibuix per a un nombre de línies demanat a l'usuari (a l’exemple 5)
| |
| − | <pre>
| |
| − | *
| |
| − | * *
| |
| − | * * *
| |
| − | * * * *
| |
| − | * * * * *
| |
| − | </pre>
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | print("Dibuix amb asteriscos de num línies")
| |
| − |
| |
| − | num = int(input("Introdueix el número de línies: "))
| |
| − | for i in range(1, num+1):
| |
| − | print("* "*i)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 11. Realitzar un programa que mostri el següent dibuix per a un nombre de línies demanat a l'usuari (a l’exemple 5)
| |
| − | <pre>
| |
| − | * * * * *
| |
| − | * * * *
| |
| − | * * *
| |
| − | * *
| |
| − | *
| |
| − | </pre>
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | print("Dibuix amb asteriscos de num línies")
| |
| − |
| |
| − | num = int(input("Introdueix el número de línies: "))
| |
| − | for i in range(num, 0, -1):
| |
| − | print("* "*i)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 12. Realitzar un programa que mostri el següent dibuix per a un nombre de línies demanat a l'usuari (a l’exemple 5)
| |
| − | <pre>
| |
| − | *
| |
| − | * *
| |
| − | * * *
| |
| − | * * * *
| |
| − | * * * * *
| |
| − | </pre>
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | print("Dibuix amb asteriscos de num línies")
| |
| − |
| |
| − | num = int(input("Introdueix el número de línies: "))
| |
| − | for i in range(1,num+1):
| |
| − | print(" "*(num-i), end='')
| |
| − | print("* "*i)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 13. Realitzar un programa que mostri el següent dibuix per a un nombre de línies demanat a l'usuari (a l’exemple 5)
| |
| − | <pre>
| |
| − | * * * * *
| |
| − | * * * *
| |
| − | * * *
| |
| − | * *
| |
| − | *
| |
| − | </pre>
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | print("Dibuix amb asteriscos de num línies")
| |
| − |
| |
| − | num = int(input("Introdueix el número de línies: "))
| |
| − | for i in range(num):
| |
| − | print(" "*i, end='')
| |
| − | print("* "*(num-i))
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | '''Bucles niuats'''
| |
| − |
| |
| − | 14. Escriu un programa que llegeixi un número num i mostri per pantalla el següent:
| |
| − | <pre>
| |
| − | Exemple num=5
| |
| − | 1
| |
| − | 1 2
| |
| − | 1 2 3
| |
| − | 1 2 3 4
| |
| − | 1 2 3 4 5
| |
| − | </pre>
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | print("Dibuix amb números consecutius")
| |
| − |
| |
| − | num = int(input("Introdueix un número enter positiu: "))
| |
| − | for i in range(1,num+1):
| |
| − | for j in range(1,i+1):
| |
| − | print(j, end='')
| |
| − | print("")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 15. Escriu un programa que llegeixi un número i mostri per pantalla el següent:
| |
| − | <pre>
| |
| − | Exemple num=5
| |
| − |
| |
| − | 5 4 3 2 1
| |
| − | 4 3 2 1
| |
| − | 3 2 1
| |
| − | 2 1
| |
| − | 1
| |
| − | </pre>
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | print("Dibuix amb números consecutius")
| |
| − |
| |
| − | num = int(input("Introdueix un número enter positiu: "))
| |
| − | for i in range(num,0,-1):
| |
| − | for j in range(i,0,-1):
| |
| − | print(j, end='')
| |
| − | print("")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 16. Escriu un programa que llegeixi un número i mostri per pantalla el següent:
| |
| − | <pre>
| |
| − | Exemple num=5
| |
| − |
| |
| − | 1
| |
| − | 2 1
| |
| − | 3 2 1
| |
| − | 4 3 2 1
| |
| − | 5 4 3 2 1
| |
| − | </pre>
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | print("Dibuix amb números consecutius decreixents")
| |
| − |
| |
| − | num = int(input("Introdueix un número enter positiu: "))
| |
| − | for i in range(1,num+1):
| |
| − | for j in range(1,num-i+1):
| |
| − | print(" ", end='')
| |
| − | for j in range(i,0,-1):
| |
| − | print(j, end='')
| |
| − | print("")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 17. Escriu un programa que llegeixi un número imparell i mostri per pantalla el següent:
| |
| − | <pre>
| |
| − | Exemple num=9
| |
| − |
| |
| − | 1
| |
| − | 3 1
| |
| − | 5 3 1
| |
| − | 7 5 3 1
| |
| − | 9 7 5 3 1
| |
| − | </pre>
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | print("Dibuix amb números consecutius decreixents")
| |
| − |
| |
| − | num = int(input("Introdueix un número enter imparell positiu: "))
| |
| − | for i in range(1, num+1, 2):
| |
| − | for j in range(i, 0, -2):
| |
| − | print(j, end=" ")
| |
| − | print("")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 18. Escriu un programa que llegeixi un número enter més gran que 0 i mostri el factorial de tots els números entre 1 i el número introduït.
| |
| − | <pre>
| |
| − | Exemple num = 4
| |
| − |
| |
| − | 1! = 1
| |
| − | 2! = 2 * 1 = 2
| |
| − | 3! = 3 * 2 * 1 = 6
| |
| − | 4! = 4 * 3 * 2 * 1 = 24
| |
| − | </pre>
| |
| − |
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Cálcul del factorial d'un número")
| |
| − |
| |
| − | # Introduim el número preparem la sortida.
| |
| − | num = int(input("Introduiex un número enter: "))
| |
| − |
| |
| − | # Recòrrer tots els números des de l'1 fins el num
| |
| − | for numactual in range(1, num+1):
| |
| − | print("%d! =" %numactual, end= " ")
| |
| − |
| |
| − | # Inicialitzem la variable per calcular el factorial
| |
| − | factorial = 1
| |
| − |
| |
| − | # Tractament diferent del factorial de 1
| |
| − | if numactual > 1:
| |
| − |
| |
| − | # Càlcul del factorial del número numactual
| |
| − | for n in range(numactual,0, -1):
| |
| − |
| |
| − | # Tractament diferent del cas 1
| |
| − | if n == 1 :
| |
| − | print("%d = " %n, end= " ")
| |
| − | else :
| |
| − | print("%d * " %n, end= " ")
| |
| − |
| |
| − | # Acumuelm el producte a cada iteració
| |
| − | factorial *= n
| |
| − |
| |
| − | # Escribim el resultat del factorial del númeor nuactual
| |
| − | print(factorial)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 19. Escriu un programa que mostri la següent sortida:
| |
| − |
| |
| − | <pre>
| |
| − | ZYWXVUTSRQPONMLKJIHGFEDCBA
| |
| − | YWXVUTSRQPONMLKJIHGFEDCBA
| |
| − | WXVUTSRQPONMLKJIHGFEDCBA
| |
| − | XVUTSRQPONMLKJIHGFEDCBA
| |
| − | VUTSRQPONMLKJIHGFEDCBA
| |
| − | UTSRQPONMLKJIHGFEDCBA
| |
| − | TSRQPONMLKJIHGFEDCBA
| |
| − | SRQPONMLKJIHGFEDCBA
| |
| − | RQPONMLKJIHGFEDCBA
| |
| − | QPONMLKJIHGFEDCBA
| |
| − | PONMLKJIHGFEDCBA
| |
| − | ONMLKJIHGFEDCBA
| |
| − | NMLKJIHGFEDCBA
| |
| − | MLKJIHGFEDCBA
| |
| − | LKJIHGFEDCBA
| |
| − | KJIHGFEDCBA
| |
| − | JIHGFEDCBA
| |
| − | IHGFEDCBA
| |
| − | HGFEDCBA
| |
| − | GFEDCBA
| |
| − | FEDCBA
| |
| − | EDCBA
| |
| − | DCBA
| |
| − | CBA
| |
| − | BA
| |
| − | A
| |
| − | </pre>
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Abecedari invers")
| |
| − |
| |
| − | # Inicialitzem codi lletra final sempre la 'A'
| |
| − | codiFinal=ord('A')
| |
| − |
| |
| − | # Codi lletra final varia en cada línia
| |
| − | for codiInicial in range(ord('Z'),ord('A')-1,-1):
| |
| − |
| |
| − | # Recorregut de tots els codis: codiInicial Fixe i codiFinal va variant...
| |
| − | for codiLletra in range(codiInicial,codiFinal,-1):
| |
| − | print(chr(codiLletra), end="")
| |
| − |
| |
| − | # Salt de línia
| |
| − | print("")
| |
| − | -->
| |
| − | 20. Realitzar un programa que mostri el següent dibuix per a un nombre de línies demanat a l'usuari (a l’exemple 5)
| |
| − | <pre>
| |
| − | 1 2 3 4 5
| |
| − | 1 2 3 4
| |
| − | 1 2 3
| |
| − | 1 2
| |
| − | 1
| |
| − | </pre>
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Dibuix amb números consecutius")
| |
| − |
| |
| − | num = int(input("Introdueix un número enter: "))
| |
| − | for i in range(num, 0, -1):
| |
| − | for j in range(1, i+1):
| |
| − | print(j, end=" ")
| |
| − | print("")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 21. Realitzar un programa que mostri el següent dibuix per a un nombre de línies demanat a l'usuari (a l’exemple 5)
| |
| − | <pre>
| |
| − | 1 1 1 1 1
| |
| − | 2 2 2 2
| |
| − | 3 3 3
| |
| − | 4 4
| |
| − | 5
| |
| − | </pre>
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Dibuix amb números")
| |
| − |
| |
| − | num = int(input("Introdueix un número enter: "))
| |
| − | for i in range(1, num+1):
| |
| − | for j in range(num, i-1, -1):
| |
| − | print(i, end=" ")
| |
| − | print("")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 22. Realitzar un programa que mostri el següent dibuix per a un nombre de línies demanat a l'usuari (a l’exemple 5)
| |
| − | <pre>
| |
| − | 5 5 5 5 5
| |
| − | 4 4 4 4
| |
| − | 3 3 3
| |
| − | 2 2
| |
| − | 1
| |
| − | </pre>
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Dibuix amb números")
| |
| − |
| |
| − | num = int(input("Introdueix un número enter: "))
| |
| − | for i in range(num, 0, -1):
| |
| − | for j in range(1, i+1):
| |
| − | print(i, end=" ")
| |
| − | print("")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 23. Realitzar un programa que mostri el següent dibuix per a un nombre de línies demanat a l'usuari (a l’exemple 7)
| |
| − | <pre>
| |
| − | 1 1 1 1 1 1 1
| |
| − | 1 2 3 4 5 6
| |
| − | 3 3 3 3 3
| |
| − | 1 2 3 4
| |
| − | 5 5 5
| |
| − | 1 2
| |
| − | 7
| |
| − | </pre>
| |
| − | <!--
| |
| − | Amb dos fors:
| |
| − | <source lang = "python">
| |
| − | print("Dibuix amb números")
| |
| − |
| |
| − | num = int(input("Introdueix un número enter: "))
| |
| − | for i in range(1, num+1):
| |
| − | for j in range(1, num-i+2):
| |
| − | if i%2==1 :
| |
| − | print(i, end=" ")
| |
| − | else:
| |
| − | print(j, end=" ")
| |
| − | print("")
| |
| − | </source>
| |
| − | -->
| |
| − | <!--
| |
| − | Amb tres fors:
| |
| − | <source lang = "python">
| |
| − | print("Dibuix amb números")
| |
| − |
| |
| − | num = int(input("Introdueix un número enter: "))
| |
| − | for i in range(1, num+1):
| |
| − | if i%2==1 :
| |
| − | for j in range(1, num-i+2):
| |
| − | print(i, end=" ")
| |
| − | else:
| |
| − | for j in range(1, num-i+2):
| |
| − | print(j, end=" ")
| |
| − | print("")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 24. Realitzar un programa que mostri el següent dibuix per a un nombre de línies demanat a l'usuari (a l’exemple 7)
| |
| − | <pre>
| |
| − | 7 7 7 7 7 7 7
| |
| − | 6 5 4 3 2 1
| |
| − | 5 5 5 5 5
| |
| − | 4 3 2 1
| |
| − | 3 3 3
| |
| − | 2 1
| |
| − | 1
| |
| − | </pre>
| |
| − |
| |
| − | <!--
| |
| − | Amb dos fors:
| |
| − | <source lang = "python">
| |
| − | print("Dibuix amb números")
| |
| − |
| |
| − | num = int(input("Introdueix un número enter: "))
| |
| − | for i in range(num, 0, -1):
| |
| − | for j in range(i, 0, -1):
| |
| − | if i%2==1 :
| |
| − | print(i, end=" ")
| |
| − | else:
| |
| − | print(j, end=" ")
| |
| − | print("")
| |
| − | </source>
| |
| − | -->
| |
| − | <!--
| |
| − | Amb tres fors:
| |
| − | <source lang="java">
| |
| − | print("Dibuix amb números")
| |
| − |
| |
| − | num = int(input("Introdueix un número enter: "))
| |
| − | for i in range(num, 0, -1):
| |
| − | if i%2==1 :
| |
| − | for j in range(i, 0, -1):
| |
| − | print(i, end=" ")
| |
| − | else:
| |
| − | for j in range(i, 0, -1):
| |
| − | print(j, end=" ")
| |
| − | print("")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | == A2.5 Exercicis estructura iterativa: recorregut ==
| |
| − |
| |
| − | 1. Escriu un programa que llegeixi números enters positius i mostri el més petit i el més gran. El programa finalitzarà quan ens introdueixin un número negatiu.
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | '''
| |
| − | Escriu un programa que llegeixi números enters positius i mostri el més petit
| |
| − | i el més gran. El programa finalitzarà quan ens introdueixin un número
| |
| − | negatiu.
| |
| − | '''
| |
| − | print("Més gran i més petit d'una seqüència de números")
| |
| − |
| |
| − | # Accedir al primer element
| |
| − | num = int(input("Introueix un valor positiu (per acabar negatiu): "))
| |
| − |
| |
| − | # Inicialitzar el tractament
| |
| − | mesPetit = num
| |
| − | mesGran = num
| |
| − |
| |
| − | # Mentre no últim element
| |
| − | while num>= 0:
| |
| − |
| |
| − | # Tractar l'element
| |
| − | if num > mesGran:
| |
| − | mesGran = num
| |
| − | if num < mesPetit:
| |
| − | mesPetit = num
| |
| − |
| |
| − | #Obtenir següent element
| |
| − | num = int(input("Introueix un valor positiu (per acabar negatiu): "))
| |
| − |
| |
| − | # Tractament final
| |
| − | print("El valor més gran és: ", mesGran)
| |
| − | print("El valor més petit és: ", mesPetit)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 2. Donat un número llegit per teclat, calcula el número de dígits que té.
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | '''
| |
| − | Donat un número llegit per teclat, calcula el número de dígits que té.
| |
| − | '''
| |
| − | print("Càlcul del nombre de dígits d'un número")
| |
| − |
| |
| − | # Accedir al primer element
| |
| − | num = int(input("Introdueix un valor positiu: "))
| |
| − |
| |
| − | # Inicialitzar tractament
| |
| − |
| |
| − | digits = 0
| |
| − |
| |
| − | # Mentre no ultim element
| |
| − | while num > 0:
| |
| − |
| |
| − | # Tractar_element
| |
| − | digits += 1
| |
| − |
| |
| − | # Obtenir següent element
| |
| − | num = num // 10
| |
| − |
| |
| − | # Tractament_final
| |
| − | print("El número té %d dígits" %digits)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 3. Donat un número llegit per teclat, realitzar la suma de tots els dígits del número.
| |
| − |
| |
| − | Per exemple si introdueixen el valor 1238, s'imprimirà el valor : 1+2+3+8 --> 14
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | '''
| |
| − | Donat un número llegit per teclat, realitzar la suma de tots els dígits del número.
| |
| − | '''
| |
| − | print("Suma de tots els digits d'un número")
| |
| − |
| |
| − | # Accedir al primer element
| |
| − | num = int(input("Introdueix un valor positiu: "))
| |
| − |
| |
| − | # Inicialitzar tractament
| |
| − | suma = 0
| |
| − |
| |
| − | # Mentre no ultim element
| |
| − | while num > 0:
| |
| − |
| |
| − | # Tractar_element
| |
| − | suma=suma+(num%10)
| |
| − |
| |
| − | # Obtenir següent element
| |
| − | num=num//10
| |
| − |
| |
| − | # Tractament_final
| |
| − | print("La suma dels dígits és: ", suma)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 4. Donat un número llegit per teclat, realitzar la suma de tots els dígits parells del número.
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | '''
| |
| − | Donat un número llegit per teclat, realitzar la suma de tots els dígits parells del número.
| |
| − | '''
| |
| − | print("Suma de tots els digits d'un número")
| |
| − |
| |
| − | # Accedir al primer element
| |
| − | num = int(input("Introdueix un valor positiu: "))
| |
| − |
| |
| − | # Inicialitzar tractament
| |
| − | suma = 0
| |
| − |
| |
| − | # Mentre no ultim element
| |
| − | while num > 0:
| |
| − |
| |
| − | # Tractar_element
| |
| − | mod = num % 10
| |
| − | if mod % 2 == 0:
| |
| − | suma = suma + mod
| |
| − |
| |
| − | # Obtenir següent element
| |
| − | num=num//10
| |
| − |
| |
| − | # Tractament_final
| |
| − | print("La suma dels dígits parells és: ", suma)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 5. Donat un número llegit per teclat, determina el número de dígits més grans que 5.
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | '''
| |
| − | Donat un número llegit per teclat, determina el número de dígits més grans que 5.
| |
| − | '''
| |
| − | print("Determinar el número de dígits més grans que 5 d'un número")
| |
| − |
| |
| − | # Accedir al primer element
| |
| − | num = int(input("Introdueix un valor positiu: "))
| |
| − |
| |
| − | # Inicialitzar tractament
| |
| − | quants = 0
| |
| − |
| |
| − | # Mentre no ultim element
| |
| − | while num > 0:
| |
| − |
| |
| − | # Tractar_element
| |
| − | if num%10>5:
| |
| − | quants +=1
| |
| − |
| |
| − | # Obtenir següent element
| |
| − | num=num//10
| |
| − |
| |
| − | # Tractament_final
| |
| − | print("Hi ha %d dígits més grans que 5" %quants)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 6. Escriu un programa que llegeixi números enters positius (finalitzarà amb la introducció de -1) i mostri totes les parelles de números consecutius que apareixen a la seqüència.
| |
| − |
| |
| − | Per exemple si la seqüència de números és: 7 10 11 23 4 5 8 10 11 12 -1, mostrarà: 10 11, 4 5, 10 11, 11 12
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | '''
| |
| − | Escriu un programa que llegeixi números enters positius (finalitzarà amb la introducció de -1)
| |
| − | i mostri totes les parelles de números consecutius que apareixen a la seqüència.
| |
| − | '''
| |
| − | print("Mostrar números consecutius d'una segqüencia")
| |
| − |
| |
| − | # Accedir al primer element
| |
| − | actual = int(input("Introdueix un valor positiu (per acabar -1): " ))
| |
| − | anterior = actual;
| |
| − |
| |
| − | # Mentre no ultim element
| |
| − | while actual != -1:
| |
| − |
| |
| − | # Tractar_element
| |
| − | if actual == anterior + 1:
| |
| − | print("%d - %d" %(anterior,actual))
| |
| − |
| |
| − | # Obtenir següent element
| |
| − | anterior = actual
| |
| − | actual = int(input("Introdueix un valor positiu (per acabar -1): " ))
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | == A2.6 Exercicis estructura iterativa: cerca ==
| |
| − |
| |
| − |
| |
| − | 1. Escriu un programa que indiqui si existeix o no algun múltiple de 5 en una seqüència de números naturals finalitzada en -1 (seria interessant que una vegada trobat un múltiple, el programa no continués executant-se).
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | '''
| |
| − | Indica si existeix o no algun múltiple de 5 en una seqüència de números naturals finalitzada en -1
| |
| − | '''
| |
| − |
| |
| − | print("Cerca d'un múltiple de 5")
| |
| − |
| |
| − | # accedir al primer element
| |
| − | num = int(input("Introdueix un valor positiu (per acabar -1): "))
| |
| − |
| |
| − | # Mentre no últim element i no element trobat fer
| |
| − | while num!=-1 and num % 5 !=0 :
| |
| − |
| |
| − | # obtenir següent element
| |
| − | num = int(input("Introdueix un valor positiu (per acabar -1): "))
| |
| − |
| |
| − | # tractament final
| |
| − | if num%5==0 :
| |
| − | print("%d és múltiple de 5" %num)
| |
| − | else :
| |
| − | print("No hi ha cap múltiple")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 2. Escriu un programa que determini si un número enter es primer o no (recorda que un número primer només és divisible per 1 i per ell mateix).
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | '''
| |
| − | Indica si un número enter és primer o no
| |
| − | '''
| |
| − |
| |
| − | print("Número primer?")
| |
| − |
| |
| − | # accedir al primer element
| |
| − | divisor=2;
| |
| − |
| |
| − | # inicialitzar tractament
| |
| − | num = int(input("Introdueix un valor enter positiu: "))
| |
| − |
| |
| − | # Mentre no últim element i no element trobat fer
| |
| − | while divisor<num and num%divisor!=0 :
| |
| − |
| |
| − | # obtenir següent element
| |
| − | divisor += 1
| |
| − |
| |
| − | # tractament final
| |
| − | if divisor==num:
| |
| − | print("Primer")
| |
| − | else :
| |
| − | print("No és primer")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 3. Escriu un programa que vagi llegint notes (per finalitzar -1) i indiqui si hi ha com a mínim tres suspesos. Només cal dir sí o no.
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | '''
| |
| − | Indica si hi ha un mínim de 3 suspesos en una seqüència de notes
| |
| − | '''
| |
| − |
| |
| − | print("Hi ha un mínim de 3 suspesos?")
| |
| − |
| |
| − | # accedir al primer element
| |
| − | nota = int(input("Introdueix un valor positiu (per acabar -1): "))
| |
| − |
| |
| − | # inicialitzar tractament
| |
| − |
| |
| − | susp = 0;
| |
| − |
| |
| − | # Mentre no últim element i no element trobat fer
| |
| − | while nota != -1 and susp < 3 :
| |
| − |
| |
| − | # tractar element
| |
| − | if nota < 5 :
| |
| − | susp += 1
| |
| − |
| |
| − | # obtenir següent element
| |
| − | if susp < 3 :
| |
| − | nota = int(input("Introdueix un valor positiu (per acabar -1): "))
| |
| − |
| |
| − | # tractament final
| |
| − | if susp == 3 :
| |
| − | print("Sí")
| |
| − | else :
| |
| − | print("No")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 4. Escriu un programa que vagi llegint números positius (per finalitzar -1) i indiqui si tots són parells.
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | '''
| |
| − | Indica si tots els números són parells
| |
| − | '''
| |
| − |
| |
| − | print("Tots els números són parells?")
| |
| − |
| |
| − | # accedir al primer element
| |
| − | num = int(input("Introdueix un valor positiu (per acabar -1): "))
| |
| − |
| |
| − | # Mentre no últim element i no element trobat fer
| |
| − | while num != -1 and num % 2 == 0 :
| |
| − |
| |
| − | # obtenir següent element
| |
| − | num = int(input("Introdueix un valor positiu (per acabar -1): "))
| |
| − |
| |
| − | # tractament final
| |
| − | if num==-1 :
| |
| − | print("Tots parells")
| |
| − | else :
| |
| − | print("No són tots parells")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 5. Escriu un programa que llegeixi un número i indiqui si tots els dígits són parells.
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | '''
| |
| − | Indica si tots els dígits d'un número són parells
| |
| − | '''
| |
| − |
| |
| − | print("Tots els dígits d'un número són parells?")
| |
| − |
| |
| − | # accedir al primer element
| |
| − | num = int(input("Introdueix un valor enter positiu: "))
| |
| − |
| |
| − | # Mentre no últim element i no element trobat fer
| |
| − | while num > 0 and num % 2 == 0 :
| |
| − |
| |
| − | # obtenir següent element
| |
| − | num = num // 10;
| |
| − |
| |
| − | # tractament final
| |
| − | if num == 0 :
| |
| − | print("Tots parells")
| |
| − | else :
| |
| − | print("No són tots parells")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 6. Escriu un programa que vagi llegint números positius (per finalitzar -1) i indiqui si cada valor és més gran que l'anterior.
| |
| − | <!--
| |
| − | <source lang="python">
| |
| − | '''
| |
| − | Indica si una seqüència de números és estrictament ascendent
| |
| − | '''
| |
| − |
| |
| − | print("La seqüència de números és estrictament ascendent?")
| |
| − |
| |
| − | # accedir al primer element
| |
| − | num = int(input("Introdueix un valor positiu (per acabar -1): "))
| |
| − | anterior = -1
| |
| − |
| |
| − | # Mentre no últim element i no element trobat fer
| |
| − | while num != -1 and anterior < num :
| |
| − |
| |
| − | # obtenir següent element
| |
| − | anterior = num
| |
| − | num = int(input("Introdueix un valor positiu (per acabar -1): "))
| |
| − |
| |
| − | # tractament final
| |
| − | if num == -1 :
| |
| − | print("Es compleix")
| |
| − | else :
| |
| − | print("No es compleix")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | == A4.1 Exercicis Cadenes ==
| |
| − |
| |
| − | 1. L’última lletra del DNI pot calcular-se a partir del seus números. Per a això només has de dividir el número per 23 i quedar-te amb la resta. Fes un programa per calcular la lletra d’un DNI. La lletra que correspon a cada número la tens en aquesta taula:
| |
| − | <pre>
| |
| − | 0 - T
| |
| − | 1 - R
| |
| − | 2 - W
| |
| − | 3 - A
| |
| − | 4 - G
| |
| − | 5 - M
| |
| − | 6 - Y
| |
| − | 7 - F
| |
| − | 8 - P
| |
| − | 9 - D
| |
| − | 10 - X
| |
| − | 11 - B
| |
| − | 12 - N
| |
| − | 13 - J
| |
| − | 14 - Z
| |
| − | 15 - S
| |
| − | 16 - Q
| |
| − | 17 - V
| |
| − | 18 - H
| |
| − | 19 - L
| |
| − | 20 - C
| |
| − | 21 - K
| |
| − | 22 – E
| |
| − | </pre>
| |
| − |
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Obtenció lletra DNI")
| |
| − |
| |
| − | # Constants
| |
| − | NUMLLETRES = 23
| |
| − | LLETRESDNI = "TRWAGMYFPDXBNJZSQVHLCKE"
| |
| − |
| |
| − | # Demanem número DNI
| |
| − | numDNI = int(input("Introdueix número d'un DNI: "))
| |
| − |
| |
| − | # Càlcul de la posició de la lletra
| |
| − | numCalcul = numDNI % NUMLLETRES
| |
| − |
| |
| − | # Mostrar la lletra
| |
| − | print("El número de DNI: %d li correspon la lletra: %s" %(numDNI,LLETRESDNI[numCalcul]))
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 2. Fes un programa per que verifiqui que la lletra d’un DNI es correspon amb el seu número:
| |
| − |
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Verificació lletra DNI")
| |
| − |
| |
| − | # Constants
| |
| − | NUMLLETRES = 23
| |
| − | LLETRESDNI = "TRWAGMYFPDXBNJZSQVHLCKE"
| |
| − |
| |
| − | # Demanem DNI
| |
| − | dni = input("Introdueix un DNI: ")
| |
| − |
| |
| − | # Lletra i número del DNI
| |
| − | lletraDNI = dni[-1]
| |
| − | numDNI = int(dni[:-1])
| |
| − |
| |
| − | # Càlcul de la posició de la lletra
| |
| − | numCalcul = numDNI % NUMLLETRES
| |
| − |
| |
| − | # Verificació
| |
| − | if lletraDNI == LLETRESDNI[numCalcul]:
| |
| − | print("ÉS correcte!")
| |
| − | else:
| |
| − | print("És incorrecte!")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 3. Genera un programa que encripti una cadena de caràcters. Per exemple: '“avadakedavra”' encriptat es '“bwbeblfebwsb”' i el mètode d’encriptació és canviar un caràcter pel seu successor a l’abecedari (el successor de ‘z’ és ‘a’).
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Encriptació d'una cadena")
| |
| − |
| |
| − | # Constants
| |
| − | LLETRES = "abcdefghijklmnopqrstvwxyza"
| |
| − |
| |
| − | # Demanem cadena a encriptar
| |
| − | cadena = input("Introdueix la cadena a encriptar: ")
| |
| − |
| |
| − | # Encriptació
| |
| − | cadenaEncriptada =""
| |
| − | for carac in cadena:
| |
| − | posCaracter = LLETRES.find(carac)
| |
| − | cadenaEncriptada += LLETRES[posCaracter+1]
| |
| − |
| |
| − | # Mostrar el text encriptat
| |
| − | print("Cadena encriptada:", cadenaEncriptada)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 4. Genera un programa que encripti una text de caràcters. Per exemple: '“hola que tal”' encriptat es '“ipmb@rvf@ubm”' i el mètode d’encriptació és canviar un caràcter pel seu successor a l’abecedari (el successor de ‘z’ és ‘a’ i el caràcter ' ' es substitueix per '@').
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Encriptació d'un text")
| |
| − |
| |
| − | # Constants
| |
| − | LLETRES = "abcdefghijklmnopqrstvwxyza @"
| |
| − |
| |
| − | # Demanem número DNI
| |
| − | text = input("Introdueix el text a encriptar: ")
| |
| − |
| |
| − | # Encriptació
| |
| − | textEncriptat =""
| |
| − | for carac in text:
| |
| − | posCaracter = LLETRES.find(carac)
| |
| − | textEncriptat += LLETRES[posCaracter+1]
| |
| − |
| |
| − | # Mostrar el text encriptat
| |
| − | print("Text encriptat:", textEncriptat)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 5. Feu un programa que si li passem un nom i un cognom com a paràmetres ens doni la benvinguda:
| |
| − | <pre>
| |
| − | Benvingut Sr. ...
| |
| − | i si no l'hi donem digui :
| |
| − | Hola desconegut.
| |
| − | </pre>
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Programa amb arguments ")
| |
| − |
| |
| − | # Importar llibreries
| |
| − | import sys
| |
| − |
| |
| − | # Comprovar número d'arguments
| |
| − | if(len(sys.argv) == 3):
| |
| − |
| |
| − | # Mostrar nom i cognom
| |
| − | print ("Benvingut Sr./Sra. %s %s" %(sys.argv[1], sys.argv[2]))
| |
| − |
| |
| − | # Missatge si no hi ha 2 arguments
| |
| − | else:
| |
| − | print ("Aquest programa requereix dos arguments")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 6. Feu un programa que calculi la mitjana aritmètica dels valors passats com a paràmetres. Si no es passa cap paràmetre sortirà un missatge d’error i si el primer paràmetre és '''–ajut''' el programa traurà una petita explicació del funcionament.
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Programa amb arguments: Mitjana de n números")
| |
| − |
| |
| − | # Importar llibreries
| |
| − | import sys
| |
| − |
| |
| − | # Comprovar número d'arguments
| |
| − | if(len(sys.argv) > 1):
| |
| − |
| |
| − | # Comprovar si necessiten l'ajuda
| |
| − | if(sys.argv[1] == "-ajut"):
| |
| − | print ("Aquest programa calcula la mitjana dels valors passats com a arguments")
| |
| − |
| |
| − | # Calculem la mitja dels arguments
| |
| − | else:
| |
| − | suma = 0
| |
| − | for i in range(1,len(sys.argv)):
| |
| − | suma += int(sys.argv[i])
| |
| − | print ("Resultat de la mitjana és:", suma/(len(sys.argv)-1))
| |
| − | # Missatge si no hi ha 2 arguments
| |
| − | else:
| |
| − | print ("Aquest programa requereix arguments")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 7. Genereu un programa anomenat '''ComptaAsString''' que compti quantes lletres 'a' conté una cadena de text. El text per tractar pot ser qualsevol i el podeu declarar com una constant en el codi font.
| |
| − | <!--
| |
| − | versió 1
| |
| − | <source lang = "python">
| |
| − | print("Programa compar a's d'una frase")
| |
| − |
| |
| − | # Entrada: frase a avaluar
| |
| − | frase = input("Introdueix la frase a avaluar: ")
| |
| − |
| |
| − | # Inicialitzar variables
| |
| − | comptador = 0
| |
| − |
| |
| − | # Comptar a's
| |
| − | for i in range(len(frase)):
| |
| − | if frase[i] == 'a':
| |
| − | comptador += 1
| |
| − |
| |
| − | # Mostrar el resultat
| |
| − | print("Hi ha %d a's en la frase" %comptador)
| |
| − |
| |
| − | </source>
| |
| − | -->
| |
| − | <!--
| |
| − | versio 2
| |
| − | <source lang = "python">
| |
| − |
| |
| − | print("Programa comptar a's d'una frase")
| |
| − |
| |
| − | # Entrada: frase a avaluar. Per ex: "La ment que s'obre a una nova idea, mai torna a la seva mida original."
| |
| − | frase = input("Introdueix la frase a avaluar: "
| |
| − |
| |
| − | # Inicialitzar variables
| |
| − | comptador = 0
| |
| − | pos = frase.find("a")
| |
| − | # Comptar a's
| |
| − | while pos != -1 :
| |
| − | comptador += 1
| |
| − | pos = frase.find("a",pos+1)
| |
| − | # Mostrar el resultat
| |
| − | print ("Hi ha %d a's en la frase" %comptador)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 8. Fes un programa que, primer demani a l’usuari escriure una rere l’altra, tres paraules que només continguin lletres minúscules. A continuació el programa ha d’escriure quina és la paraula més llarga i quina és l’alfabèticament menor.
| |
| − |
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Programa ordenar paraules")
| |
| − |
| |
| − | # Entrada de les paraules
| |
| − | par1 = input("Introdueix la primera paraula: ")
| |
| − | par2 = input("Introdueix la primera paraula: ")
| |
| − | par3 = input("Introdueix la primera paraula: ")
| |
| − |
| |
| − | # Cerquem la paraula més llarga
| |
| − | mesLlarga = par1
| |
| − | if len(mesLlarga) < len(par2):
| |
| − | mesLlarga = par2
| |
| − | if len(mesLlarga) < len(par3):
| |
| − | mesLlarga = par3
| |
| − |
| |
| − | # Cerquem la paraula lexicogràficament menor
| |
| − | alfMenor = par1
| |
| − | if alfMenor > par2:
| |
| − | alfMenor = par2
| |
| − | if alfMenor > par3:
| |
| − | alfMenor = par3
| |
| − |
| |
| − | # Reultats
| |
| − | print("La paraula més llarga és: ", mesLlarga)
| |
| − | print("La paraula lexicogràficament menor és: ", alfMenor)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 9. Fes un programa que llegeixi una frase i un número enter N i ens digui quines i quantes paraules tenen longitud N.
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Programa paraules de N caràcters")
| |
| − |
| |
| − | # Entrada de dades
| |
| − | frase = input("Introdueix la frase a tractar: ")
| |
| − | num = int(input("Introdueix el número de caràcters: "))
| |
| − |
| |
| − | # Inicialització de variables
| |
| − | numParaules = 0
| |
| − |
| |
| − | # Recorregut de la frase mostrant les paraules de N caràcters
| |
| − | print("Paraules de %d caràcters: " %num, end =' ')
| |
| − | for par in frase.split():
| |
| − | if len(par) == num:
| |
| − | print(par, end=' ')
| |
| − | numParaules +=1
| |
| − | print("Num paraules: ", numParaules)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 10. Fes un programa que llegeixi una frase i la mostri invertida.
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Programa mostrar frase invertida")
| |
| − |
| |
| − | # Entrada de dades
| |
| − | frase = input("Introdueix la frase a invertir: ")
| |
| − |
| |
| − | # Recorregut de la frase caràcter a caràcter començant pel final
| |
| − | print("Frase invertida: ", end =' ')
| |
| − | for car in range(len(frase)-1, -1, -1):
| |
| − | print(frase[car], end='')
| |
| − | print()
| |
| − | </source>
| |
| − | -->
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Programa mostrar frase invertida")
| |
| − |
| |
| − | # Entrada de dades
| |
| − | frase = input("Introdueix la frase a invertir: ")
| |
| − |
| |
| − | # Imprimir la frase invertida
| |
| − | print("Frase invertida: %s" %''.join(reversed(frase)))
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 11. Volem un programa per treballar amb cadenes que mitjançant un menú ens permeti les següents opcions:
| |
| − |
| |
| − | :*Mostrar els n primers caràcters d’una cadena
| |
| − | :*Mostrar els n últims caràcters d’una cadena (d’esquerra a dreta)
| |
| − | :*Eliminar els espais en blanc que hi hagi al final de la cadena
| |
| − | :*Eliminar els espais en blanc que hi hagi al principi de la cadena
| |
| − | :*Eliminar d’una cadena els n caràcters que apareixen a partir de la posició p
| |
| − | :*Inserir una cadena dins d’una altra a partir de la posició p
| |
| − | :*Comptar el nombre de vegades que apareix una cadena dins d’una altra
| |
| − | :*Esborrar totes les aparicions d’una cadena dins d’una altra
| |
| − |
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | salir = False
| |
| − | while not salir:
| |
| − | print("Menú de opciones")
| |
| − | print("----------------")
| |
| − | print("1. Mostrar els n primers caràcters d’una cadena\n"
| |
| − | + "2. Mostrar els n últims caràcters d’una cadena (d’esquerra a dreta)\n"
| |
| − | + "3. Eliminar els espais en blanc que hi hagi al final de la cadena\n"
| |
| − | + "4. Eliminar els espais en blanc que hi hagi al principi de la cadena\n"
| |
| − | + "5. Eliminar d’una cadena els n caràcters que apareixen a partir de la posició p\n"
| |
| − | + "6. Inserir una cadena dins d’una altra a partir de la posició p\n"
| |
| − | + "7. Comptar el nombre de vegades que apareix una cadena dins d’una altra\n"
| |
| − | + "8. Esborrar totes les aparicions d’una cadena dins d’una altra\n"
| |
| − | + "9. Sortir\n")
| |
| − | opcion = int(input("Introdueix una opció de menú: "))
| |
| − | cadena = input("Introdueix una cadena de text: ")
| |
| − | #numeric = int(input("Has d'introduir un valor numèric: "))
| |
| − | if opcion == 1:
| |
| − | scaner = int(input("Introdueix el nombre de caràcters a mostrar: "))
| |
| − | print(cadena[0:scaner])
| |
| − | elif opcion == 2:
| |
| − | scaner = int(input("Introdueix el nombre de caràcters a mostrar: "))
| |
| − | print(cadena[-scaner:])
| |
| − | elif opcion == 3:
| |
| − | print(cadena.rstrip())
| |
| − | elif opcion == 4:
| |
| − | print(cadena.lstrip())
| |
| − | elif opcion == 5:
| |
| − | # Opción 1
| |
| − | scaner = int(input("Introdueix el nombre de caràcters a eliminar: "))
| |
| − | posini = int(input("Introdueix la posició inicial: "))
| |
| − | posfin = len(cadena)
| |
| − | print(cadena[:-(posfin-posini)] + cadena[scaner+posini:posfin])
| |
| − | # Opción 2
| |
| − | #for car in range(len(cadena)):
| |
| − | # if car < posini or car >= (scaner+posini):
| |
| − | # print(cadena[car], end='')
| |
| − | #print("\n")
| |
| − | elif opcion == 6:
| |
| − | scaner = input("Introdueix la cadena(palabra) a insertar: ");
| |
| − | posini = int(input("Introdueix la posició de la cadena: "));
| |
| − | cadsplit = cadena.split()
| |
| − | cadsplit.insert(posini-1, scaner)
| |
| − | cadenafinal = ' '.join(cadsplit)
| |
| − | print(cadenafinal)
| |
| − | elif opcion == 7:
| |
| − | scaner = input("Introdueix la cadena a buscar: ");
| |
| − | ocurrencias = cadena.count(scaner)
| |
| − | print(ocurrencias)
| |
| − | elif opcion == 8:
| |
| − | scaner = input("Introdueix la cadena a borrar: ");
| |
| − | replaced_text = cadena.replace(scaner, '')
| |
| − | print(replaced_text)
| |
| − | #Opció 2
| |
| − | posIni = 0
| |
| − | posFin = cadena.find(scaner)
| |
| − | while posFin != -1:
| |
| − | cadAux += cadena[posIni:posFin]
| |
| − | posIni = posFin + len(scaner)
| |
| − | posFin = frase.find(scaner, posIni)
| |
| − | cadAux += cadena[posIni:]
| |
| − | cadena = cadAux
| |
| − | print("Frase sense la cadena: ", cadena)
| |
| − | #Opció 3
| |
| − | #posini = 0
| |
| − | #cadfin=[]
| |
| − | #for par in cadena.split():
| |
| − | #if par != scaner:
| |
| − | #cadfin.insert(posini, par)
| |
| − | #posini +=1
| |
| − | #print(" ".join(cadfin))
| |
| − | elif opcion == 9:
| |
| − | salir = True
| |
| − | print("¡Adiós!")
| |
| − | else:
| |
| − | print ("Introduce un numero entre 1 y 9\n")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 12. Escriu un programa per comparar dues cadenes introduïdes per l’usuari. L’aplicació
| |
| − | rebrà com a entrada el nombre de caràcters a comparar i l’índex inicial de cada cadena
| |
| − | de la comparació. L’aplicació haurà d’indicar si les subcadenes són iguals.
| |
| − |
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Comparació de substrings")
| |
| − |
| |
| − | # Introducció de dades
| |
| − | cadena1 = input("Introdueix una cadena: ")
| |
| − | cadena2 = input("Introdueix una altra cadena: ")
| |
| − | numCar = int(input("Introdueix nombre de caràcters a comparar: "))
| |
| − | index1 = int(input("Posició inicial cadena 1: "))
| |
| − | index2 = int(input("Posició inicial cadena 2: "))
| |
| − |
| |
| − | # Comprovació dels límits de les cadenes
| |
| − | if (len(cadena1) < index1 + numCar) or (len(cadena2) < index2 + numCar):
| |
| − | print("S'excedeixen els límits de les cadenes")
| |
| − |
| |
| − | # Comparació dels substrings
| |
| − | else:
| |
| − | subCad1 = cadena1.lower()[index1-1:index1-1+numCar]
| |
| − | subCad2 = cadena2.lower()[index2-1:index2-1+numCar]
| |
| − | if subCad1 == subCad2:
| |
| − | print("Les subcadenes són iguals. Subcadena: %s" %subCad1)
| |
| − | else:
| |
| − | print("No són iguals. Subcadena1: %s, Subcadena2: %s" %(subCad1, subCad2))
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 13. Escriu una aplicació que rebi com a entrada una línia de text i un caràcter de cerca
| |
| − | i indiqui el nombre d’ocurrències del caràcter en el text.
| |
| − |
| |
| − | </source>
| |
| − | -->
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − |
| |
| − | print("Programa comptar ocurrències caràcter en una frase")
| |
| − |
| |
| − | # Entrada: frase a avaluar. Per ex: "La ment que s'obre a una nova idea, mai torna a la seva mida original."
| |
| − | frase = input("Introdueix la frase a avaluar: ")
| |
| − | caracter = input("Introdueix un caràcter: ")
| |
| − |
| |
| − | # Inicialitzar variables
| |
| − | comptador = 0
| |
| − | pos = frase.find(caracter)
| |
| − | # Comptar ocurrències caràcter
| |
| − | while pos != -1 :
| |
| − | comptador += 1
| |
| − | pos = frase.find(caracter,pos+1)
| |
| − | # Mostrar el resultat
| |
| − | print ("Hi ha %d %s's en la frase" %(comptador,caracter))
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 14. Féu un programa que llegeixi una cadena de caràcters i indiqui si la cadena és un
| |
| − | palíndrom. Un palíndrom és una cadena que es llegeix d’igual manera
| |
| − | d’esquerra a dreta que de dreta a esquerra. Com per exemple : dabale arroz a la
| |
| − | zorra el abad. Cal entendre que per poder-ho fer d’aquesta manera no han
| |
| − | d’haver-hi espais en blanc.
| |
| − |
| |
| − | <!--
| |
| − | :'''Slicing: indicant un rang'''
| |
| − | <source lang = "python">
| |
| − | miCadenaDeTexto = input("Introdueix una cadena: ")
| |
| − | # Imprimeix si"Es palíndrom"
| |
| − | if miCadenaDeTexto == miCadenaDeTexto[::-1]:
| |
| − | print("És palindrom")
| |
| − | else:
| |
| − | print("No és palindrom")
| |
| − | </source>
| |
| − | :'''Funció reversed'''
| |
| − | <source lang = "python">
| |
| − | miCadenaDeTexto = input("Introdueix una cadena: ")
| |
| − | # Imprimeix si"Es palíndrom"
| |
| − | if miCadenaDeTexto == "".join(reversed(miCadenaDeTexto)):
| |
| − | print("És palindrom")
| |
| − | else:
| |
| − | print("No és palindrom")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 15. '''languageGames''': En molts idiomes disposem de variants lúdiques de l'idioma. Aquest programa codificarà dos mètodes que ens permetran traduir paraules d'idiomes coneguts a variants lúdiques d'aquests. Expliquem primer aquestes variants:
| |
| − |
| |
| − | :'''a) Jerigonza''' (variant lúdica del castellà): després de cada vocal s'afegeix una 'p' i es repeteix la vocal.
| |
| − |
| |
| − | Exemples:
| |
| − |
| |
| − | ::*“casa” seria “capasapa”
| |
| − | ::*“Gabriel” seria “Gapabripiepel”
| |
| − | ::*“murcielago” seria “mupurcipiepelapagopo”
| |
| − |
| |
| − | '''NOTA:''' Per simplificar-ho suposarem que no s'introdueixen accents.
| |
| − |
| |
| − | :'''b) Basic Pig Latin''' (variant lúdica de l'anglès): tenim dues regles:
| |
| − |
| |
| − | :A les paraules que comencen per vocal se'ls afegeix al darrera el sufix “ay”. Exemples:
| |
| − |
| |
| − | ::*“ant” seria “antay”
| |
| − | ::*“astronaut” seria “astronautay”
| |
| − |
| |
| − | :A les paraules que comencen per consonant, es mouen totes les consonants del davant de la primera vocal al final i s'afegeix el sufix “ay”. Exemples:
| |
| − |
| |
| − | ::*“mess” seria “essmay”
| |
| − | ::*“father” seria “atherfay”
| |
| − | ::*“chick” seria “ickchay”
| |
| − | ::*“star” seria “arstay”
| |
| − |
| |
| − | El programa ha d'implementar les dues variants: jerigonza i basic pig latin.
| |
| − |
| |
| − |
| |
| − | '''NOTA:''' Per simplificar, podeu suposar que la dada d'entrada serà UNA ÚNICA paraula i que aquesta no tindrà ni accents ni caràcters diferents de lletres.
| |
| − |
| |
| − | == A4.2 Exercicis Llistes ==
| |
| − |
| |
| − | 1. Fes un programa que emmagatzemi els mòduls de primer d'ASIX ("Implantació de sistemes operatius", "Gestió de bases de dades", "Programació bàsica" ...) en una llista i a continuació, la mostri per pantalla.
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Programa mòduls 1r d'ASIX")
| |
| − | print("-------------------------")
| |
| − |
| |
| − | # Constant
| |
| − | MODULS = ["Sistemes operatius", "Gestió de bases de dades", "Programació bàsica", "Llenguatge de marques", "Fonaments de maquinari", "Planificació i administració de xarxes", "Implantació d'aplicacions web", "Formació i orientació laboral"]
| |
| − |
| |
| − | # Recórrer la llista i mostrar cada mòdul
| |
| − | for modul in MODULS :
| |
| − | print(modul)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 2. Fes un programa que emmagatzemi els mòduls de primer d'ASIX ("Implantació de sistemes operatius", "Gestió de bases de dades", "Programació bàsica" ...) en una llista i a continuació, demani la nota obtinguda de cada mòdul i ens digui quants mòduls ha aprovat, ha suspès o té convalidats.
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Programa mòduls aprovats, suspesos i convalidats de 1r d'ASIX \n")
| |
| − |
| |
| − | # Constant
| |
| − | MODULS = ["Sistemes operatius", "Gestió de bases de dades", "Programació bàsica", "Llenguatge de marques", "Fonaments de maquinari", "Planificació i administració de xarxes", "Implantació d'aplicacions web", "Formació i orientació laboral"]
| |
| − |
| |
| − | # Inicialitzar variables
| |
| − | aprovats = 0
| |
| − | suspesos = 0
| |
| − | convalidats = 0
| |
| − |
| |
| − | # Recórrer la llista i demanar cada nota
| |
| − | for modul in MODULS :
| |
| − | nota = input("Nota de %s: " %modul)
| |
| − | if nota == "convalidat":
| |
| − | convalidats += 1
| |
| − | elif int(nota) >= 5 :
| |
| − | aprovats += 1
| |
| − | else :
| |
| − | suspesos += 1
| |
| − |
| |
| − | # Mostrar el resultat
| |
| − |
| |
| − | print("Aprovats: ", aprovats)
| |
| − | print("Suspesos: ", suspesos)
| |
| − | print("convalidats: ", convalidats)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 3. Fes un programa que emmagatzemi els mòduls de primer d'ASIX ("Implantació de sistemes operatius", "Gestió de bases de dades", "Programació bàsica" ...) en una llista i a continuació, demani la nota obtinguda de cada mòdul i elimini de la llista els aprovats i convalidats i mostri els mòduls pendents d'aprovar.
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Programa mòduls pendents de 1r d'ASIX \n")
| |
| − |
| |
| − | # Inicialitzar moduls
| |
| − | moduls = ["Sistemes operatius", "Gestió de bases de dades", "Programació bàsica", "Llenguatge de marques", "Fonaments de maquinari", "Planificació i administració de xarxes", "Implantació d'aplicacions web", "Formació i orientació laboral"]
| |
| − |
| |
| − | # Inicialitzar variables
| |
| − | aprovats = []
| |
| − |
| |
| − | # Recórrer la llista i demanar cada nota
| |
| − | for modul in moduls :
| |
| − | nota = input("Nota de %s: " %modul)
| |
| − | if nota == "convalidat" or int(nota) >= 5 :
| |
| − | aprovats.append(modul)
| |
| − |
| |
| − | # Treure els mòduls aprovats
| |
| − | for modul in aprovats :
| |
| − | moduls.remove(modul)
| |
| − |
| |
| − | # Mostrar els mòduls pendents
| |
| − | print("Mòduls pendents: "+ str(moduls))
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 4. Feu un programa que donades dues llistes inicialitzades amb els valors [-3, 5, 1, -4, 8, 20, -9, 2, 11, -1], posi a una tercera llista, per a cada posició, la suma dels elements de les altres llistes.
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | # Inicialitzar les llistes
| |
| − | llista1 = [-3, 5, 1, -4, 8, 20, -9, 2, 11, -1]
| |
| − | llista2 = [-3, 5, 1, -4, 8, 20, -9, 2, 11, -1]
| |
| − |
| |
| − | # Declarar la llista resultat
| |
| − | resultat = []
| |
| − |
| |
| − | # Recórrer les llistes
| |
| − | for i in range(len(llista1)):
| |
| − |
| |
| − | # suma de cada posició de les dues llistes
| |
| − | resultat.append(llista1[i] + llista2[i])
| |
| − |
| |
| − | # Mostrar la llista amb el resultat
| |
| − | print(resultat)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 5. Fes un programa que donada una llista de números ja inicialitzada, la recorri amb un for i quan surti del for imprimeixi el valor més petit de la taula.
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | # Inicialitzar la llista
| |
| − | llista_num = [-3, 5, 1, -4, 8, 20, -9, 2, 11, -1]
| |
| − |
| |
| − | # Inicialitzar més petit
| |
| − | mesPetit = llista_num[0]
| |
| − |
| |
| − | # Recórrer la llista
| |
| − | for numActual in llista_num :
| |
| − |
| |
| − | # En cas que el número actual sigui més petit s'actualtiza mesPetit
| |
| − | if numActual < mesPetit :
| |
| − | mesPetit = numActual
| |
| − |
| |
| − | # Mostrar la llista amb el resultat
| |
| − | print("Número més petit de la llista:", mesPetit)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 6. Fes un programa que donada una llista de números ja inicialitzada, imprimeixi per pantalla els valors en ordre invers.
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | # Inicialitzar la llista
| |
| − | llista_num = [-3, 5, 1, -4, 8, 20, -9, 2, 11, -1]
| |
| − |
| |
| − | # Recórrer la llista en ordre invers
| |
| − | for num in reversed(llista_num) :
| |
| − |
| |
| − | # Mostrar el número de la posició índex
| |
| − | print(num, end= " ")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 7. Fes un programa que faci una rotació cap a l’esquerra o cap a la dreta (segons ens indiqui l’usuari) de tots els elements de una llista (en rotació esquerra l’element que està a la primera posició passarà a l’ultima i en rotació dreta l’element que està l’últim passarà a la primera posició).
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | # Inicialitzar la llista
| |
| − | llista_num = [1, 2, 3, 4, 5, 6, 7, 8, 9]
| |
| − |
| |
| − | # Inicialitzar sentit rotació
| |
| − | rotacio = input("Rotació esquerra o dreta? ")
| |
| − |
| |
| − | if rotacio == "esquerra" :
| |
| − |
| |
| − | # Rotació esquerra
| |
| − | aux = llista_num[0]
| |
| − | for index in range(len(llista_num)-1) :
| |
| − | llista_num[index] = llista_num[index +1]
| |
| − | llista_num[len(llista_num)-1] = aux
| |
| − | print(llista_num)
| |
| − |
| |
| − | elif rotacio == "dreta" :
| |
| − |
| |
| − | # Rotació dreta
| |
| − | aux = llista_num[len(llista_num)-1]
| |
| − | for index in range(len(llista_num)-1, 0, -1) :
| |
| − | llista_num[index] = llista_num[index-1]
| |
| − | llista_num[0] = aux
| |
| − | print(llista_num)
| |
| − |
| |
| − | else :
| |
| − | # Opció incorrecte
| |
| − | print("Opció incorrecte: opcions vàlides són esquerra o dreta")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 8. Feu un programa anomenat '''ParaulesSenars''' que llegeixi una frase escrita en una sola línia des del teclat i tot seguit escrigui les paraules que hi ha en posició senar (la primera, la tercera, etc.). Per exemple, si s'escriu “Hi havia una vegada un lloc...”, es mostrarà “Hi una un”.
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Programa paraules senars d'una frase")
| |
| − |
| |
| − | # Inicialitzar variables
| |
| − | frase = input("Introdueix una frase: ")
| |
| − | index = 0
| |
| − |
| |
| − | # Obtenir llista de paraules
| |
| − | paraules = frase.split(' ')
| |
| − |
| |
| − | # Recórrer la llista i mostrar les paraules senars
| |
| − | while index < len(paraules) :
| |
| − | # Mostrar la paraula
| |
| − | print(paraules[index])
| |
| − | # Paraula següent
| |
| − | index +=2
| |
| − |
| |
| − | # Amb for ...
| |
| − | '''
| |
| − | for index in range(0, len(paraules), 2):
| |
| − | print(paraules[index])
| |
| − | '''
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | == A4.3 Exercicis Diccionaris ==
| |
| − |
| |
| − | 1. Escriu un programa que llegeixi una frase i crei un diccionari amb la quantitat d'aparicions de cada caràcter. A continuació, mostra el contingut del diccionari.
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Repeticions caràcters en una frase \n")
| |
| − |
| |
| − | # Inicialització diccionari i frase
| |
| − | caracters = {}
| |
| − | frase = input("Escriu una frase: ")
| |
| − |
| |
| − | # Recórrer la frase i comptar caràcter
| |
| − | for caracter in frase:
| |
| − | if caracter in caracters:
| |
| − | caracters[caracter] += 1 # el caràcter ja està en el diccionari
| |
| − | else:
| |
| − | caracters[caracter] = 1 # primera aparició del caràcter
| |
| − |
| |
| − | # Mostrar el resultat
| |
| − | for clau,valor in caracters.items():
| |
| − | print(clau,":",valor)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 2. Escriu un programa, que declari un diccionari amb l'inventari d'un departament d'informàtica (ordinadors sobretaula, portàtils, projectors, impressores, ...). Presenteu un menú amb les opcions necessaris per fer un manteniment de l'inventari (insercions, actualitzacions, eliminacions i llistat). La darrera opció del menú serà per sortir del programa.
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | # Declarem l'inventari inicial
| |
| − | inventari = {"ordinadors": 102, "portatils": 25, "projectors": 6, "impressores": 3}
| |
| − |
| |
| − | # Menú
| |
| − | print("\nMenú principal \n\n 1. Afegir \n 2. Actualitzar \n 3. Eliminar \n 4. Llistat \n 5. Sortir \n")
| |
| − | opcio = input("Opcio: ")
| |
| − | print("")
| |
| − |
| |
| − | # Mentre no Sortir
| |
| − | while opcio != '5' :
| |
| − |
| |
| − | # Afegir producte comprovant que no existeix...
| |
| − | if opcio == '1' :
| |
| − | producte = input("Nom del producte: ")
| |
| − | if producte in inventari :
| |
| − | print("Aquest producte ja existeix!!")
| |
| − | else :
| |
| − | unitats = int(input("Unitats: "))
| |
| − | inventari[producte] = unitats
| |
| − |
| |
| − | # Actualitzar producte comprovant que existeix...
| |
| − | elif opcio == '2' :
| |
| − | producte = input("Nom del producte: ")
| |
| − | if producte in inventari :
| |
| − | print("Unitats inventari: %d" %inventari[producte])
| |
| − | unitats = int(input("Unitats actuals: "))
| |
| − | inventari[producte] = unitats
| |
| − | else :
| |
| − | print("Aquest producte no existeix!!")
| |
| − |
| |
| − | # Eliminar producte comprovant que existeix...
| |
| − | elif opcio == '3' :
| |
| − | producte = input("Nom del producte: ")
| |
| − | if producte in inventari :
| |
| − | unitats = inventari.pop(producte)
| |
| − | print("El producte tenia %d unitats" %unitats)
| |
| − | else :
| |
| − | print("Aquest producte no existeix!!")
| |
| − |
| |
| − | # Llistat de tots els productes de l'inventari
| |
| − | elif opcio == '4' :
| |
| − | print("\nProducte Unitats")
| |
| − | print("-------- -------")
| |
| − | for clau, valor in inventari.items(): # retorna les claus i els seus valors
| |
| − | print(clau.ljust(16)+str(valor).rjust(5))
| |
| − |
| |
| − |
| |
| − | else :
| |
| − | print("Opció incorrecte!!")
| |
| − |
| |
| − | # Menú
| |
| − | print("\nMenú principal \n\n 1. Afegir \n 2. Actualitzar \n 3. Eliminar \n 4. Llistat \n 5. Sortir \n")
| |
| − | opcio = input("Opcio: ")
| |
| − | print("")
| |
| − |
| |
| − | print("\n\nGràcies per utilitzar aquest programa!\n\n")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 3. Escriu un programa que implementi una agenda de telèfons. Utilitza un diccionari amb clau nom del contacte e i valor el seu telèfon. Presenteu un menú amb les opcions: afegir/modificar, cercar contactes, eliminar un contacte i sortir del programa.
| |
| − |
| |
| − | Descripció de les opcions:
| |
| − | :* Afegir/modificar: demana un nom de contacte. Si es troba en l'agenda ha de mostrar el telèfon i, opcionalment, permetre modificar-lo. Si el nom no es troba enl'agenda es demanarà el telèfon i s'afagirà el contacte a l'agenda.
| |
| − | :* Cercar: demana els primers caracters dels noms i mostrarà tots els noms dels contactes que comencin per aquests caracters juntament en els seus respectius telèfons.
| |
| − | :* Eliminar: demana el nom d'un contacte i si existeix mostra el seu telèfon i demana confirmació per elimniar-lo; en cas afirmatiu l'eliminarà de l'agenda. Si el contacte no existeix informarà del fet.
| |
| − | :* Llistar: mostrarà tots els contactes de l'agenda, juntament amb els seus telèfons.
| |
| − | :* Sortir: finalitzarà el programa amb un missatge de comiat.
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Agenda de contactes")
| |
| − |
| |
| − | # Declarmem el diccionari
| |
| − | agenda = {}
| |
| − |
| |
| − | # Menú
| |
| − | print("\nMenú principal \n\n 1. Afegir/modificar \n 2. Cercar \n",
| |
| − | "3. Eliminar \n 4. Llistar \n",
| |
| − | "5. Sortir \n")
| |
| − | opcio = input("Opció: ")
| |
| − | print("")
| |
| − |
| |
| − | # Mentre no Sortir
| |
| − | while opcio != '5' :
| |
| − |
| |
| − | # Afegir / modificar persona i/o telèfon
| |
| − | if opcio == '1' :
| |
| − | nomContacte = input("Nom del contacte: ")
| |
| − | if nomContacte in agenda :
| |
| − | print("Telèfon actual: ", agenda[nomContacte])
| |
| − | if input("Vols modificar el telèfon (Sí / No): ").lower().startswith('s'):
| |
| − | nouTelefon = input("Telèfon: ")
| |
| − | agenda[nomContacte] = nouTelefon
| |
| − | else:
| |
| − | nouTelefon = input("Telèfon: ")
| |
| − | agenda[nomContacte] = nouTelefon
| |
| − |
| |
| − | # Cercar totes les persones que comencin per una subcadena
| |
| − | elif opcio == '2' :
| |
| − | nomContacte = input("Introdueix inici noms: ")
| |
| − | print("\nContacte Telèfon")
| |
| − | print("--------- -------")
| |
| − | for contacte, telefon in agenda.items():
| |
| − | if contacte.startswith(nomContacte):
| |
| − | print(contacte.ljust(12)+telefon)
| |
| − |
| |
| − | # Eliminar una persona comprovant que existeix...
| |
| − | elif opcio == '3' :
| |
| − | nomContacte = input("Nom del contacte: ")
| |
| − | if nomContacte in agenda :
| |
| − | print("Telèfon actual: ", agenda[nomContacte])
| |
| − | if input("Segur que vols elimiar aquest contacte (Sí / No): ").lower().startswith('s'):
| |
| − | contacteEl = agenda.pop(nomContacte)
| |
| − | else :
| |
| − | print("Aquest contacte no existeix!!")
| |
| − |
| |
| − | # Llistat de tota l'agenda
| |
| − | elif opcio == '4' :
| |
| − | print("\nContacte Telèfon")
| |
| − | print("--------- -------")
| |
| − | for contacte, telefon in agenda.items(): # retorna les claus i els seus valors
| |
| − | print(contacte.ljust(12)+telefon)
| |
| − | else :
| |
| − | print("Opció incorrecte!!")
| |
| − |
| |
| − | # Menú
| |
| − | print("\nMenú principal \n\n 1. Afegir/modificar \n 2. Cercar \n",
| |
| − | "3. Eliminar \n 4. Llistar \n",
| |
| − | "5. Sortir \n")
| |
| − | opcio = input("Opció: ")
| |
| − | print("")
| |
| − |
| |
| − | print("\n\nGràcies per utilitzar aquest programa!\n\n")
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 4. Escriu un programa, que ens permeti emmagatzemar els noms dels alumnes d'una classe i les notes obtingudes. Els alumnes poden tenir diferents número de notes. Utilitza un diccionari amb clau nom de l'alumne i valors les llistes de notes de cada alumne. Presenteu un menú amb les opcions: afegir alumne (sense notes), afegir alumne amb notes, afegir notes a un alumne, modificar una nota (primer cal mostrar-les), eliminar un alumne, mostrar les notes d'un alumne, calcular la nota mitjana, llistar tots els alumnes amb les seves notes i la darrera opció per sortir del programa.
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Notes alumnes")
| |
| − |
| |
| − | # Declarmem el diccionari
| |
| − | alumnes = {}
| |
| − |
| |
| − | # Menú
| |
| − | print("\nMenú principal \n\n 1. Afegir alumne \n 2. Afegir alumne i notes \n",
| |
| − | "3. Afegir notes a un alumne \n",
| |
| − | "4. Modificar nota \n 5. Eliminar alumne \n",
| |
| − | "6. Mostrar notes alumne \n 7. Calcula la mitja d'un alumne \n",
| |
| − | "8. Llistat alumnes amb notes \n 9. Sortir \n")
| |
| − | opcio = input("Opció: ")
| |
| − | print("")
| |
| − |
| |
| − | # Mentre no Sortir
| |
| − | while opcio != '9' :
| |
| − |
| |
| − | # Afegir alumne sense notes comprovant que no existeix...
| |
| − | if opcio == '1' :
| |
| − | nomAlumne = input("Nom de l'alumne: ")
| |
| − | if nomAlumne in alumnes :
| |
| − | print("Aquest alumne ja existeix!!")
| |
| − | else :
| |
| − | alumnes[nomAlumne] = []
| |
| − |
| |
| − | # Afegir alumne amb notes comprovant que no existeix...
| |
| − | if opcio == '2' :
| |
| − | nomAlumne = input("Nom de l'alumne: ")
| |
| − | if nomAlumne in alumnes :
| |
| − | print("Aquest alumne ja existeix!!")
| |
| − | else :
| |
| − | print("Introdueix les notes de l'alumne (-1 per acabar)")
| |
| − | numNota = 1
| |
| − | nota = int(input("Nota %d alumne: " %numNota))
| |
| − | notes =[]
| |
| − | while nota != -1:
| |
| − | if nota >=0 and nota <=10:
| |
| − | notes.append(nota)
| |
| − | numNota += 1
| |
| − | else:
| |
| − | print("Nota Incorrecte")
| |
| − | nota = int(input("Nota %d alumne: " %numNota))
| |
| − | alumnes[nomAlumne] = notes
| |
| − |
| |
| − | # Afegir notes a un alumne comprovant que existeix...
| |
| − | elif opcio == '3' :
| |
| − | nomAlumne = input("Nom de l'alumne: ")
| |
| − | if nomAlumne in alumnes :
| |
| − | print("Introdueix les noves notes de l'alumne (-1 per acabar)")
| |
| − | numNota = 1
| |
| − | nota = int(input("Nova nota %d alumne: " %numNota))
| |
| − | notes = alumnes[nomAlumne]
| |
| − | while nota != -1:
| |
| − | if nota >=0 and nota <=10:
| |
| − | notes.append(nota)
| |
| − | numNota += 1
| |
| − | else:
| |
| − | print("Nota Incorrecte")
| |
| − | nota = int(input("Nova nota %d alumne: " %numNota))
| |
| − | alumnes[nomAlumne] = notes
| |
| − | else :
| |
| − | print("Aquest alumne no existeix!!")
| |
| − |
| |
| − |
| |
| − | # Modificar una nota d'un alumne comprovant que existeix...
| |
| − | elif opcio == '4' :
| |
| − | nomAlumne = input("Nom de l'alumne: ")
| |
| − | if nomAlumne in alumnes :
| |
| − | # Mostrar les notes de l'alumne
| |
| − | numNota = 1
| |
| − | for nota in alumnes[nomAlumne]:
| |
| − | print("Nota %d: %d" %(numNota,alumnes[nomAlumne][numNota-1]))
| |
| − | numNota += 1
| |
| − | notaMod=int(input("Quina nota vols modificar? "))
| |
| − | if notaMod >= 1 and nota <= len(alumnes[nomAlumne]):
| |
| − | notaNova = int(input("Nota nova: "))
| |
| − | notaEl = alumnes[nomAlumne].pop(notaMod-1)
| |
| − | alumnes[nomAlumne].insert(notaMod-1,notaNova)
| |
| − | else :
| |
| − | print("Aquest alumne no existeix!!")
| |
| − |
| |
| − | # Eliminar un alumne comprovant que existeix...
| |
| − | elif opcio == '5' :
| |
| − | nomAlumne = input("Nom de l'alumne: ")
| |
| − | if nomAlumne in alumnes :
| |
| − | notesEl = alumnes.pop(nomAlumne)
| |
| − | else :
| |
| − | print("Aquest alumne no existeix!!")
| |
| − |
| |
| − | # Mostrar notes d'un alumne
| |
| − | elif opcio == '6' :
| |
| − | nomAlumne = input("Nom de l'alumne: ")
| |
| − | if nomAlumne in alumnes :
| |
| − | print("\nAlumne Notes")
| |
| − | print("------ -----")
| |
| − | print(nomAlumne.ljust(12)+str(alumnes[nomAlumne]))
| |
| − | else :
| |
| − | print("Aquest alumne no existeix!!")
| |
| − |
| |
| − | # Calcular la mitja d'un alumne
| |
| − | elif opcio == '7' :
| |
| − | nomAlumne = input("Nom de l'alumne: ")
| |
| − | if nomAlumne in alumnes :
| |
| − | sumaNotes = 0;
| |
| − | print("\nAlumne Mitja")
| |
| − | print("------ -----")
| |
| − | print(nomAlumne.ljust(12)+str(sum(alumnes[nomAlumne])/len(alumnes[nomAlumne])).rjust(5))
| |
| − | else :
| |
| − | print("Aquest alumne no existeix!!")
| |
| − |
| |
| − | # Llistat de tots els alumnes
| |
| − | elif opcio == '8' :
| |
| − | print("\nAlumne Notes")
| |
| − | print("------ -----")
| |
| − | for clau, valor in alumnes.items(): # retorna les claus i els seus valors
| |
| − | print(clau.ljust(12)+str(valor))
| |
| − | else :
| |
| − | print("Opció incorrecte!!")
| |
| − |
| |
| − | # Menú
| |
| − |
| |
| − | print("\nMenú principal \n\n 1. Afegir alumne \n 2. Afegir alumne i notes \n",
| |
| − | "3. Afegir notes a un alumne \n",
| |
| − | "4. Modificar nota \n 5. Eliminar alumne \n",
| |
| − | "6. Mostrar notes alumne \n 7. Calcular la mitja d'un alumne \n",
| |
| − | "8. Llistat alumnes amb notes \n 9. Sortir \n")
| |
| − | opcio = input("Opció: ")
| |
| − | print("")
| |
| − |
| |
| − | print("\n\nGràcies per utilitzar aquest programa!\n\n")
| |
| − | </source>
| |
| − | -->
| |
| − | == A4.4 Exercicis Tuples ==
| |
| − |
| |
| − | 1.Escriviu un programa de Python que calculi el producte, multiplicant tots els números d'una tupla donada.
| |
| − |
| |
| − | Original Tuple: (4, 3, 2, 2, -1, 18) Sortida: -864
| |
| − |
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Multiplicar Tuples")
| |
| − | nums = (4, 3, 2, 2, -1, 18)
| |
| − | product = 1
| |
| − | # recorren la tupla
| |
| − | for x in nums:
| |
| − | product *= x
| |
| − | print ("Tupla Original: ")
| |
| − | print(nums)
| |
| − | print("Multiplicant tots els nombres de la tupla:",product)
| |
| − |
| |
| − | # Utilitzant una llista
| |
| − | temp = list(nums)
| |
| − | product = 1
| |
| − | for x in temp:
| |
| − | product *= x
| |
| − | print ("Tupla Original: ")
| |
| − | print(temp)
| |
| − | print("Multiplicant tots els nombres de la tupla:",product)
| |
| − |
| |
| − | # Si entramos los valores por input:
| |
| − | # temp = list(tuple(map(int,input("Entrar els elements de la Tupla: ").split())))
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | 2. Escriure un programa Python per comptar les ocurrències de tots els elements d'una tupla en una llista.
| |
| − | Utilitzarem un bucle for i comptarem quantes vegades apareix cada element de la llista.
| |
| − |
| |
| − | Exemples: Entrada: tupla = ('a', 'a', 'c', 'b', 'd') llista = ['a', 'b'] Sortida: 3
| |
| − | <!--
| |
| − | <source lang = "python">
| |
| − | print("Ocurrències Tuples")
| |
| − | tup = ('a', 'a', 'c', 'b', 'd')
| |
| − | lst = ['a', 'b']
| |
| − | count = 0
| |
| − | for item in tup:
| |
| − | if item in lst:
| |
| − | count+= 1
| |
| − | print("Ocurrencias", count)
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | == A4.5 Exercicis Tipus definits per l'usuari (clases) ==
| |
| − |
| |
| − | '''Exemplars llibres'''
| |
| − |
| |
| − | Per a la gestió dels llibres d'una petita biblioteca és precís conèixer el seu títol, autor, l'ISBN (cadena de 17 caràcters: 978-3-16-148410-0), el número d'exemplar (1, 2, 3, ...) i si es troba prestat o no. Escriu un programa en java que:
| |
| − |
| |
| − | a) Defineix una estructura denominada ExemplarLlibre que permeti emmagatzemar les dades de qualsevol llibre.
| |
| − |
| |
| − | b) Declarara e inicialitza dues variables del tipus ExemplarLlibre
| |
| − |
| |
| − | c) Comprova si les variables declarades representen exemplars d'un mateix llibre o de llibres diferents.
| |
| − |
| |
| − | <!--
| |
| − | :'''ClaseExemplarLlibre.py'''
| |
| − | <source lang = "python">
| |
| − | class ExemplarLlibre:
| |
| − | titol = ''
| |
| − | autor = ''
| |
| − | isbn = ''
| |
| − | exemplar = 0
| |
| − | prestat = False
| |
| − | </source>
| |
| − | :'''ExemplarsLlibres.py'''
| |
| − | <source lang = "python">
| |
| − | from ClaseExemplarLlibre import ExemplarLlibre
| |
| − |
| |
| − | #Dues instàncies d'exemplar llibre
| |
| − | llibre1 = ExemplarLlibre()
| |
| − | llibre2 = ExemplarLlibre()
| |
| − |
| |
| − | # Dades Llibre 1
| |
| − | llibre1.titol = "Python 3"
| |
| − | llibre1.autor = "Sébastien Chazallet"
| |
| − | llibre1.isbn = "978-2-40-902575-4"
| |
| − | llibre1.exemplar = 1
| |
| − | llibre1.prestat = False
| |
| − |
| |
| − | # Dades llibre 2
| |
| − | llibre2.titol = "Learning python"
| |
| − | llibre2.autor = "Lutz"
| |
| − | llibre2.isbn = "978-0-59-651398-6"
| |
| − | llibre2.exemplar = 1
| |
| − | llibre2.prestat = True
| |
| − |
| |
| − |
| |
| − | # Comparem llibres
| |
| − |
| |
| − | if llibre1.titol==llibre2.titol and llibre1.autor==llibre2.autor:
| |
| − | print("Són exemplars del mateix llibre")
| |
| − | else:
| |
| − | print("No són exemplars del mateix llibre")
| |
| − |
| |
| − | # Comparem instancies
| |
| − |
| |
| − | if llibre1 == llibre2:
| |
| − | print("És la mateixa instancia!")
| |
| − | else:
| |
| − | print("No és la mateixa instancia")
| |
| − |
| |
| − |
| |
| − | # I si copiem les dades ...
| |
| − |
| |
| − | llibre2.titol = llibre1.titol
| |
| − | llibre2.autor = llibre1.autor
| |
| − | llibre2.isbn = llibre1.isbn
| |
| − | llibre2.exemplar = llibre1.exemplar
| |
| − | llibre2.prestat = llibre1.prestat
| |
| − |
| |
| − | if llibre1 == llibre2:
| |
| − | print("És la mateixa instancia!")
| |
| − | else:
| |
| − | print("No és la mateixa instancia")
| |
| − |
| |
| − |
| |
| − | #I si assignem la instancia...
| |
| − |
| |
| − | llibre2 = llibre1;
| |
| − |
| |
| − | if llibre1 == llibre2:
| |
| − | print("És la mateixa instancia!")
| |
| − | else:
| |
| − | print("No és la mateixa instancia")
| |
| − |
| |
| − | #Aleshores que és llibre...
| |
| − | print(llibre1)
| |
| − |
| |
| − | # I si ara canviem l'autor del llibre1
| |
| − |
| |
| − | llibre2.autor "Alfredo Moreno Muñoz"
| |
| − | print(llibre1.autor)
| |
| − |
| |
| − | </source>
| |
| − | -->
| |
| − | '''Estadístiques cargols'''
| |
| − |
| |
| − | una fàbrica de cargols ens ha sol·licitat desenvolupar un programa en java que permeti obtenir e imprimir les estadístiques d'una determinada mostra de cargols. Per això, ens indiquen que cada cargol es caracteritza per la seva longitud i el seu diàmetre i que ambdues mesures han de emmagatzemar-se en un registre amb dos camps. El programa haurà de:
| |
| − |
| |
| − | a) Sol·licitar a l'usuari les dades d'una mostra de cargols (longitud i diàmatre) i els emmagatzemi en una llista.
| |
| − |
| |
| − | b) A partir de les dades introduïdes calcular i mostrar per pantalla la mitjana de les longituds i la mitjana dels diàmetres.
| |
| − |
| |
| − | <!--
| |
| − | :'''ClaseCargol.py'''
| |
| − | <source lang = "python">
| |
| − | class Cargol:
| |
| − | longitud = 0
| |
| − | diametre = 0
| |
| − | </source>
| |
| − | :'''llistaCargols.py'''
| |
| − | <source lang = "python">
| |
| − | from ClaseCargol import Cargol
| |
| − |
| |
| − | # Inicialitzacio Variables
| |
| − | llistaCargols = []
| |
| − | sumaLongitud = 0
| |
| − | sumaDiametre = 0
| |
| − |
| |
| − | # Crear una llista de càrgols
| |
| − | mesCargols = input('Vols introduir un nou càrgol (S/N)?')
| |
| − | while mesCargols == 'S':
| |
| − | nouCargol = Cargol()
| |
| − | nouCargol.longitud = int(input('Longitud: '))
| |
| − | nouCargol.diametre = int(input('Diàmetre: '))
| |
| − | llistaCargols.append(nouCargol)
| |
| − | mesCargols = input('Vols introduir un nou càrgol (S/N)? ')
| |
| − |
| |
| − | for carg in llistaCargols:
| |
| − | sumaLongitud += carg.longitud
| |
| − | sumaDiametre += carg.diametre
| |
| − |
| |
| − | print("Mitja longituds dels cargols:", sumaLongitud / len(llistaCargols))
| |
| − | print("Mitja Diàmetres dels cargols:", sumaDiametre / len(llistaCargols))
| |
| − |
| |
| − | </source>
| |
| − | -->
| |
| − |
| |
| − | '''Llançament daus'''
| |
| − |
| |
| − | Volem fer un estudi estadístic en relació al llançament d'un dau de sis cares. En concret volem obtenir 100 seqüències '''i a continuació''' determinar quina ha estat la seqüencia més llarga, la més curta, el número que s'ha repetit més vegades i el número que més vegades ha tancat una seqüencia.
| |
| − |
| |
| − | Una seqüencia acaba quan han sortit totes les cares del dau.
| |
| − |
| |
| − | Definiu la classe seqüencia per recullir totes les dades d'una seqüencia.
| |
| − |
| |
| − | Per simular el llançament d'un dau utilitzeu la classe Ramdom:
| |
| − |
| |
| − | <!--
| |
| − | :'''EstadistiquesDau.py'''
| |
| − | <source lang = "python">
| |
| − | import random
| |
| − | class EstDau:
| |
| − | tirades = 0
| |
| − | cares = {}
| |
| − | caraTancament = 0
| |
| − | </source>
| |
| − | :'''llençamentsDau.py'''
| |
| − | <source lang = "python">
| |
| − | from EstadistiquesDau import EstDau
| |
| − |
| |
| − | # Inicialitzacio Variables
| |
| − | NUM_SEQ = 10
| |
| − | cara = 0
| |
| − | sequencies=[]
| |
| − |
| |
| − | # Generar seqüències
| |
| − | for _ in range(NUM_SEQ):
| |
| − | seq = EstDau()
| |
| − | seq.cares = {1:0, 2:0, 3:0, 4:0, 5:0, 6:0}
| |
| − | while seq.cares[1] == 0 or seq.cares[2] == 0 or seq.cares[3] == 0 or seq.cares[4] == 0 or seq.cares[5] == 0 or seq.cares[6] == 0:
| |
| − | cara = random.randrange(1,7)
| |
| − | seq.cares[cara] += 1
| |
| − | seq.tirades += 1
| |
| − | seq.caraTancament = cara
| |
| − | sequencies.append(seq)
| |
| − |
| |
| − | # Resultats
| |
| − | seqMesLlarga = sequencies[0].tirades
| |
| − | numSeqMesLlarga = 1
| |
| − | seqMesCurta = sequencies[0].tirades
| |
| − | numSeqMesCurta = 1
| |
| − | caraMesVegadesTancament = 0
| |
| − | caraMesRepetida = {1:0, 2:0, 3:0, 4:0, 5:0, 6:0}
| |
| − | numSeq = 1
| |
| − | for seq in sequencies:
| |
| − | print('Num seqüència: %2d Tirades: %2d Cara tancament: %2d' %(numSeq, seq.tirades, seq.caraTancament))
| |
| − | if seq.tirades > seqMesLlarga:
| |
| − | seqMesLlarga = seq.tirades
| |
| − | numSeqMesLlarga = numSeq
| |
| − | if seq.tirades < seqMesCurta:
| |
| − | seqMesCurta = seq.tirades
| |
| − | numSeqMesCurta = numSeq
| |
| − | for clau, valor in seq.cares.items():
| |
| − | caraMesRepetida[clau] += valor
| |
| − | numSeq += 1
| |
| − | print('Seqüència mès llarga: %2d Tirades: %2d' %(numSeqMesLlarga, seqMesLlarga))
| |
| − | print('Seqüència mès curta: %2d Tirades: %2d' %(numSeqMesCurta, seqMesCurta))
| |
| − | caraMesRep = 1
| |
| − | repeticions = caraMesRepetida[1]
| |
| − | for clau, valor in caraMesRepetida.items():
| |
| − | if valor > repeticions:
| |
| − | caraMesRep = clau
| |
| − | repeticions = valor
| |
| − | print(caraMesRepetida)
| |
| − | print('Cara més repetida: %2d Repeticions: %2d' %(caraMesRep, repeticions))
| |
| − | </source>
| |
| − | -->
| |
