Encriptar y desencriptar con Python

El codigo de abajo usando un diccionario encripta y desencripta le texto que tú le des.

d1={'00':'a','01':'b','02':'c','03':'d','04':'e','05':'f','06':'g','07':'h','08':'i','09':'j','10':'k','11':'l','12':'m','13':'n','14':'ñ','15':'o','16':'p','17':'q','18':'r','19':'s','20':'t','21':'u','22':'v','23':'w','24':'x','25':'y','26':'z'}
d2 = {v: k for k, v in d1.items()} #d2 es el diccionario inverso a d1

def encriptar(x,d2):
  resultado=''
  for i in x:
    resultado+=d2.get(i)
  return resultado

def desencriptar(y,d1):
  resultado=''
  for i in range(0,len(y),2):
    resultado+=d1.get(y[i]+y[i+1])
  return resultado

x=list(input("¿Qué frase quieres encriptar?").lower() or 'hola')
y=encriptar(x,d2)
print(y)
z=desencriptar(y,d1)
print(z)

Primero definimos el diccionario con los valores de las letras y el número que las identifica. Usando una función para encriptar, que empieza resultado como una variable vacía y usa un for para recorrer una por una las letras de la frase que nos ha dado el usuario, añadimos a resultado el número que representa a la letra que estamos analizando, devolvemos el valor final de resultados y lo imprimimos ya fuera del def.

Para el def desencriptar hacemos algo parecido, definimos resultado vacio, for recorriendo uno por uno los elementos de y, una variable que tiene el mismo valor que el mensaje encriptado, y luego añadimos a nuestra nueva variable, resultado, el valor que le corresponde a cada número de el diccionario de d2, que es el diccionario d1 pero cambiamos los números por las letras, y viceversa, devolvemos lo que eso nos dé.

Para finalizar el código definimos la variable x, que coge el mensaje del usuario, ejecutamos los dos def, y les damos los valores en los paréntesis, para encriptar y desencriptar e imprime todo.

Donut de colores

 Utilizando la librería matplotlib.pyplot hemos conseguido generar unos puntos de diferentes colores y que no se impriman cuando están dentro de un rango, en este caso hemos creado una forma redonda como si fuera un Donut, aunque se puede cambiar para que haga cualquier forma.

El codigo Python:

from math import sqrt  
import random  
import matplotlib.pyplot as plt  
n = 10000  
p=q=0  
plt.figure(figsize=(7,7))  
for i in range(n):  
  p = random.random() * 8 - 4  
  q = random.random() * 8 - 4  
  r = sqrt(p ** 2 + q ** 2)  
  if 2<r<4:  
    x,y=p,q  
    plt.plot(x,y,'o',markersize=1)  
plt.show()  

El resultado de ese codigo:

En el código utilizamos coordenadas cartesianas para saber en qué lugar van a estar los puntos, generamos aleatoriamente las variables x e y que pondrá los puntos aleatoriamente por toda la pantalla, no sin antes usando un if para filtrar los puntos que son impresos en la pantalla, aquí es donde podemos elegir la forma de la figura que se termine de imprimir en pantalla.

En nuestro caso esto es la parte que crea esa forma de donut.

p = random.random() * 8 - 4   
q = random.random() * 8 - 4   
r = sqrt(p ** 2 + q ** 2)   
if 2<r<4:   
  x,y=p,q   
  plt.plot(x,y,'o',markersize=1)   

Primero generamos p y q aleatoriamente con random.random(), como esto solo genera números entre uno y cero la multiplicarlo por ocho y restarle cuatro le damos los márgenes que queremos para las coordenadas cartesianas. Luego aplicamos el teorema de Pitágoras para saber a qué distancia está ese punto desde el centro del plano.

Esta imagen puede que ayude a entender lo que estamos intentando hacer:

Y luego usando un if, si ese punto está dentro de las coordenadas dos y cuatro entonces les paso los valores de p,q y x,y para añadirlo al plot y luego imprimirlo.

Nota: Si ejecutas este código en algunos editores de código como PyCharm, al importar la librería matplotlib no solo tendrás que importarla escribiéndola en el código si no que tendrás que importarla desde el propio editor. Aquí os enseñamos cómo hacerlo: https://www.youtube.com/watch?v=aROm4KYHXLI&feature=youtu.be

Algoritmo por dicotomía para obtener la raíz cuadrada de un número en Javascript

Vamos a calcular la raíz cuadrada de un número usando un algoritmo por dicotomía.

Se denomina por dicotomía ya que lo que se hace es dividir el intervalo en dos mitades y analizar en cuál de las dos mitades debería estar el valor buscado, y luego volver a dividir esa mitad en dos mitades y así sucesivamente.

Primero lo vamos a ver paso a paso en la hoja de cálculo de Google. Este es el enlace:

• https://docs.google.com/spreadsheets/d/1HtdVFoBQVLFM1kNZtgVDBchdMKRFIleBY8K2t9dp4ZA/edit?usp=sharing

Para calcular la raíz cuadrada de un número introducimos éste en la celda de color rosa (B3). Creamos una tabla con 100 iteraciones. Veamos cada columna.

