Ejercicios de clases y objetos en python (parte 1)

Victor Cueva dice:

Este comentario ha sido eliminado por el autor.

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

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

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)

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)

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

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

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

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

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