#!/usr/bin/python
# -*- coding: utf-8 -*-
# Algoritmo Cifrado de Hill en 26 caracteres.
# Funciona perfectamente. IMPORTANTISIMO LO DEL -coding utf-8- y las matrices en mod26 y mod27
# INTRODUCIMOS EN UNA LISTA EL NUMERO DE CARACTERES A UTILIZAR
v2 = ["00 ", "01 ", "02 ", "03 ", "04 ", "05 ", "06 ", "07 ", "08 ", "09 ", "10 ", "11 ", "12 ", "13 ", "14 ", "15 ", "16 ", "17 ", "18 ", "19 ", "20 ", "21 ", "22 ", "23 ", "24 ", "25 "] # 26 caracteres que conforman el alfabeto ya que -00- se cuenta como caracter.
# INTRODUCIMOS LOS CARACTERES POR LOS QUE VAN A SER SUSTITUIDOS
v1 = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"] # 26 caracteres.
print
# FUNCION QUE CONVIERTE LAS LETRAS EN NUMEROS DEL -O- AL -25-.
def crypt(text): # FUNCION QUE CODIFICA EL TEXTO PLANO
texto = text
salir = False
v3 = 0
while v3 <= 25: # MODIFICAMOS SEGUN LOS VALORES DE v1 Y v2 PARA ENTRAR EN RANGO. LO CORRECTO AQUI ES 25 YA QUE EL LIMITE DE v2 ES 25.
text = text.replace(v1[v3], v2[v3]) # REEMPLAZAMOS UNOS CARACTERES POR OTROS.
v3 = v3 + 1 # CONTADOR
# print text # ESTA LINEA IMPRIME POR PANTALLA EL RESULTADO DETALLADO. LA PODEMOS QUITAR.
print "EL TEXTO CONVERTIDO EN NUMEROS DEL -0- AL -25- ES: ", text # ESTA IMPRIME EL RESULTADO FINAL.
crypt(raw_input("INTRODUCE TEXTO PLANO -MENSAJE- A CONVERTIR EN NUMEROS DEL -0- AL -25-: "))
print
# YA TENEMOS NUESTRO TEXTO PLANO PASADO A NUMEROS DEL 0 AL 25.
# AHORA CREAMOS LAS LISTAS QUE CONTENDRA LA MATRIZ Y LAS MATRICES EN SI. CODIFICACION Y TEXTO.
# CREAMOS MATRIZ -K- QUE DEBE SER INVERTIBLE, ES DECIR, determinante distinto de 0 y m.c.d. (det, mod) = 1.
matriz1 = []
filas = int(raw_input("Inserta FILAS de Matriz de codificacion: "))
columnas = int(raw_input("Inserta COLUMNAS de Matriz de codificacion: "))
for i in range(filas):
matriz1.append([0]*columnas)
for f in range(filas):
for c in range(columnas):
matriz1[f][c] = int(raw_input("Elemento f%d, c%d : " % (f,c)))
print matriz1 # IMPRIMIMOS MATRIZ 1 o MATRIZ DE CODIFICACION
for elemento in matriz1: # IMPRIMIMOS EN FORMA DE MATRIZ
print elemento
print
# CREAMOS MATRIZ 2 QUE SERA EL TEXTO PASADO A NUMEROS ENTRE 0 Y 25
matriz2 = [] # ESTA MATRIZ NO GENERA UNA OPERACION AUTENTICA DE MATRIZ, SOLO MULTIPLICA FILAS.
filas = int(raw_input("Inserta FILAS de Matriz 2 -texto- : "))
columnas = int(raw_input("Inserta COLUMNAS de Matriz 2 -texto- : "))
for i in range(filas):
matriz2.append([0]*columnas)
for f in range(filas):
for c in range(columnas):
matriz2[f][c] = int(raw_input("Elemento %d, %d : " % (f,c))) # POR ESO AQUI NO PONEMOS FILAS Y COLUMNAS.
print matriz2 # IMPRIMIMOS MATRIZ 2
for elemento in matriz2: # IMPRIMIMOS EN FORMA DE MATRIZ
print elemento
print
# CREAMOS LA ESTRUCTURA DE LA MATRIZ RESULTADO
matrizresultado = []
filas = int(raw_input("Inserta FILAS de la Matriz Resultado: "))
columnas = int(raw_input("Inserta COLUMNAS de la Matriz Resultado: "))
for i in range(filas):
matrizresultado.append([0]*columnas)
for f in range(filas):
for c in range(columnas):
# matrizresultado[f][c] = int(raw_input("Elemento f%d, c%d : " % (f,c)))
matrizresultado[f][c] = 0 # LA MATRIZ RESULTADO DEBE SER UNA MATRIZ VACIA
print matrizresultado # IMPRIMIMOS LA FORMA DE LA MATRIZ RESULTADO
for elemento in matrizresultado: # IMPRIMIMOS LA MATRIZ RESULTADO EN FORMA DE MATRIZ
print elemento
print
# AQUI VIENE EL PROCESO DE MULTIPLICACION DE FILAS Y COLUMNAS, QUE COMO HEMOS DICHO, NO ES MUY CORRECTO.
a=3 # int(raw_input("Inserta -COLUMNAS- matriz de codificacion: ")) # METEMOS EL NUMERO DE FILAS Y COLUMNAS PARA NO LIMITARLO A 3
b=int(raw_input("Inserta -COLUMNAS- matriz de texto: ")) # EJEM: PARA MATRIZ 3 x 1 => a=3 b=1 r=3
r=3 # int(raw_input("Inserta -FILAS- matriz resultado: ")) # EJEM: PARA MATRIZ 3 x 2 => a=3 b=2 r=3
# EJEM: PARA MATRIZ 3 x 3 => a=3 b=3 r=3
# EJEM: PARA MATRIZ 3 x 4 => a=3 b=4 r=3
#for x in range(0,3):
for x in range(0,a):
# for y in range(0,3):
for y in range(0,b):
# for z in range(0,3):
for z in range(0,r):
matrizresultado[x][y]+=matriz1[x][z]*matriz2[z][y]
print matrizresultado
for elemento in matrizresultado:
print elemento
print
# AHORA TRATAMOS DE APLANAR LA LISTA DE LISTAS Y PASARLO A mod26.
def flattener(lst): # DEFINIMOS LA FUNCION QUE NOS APLANARA LA LISTA
return [item for sublist in lst for item in sublist]
#lista = [[36, 60, 41],[25, 55, 46]] ejemplo de como queda
print flattener(matrizresultado) # IMPRIMIMOS LAS LISTAS EN UNA SOLA LISTA.
#[36, 60, 41, 25, 55, 46] ejemplo de como queda
for elemento in flattener(matrizresultado): # IMPRIMIMOS EL RESULTADO EN mod 26
print elemento%26, # LA , ES PARA IMPRIMIR HORIZONTAL. (mod26)
print
# UNA VEZ OBTENIDO EL RESULTADO DE LA MULTIPLICACION DE MATRICES, PASAMOS A LA CONVERSION DE LOS NUMEROS EN TEXTO.
# INTRODUCIMOS LA LISTA DE NUMEROS A UTILIZAR
v1 = ["00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25"] # 26 caracteres que conforman el alfabeto ya que el -00- cuenta como caracter.
# INTRODUCIMOS LOS CARACTERES POR LOS QUE VAN A SER SUSTITUIDOS
v2 = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"] # 26 caracteres.
print
# FUNCION QUE NOS CONVERTIRA LAS CIFRAS OBTENIDAS EN mod26 EN LETRAS DEL ALFABETO.
def crypt(text): # FUNCION QUE CODIFICA EL TEXTO PLANO
texto = text
salir = False
v3 = 0
while v3 <= 25: # MODIFICAMOS SEGUN LOS VALORES DE v1 Y v2 PARA ENTRAR EN RANGO. LO CORRECTO ES 25.
text = text.replace(v1[v3], v2[v3]) # REEMPLAZAMOS UNOS CARACTERES POR OTROS.
v3 = v3 + 1 # CONTADOR
# print text # ESTA LINEA IMPRIME POR PANTALLA EL RESULTADO DETALLADO. LA PODEMOS QUITAR.
print "Y POR FIN, EL TEXTO FINAL ES: ", text # ESTA IMPRIME EL RESULTADO FINAL.
crypt(raw_input("PASO FINAL.- Introduce los GUARISMOS de dos en dos para convertir en TEXTO PLANO: "))
print
Mes: julio 2020
Modo sencillo y práctico de crear una matriz
#!/usr/bin/python
#
# ALGORITMO PARA CREAR UNA MATRIZ.
matriz = []
filas = int(raw_input("Inserta numero de Filas: "))
columnas = int(raw_input("Inserta numero de Columnas: "))
for i in range(filas):
matriz.append([0]*columnas)
for f in range(filas):
for c in range(columnas):
matriz[f][c] = int(raw_input("Elemento %d, %d : " % (f,c)))
print matriz
Crear una matriz
Aquí podemos ver tres formas simples de crear una matriz tanto de ceros como de los números que elijamos.
#!/usr/bin/python
#
# CREANDO MATRICES FACIL
# LA PRIMERA MAS SENCILLA E INTUITIVA
matriz1 = []
numero_filas = 3
numero_columnas = 4
for i in range(numero_filas):
matriz1.append([])
for j in range(numero_columnas):
matriz1[i].append(0) # SI QUIERES UNA MATRIZ DE CEROS O LO QUE QUIERAS.
print matriz1
print
# LA SEGUNDA MENOS INTUITIVA PERO MAS EFICIENTE
matriz2 = [None] * numero_filas
for i in range(numero_filas):
matriz2[i] = [2] * numero_columnas
print matriz2
print
# MATRIZ VACIA
matrizvacia = [None] * numero_filas
for i in range(numero_filas):
matrizvacia[i] = [] * numero_columnas
print matrizvacia
print
# VERSION MAS COMPACTA
matriz3 = [range(numero_columnas) for i in range(numero_filas)]
print matriz3
print
# VARIACION DE LA ANTERIOR
matriz4 = [[0] * numero_columnas for i in range(numero_filas)]
print matriz4
print
La salida que nos dará el script será la siguiente:
[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
[[2, 2, 2, 2], [2, 2, 2, 2], [2, 2, 2, 2]]
[[], [], []]
[[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]
[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
Funciones Lambda
#!/usr/bin/python
#
print
print "Funcion -lambda-. Permite crear una funcion anonima en linea. Resume codigo. Aqui da numeros pares e impares."
print
# LA FUNCION ORIGINAL SERIA ASI:
def es_par(n):
return (n % 2.0 == 0)
l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
l2 = filter(es_par, l)
print l2
# LA FUNCION CON lambda SERIA LA SIGUIENTE:
# PARA QUE NOS DE LOS NUMEROS PARES
l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
l2 = filter(lambda n: n % 2.0 == 0, l)
print l2
# PARA QUE NOS DE LOS NUMEROS IMPARES
l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
l3 = filter(lambda n: n % 2.0 != 0, l)
print l3
Este es un pequeño ejemplo de funciones Lambda. Son funciones que habitualmente se resumen en una sola línea de código y resumen una función más amplia. En el ejemplo vemos la función original y luego la función Lambda. La primera nos da los números pares y la segunda los impares.
Crear carpetas ocultas y codificadas en Windows
cls
@ECHO OFF
title Folder Nuevo
if EXIST "Control Panel.{21EC2020-3AEA-1069-A2DD-08002B30309D}" goto UNLOCK
if NOT EXIST Nuevo goto MDLOCKER
:CONFIRM
echo desea activar la contraseña?(Y/N)
set/p "cho=>"
if %cho%==Y goto LOCK
if %cho%==y goto LOCK
if %cho%==n goto END
if %cho%==N goto END
echo Invalid choice.
goto CONFIRM
:LOCK
ren Nuevo "Control Panel.{21EC2020-3AEA-1069-A2DD-08002B30309D}"
attrib +h +s "Control Panel.{21EC2020-3AEA-1069-A2DD-08002B30309D}"
echo Folder locked
goto End
:UNLOCK
echo Ingrese la clave para axceder a la carpeta
set/p "pass=>"
if NOT %pass%==Pon la contraseña goto FAIL
attrib -h -s "Control Panel.{21EC2020-3AEA-1069-A2DD-08002B30309D}"
ren "Control Panel.{21EC2020-3AEA-1069-A2DD-08002B30309D}" Nuevo
echo Folder Unlocked successfully
goto End
:FAIL
echo Invalid password
goto end
:MDLOCKER
md Nuevo
echo Nuevo created successfully
goto End
:End
Muy sencillo de usar.
Abres un documento .txt y copias el texto arriba indicado.
Donde pone «if NOT %pass%==Pon la contraseña goto FAIL», justo donde pone «Pon la contraseña», pones la clave que tú quieras sin dejar espacios y guardas el archivo como archivo.bat. Pinchas en el archivo y te aparecerá una nueva carpeta que se llama «nuevo». Si vuelves a pinchar en el archivo .bat, te dirá si quieres aplicar la contraseña. Le dices que sí (Y) y la carpeta se esconderá. La siguiente vez que vuelvas a pinchar en el archivo.bat te pedirá la contraseña para mostrar la carpeta. La pones y te aparecerá de nuevo la carpeta. Es muy fácil y práctico para que no te fisguen tus archivos.
Algoritmo de criptografía Arc4
#!/usr/bin/python
# -*- coding: utf-8 -*-
# WEB blog.hackxcrack.es
class ARC4:
S = []
i = 0
j = 0
def inicializacion(self, k):
S = range(256)
j = 0
for i in xrange(256):
j = (j + S[i] + ord(k[i % len(k)])) % 256
S[i], S[j] = S[j], S[i]
self.S = S
def __init__(self, clave):
self.inicializacion(clave)
def siguienteByte(self):
self.i = (self.i + 1) % 256
self.j = (self.j + self.S[self.i]) % 256
self.S[self.i], self.S[self.j] = self.S[self.j], self.S[self.i]
K = self.S[(self.S[self.i] + self.S[self.j]) % 256]
print self.S[(self.S[self.i] + self.S[self.j]) % 256], # AL PONER LA , CAMBIAMOS IMPRESION DE VERTICAL A HORIZONTAL
return K
def cifra(self, texto):
cifrado = []
for caracter in texto:
byte_texto = ord(caracter)
byte_clave = self.siguienteByte()
byte_cifrado = byte_texto ^ byte_clave # XOR !
caracter_cifrado = chr(byte_cifrado)
cifrado.append(caracter_cifrado)
return ''.join(cifrado)
cifrador = ARC4("texto")
mensaje = raw_input("Introduce mensaje para cifrar: ")
mensaje_cifrado = cifrador.cifra(mensaje)
print "El mensaje cifrado es: ", mensaje_cifrado
descifrador = ARC4("texto")
mensaje_descifrado = descifrador.cifra(mensaje_cifrado)
print "El mensaje original es: ", mensaje_descifrado
Buscador completo en archivos de texto .txt
Este buscador localiza por líneas de texto en archivos .txt
#!/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")
# 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
Imaginemos un archivo de texto con el siguiente contenido:
1 juan martinez perez fontanero 636 disponible madrid
2 pedro lopez saez albañil 434 disponible logroño
3 alberto sanchez fiz electricista 555 no disponible barcelona
4 roberto mendez enlosador 778 no disponible sevilla
Pues bien, si nosotros quisieramos buscar que trabajadores «no están disponibles» y cuales de ellos viven en «Sevilla», introduciríamos los dos parámetros a buscar y nos daría el resultado
Si introducimos los parámetros de búsqueda «no disponible» y «sevilla» inmediatamente nos llevaría a «4 roberto mendez enlosador…»
Plantilla Excel completísima de horas de trabajo en uno, dos y hasta tres turnos de mañana, tarde y noche.
La siguiente plantilla es un libro completísimo de Excel de contabilización de horas de trabajo y nómina del trabajador. Se compone a una plantilla donde se pueden hacer hasta tres turnos -mañana, tarde y noche- y lo contabiliza absolutamente todo, incluso dietas, comidas, viajes, etc… Conforme al horario que introduzcamos, nos dará el horario normal, las horas extras, si éstas son por la mañana, tarde, noche, sábados, etc… Fue un trabajo que llevó cerca de dos meses dedicándole muchas horas para que no hubiese ningún error. Lo comparto para que hagáis buen uso de ella. «El conocimiento humano pertenece al mundo».
Juego del ahorcado en Bash/Shell.
Este es el típico juego del ahorcado en Bash. Tú le pones la palabra con la que quieres jugar. Está muy bien hecho y divertido.
#!/bin/bash
# FUNCIONA PERFECTAMENTE
# Autores: Jorge Blanco De Gracia & Pablo Morata López & Daniel G. Trabada
# Licencia : GPL v3
'
_____
| \|
| |
| |
|
|
________|____
_____
| \|
| |
O|O | ALERTA. HAS COMETIDO UN ERROR. YA NO TIENES CABEZA.
|
|
________|____
_____
| \|
| |
O|O |
// | ALERTA 2. HAS COMETIDO DOS ERRORES. YA NO TIENES BRAZO.
|
________|____
_____
| \|
| |
O|O |
// \\ | ALERTA 3. HAS COMETIDO TRES ERRORES. TE HAS QUEDADO SIN DOS BRAZOS.
|
________|____
_____
| \|
| |
O|O |
// \\ |
|| | ALERTA 4. HAS COMETIDO CUATRO ERRORES. SOLO TE QUEDA UNA PIERNA. SI FALLAS UNA VEZ MAS, PIERDES.
________|____
BUSCALO EN GOOGLE. SI LO ENCUENTRAS, AVISA.
_____
| \|
| |
O|O |
// \\ |
|| || | ERES TONTO DEL CULO. YA NO HAY ALERTAS. HAS PERDIDO.
________|____
'
clear
echo -n "¿QUE PALABRA VAMOS A ADIVINAR?: "
read word
echo
# echo "Pulsa enter para continuar..."
# read continuar
clear
letra="*"
fallos=5
letras=`echo $word | sed "s/[^${letra}]/*"/g` #MOSTRAMOS LOS CARACTERES DE LA PALABRA SUSTITUIDOS POR * -ASTERISCO-
sust=$letras
while [ "$sust" != "$word" ] #MIENTRAS TODOS LOS CARACTERES NO SEAN IGUALES A LA PALABRA...
do
# clear
echo
echo "LAS LETRAS SON $sust"
echo
sed -n "$fallos,$((fallos+7))p" $0
echo
echo LETRAS INTRODUCIDAS HASTA AHORA: $a
echo
echo -n "INTRODUCE UNA LETRA: "
read letra
a=${a}$letra
palabra=${letra}$palabra #CONCATENA LAS LETRAS QUE METEMOS CON LAS QUE HAY YA INTRODUCIDAS
echo
existe=`echo ${word} | grep ${letra}` #COMPARA, Y SI NO SON IGUALES, NO MUESTRA NADA
if [ "$existe" = "" ]
then
echo "OOOOOH NO ES CORRECTO. BUSCALO EN GOOGLE - ${letra} - NO APARECE EN LA PALABRA OCULTA"
error=$((error + 1))
if [ $error = 5 ]
then
# clear
fallos=$(($fallos+9))
sed -n "$fallos,$((fallos+7))p" $0
echo "HAS COMETIDO $error ERRORES. ESTAS MUERTO"
echo
echo
exit
else
if [ $error = 1 ]
then
echo "HAS COMETIDO $error ERROR"
fallos=$(($fallos+9))
else
fallos=$(($fallos+9))
fi
fi
else
sust=`echo $word | sed "s/[^${palabra}]/*"/g` #SUSTITUYE LAS LETRAS POR LOS * ASTERISCOS
fi
if [ "${sust}" = "${word}" ] #SI SON IGUALES
then
echo "ENHORABUENA. HAS DESCUBIERTO LA PALABRA SECRETA. LA MISMA ES: ${word}."
echo
echo
fi
done
Calculadora de Máximo Común Divisor de dos números. Útil para criptografía.
Dos números son coprimos o primos entre sí cuando no tienen divisores en común (excepto 1 y -1). Por tanto, la manera de saber si dos números son coprimos es ver sus divisores. Si hay algún divisor en común entre los dos números además del 1, los números no son coprimos y si no existen, sí son coprimos.
También sabemos que el máximo común divisor de dos números coprimos es siempre 1. Por lo que también tenemos otra manera de saber cuando dos números son coprimos mirando su MCD.
MCD (A, B) = 1 ==> ENTONCES A Y B SON COPRIMOS
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# CALCULADORA M.C.D DE DOS NUMEROS. UTIL PARA CRIPTOGRAFIA, CIFRADO RSA.
# TRABAJAMOS CON DOS FUNCIONES
print
print "Calculadora de numeros coprimos o primos relativos entre si"
print
# DEFINIMOS LA PRIMERA FUNCION
x = input("Introduce el primer numero: ") # INTRODUCIMOS LOS DOS NUMEROS A COMPROBAR
y = input("Introduce el segundo numero: ")
def mcd(a, b):
if b == 0:
return a
else:
return mcd(b, a%b)
#print mcd(x, y)
print
print "El Maximo Comun Divisor de ", x, "y ", y," es: ", mcd(x, y)
print
if mcd(x, y) == 1:
print "Los numeros SON coprimos o primos relativos entre si"
else:
print "Los numeros NO SON coprimos entre si"
print
# SEGUNDA FUNCION
def mcd(a, b):
resto = 0
while(b > 0):
resto = b
b = a % b
a = resto
return a
num1 = int(input("Introduce el primer numero: "))
num2 = int(input("Introduce el segundo numero: "))
print
print "El Maximo Comun Divisor de ", num1, " y " , num2, " es: ", mcd(num1, num2)
print
if mcd(num1 ,num2) == 1:
print "Los números SON coprimos o primos relativos entre si"
else:
print "Los números NO SON coprimos entre si"
print
Presentamos un script con dos funciones que hayan el Máximo Común Divisor de dos números. Nos pedirá que ingresemos dos números.
Si por ejemplo, ingresamos los números 1 y 7 nos dirá que SON COPRIMOS o PRIMOS RELATIVOS ENTRE SÍ, ya que 1 y 7 solo son divisibles por 1.
Si ingresamos los números 9 y 27 nos dirá que los números NO SON COPRIMOS ya que 9 y 27 son divisibles también por el número 9.
Si ingresásemos los números 3 y 15 nos diría que NO SON COPRIMOS ya que ambos se pueden dividir por 3.
Python y Bash Shell en Linux 