• inf. Es el valor inferior del intervalo en el que se encuentra la raíz del número buscado. Inicialmente es cero, ya que al raíz de un número positivo siempre tendrá como valor inferior el cero.
• sup. Es el valor superior del intervalo donde estamos buscando la raíz del número buscado.  Inicialmente usamos como límite superior del ese intervalo el propio valor x. Si x es 2 y estamos buscando calcular la raíz de 2, el límite superior inicialmente será 2.
• med. Es la media. Es el valor medio entre el límite inferior y el límite superior. med = (inf+sup)/2. Este valor se supone que a medida que aumenten las iteraciones irá tendiendo a la raíz de x.
• med^2. Es la media al cuadrado. Este valor se supone que a medida que se sucedan las iteraciones irá tendiendo al valor de x.

Si x=2 quiere decir que estamos intentando calcular la raíz cuadrada de 2.

Veamos como se calcula el valor inf y sup de las siguientes iteraciones. Se calcula utilizando condicionales IF.

• Si med^2 es menor que x entonces inf=med. Vea la fórmula de la celda E5: =if(H4<$B$3;G4;E4)
•  Si med^2 es mayor que x entonces sup=med. Vea la fórmula de la celda E6: =if(H4>$B$3;G4;F4)

Veamos el resultado si x=40.

Veamos el resultado si x=400.

Vamos a implementar este algoritmo en Javascript.

 <!DOCTYPE html>  
 <html>  
  <head>  
   <meta charset="utf-8">  
   <title>Algoritmo de cálculo de la Raíz cuadrada en Javascript</title>  
  </head>  
  <body>  
   <script>  
    var x=Math.floor(prompt("Indique el número",40));  
    var inf=0;  
    var sup=x;  
    var media=(inf+sup)/2;  
    var ciclos=0;  
    console.log("x: "+x);  
    while(Math.abs(Math.pow(media,2)-x)>1e-16 && ciclos<1000){  
    console.log("inf: "+inf);  
    console.log("sup: "+sup);  
    console.log("media: "+media);  
    console.log("_____________");  
    if (Math.pow(media,2)<x){  
     inf=media;  
    }else{  
     sup=media;  
    }  
    media=(inf+sup)/2;  
    ciclos++; //ciclos evita que se quede pillado el código por haber pedido una precisión tan fina  
    //se podría haber quitado ciclos si la precisión fuera 1e-14  
    }  
    document.write(media +" valor calculado"+"<br>");  
    document.write(Math.sqrt(x,2)+" raiz cuadrada"+"<br>");  
    document.write(Math.abs(Math.sqrt(x,2)-media)+" Error");  
   </script>  
  </body>  
 </html>  

El enlace para ver el programa es el siguiente. Vea la consola (pulsando F12 y Console, en Chrome) para comprobar cómo se ha ido produciendo la convergencia.

• https://financieras.github.io/js/raizCuadrada/raizCuadrada.html

Después de ejecutar el programa puede ver el código pulsando Control+u.

El juego de la última piedra.

Hay X número de piedras, en cada ronda tendrás que quitar una dos o tres, la máquina hará lo mismo.

El jugador que quite la última piedra pierde.

Para jugar: https://magnitopic.github.io/edujs/piedras/

El código de JavaScript

  function maquina(n){  
     m=(n-1)%4 //número de piedas que quita la máquina  
     if (m==0){  
         m=(Math.floor(Math.random()*3)+1);  
     }  
     return m;  
 }  
 document.write('<h1>'+"Este es el juego de"+'</h1>');  
 document.write('<h1>'+"LA ÚLTIMA PIEDRA"+'</h1>');  
 document.write("Usted dispone de un conjunto de piedras iniciales."+'<br>');  
 document.write("Juega contra la máquina"+'<br>');  
 document.write("En cada tirada, tanto usted como la máquina,"+'<br>');  
 document.write("pueden quirar una piedra, dos piedras o tres piedras."+'<br>');  
 document.write("Es obligatorio quitar como mínimo 1 pieda y como máximo 3."+'<br>');  
 document.write("Comienza jugando usted y el último que quita pierde."+'<br>');  
 var n=Math.floor(Math.random()*12)+10 //número inicial de piedras  
 document.write("Número inicial de piedras: "+n+'<br>');  
 var x,m,juega=true;  
 do {  
     do {  
         x = prompt ("Quedan "+n+"\nDime cuantas piedas quitas: 1, 2 o 3");  
     }  
     while (x<1 || x>3)  
     n=n-x;  
     document.write("Usted ha quitado "+x+" piedas. Quedan "+n+'<br>');  
     if (n<=0){  
         juega=false;  
         document.write('<h2>'+"La máquina gana."+'</h2>');  
     } else {  
         m=maquina(n);  
         n=n-m;  
         document.write("La máquina ha quitado "+m+" piedas. Quedan "+n+'<br>');  
         if (n<=0){  
             juega=false;  
             document.write('<h2>'+"Usted gana."+'</h2>');  
         }  
     }  
 }  
 while (juega);   

El código de HTML

  <!DOCTYPE html>   
  <html>   
  <head>   
  <meta charset="UTF-8">   
  <title>juego de la última piedra en JavaScript</title>   
  <script type="text/javascript" src="piedras.js">   
  </script>   
  </head>   
  <body>   
  </body>   
  </html>