#!/usr/bin/python

while 1:
    print """
    Opcion:
    1- Calcular area de un triangulo
    2- Calcular area de un circulo
    3- Salir
        """
    Opc = input("Elige opcion: ")
    if Opc == 1:
        dBase = input("Base: ")
        hAltura = input("Altura: ")
        print "Solucion: %d" % (dBase * hAltura / 2) 
    elif Opc == 2:
        PI = 3.14
        rRadio = input("Radio: ")
        print "Solucion: %d" % (PI * rRadio * rRadio)
    else:
        exit()

#!/usr/bin/python
# INVERSO MULTIPLICATIVO MODULAR

def egcd(a, b):
    if a == 0:
        return (b, 0, 1)
    else:
        g, y, x = egcd(b % a, a)
        return (g, x - (b // a) * y, y) 

def modinv(a, m):
    g, x, y = egcd(a, m) 
    if g != 1: 
        raise Exception("No existe el inverso modular") # SI NO EXISTE, DEVUELVE ERROR
    else: 
        return x % m 

print 
print "Ejemplo. El inverso multiplicador del numero 63 en modulo 26 es 19."
print modinv(63, 26)    # ESTA OPERACION DA 19
print  

valor1 = input("Ingresa el numero: ") 
valor2 = input("Ingresa el modulo: ") 

print
print "El INV. MULT. MODUL. del valor introducido en el modulo introducido es: ", modinv(valor1, valor2) 
print 

# =================== SEGUNDA FUNCION =================
# FUNCION LAMBDA

MMI = lambda A, n,s=1,t=0,N=0: (n < 2 and t%N or MMI(n, A%n, t, s-A//n*t, N or n),-1)[n<1] 

# DEVOLVERA (-1) SI EL VALOR (A) NO TIENE INVERSO MULTIPLICATIVO EN (N) 
# USO 
# MMI(23, 99)  DEVUELVE 56
# MMI(18, 24)  DEVUELVE -1 

print MMI(23, 99) 
print MMI(18, 24) 

# ================== TERCERA FUNCION =================

def imod(a, n):
    c = 1
    while (c % a > 0): 
        c += n
    return c // a

print imod(63, 26) # RESULTADO 19. SI NO HAY INVERSO MULTIPLICATIVO SE QUEDA EN BLANCO. 

# ==================== CUARTA FUNCION ====================

# COMO HAY TANTAS FUNCIONES DEJO EL ENLACE DE LA PAGINA DONDE LAS HE SACADO

# https://www.it-swarm.dev/es/python/funcion-inversa-multiplicativa-modular-en-python/972004398/ 

# FUNCION BASADA EN ALGORITMO DE EUCLIDES

def multiplicative_inverse(a, b):
    origA = a
    X = 0
    prevX = 1
    Y = 1
    prevY = 0
    while b != 0:
        temp = b
        quotient = a/b
        b = a%b
        a = temp
        temp = X
        a = prevX - quotient * X
        prevX = temp
        temp = Y
        Y = prevY - quotient * Y
        prevY = temp

    return origA + prevY

print multiplicative_inverse(59, 26)  # NO SE QUE PASA. DA 60 Y DEBERIA DAR 15 !!! ojo !!! 

# ==================== QUINTA FUNCION ==================

def find_mod_inv(a,m):

    for x in range(1,m):
        if((a%m)*(x%m) % m==1):
            return x
    raise Exception("El inverso modular no existe.")

#a = 13
#m = 22

a = int(input("Introduce numero: "))
m = int(input("Introduce modulo: ")) 

try:
    res=find_mod_inv(a,m)
    print("El Inverso Multiplicativo Modular es: "+ str(res))

except:
    print('El inverso modular no existe.') 

# ================ SEXTA FUNCION ===================

# USAMOS LA FUNCION INCORPORADA EN PYTHON -pow- 

print 
print "Usamos la funcion de python -pow-" 
print 

a = 38
m = 97

res = pow(a, m-2, m)
print "El inverso multiplicativo modular es: " + str(res) 
print 

 #!/usr/bin/python
# -*- coding: utf-8 -*- 
# PEQUEÑA CALCULADORA DE FRACCIONES.
from fractions import Fraction
a = Fraction(3, 5)
b = Fraction(8, 12)
c = a + b
print "(3/5) + (8/12):", c
d = Fraction(4, 6)
e = Fraction(56, 23) 
f = d - e 
print "(4/6) - (56/23):", f
g = Fraction(27, 35)
h = Fraction(17, 22) 
i = g * h 
print "(27/35) * (17/22):", i
j = a + b - e * g
print "(3/5) + (8/12) - (56/23) * (27/35)", j

#!/usr/bin/python

# SCRIPT SIMPLE DE IF-ELSE

import random

valor1 = random.randint(1,10) 
valor2 = random.randint(1,10)

print "Primer Valor:"
print valor1

print "Segundo Valor:"
print valor2

if valor1 == valor2:     
    print valor1    
    print valor2
    print "EL PRIMER VALOR ES IGUAL AL SEGUNDO VALOR"
else:
    print "EL PRIMER VALOR NO ES IGUAL AL SEGUNDO VALOR"
    
if valor1 < 5:
    print valor1
    print valor2
    print "EL PRIMER VALOR ES MENOR QUE 5"
else:
    print "EL PRIMER VALOR NO ES MENOR QUE 5"

if valor2 > 5:
    print valor1
    print valor2
    print "EL SEGUNDO VALOR ES MAYOR QUE 5"
else:
    print "EL SEGUNDO VALOR NO ES MAYOR QUE 5"

#!/usr/bin/python
#
x = int(input("Introduce un numero de menos de 5 digitos: ")) 
print x

# LA ESCALA VA DE MENOR A MAYOR. SI EL VALOR INTRODUCIDO TIENE TRES DIGITOS, EL SCRIPT DESCARTA QUE SEA MENOR QUE -10- O MENOR QUE -100-, Y ASI SUCESIVAMENTE

if x < 10:          
    print 'El valor generado tiene -1- digito'
elif x < 100: 
    print 'El valor generado tiene -2- digitos'
elif x < 1000: 
    print "El valor tiene -3- digitos" 
elif x < 10000:
    print "El valor tiene -4- digitos" 
elif x > 10000:
    print "El valor tiene -5 o mas- digitos" 

#!/usr/bin/python
# SCRIPT QUE HACE UNA COPIA DEL -archivo1- y crea el -archivo2- 

inp=open('archivo1','rb+')
outp=open('archivo2','wb+')
string=inp.read(1)

while len(string)>0:  
    outp.write(string)
    string=inp.read(1)

inp.close()
outp.close()

print "Archivo copiado"

#!/usr/bin/python
#
# SCRIPT QUE APLANA LISTAS, ES DECIR, CONVIERTE UNA LISTA DE LISTAS EN UNA SOLA LISTA

matrizresultado = [[1,2,3],[4,5,6],[7,8,9]]     # ESTO ES PARA UNA MATRIZ FIJA DE 3 X 3

print matrizresultado

# APLANANDO LISTAS

def flattener(lst):       # FUNCION QUE APLANA LA LISTA. CONVIERTE LA LISTA DE LISTAS EN UNA SOLA LISTA
    return [item for sublist in lst for item in sublist]

print flattener(matrizresultado)  # IMPRIMIMOS LA LISTA DE LISTAS EN UNA SOLA LISTA. 

# Y EL BUCLE FOR RECORRE LA LISTA E IMPRIME CADA ELEMENTO DE LA MISMA SUELTO. ELIMINAMOS LA LISTA. 

for elemento in flattener(matrizresultado):      # IMPRIMIMOS EL RESULTADO EN mod 26
    print elemento,  #%26,                        

print 

#!/usr/bin/python
#
# Interpolacion de Lagrange como calculadora de sombras.
# PRIMERO CALCULAREMOS LAS SOMBRAS 
# ELEGIMOS DOS VALORES ALEATORIOS Y EL VALOR DE LA CLAVE A OCULTAR
valor1=input("Introduce Valor 1: ")      
valor2=input("Introduce Valor 2: ")      
clave=input ("Introduce Clave: ")        
print 
# ELEGIMOS 5 VALORES AL AZAR DE x
x1=input("Introduce valor x1: ")     
x2=input("Introduce valor x2: ")     
x3=input("Introduce valor x3: ")     
x4=input("Introduce valor x4: ")     
x5=input("Introduce valor x5: ")     
print 
# CONFECCIONAMOS NUESTRAS SOMBRAS
s1=((valor1*(x1)**2)+(valor2*x1)+clave) 
s2=((valor1*(x2)**2)+(valor2*x2)+clave)
s3=((valor1*(x3)**2)+(valor2*x3)+clave) 
s4=((valor1*(x4)**2)+(valor2*x4)+clave) 
s5=((valor1*(x5)**2)+(valor2*x5)+clave) 
print 
print "Primera sombra: ", (x1,s1)
print "Segunda sombra: ", (x2,s2)
print "Tercera sombra: ", (x3,s3)
print "Cuarta sombra: ", (x4,s4)
print "Quinta sombra: ", (x5,s5) 
print  
# OPERACIONES PARA DESCIFRAR LA CLAVE PRIMIGENIA 
print
print "A continuacion introduciremos los tres pares de sombras."
print 
a=input("Introduce valor x1: ")       
b=input("Introduce valor x2: ")       
c=input("Introduce valor x3: ")       
d=input("Introduce segundo valor FLOTANTE sombra 1: ")   
e=input("Introduce segundo valor FLOTANTE sombra 2: ")   
f=input("Introduce segundo valor FLOTANTE sombra 3: ")   
print 
#==========FASE DE OPERACIONES============
g=(-b)+(-c) 
h=(-b)*(-c) 
i=a-b
j=a-c
k=i*j
l=d/k 
m=((d)*(g))/k
n=((d)*(h))/k
print 
#=======================
g1=(-a)+(-c)
h1=(-a)*(-c)
i1=b-a
j1=b-c
k1=i1*j1 
l1=e/k1 
m1=((e)*(g1))/k1
n1=((e)*(h1))/k1
print 
#=====================
g2=(-a)+(-b)
h2=(-a)*(-b)
i2=c-a
j2=c-b
k2=i2*j2 
l2=f/k2
m2=((f)*(g2))/k2
n2=((f)*(h2))/k2
print 
#======================
result1=l+l1+l2
print result1         
result2=m+m1+m2
print result2         
result3=n+n1+n2
print result3         

print
print "El numero secreto es: ", result3
print

#!/usr/bin/python
#
# BUSCADOR. EFECTUA LAS MISMAS OPERACIONES QUE grep EN bash-shell.  
# TE PIDE HASTA CUATRO PATRONES Y TE LOCALIZA LA LINEA QUE CONTENGA LOS QUE LE DES -DE 1 A LOS 4-.
# LE PUEDES PEDIR UNO O DOS Y NO TE DA NINGUN ERROR. TE BUSCA INCLUSO SUBCADENAS (amador = ama)  
print
print "Buscador. Puedes introducir hasta 4 parametros de busqueda y subcadenas."
print

archivo_de_texto = open(raw_input("Introduce el fichero con extension: "),"r")    # AQUI PODEMOS ELEGIR EL ARCHIVO A ABRIR

# PATRONES DE BUSQUEDA. SI NO INTRODUCIMOS NINGUN PATRON, NOS LISTARA EL ARCHIVO COMPLETO.  

a = raw_input("Patron 1: ")
b = raw_input("Patron 2: ")
c = raw_input("Patron 3: ")
d = raw_input("Patron 4: ")

for linea in archivo_de_texto:
    if a in linea:
        if b in linea:
            if c in linea:
                if d in linea: 
                    print linea

#!/usr/bin/python
#
# ESTE SCRIPT BUSCA UNA CADENA DE TEXTO (PALABRA) EN UNA LINEA DE UN ARCHIVO (por ejemplo un .txt), Y NOS DICE CUANTAS VECES SE REPITE. 
# SOLO BUSCA PALABRAS COMPLETAS, NO SUBCADENAS DE TEXTO.  
# SI TENEMOS LA PALABRA -murcielago- Y LE DECIMOS QUE BUSQUE -murcie- NO LO ENCONTRARA. 

print "Este programa busca una cadena de texto (solo palabras completas) en un archivo y nos dice cuantas veces se repite"


palabra = raw_input("Palabra completa a buscar: ")
archivo = raw_input("Archivo donde buscar incluida extension: ")

repetidas = 0                   
f = open(archivo, "r")          
lines = f.readlines()           

for line in lines:              
    palabras = line.split(' ')   
    for p in palabras:          
        if p == palabra:        
            repetidas = repetidas + 1   # CONTADOR

 
print "La palabra \"{0}\" se repite {1} veces en el archivo {2}".format(palabra,repetidas,archivo)