Google+ Seguidores

lunes, 16 de noviembre de 2015

Ejercicios de clases y objetos en python (parte 1)

Buenas, la idea de esta entrada es comenzar a practicar con algunos ejercicios la programación orientada a objetos en python.
La programación orientada a objetos (POO) es un enfoque formal de programación que combina los datos y las acciones asociadas (métodos) en estructuras lógicas (objetos). Este enfoque mejora la capacidad de gestionar software complejos como también así el desarrollo y mantenimiento de aplicaciones de gran tamaño.

Puedes ver la entrada sobre Programación Orientada a Objetos en python que escribí ya hace algún tiempo. También puedes dar una vuelta por todo el repertorio de ejercicios que hemos ido publicando en el blog aquí: Ejercicios Python

Espero estos ejercicios te sean de ayuda.

Ejercicio 1
Escribir una clase en python que convierta un número entero a número romano

Ejercicio 2
Escribir una clase en python que convierta un número romano en un número entero

Ejercicio 3
Escribir una clase en python para encontrar la validez de una cadena de paréntesis, '(', ')', '{', '}', '['  ']. Los paréntesis deben aparecer en el orden correcto, por ejemplo "()" y "()[]{}" son validos, pero "[)", "({[)]" y "{{{" son inválidos.

Ejercicio 4
Escribir una clase en python que obtenga todos los posibles subconjuntos únicos de un conjunto de números enteros distintos.
Entrada: [4, 5, 6]
Salida: [[], [6], [5], [5, 6], [4], [4, 6], [4, 5], [4, 5, 6]]

Ejercicio 5
Escribir una clase en python que encuentre un par de elementos (índice de los números) de una matriz dada cuya suma es igual a un número de destino especifico.
Entrada: numeros = [10,20,10,40,50,60,70], objetivo=50
Salida: 3, 4

Ejercicio 6
Escribir una clase en python que encuentre los 3 elementos que sumen 0 a partir de números reales
Entrada: [-25, -10, -7, -3, 2, 4, 8, 10]
Salida: [[-10, 2, 8], [-7, -3, 10]]

Ejercicio 7
Escribir una clase en python que calcule pow(x, n)
x = es la base
n = es el exponente

Entrada: pow(2, -3)
Salida: 0.125

Entrada: pow(3, 5)
Salida: 234

Ejercicio 8
Escribir una clase en python que revierta una cadena de palabras
Entrada: "Mi Diario Python"
Salida: "Python Diario Mi"

Ejercicio 9
Escribir una clase en python con 2 métodos: get_string y print_string. get_string acepta una cadena ingresada por el usuario y print_string imprime la cadena en mayúsculas.

Ejercicio 10
Escribir una clase en python llamada rectangulo que contenga una base y una altura, y que contenga un método que devuelva el área del rectángulo.

Ejercicio 11
Escribir una clase en python llamada circulo que contenga un radio, con un método que devuelva el área y otro que devuelva el perímetro del circulo.


Las soluciones a los ejercicios pueden publicarlas en los comentarios.

Hasta acá los ejercicios, a meter código muchachos, nos vemos en las soluciones ;)

Saludos, Diego...

