lunes, 16 de noviembre de 2015

Ejercicios de clases y objetos en python (parte 1)

16:58 34

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

Sobre PythonDiario

Creador de @PythonDiario Amante de la Tecnología y la Naturaleza. Testing de Software, Programador Python, C# . NET

34 comentarios :

Write comentarios

Unknown23 de enero de 2016, 6:35
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
Respuestas
Unknown23 de enero de 2016, 6:52
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
Victor Cueva13 de febrero de 2016, 10:51
Este comentario ha sido eliminado por el autor.
ResponderEliminar
Respuestas
Victor Cueva13 de febrero de 2016, 12:57
Mi código: ideone.com
ResponderEliminar
Respuestas
Víctor1 de julio de 2016, 9:37
Este comentario ha sido eliminado por el autor.
ResponderEliminar
Respuestas
Víctor1 de julio de 2016, 9:50
# -*- 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
Respuestas
Víctor1 de julio de 2016, 9:53
Seguiré con los demás ejercicios, por lo pronto ahí esta el primero. Excelente pagina, Dios les bendiga.
ResponderEliminar
Respuestas
Edu3 de julio de 2016, 11:59
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
Anónimo30 de mayo de 2017, 12:34
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
Respuestas
Anónimo30 de mayo de 2017, 12:53
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
Respuestas
Anónimo30 de mayo de 2017, 13:15
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
Respuestas
Unknown4 de octubre de 2017, 13:03
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
Respuestas
Unknown4 de octubre de 2017, 22:25
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
Respuestas
Unknown5 de octubre de 2017, 10:36
Este comentario ha sido eliminado por el autor.
ResponderEliminar
Respuestas
Unknown5 de octubre de 2017, 11:06
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
Respuestas
Unknown26 de abril de 2018, 18:37
este es mi código para convertir de romanos a números y viceversa
https://ideone.com/NjKaQh
ResponderEliminar
Respuestas
Anónimo17 de mayo de 2018, 17:19
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.
ResponderEliminar
Respuestas
Unknown15 de febrero de 2019, 6:53
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()
ResponderEliminar
Respuestas
Anónimo17 de junio de 2019, 9:43
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))
ResponderEliminar
Respuestas
Anónimo11 de febrero de 2020, 22:31
'''
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()
ResponderEliminar
Respuestas
Anónimo11 de febrero de 2020, 22:33
'''
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))
ResponderEliminar
Respuestas
Anónimo11 de febrero de 2020, 22:34
'''
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())
ResponderEliminar
Respuestas
Anónimo11 de febrero de 2020, 22:34
'''
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))
ResponderEliminar
Respuestas
Anónimo11 de febrero de 2020, 22:35
'''
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))
ResponderEliminar
Respuestas
Anónimo11 de febrero de 2020, 22:36
'''
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))
ResponderEliminar
Respuestas
Anónimo11 de febrero de 2020, 22:37
'''
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))
ResponderEliminar
Respuestas
Omar26 de febrero de 2020, 14:30
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())
ResponderEliminar
Respuestas

Añadir comentario

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

Mi diario Python

lunes, 16 de noviembre de 2015

Ejercicios de clases y objetos en python (parte 1)

Sobre PythonDiario

34 comentarios :

Post Populares

Categorias

Destacado

Escritores Activos