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...

  1. Unknown dice:

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

  2. Unknown dice:

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

    1. PythonDiario dice:

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

  3. Victor Cueva dice:

    Este comentario ha sido eliminado por el autor.

  4. Victor Cueva dice:

    Mi código: ideone.com

    1. PythonDiario dice:

      Excelente Victor. Gracias por visitar y participar en el blog. saludos

  5. Víctor dice:

    Este comentario ha sido eliminado por el autor.

  6. Víctor dice:

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

  7. Víctor dice:

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

    1. PythonDiario dice:

      Excelente Victor. Saludos y gracias por visitar el blog 🙂

  8. Edu dice:

    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.

    1. PythonDiario dice:

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

    2. Anónimo dice:

      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

  9. Anónimo dice:

    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

  10. Anónimo dice:

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

  11. Anónimo dice:

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

  12. Unknown dice:

    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)

  13. Unknown dice:

    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)

  14. Unknown dice:

    Este comentario ha sido eliminado por el autor.

  15. Unknown dice:

    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)

  16. Unknown dice:

    este es mi código para convertir de romanos a números y viceversa
    https://ideone.com/NjKaQh

  17. Anónimo dice:

    Me podrian ayudar con este ejercicio porfa

    * 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.

    1. Branco dice:

      class rectangulo:
      def __init__(self, ladosLargos, ladosCortos):
      self.ladoLargo=ladosLargos;
      self.ladoCorto=ladosCortos;

      def perimetro(self):
      self.perimetro=(self.ladoLargo*2)+(self.ladoCorto*2);
      return self.perimetro;
      def area(self):
      self.Area=self.ladoCorto*self.ladoLargo;
      return self.Area;

      class triangulo:
      def __init__(self, base, lado2, lado3, altura):
      self.Base=base;
      self.ladoDos=lado2;
      self.ladoTres=lado3;
      self.Altura=altura;
      def perimetro(self):
      self.perimetro=self.base+self.ladoDos+self.ladoTres;
      return self.perimetro;
      def area(self):
      self.Area=self.Base*self.Altura;
      return self.Area;

      lado1=float(input("Dame el lado largo: "));
      lado2=float(input("Dame el lado corto: "));
      rectangulo= rectangulo(lado1, lado2);
      print("El perimetro es:", rectangulo.perimetro()," y el área es:", rectangulo.area())

    2. Branco dice:

      ahi esta el del triangulo y el del rectangulo, amigo

  18. Unknown dice:

    Mi solucion particular para el caso de 1,2 y hasta 3 elementos del ejercicio 4,observen como utlizo un operador en python que he decubierto el operador [d:e:s] que se aplica sobre una lista y puede devolver la misma lista u otra diferente, presten atencion que no hace lo mismo que el conocido operador[n:f],donde las letras son numeros enteros.

    class conbinatoria_deelementos():
    def __init__(self):
    self.entrada=list(input("Introdusca una lisa de numeros :"))
    self.tamaño=len(self.entrada)
    self.lista=[]
    self.listavariable=[]

    def creaciondesubgrupos(self):

    n=0
    s=0

    for i in range(0,self.tamaño):
    self.listavariable.append(self.entrada[i])
    for j in range(0,self.tamaño-n):

    self.lista.append(self.entrada[i:j+2+s:j+1])

    n=n+1
    s=s+1
    #j=j-1

    self.lista.append([])

    if self.listavariable in self.lista:

    print(self.lista)
    else:
    self.lista.append(self.listavariable)
    print(self.lista)
    conjunto=conbinatoria_deelementos()
    conjunto.creaciondesubgrupos()

  19. Anónimo dice:

    Lo he hecho mas o menos. Todo lo que viene a ser el método que convierte un entero -menor de 4000- en romano esta bien pero la parte de la clase y donde se instancia el entero como un número está mal:

    class Conversor:

    def __init__(self,numero):
    self.numero = numero

    def convertir(self,numero):

    romanos = {1500:'DM',1000:'M',900:'CM',500:'D',450:'LD',400:'CD',
    100:'C',90:'XC',50:'L',40:'XL',10:'X',9:'I',5:'V',4:'IV',1:'I',0:''}

    numlist = {0:'V', 1:'L', 2:'D'}
    listnum = []
    numero = str(numero)

    for i in numero:
    listnum.append(i)

    for i in listnum:
    listnum.insert(listnum.index(i),int(i))
    listnum.remove(i)

    numrom = ''
    numero = int(numero)
    x = len(listnum)

    if numero < 4000:
    for i in listnum:
    if i in romanos:
    i *= (10**(x-1))
    numrom += romanos[i]
    else:
    if i == 2:
    numrom += romanos[10**(x-1)]*2
    elif i == 3:
    numrom += romanos[10**(x-1)]*3
    elif i == 6:
    numrom += (numlist[x-1] + romanos[10**(x-1)])
    elif i == 7:
    numrom += (numlist[x-1] + romanos[10**(x-1)]*2)
    elif i == 8:
    numrom += (numlist[x-1] + romanos[10**(x-1)]*3)

    x-= 1
    return numrom
    else:
    return 'No podemos convertir ese numero'

    Entero = Conversor(467)
    print(Entero.convertir(467))

  20. Anónimo dice:

    '''
    Escribe una Clase que Convierta un Número Entero a Número Romano.
    '''

    class Roman_Numerals(object):

    # Atributo de Clase.
    dictNumber = {1: "I", 2: "II", 3: "III", 4: "IV", 5: "V", 6: "VI", 7: "VII", 8: "VIII", 9: "IX", 10: "X"}

    # Constructor.
    def __init__(self, intNumber):
    # Variable de Instancia.
    self.intNumber = intNumber

    # Método de Instancia.
    def Convert(self):
    # Recorremos el Diccionario por las Llaves.
    for number in self.dictNumber:
    if self.intNumber == number:
    # get() regresa el Valor según la Llave asignada.
    print("El Numero {0} en Romano es {1}".format(self.intNumber, self.dictNumber.get(number)))

    if __name__ == '__main__':
    rn = Roman_Numerals(6)
    rn.Convert()

  21. Anónimo dice:

    '''
    Escribe una Clase que Convierta un Número Romano a Número Entero.
    '''

    class Roman_Numerals(object):
    # Atributo de Clase.
    dictNumber = {1: "I", 2: "II", 3: "III", 4: "IV", 5: "V", 6: "VI", 7: "VII", 8: "VIII", 9: "IX", 10: "X"}

    # Constructor.
    def __init__(self, strNumber):
    self.strNumber = strNumber

    # Método de Instancia.
    def Convert(self):
    # Recorremos el Diccionario por los Valores.
    for i in range(1, len(self.dictNumber) + 1):
    if self.strNumber == self.dictNumber[i]:
    # Obtenemos las Llaves en un tipo 'dict_keys' que después convertiremos a Lista.
    self.listKeys = list(self.dictNumber.keys())
    # Le Restamos 1 dado que las Listas empiezan con el Índice 0.
    self.listKeys = self.listKeys[i - 1]

    def __str__(self):
    return "El Numero Romano {0} es el Numero Entero {1}".format(self.strNumber, self.listKeys)

    if __name__ == '__main__':
    rn = Roman_Numerals("VII")
    rn.Convert()
    print(str(rn))

  22. Anónimo dice:

    '''
    Escribe una Clase 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]]
    '''

    class Subconjuntos:

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

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

    return sub

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

    print(s.subconj())

  23. Anónimo dice:

    '''
    Ejercicio 5
    Escribe una clase que Encuentre un Par de Elementos de una Matriz cuya Suma es Igual a un Objetivo Específico.
    Entrada: Numeros = [10,20,10,40,50,60,70] ; Objetivo=50
    Salida: 3, 4
    '''

    class Peers(object):

    # Atributo de Clase.
    list_Numbers = [10, 20, 10, 40, 50, 60, 70]

    # Constructor.
    def __init__(self, int_Obj):
    self.int_Obj = int_Obj

    # Método de Instancia.
    def findPeers(self):
    for i in range(len(self.list_Numbers)):
    if (self.list_Numbers[i] + self.list_Numbers[i - 1]) == self.int_Obj:
    self.i = i
    self.i_1 = (i-1)

    def __str__(self):
    return ("Los Indices que Suman {0} son ({2}, {1}).".format(self.int_Obj, self.i, self.i_1))

    if __name__ == '__main__':
    peers = Peers(50)
    peers.findPeers()
    print(str(peers))

  24. Anónimo dice:

    '''
    Escribir una Clase 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]]
    '''

    class Find(object):

    def __init__(self, list_Enter):
    self.listEnter = list_Enter
    self.listOut = []

    def set_Zero(self):
    for i in range(len(self.listEnter)):
    j = i + 1
    for j in range(j, len(self.listEnter)):
    k = j + 1
    for k in range(k, len(self.listEnter)):
    if (self.listEnter[i] + self.listEnter[j] + self.listEnter[k] == 0):
    self.listOut.append( [self.listEnter[i], self.listEnter[j], self.listEnter[k]] )

    def get_Zero(self):
    return self.listOut

    def __str__(self):
    return "{0}".format(self.listOut)

    sum_Zero = property(get_Zero, set_Zero)

    if __name__ == '__main__':
    f = Find( [-25,-10,-7,-3,2,4,8,10] )
    f.set_Zero()
    print("Get: ", f.get_Zero())
    print("Property: ", f.sum_Zero)
    print("STR: ", str(f))

  25. Anónimo dice:

    '''
    Escribe una Clase que Calcule pow(x, n)
    x = es la base
    n = es el exponente

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

    class Pow(object):

    # Constructor.
    def __init__(self, x, n):
    self.x = x
    self.n = n

    # Método de Instancia.
    def findPow(self):
    self.ans = (self.x ** self.n)

    def __str__(self):
    return "Entrada: ({0}, {1}). Salida: {2}.".format( self.x, self.n, self.ans )

    if __name__ == '__main__':
    p = Pow(2, -3)
    p.findPow()
    print(str(p))

  26. Anónimo dice:

    '''
    Escribe una Clase que Revierta una Cadena de Palabras.
    Entrada: "Mi Diario Python"
    Salida: "Python Diario Mi"
    '''

    class Reverse(object):

    # Constructor.
    def __init__(self, strCadena):
    self.strCadena = strCadena
    self.list_Cadena = self.strCadena.split(" ")
    self.newCadena = []

    # Método de Instancia.
    def reverse(self):
    for i in range( 0, len(self.list_Cadena) ):
    self.newCadena.append( self.list_Cadena[(i+1) * -1] )
    self.newCadena = ' '.join(self.newCadena)

    def __str__(self):
    return "Entrada: {0}. Salida: {1}.".format(self.strCadena, self.newCadena)

    if __name__ == '__main__':
    r = Reverse("Mi Diario Python")
    r.reverse()
    print(str(r))

    1. Unknown dice:

      Tiene Error,no Corre el programa

    2. Unknown dice:

      en el metodo de Instancia

    3. Anónimo dice:

      Como saldria

    4. Unknown dice:

      ayuden, bien el código porfa

  27. Omar dice:

    Numeros romanos (se que esta pobre pero es un avance):
    class Numero():

    def __init__(self,n):
    self.numero = n

    def convertir(self):

    n = self.numero
    nr = int(n)
    cont = len(n)
    pos = len(n)-1
    cad = ""
    aux = ""
    nums = {9:"IX",8:"VIII",7:"VII",6:"VI",5:"V",4:"IV",3:"III",2:"II",1:"I",0:"",10:"X",20:"XX",30:"XXX",40:"LX",50:"L",60:"LX",70:"LXX",80:"LXXX",90:"XC",
    100:"C",200:"CC",300:"CCC",400:"CD",500:"D",600:"DC",700:"DCC",800:"DCCC",900:"CM",1000:"M",2000:"MM",3000:"MMM"}
    x = 0
    while x < cont:
    l = int(n[pos:cont])
    cad = nums[l]+cad
    x = x+1
    pos = pos-1
    nr = nr - int(l)
    n = str(nr)
    return cad

    num = input("Dame un numero n")
    miNumero = Numero(num)
    print("El numero en romano es :")
    print(miNumero.convertir())

  28. Unknown dice:

    Ejercicio 11

    if __name__ == "__main__":
    class Circulo: #<-- Clase
    def __init__(self, radio, diametro): #<-- Constructor
    self.radio=radio
    self.diametro=diametro
    def calcularArea(self): #<-- 1er Metodo
    pi = 3.14
    return (self.radio**2)*pi #<-- Operacion ** significa elevado
    def calcularPeri(self): #<-- 2do Metodo
    pi = 3.14
    return self.diametro*pi
    radio=float(input("Ingrese el valor del radio: "))
    diametro=float(input("Ingrese el valor del diámetro: "))
    cir=Circulo(radio,diametro) # objeto cir llamando a la clase
    area=cir.calcularArea() # objeto area que llama al 1er metodo
    perimetro=cir.calcularPeri() #objeto perimetro que llama al 2do metodo
    print("El area del círculo es: ",area)
    print("El perimetro del círculo es: ",perimetro)

  29. David dice:

    pues, la verdad hice un desastre pero el programa funciona xD. solo admite numeros hasta el 3999 porque tome solo un grupo de caracteres romanos.

    class roman:
    def __init__(self, integer):
    self.integer = integer

    def convert(self):
    romanos = {'1':'I','5':'V','10':'X','50':'L','100':'C','500':'D','1000':'M'}
    numero_romano = [] # Lista con el resultado final
    descompose = []
    number = self.integer
    for i in range(len(number)):
    digito = number[i] + ('0'*(len(number)-(i+1)))
    descompose.append(digito)

    for n in descompose:
    numero = int(n)
    base = int(n[0])
    subnum = int(numero/ base)

    if base 4 and base 3999:
    print('Numero muy alto')
    continue
    else:
    variable = roman(intro)
    print(f'El numero {intro} equivale a:')
    new_rom = ''
    for n in variable.convert():
    new_rom += n
    print(new_rom, end='\n')
    except Exception:
    print(f'"{intro}" no es un dato valido')

    # Nota: el maximo numero posible es 3999.

    1. dcaraballo dice:

      Gracias por publicar tu solución. Saludos

  30. Jaime dice:

    class Entero:
    def __init__(self, numero):
    self.numero = numero
    self.numerosRomanos = {}

    def convertirRomano(self):
    self.numerosRomanos ={
    "0":"","1":"I","2":"II","3":"III","4":"IV","5":"V","6":"VI","7":"VII","8":"VIII","9":"IX",
    "10":"X","20":"XX","30":"XXX","40":"XL","50": "L","60":"LX","70":"LXX","80":"LXXX","90":"XC",
    "100":"C","200":"CC","300":"CCC","400":"CD","500":"D","600":"DC","700":"DCC","800":"DCC","900":"CM",
    "1000":"M","2000":"MM","3000":"MMM","4000":"(iv)"
    }
    if self.numero >= 5000 or self.numero < 0:
    print("Número no permitido")
    if self.numero = 0:
    if str(self.numero) in self.numerosRomanos:
    print("Número Romano: ",self.numerosRomanos[str(self.numero)])
    else:
    int(self.numero)
    self.separarNumeros()

    def separarNumeros(self):
    listaNumeros = []
    nc = ""
    if self.numero > 10 and self.numero 100 and self.numero 1000 and self.numero < 5000:
    n = self.numero // 1000
    listaNumeros.append(str(n*1000))
    n1 = self.numero % 1000
    listaNumeros.append(str((n1//100)*100))
    n2 = self.numero % 100
    listaNumeros.append(str((n2//10)*10))
    n3 = self.numero % 10
    listaNumeros.append(str(n3))
    for i in range(0,4):
    nc += self.numerosRomanos[listaNumeros[i]]
    print("Número Romano:", nc)

    while True:
    num = int(input("Ingrese un número entero: "))
    numero1 = Entero(num)
    numero1.convertirRomano()

  31. Jaime dice:

    #Ejercicio 1

    class Entero:
    def __init__(self, numero):
    self.numero = numero
    self.numerosRomanos = {}

    def convertirRomano(self):
    self.numerosRomanos ={
    "0":"","1":"I","2":"II","3":"III","4":"IV","5":"V","6":"VI","7":"VII","8":"VIII","9":"IX",
    "10":"X","20":"XX","30":"XXX","40":"XL","50": "L","60":"LX","70":"LXX","80":"LXXX","90":"XC",
    "100":"C","200":"CC","300":"CCC","400":"CD","500":"D","600":"DC","700":"DCC","800":"DCC","900":"CM",
    "1000":"M","2000":"MM","3000":"MMM","4000":"(iv)"
    }
    if self.numero >= 5000 or self.numero < 0:
    print("Número no permitido")
    if self.numero = 0:
    if str(self.numero) in self.numerosRomanos:
    print("Número Romano: ",self.numerosRomanos[str(self.numero)])
    else:
    int(self.numero)
    self.separarNumeros()

    def separarNumeros(self):
    listaNumeros = []
    nc = ""
    if self.numero > 10 and self.numero 100 and self.numero 1000 and self.numero < 5000:
    n = self.numero // 1000
    listaNumeros.append(str(n*1000))
    n1 = self.numero % 1000
    listaNumeros.append(str((n1//100)*100))
    n2 = self.numero % 100
    listaNumeros.append(str((n2//10)*10))
    n3 = self.numero % 10
    listaNumeros.append(str(n3))
    for i in range(0,4):
    nc += self.numerosRomanos[listaNumeros[i]]
    print("Número Romano:", nc)

    while True:
    num = int(input("Ingrese un número entero: "))
    numero1 = Entero(num)
    numero1.convertirRomano()

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Subir
White Monkey