20 comentarios :
Write comentarios
  1. Un intento de los numeros romanos :



    categorias = [['I','V','X'],['X','L','C'],['C','D','M']]
    popurri = {0:'',1:'0',2:'00',3:'000',4:'01',5:'1',6:'10',7:'100',8:'1000',9:'02'}


    class Romano(object):
    def __init__(self, numero):
    self.number = str(numero)
    self.largo = len(self.number)


    def romanizar (self):

    respuestafinal = ''
    for x in range(0,self.largo):

    respuestafinal = respuestafinal + self.romanizardig(self.number[x],self.largo-x-1)

    return respuestafinal

    def romanizardig(self,digito,categoria):


    logica = categorias[categoria]
    respuesta = ''

    dig_a_procesar = [x for x in popurri[int(digito)]]

    for x in dig_a_procesar:

    respuesta = respuesta + logica[int(x)]

    return respuesta




    Prueba = Romano(950)
    print Prueba.romanizar()

    ResponderEliminar
  2. Ejercicio 2



    popurri = {'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}


    class Normalizador(object):
    def __init__(self, numero):
    self.number = numero
    self.largo = len(numero)

    def normalizar(self):

    sumatotal = 0

    for x in range(0,self.largo):

    valor = popurri[self.number[x]]

    if x != self.largo-1:
    if valor < popurri[self.number[x+1]]:
    valor = -valor

    sumatotal += valor

    return sumatotal



    Prueba = Normalizador('DCXCII')
    print Prueba.normalizar()

    ResponderEliminar
    Respuestas
    1. Excelente Lucas. Gracias por visitar y participar en el blog. saludos

      Eliminar
  3. Este comentario ha sido eliminado por el autor.

    ResponderEliminar
  4. Respuestas
    1. Excelente Victor. Gracias por visitar y participar en el blog. saludos

      Eliminar
  5. Este comentario ha sido eliminado por el autor.

    ResponderEliminar
  6. # -*- coding: utf-8 -*-

    class Dec_Rom:

    ....def __init__(self,n):
    ........self.n=n
    ........self.numero=[]
    ........if int(self.n)<=100000:
    ............self.numero += n
    ........else:
    ............print 'El numero debe ser menor o igual a 100000'

    ....def check(self):
    .........self.nums={1:'I',5:'V',10:'X',50:'L',100:'C',500:'D',1000:'M',4000:'ÏǗ',5000:'Ǘ',6000:'ÜÏ',7000:'ÜÏÏ',8000:'ÜÏÏÏ',9000:'ÏẌ',10000:'Ẍ',20000:'ẌẌ',30000:'ẌẌẌ',40000:'ẌĹ',50000:'Ĺ',60000:'ĹẌ',70000:'ĹẌẌ',80000:'ĹẌẌẌ',90000:'ẌĆ',100000:'Ć'}
    ........roma,resul,indice,pase='',0,0,False
    ........if len(self.numero)==6:
    ............roma += self.nums[100000]
    ............return roma
    ........elif len(self.numero)==5:
    ............conv=int(self.numero[indice])*10000
    ............resul=self.nums[conv]
    ............roma += resul
    ............indice += 1
    ............pase=True
    ........else:
    ............pass
    ........if len(self.numero)==4 or pase:
    ............base,medinf,med,sup,sups=100,400,500,900,1000
    ............if int(self.numero[indice])<4:
    ................conv=int(self.numero[indice])*self.nums[1000]
    ................roma += conv
    ................indice += 1
    ............else:
    ................conv=int(self.numero[indice])*1000
    ................resul=self.nums[conv]
    ................roma += resul
    ................indice += 1
    ........elif len(self.numero)==3:
    ............base,medinf,med,sup,sups=100,400,500,900,1000
    ........elif len(self.numero)==2:
    ............base,medinf,med,sup,sups=10,40,50,90,100
    ........elif len(self.numero)==1:
    ............base,medinf,med,sup,sups=1,4,5,9,10
    ........while indice<len(self.numero):
    ............conv=int(self.numero[indice])*base
    ............if conv<medinf:
    ................conv=int(self.numero[indice])*self.nums[base]
    ................roma += conv
    ............elif conv==med:
    ................resul=self.nums[conv]
    ................roma += resul
    ............elif conv==sup:
    ................roma += self.nums[base]
    ................roma += self.nums[sups]
    ............else:
    ................resul=conv-med
    ................if resul<0:
    ....................resul *= -1
    ....................roma += self.nums[resul]
    ....................roma += self.nums[med]
    ................else:
    ....................resul /= base
    ....................roma += self.nums[med]
    ....................conv=resul*self.nums[base]
    ....................roma += conv
    ............if len(self.numero)==5 and indice ==2 or len(self.numero)==4 and indice ==1 or len(self.numero)==3 and indice == 0:
    ................base,medinf,med,sup,sups=10,40,50,90,100
    ............elif len(self.numero)==5 and indice ==3 or len(self.numero)==4 and indice ==2 or len(self.numero)==3 and indice == 1 or len(self.numero)==2 and indice==0:
    ................base,medinf,med,sup,sups=1,4,5,9,10
    ............indice += 1
    ........return roma

    while True:
    ....entrada=raw_input()
    ....num=Dec_Rom(entrada)
    ....print num.check()

    ResponderEliminar
  7. Seguiré con los demás ejercicios, por lo pronto ahí esta el primero. Excelente pagina, Dios les bendiga.

    ResponderEliminar
    Respuestas
    1. Excelente Victor. Saludos y gracias por visitar el blog :)

      Eliminar
  8. Hola aquí dejo mi versión. Son el ejercicio 1 y 2 juntos.
    Está colgado en https://github.com/Didweb/R-mer/blob/master/romanos.py

    He mirado de ponerlo aquí pero era muy largo.

    Gracias por la web es muy motivadora y me esta ayudando mucho. Saludos.

    ResponderEliminar
    Respuestas
    1. Hola Edu, gracias a ti por visitar el blog... a seguir metiendo código ;). Saludos

      Eliminar
    2. ejercicio 1

      def toRomanNumbers (entero):
      entero = int(entero)
      numero_romano=""

      if(int(entero/1000)>0): #M
      for i in range(0,int(entero/1000)):
      numero_romano=numero_romano+"M"
      entero = entero%1000

      if(int(entero/100)==9): #CM
      entero=entero-900
      numero_romano=numero_romano+"CM"

      if(int(entero/100)==4): #CD
      entero=entero-400
      numero_romano=numero_romano+"CD"

      if(int(entero/500)>0): #D
      for i in range(0,int(entero/500)):
      numero_romano=numero_romano+"D"
      entero = entero%500

      if(int(entero/10)==9): #XC
      entero=entero-90
      numero_romano=numero_romano+"XC"

      if(int(entero/10)==4): #XL
      entero=entero-40
      numero_romano=numero_romano+"XL"

      if(int(entero/100)>0): #C
      for i in range(0,int(entero/100)):
      numero_romano=numero_romano+"C"
      entero = entero%100

      if(int(entero/50)>0): #L
      for i in range(0,int(entero/50)):
      numero_romano=numero_romano+"L"
      entero = entero%50

      if(entero==9): #IX
      entero=entero-9
      numero_romano=numero_romano+"IX"

      if(int(entero/10)>0): #X
      for i in range(0,int(entero/10)):
      numero_romano=numero_romano+"X"
      entero = entero%10

      if(int(entero/5)>0): #V
      for i in range(0,int(entero/5)):
      numero_romano=numero_romano+"V"
      entero = entero%5

      if(entero==4): #IV
      numero_romano=numero_romano+"IV"
      entero=entero-4

      if(entero!=0): #I
      for i in range(0,int(entero)):
      numero_romano=numero_romano+"I"

      return numero_romano

      Eliminar
  9. ejercicio 1

    class Romano:

    _roman = {1: 'I', 5: 'V', 10:'X', 50: 'L', 100: 'C', 500: 'D', 1000: 'M'}

    def __init__(self, num = None):
    self.num = num

    def romanizar(self):
    entero = int(self.num)
    str_romano = ''
    for x in (1000, 100, 10, 1):
    if entero // x != 0:
    valor = entero // x
    entero %= x
    str_romano += self.asignar(valor, x)
    return str_romano


    def asignar(self, valor, a):
    aux = ''
    if valor == 4:
    return self._roman[a] + self._roman[5 * a]
    elif valor == 9:
    return self._roman[a] + self._roman[10 * a]
    elif valor >= 5:
    aux += self._roman[a * 5]
    valor -= 5
    aux += self._roman[a] * valor

    return aux

    ResponderEliminar
  10. class Subconjuntos:

    def __init__(self, conjunto = None):
    self.conjunto = conjunto

    def subconj(self):
    sub = [[], self.conjunto]
    corta = 0
    for prim in self.conjunto:
    corta += 1
    sub += [[prim]]
    for sec in self.conjunto[corta:]:
    sub += [[prim, sec]]

    return sub

    s = Subconjuntos([4,5,6])

    print(s.subconj())

    ResponderEliminar
  11. ejercicio 5


    class Elementos:

    def __init__(self, matriz = None):
    self.matriz = matriz


    def search_elemnt(self):
    ant = self.matriz[0]
    i = 1

    for act in (self.matriz[1:]):
    if i == len(self.matriz)-1:
    return False

    if (ant + act) == self.matriz[i+1]:
    return i-1 , i
    i += 1
    ant = act



    c = Elementos([10,20,40,40,50,60,70])

    print(c.search_elemnt())

    ResponderEliminar
  12. Esta es mi solucion para el ejercicio 1: Solo funciona hasta el 4999 por que no se como poner el cinco mil. podrias poner tu solucion:

    class NumerosRomanos():
    def __init__(self):
    self.numero1="I"
    self.numero5="V"
    self.numero10="X"
    self.numero50="L"
    self.numero100="C"
    self.numero500="D"
    self.numero1000="M"

    def imprimirlista(self,listanueva):
    for i in listanueva:
    print(i, end="")


    def menorque5(self,numeroarabigo):
    self.elnumero=numeroarabigo
    self.i=1
    self.lista=[]
    if 0<self.elnumero<=3:
    while self.i<=self.elnumero:
    self.lista.append(self.numero1)
    self.i=self.i+1
    elif self.elnumero==4:
    self.lista=["IV"]
    else:
    #lista=""
    pass
    return self.lista


    def menorque10(self, numeroarabigo):
    self.i=6
    self.lista=["V"]
    if 5<numeroarabigo<=8:
    while self.i<=numeroarabigo:
    self.lista.append(self.numero1)
    self.i=self.i+1
    elif numeroarabigo==9:
    self.lista=["IX"]
    else:
    self.lista=["V"]
    return self.lista

    def menorque50(self, numeroarabigo):
    self.i=1
    self.lista=[]
    if 0<numeroarabigo<=3:
    while self.i<=numeroarabigo:
    self.lista.append(self.numero10)
    self.i=self.i+1
    elif numeroarabigo==4:
    self.lista=["XL"]
    else:
    #lista=""
    pass
    return self.lista

    def menorque100(self, numeroarabigo):
    self.i=6
    self.lista=["L"]
    if 5<numeroarabigo<=8:
    while self.i<=numeroarabigo:
    self.lista.append(self.numero10)
    self.i=self.i+1
    elif numeroarabigo==9:
    self.lista=["XC"]
    else:
    self.lista=["L"]
    return self.lista

    def menorque500(self, numeroarabigo):
    self.i=1
    self.lista=[]
    if 0<numeroarabigo<=3:
    while self.i<=numeroarabigo:
    self.lista.append(self.numero100)
    self.i=self.i+1
    elif numeroarabigo==4:
    self.lista=["CD"]
    else:
    #lista=""
    pass
    return self.lista

    def menorque1000(self, numeroarabigo):
    self.i=6
    self.lista=["D"]
    if 5<numeroarabigo<=8:
    while self.i<=numeroarabigo:
    self.lista.append(self.numero100)
    self.i=i+1
    elif numeroarabigo==9:
    self.lista=["CM"]
    else:
    self.lista=["D"]
    return self.lista

    def menorque5000(self, numeroarabigo):
    self.elnumero=numeroarabigo
    self.i=1
    self.lista=[]
    if 0<self.elnumero<=3:
    while self.i<=self.elnumero:
    self.lista.append(self.numero1000)
    self.i=self.i+1
    elif self.elnumero==4:
    self.lista=["MV"]
    else:
    #lista=""
    pass
    return self.lista

    def romanizar(self,arabigo):
    for i in range(len(arabigo)):
    k=len(arabigo)-i
    if int(arabigo[i])<5 and k==1:
    self.imprimirlista(self.menorque5(int(arabigo[i])))
    elif 5<=int(arabigo[i])<10 and k==1:
    self.imprimirlista(self.menorque10(int(arabigo[i])))
    elif int(arabigo[i])<5 and k==2:
    self.imprimirlista(self.menorque50(int(arabigo[i])))
    elif 5<=int(arabigo[i])<10 and k==2:
    self.imprimirlista(self.menorque100(int(arabigo[i])))
    elif int(arabigo[i])<5 and k==3:
    self.imprimirlista(self.menorque500(int(arabigo[i])))
    elif 5<=int(arabigo[i])<10 and k==3:
    self.imprimirlista(self.menorque1000(int(arabigo[i])))
    elif int(arabigo[i])<5 and k==4:
    self.imprimirlista(self.menorque5000(int(arabigo[i])))

    arabe=input("Podrias introducir el numero a convertir: ")

    minumero=NumerosRomanos()

    minumero.romanizar(arabe)

    ResponderEliminar
  13. Mi version del numero dos, de igual manera solo funciona hasta el 4999 por que no se como expresar el cinco mil:

    class RomanoArabigo():
    def __init__(self):
    self.lista=["I", "V", "X", "L", "C", "D", "M"]
    self.sumatoria=0

    def validar(self, romano):
    self.numero=romano
    bandera=False
    contador=0
    for i in self.numero:
    if i.upper() in self.lista:
    contador=contador+1
    else:
    contador=0
    break
    if contador==0:
    bandera=False
    print("El Numero es invalido")
    else:
    bandera=True
    return bandera

    def enlistar(self, romano):
    self.lista=[]
    for i in romano:
    self.lista.append(i)
    return self.lista


    def analiza(self, nromano):
    self.milista=self.enlistar(nromano)
    i=0
    while i<(len(self.milista)-1) and i>=0:
    if i<len(self.milista):
    b=i
    if self.milista[i]=="I" and self.milista[i+1]=="V":
    self.sumatoria=self.sumatoria+4
    self.milista.remove(self.milista[i])
    self.milista.remove(self.milista[i])
    i=b
    elif self.milista[i]=="I" and self.milista[i+1]=="X":
    self.sumatoria=self.sumatoria+9
    self.milista.remove(self.milista[i])
    self.milista.remove(self.milista[i])
    i=b
    elif self.milista[i]=="X" and self.milista[i+1]=="L":
    self.sumatoria=self.sumatoria+40
    self.milista.remove(self.milista[i])
    self.milista.remove(self.milista[i])
    i=b
    elif self.milista[i]=="X" and self.milista[i+1]=="C":
    self.sumatoria=self.sumatoria+90
    self.milista.remove(self.milista[i])
    self.milista.remove(self.milista[i])
    i=b
    elif self.milista[i]=="C" and self.milista[i+1]=="D":
    self.sumatoria=self.sumatoria+400
    self.milista.remove(self.milista[i])
    self.milista.remove(self.milista[i])
    i=b
    elif self.milista[i]=="C" and self.milista[i+1]=="M":
    self.sumatoria=self.sumatoria+900
    self.milista.remove(self.milista[i])
    self.milista.remove(self.milista[i])
    i=b
    elif self.milista[i]=="M" and self.milista[i+1]=="V":
    self.sumatoria=self.sumatoria+4000
    self.milista.remove(self.milista[i])
    self.milista.remove(self.milista[i])
    i=b
    else:
    i=i+1
    self.sumatoria=self.sumatoria+(self.lista.count("I")*1)
    self.sumatoria=self.sumatoria+(self.lista.count("V")*5)
    self.sumatoria=self.sumatoria+(self.lista.count("X")*10)
    self.sumatoria=self.sumatoria+(self.lista.count("L")*50)
    self.sumatoria=self.sumatoria+(self.lista.count("C")*100)
    self.sumatoria=self.sumatoria+(self.lista.count("D")*500)
    self.sumatoria=self.sumatoria+(self.lista.count("M")*1000)
    print("Tu numero Romano convertido al Arabigo es:")
    print(self.sumatoria)

    Romano=RomanoArabigo()

    validacion=False

    while validacion!=True:
    minumero=input("Por favor introduce un numero romano: ")
    validacion=Romano.validar(minumero)

    Romano.analiza(minumero)

    ResponderEliminar
  14. Este comentario ha sido eliminado por el autor.

    ResponderEliminar
  15. Mi solucion al numero 3, tambien valida casos como un parentesis de cerradura antes de uno de apertura ejemplo: ())[]

    class Parentesis():
    def __init__(self):
    self.curvos1=('(')
    self.curvos2=(')')
    self.cuadrados1=('[')
    self.cuadrados2=(']')
    self.llaves1=('{')
    self.llaves2=('}')


    def verificar(self, parentesisr):
    self.parentesisl=[""]
    for i in parentesisr:
    self.parentesisl.append(i)


    self.curv1=self.parentesisl.count(self.curvos1)
    self.curv2=self.parentesisl.count(self.curvos2)
    self.cuad1=self.parentesisl.count(self.cuadrados1)
    self.cuad2=self.parentesisl.count(self.cuadrados2)
    self.llave1=self.parentesisl.count(self.llaves1)
    self.llave2=self.parentesisl.count(self.llaves2)


    self.b=True

    for i in range(len(parentesisr)):
    if parentesisr[i] in self.curvos2 and i==0:
    self.b=False
    elif parentesisr[i] in self.curvos2 and i>0:
    c=i-1
    while c>=0:
    if parentesisr[c] in self.curvos1:
    self.b=True
    break
    else:
    self.b=False
    c=c-1
    elif parentesisr[i] in self.cuadrados2 and i==0:
    self.b=False
    elif parentesisr[i] in self.cuadrados2 and i>0:
    c=i-1
    while c>=0:
    if parentesisr[c] in self.cuadrados1:
    self.b=True
    break
    else:
    self.b=False
    c=c-1
    elif parentesisr[i] in self.llaves2 and i==0:
    self.b=False
    elif parentesisr[i] in self.llaves2 and i>0:
    c=i-1
    while c>=0:
    if parentesisr[c] in self.llaves1:
    self.b=True
    break
    else:
    self.b=False
    c=c-1



    if self.curv1==self.curv2 and self.cuad1==self.cuad2 and self.llave1==self.llave2 and self.b==True:
    print("La estructura de parentesis es valida")
    else:
    print("La estructura de parentesis es invalida")


    estructura=input("Por favor introduce una estructura de parentesis: ")

    MisParentesis=Parentesis()

    MisParentesis.verificar(estructura)

    ResponderEliminar

Tu comentario es importante y nos motiva a seguir escribiendo...

Entradas más recientes

Powered by Blogger .