Mostrando entradas con la etiqueta funciones. Mostrar todas las entradas
Mostrando entradas con la etiqueta funciones. Mostrar todas las entradas

martes, 19 de enero de 2021

Factorización en Python

Esta entrada del blog pertenece a una serie:


La factorización o descomposición en factores primos nos permite, dado un entero positivo, encontrar los números primos que multiplicados entre si nos den el número analizado. Por ejemplo, el número 33.880 se puede expresar como el producto de los siguientes números primos:

33880   =   2 x 2 x 2 x 5 x 7 x 11 x 11   =   23 x 5 x 7 x 112

A este proceso también se le conoce como descomposición factorial.

Descomposición factorial de un número

En Python podemos utilizar el siguiente código para conseguir descomponer números enteros positivos.

#!/bin/python3
# Descomposición en factores primos

def factoring(n): #descomposición en factores primos
  text= str(n) + ' = '
  i = 1
  for i in range(1, int(n/2)+1, 2):      # recorre los impares
    if i==1: i=2                         # salvo el 1 que será 2
    counter = 0
    while n % i == 0:
      n /= i
      counter += 1
    if counter == 1:
      text += str(i)+ ' × '
    elif counter > 1:
      text += str(i) + '^' + str (counter) + ' × '
  if text[-2] == "=":       # si no hay divisores
    text += str(n) + ' × '  # en ese caso el propio n será primo
  text += '1'
  return text

if __name__ == "__main__":
  while True:
    try:
      n = int(input('Introduzca el número a factorizar: ') or 202)
      if 1 < n <= 1e10:
        break
      else:
        print('Por favor, introduzca un número en el rango [2,10_000_000_000]')
    except ValueError:
      print('Por favor itroduzca un número entero positivo.')

  print(factoring(n))

Se basa en ir dividiendo sucesivamente primero entre 2, hasta que no sea divisible, luego entre 3 hasta que no sea divisible, y así con todos los números siguientes. Si bien, sabemos que si ya hemos dividido entre 2 todo lo posible, el número analizado no será divisible entre 4, por lo que podríamos saltar el 4. Esto es, únicamente tendríamos que dividir entre los primos menores al número analizado. Pero esto nos obligaría a ir calculando previamente los primos, por lo que optamos por dividir entre 2 y entre todos los impares menores que el número analizado.


Hemos solicitado factorizar el número 4.379.695.320 y el resultado que hemos obtenido es:

4379695320 = 2^3 × 3 × 5 × 7 × 11 × 13 × 19^2 × 101 × 1

Factorizar una serie de números

En este caso hemos adaptado el código anterior para poder aplicar la descomposición en factores primos a un rango de números.

#!/bin/python3  
# Descomposición en factores primos  
def factoring(n): #descomposición en factores primos  
  global r  
  r=1 # r es el resultado (variable global), sirve para comprobar que al final se cumple que r = n  
  text= str(n) + ' = '  
  for i in range(1,n+1,2):      # recorre los impares  
    if i==1: i=2          # salvo el 1 que será 2  
    counter = 0  
    while n%i == 0:  
      n /= i  
      r *= i           # el resultado r al final ha de coincidir con n. El valor de r se forma multiplicando los factores  
      counter+=1  
    if counter == 1:  
      text += str(i)+ ' × '  
    elif counter >1:  
      text += str(i) + '^' + str (counter) + ' × '  
  text += '1'  
  return text  
for j in range(2,20): # Descomposición en factores primos para los números comprendidos entre 2 y 19  
  text=factoring(j)  # Invocamos la función  
  print('{}  {}'.format(j==r, text))  # Si el número analizado coincide con el resultado r da True. r se obtiene multiplicando sus factores  
  if j!=r:  
    print('r = ',r)  
    break               # Si la comprobación da False se muestra el valor de r para ver el posible error.  


El valor True que figura en cada línea impresa indica que se ha pasado exitosamente la comprobación en la que el resultado r ha coincidido con el valor analizado en cada línea. El valor r se obtiene multiplicando todos los factores en los que hemos conseguido descomponer el número analizado.

Si lo desea, puede aumentar el rango para que llegue hasta 1.000 o más, y verá que, rápidamente, se llena su pantalla con todos los números sobre los que se va produciendo la descomposición en factores primos.

lunes, 15 de julio de 2019

Funciones en JavaScript (2/3)

Esta entrada forma parte de una serie.
  1. Funciones en JavaScript (1/3)
  2. Funciones en JavaScript (2/3)  ← Estamos en esta entrada
  3. Funciones en JavaScript (3/3)

Invocar dos funciones

Podemos crear dos funciones independientes y luego invocar una y usar como argumento el resultado de invocar la otra.

Creamos una primera función denominada aleatorio(min,max) que genera un número aleatorio entero entre dos valores dados.
Creamos una segunda función denominada davocal(num) que devuelve una vocal de la lista de vocales según el orden que le indiquemos de esa lista. Se ha de tener en cuenta que las listas comienzan en cero.
Finalmente invocamos la función davocal que es una función que tiene como argumento el resultado de otra función que es la función aleatorio.


https://repl.it/@valoro/JS-invocar-dos-funciones


 // Veamos como invocar a dos funciones  
 // Primera función: genera un número aleatorio  
 function aleatorio(min,max){  
  alea=Math.round(Math.random()*(max-min)+min);  
  return alea;  
 }  
 // Segunda función: proporciona una vocal  
 function davocal(num){  
  var vocales=["a","e","i","o","u"];  
  return vocales[num];  
 }  
   
 var elegida=davocal(aleatorio(0,4));  
 document.write("La vocal del sorteo 1 es: "+elegida);  

Función dentro de otra función

Una función puede invocar a otra función dentro de ella. El ejemplo planteado es similar al anterior donde queremos generar una vocal elegida aleatoriamente de entre las contenidas en la lista de vocales. La primera función se denomina aleatorio y es idéntica a la del caso anterior. La segunda función se denomina damevocal() y difiere calramente del caso anterior ya que en esta ocasión invocamos a la función primera dentro de la función segunda.


https://repl.it/@valoro/JS-funcion-dentro-de-funcion


 // Una función llama a otra función dentro de ella  
 // Primera función: genera un número aleatorio  
 function aleatorio(min,max){  
  alea=Math.round(Math.random()*(max-min)+min);  
  return alea;  
 }  
   
 // Segunda función: proporciona una vocal  
 function damevocal(){  
  var vocales=["a","e","i","o","u"];  
  return vocales[aleatorio(0,4)];  
 }  
 // Invocamos la función  
 var mielegida=damevocal();  
 document.write("La vocal del sorteo 2 es: "+mielegida);  

Función autoejecutable

Podemos crear una función anónima que se ejecuta ella sola, no es necesario invocarla. Veamos un ejemplo.

La siguiente función ejecutará un alert que nos saluda. Observe que la función no ha sido invocada y sin embargo se ejecuta automáticamente. No es necesario llamar a la función para que ésta se ejecute.


https://repl.it/@valoro/JS-funcion-autoejecutable

 (function(){alert("Hola")})();  

Analicemos detenidamente la línea de código anterior. Tenemos una función anónima, que no lleva nombre. Las funciones anónimas habitualmente se asignan a una variable pero en este caso no lo hacemos.

El núcleo básico de la función anónima es el siguiente, pero si lo ejecuta dará error.

function(){alert("Hola")}

El error que proporciona es el siguiente.

SyntaxError: Function statements require a function name

Es un error que nos indica que la función no tiene nombre y que tampoco se trata de una función anónima normal ya que en ese caso debería ir asignada a una variable.
Una forma de solucionar el error sería asignar una variable a la función anónima de la siguiente forma.

var f=function(){alert("Hola")};
f();

Pero esta no será la forma en la que solucionemos este error ya que no deseamos asignar la función anónima a una variable. Lo que queremos es que la función anónima de momento no de error y luego deseamos conseguir que se ejecute ella sola.
Para evitar que de error podemos envolver la función entre paréntesis. De momento quedaría de esta forma.

(function(){alert("Hola")});

Con la línea de código anterior no obtenemos error pero no hace nada.

Nos gustaría que se autoejecutara la función para ello añadiremos unos paréntesis al final. Los dos paréntesis finales () permiten llamar a la función anónima.

(function(){alert("Hola")})();

Ahora ya hemos conseguido que se ejecute automáticamente la función, ya tenemos una función anónima autoejecutable.

Los paréntesis que rodean la función se pueden sustituir por otros signos, por ejemplo + , - , ~, ! o con todos al mismo tiempo. Lo que hacen estos signos es forzar a que la función esté correctamente definida ya que evitan que aún siendo una función anónima se tenga que asignar a una variable.

Así pues, también funcionaraía lo siguiente, aunque queda un poco extraño.

!+-~function(){alert("Hola")}();

Llamar a una función en JavaScript usando los paréntesis

En JavaScript para llamar a una función hemos de usar los paréntesis (), incluyendo dentro de ellos los argumentos de la función en caso de que las función tenga parámetros que utilizar. Si no se ponden los paréntesis no obtendremos un error, lo que conseguiremos es hacer referencia a esa función pero si la función devuelve un valor con return no conseguiremos capturar ese valor devuelto. Veamos un ejemplo.



https://repl.it/@valoro/JS-referencia-a-una-funcion

 function miFuncion1(){return 10};  
 function miFuncion2(){return 20};  
   
 var f1=miFuncion1();  
 var f2=miFuncion2;  
   
 document.write("El contenido de f1 es: ",f1);  
 document.write("<br>");  
 document.write("El contenido de f2 es: ",f2);  
 document.write("<br>");  
 document.write("El contenido de f2() es: ",f2());  

La diferencia entre f1 y f2 reside en la forma en la que hemos definido con var estas dos variables. En el caso de f1 ha sido asignada a la función miFuncion1(), los paréntesis finales son importantes ya que permiten que la función se ejecute y el resultado enviado por el return se almacene en la variable f1. Este es el motivo por el que f1 vale 10 cuando lo imprimimos con document.write.

Por el contrario, al definir f2 con var hemos omitido los paréntesis finales esto supone que la función miFuncion2 no se ejecutará pero si existe una referencia a miFuncion2. Por este motivo, para ejecutar la función no basta con escribir f2 sino que hemos de esciribir f2(), de forma que al añadir los paréntisis finales conseguimos que la función miFuncion2 se ejecute y que f2 almacene el valor 20 devuelto por el return.

Encapsular funciones dentro de una función

En ocasiones utilizamos nombres de variables o funciones de los que no estamos seguros si ya se estarán utilizando en la página web en la que estamos introduciendo este nuevo script. Para evitar interferencias con otras variables globales o con otros nombres de función es habitual utilizar una técnica de programación que consiste en encerrar todo nuestro nuevo código dentro de una función anónima autoejecutable. Debido a que las variables dentro de una función únicamente actuan en ese ámbio nos garantizamos que quedan aisladas de las que puedieran existir en otros script previos que están corriendo en nuestra página.


La comprobación de que la función está correctamente construida podemos verla si convertimos en un comentario la declaración de la variable mititulo. De esta forma queda anulada la variable y únicamente actua correctamente la función. La función lo que hace es proporcionarnos el título de la página web en la que se esta ejecutando.

Supongamos que definimos con var la variable mititulo y luego creamos una función con nombre mititulo. Lo que conseguiremos al ejecutar la función es un error ya que estamos empleando el mismo nombre para la función y para el título.


Este comportamiento es frecuente en páginas web con una gran cantidad de nombres de variables y funciones que en muchos casos no hemos creado nosotros y sobre las que deseamos añadir una nueva función. Para evitar conflictos de nombres un buen truco consiste en encapsular nuestro script dentro de una función anónima autoejecutable. Este truco es tan habitual en muchos casos que se ha convertido en una metodología de programación dentro de JavaScript.

Mediante el siguiente código vamos a encapsular dentro de una función autoejecutable otra función denominada miFuncion. Observe como los parámetros window y document se pasan al interior de la función anónima con los alias w y d.

https://repl.it/@valoro/JS-parametros-de-inicializacion


 (function (w, d){  
  (function miFuncion(){  
   alert(d.title)  
  })();  
 })(window, document);  

domingo, 14 de julio de 2019

Funciones en JavaScript (1/3)

Esta entrada forma parte de una serie.
  1. Funciones en JavaScript (1/3)  ← Estamos en esta entrada
  2. Funciones en JavaScript (2/3)
  3. Funciones en JavaScript (3/3)

Veamos la estructura habitual en una función de JavaScript y luego iremos viendo direfentes variantes.

Función sin parámetros y sin return

Las funciones en JavaScript se definen o declaran escribiendo la palabra calve function luego el nombre de la función seguido de unos paréntesis () dentro de los que pueden ir de forma optativa una serie de argumentos o parámetros, luego van una llaves {} dentro de las cuales se añaden las diferentes líneas de código que lleva la función. La última línea de código dentro de las llaves es una instrucción return que es optativa, y en caso de existir, proporciona el valor que devuelve la función.

En general es una buena práctica de programación crear funciones que devuelvan un valor por lo que lo recomendable es que exista ese return pero esta forma de trabajar es optativa. En este ejemplo vamos a crear una función que no lleva ni return ni parámetros dentro de los paréntesis.

La función tiene un nombre que es saluda. Dentro de los paréntesis no escribimos ningún parámetro. Dentro de la función está la instrucción que mustra en pantalla la palabra 'Hola' pero no existe ningún return al final de la función que nos devuelva algún valor.

La función se invoca o ejecuta escribiendo el nombre de la función y los paréntesis saluda(), si llevara parámetros o argumentos deberían ir dentro de los paréntesis.

El resultado se puede ver en una página web donde únicamente se mustra la palabra 'Hola'.


https://repl.it/@valoro/FuncionJSsinParametrossinReturn

 // FUNCIONES EN JavaScript  
 // Una función sencilla sin return  
 function saluda(){  
  document.write("Hola");  
 }  
 saluda(); //invocamos la función  

Función sin parámetros y con return

Lo habitual y lo aconsejable es que una función finalice con un return que devuelve un valor. Ese valor es el que ha elaborado la función y es lo que al concluir el código de la función ésta devuelve. Y justo se devuelve en el punto en el que ha sido invocada esa función.


https://repl.it/@valoro/FuncionJSsinParametrosconReturn

 // La misma función que antes pero con return  
 function saluda(){  
  return "¿Qué tal?"  
 }  
 document.write(saluda());  //Llamamos a la función  

Función con un parámetro

Veamos cómo se trabaja en una función cuando lleva un parámetro dentro de los paréntesis. En este ejemplo, queremos que la función salude a una persona y por lo tanto la función recibe como parámetro el nombre de la persona que debe saludar.

https://repl.it/@valoro/Una-funcion-con-un-parametro

Cuando invocamos la función le pasamos el nombre de una persona saluda("Alex"). La función recibe ese nombre y lo convierte a mayúsculas. Esta es una línea que se ha escrito dentro de la función a modo de ejemplo, para ver que la función realizará los cálculos que tengamos previostos y finalmente devolverá su resultado mediante el uso de return.


 // Una función con un parámetro  
 function saluda(persona){  
  persona=persona.toUpperCase()  
  return "¿Cómo vas, "+persona  
 }  
 document.write(saluda("Alex"),"?");  

Función con dos parámetros

Ahora vamos a crear una función que utiliza dos parámetros que hemos llamado a y b. Queremos restar a-b. Aquí el orden importa y sabemos quién es el parámetro a y quién es b por el orden que ocupan. Al invocar la función restar(8,5) estaremos restando 8-5, y por el contrario si invocáramos la función restar(5,8) estaríamos restando 5-8, cuyo resultado sería diferente. Por lo tanto, el orden de los parámetros importa.


https://repl.it/@valoro/Funcion-con-dos-parametros

 // Función con dos parámetros  
 function resta(num1,num2){  
  var resultado=num1-num2;  
  return resultado;  
 }  
 var a=8;  
 var b=5;  
 var diferencia=resta(a,b);  
 document.write("Si restamos "+a+" menos "+b+" obtenemos: ",diferencia)  
 //sabemos quién es cada parámetro por el orden que ocupan  

Variables globales y variables locales

Las variables definidas dentro de una función se llaman variables locales y su ámbito de actuación se reduce únicamente al código que hay dentro de la función. Las variables que se declaran dentro de una función únicamente existen dentro de esa función. Aunque exista otra variable con el mismo nombre fuera de esa función no se verán afectadas la una por la otra, serán independientes.

Las variables que se definen fuera de una función se llaman variables globales y su ámbito de actuación abarca tanto el código que hay fuera de la función como dentro de la función y permiten que varias funciones puedan manejar los valores de esas variables. Esto supone uno de los métodos mediante los que las funciones pueden interactuar unas con otras y con el resto del código que existe fuera de ellas. La otra forma que tienen las funciones de pasarse información o datos entre ellas es utilizar los parémetros que van dentro de los paréntesis.

Si existe un nombre de variable que se ha definido fuera de una función (variable global) y ese mismo nombre también se ha definido dentro de una función (variable local), podemos comprobar que cuando la función finaliza el valor de la variable local no condiciona (no afecta) al valor de la variable global. Esto es, cuando la función finaliza con un cierto valor de la variable local, este valor no se traslada fuera, salvo que vaya en el return. Veamos un ejemplo de este comportamiento.


La variable global a toma el valor a=90. Luego dentro de la función se define el mismo nombre de función con el valor a=7. Se invoca la función y finalmente, fuera de la función, se muestra el valor de la variable a que vuelve a ser a=90. Esto supone que el valor de la variable local a=7 murió al finalizar la función y que no afectó al valor de la variable global.

https://repl.it/@valoro/JS-variables-globales-y-variables-locales

 var a=90;  
 document.write("Definimos la variable global con el valor a="+a);  
 function cambia(){  
  var a=7; //es imprescindible poner VAR pq sino no funciona bien  
  document.write("<br>"+"El valor de la variable dentro de la función es a="+a);  
 }  
 cambia(); //invocamos la función  
 document.write("<br>"+"El valor de la variable fuera de la función es a="+a);  

Nota. Si dentro de la función no ponemos la palabra clave var al definir la variable a no se cumple lo que hemos dicho. Esto es importante para evitar errores y para que no nos volvamos locos media mañana haciendo debugging buscando el error.

Variables globales

Veamos un nuevo ejemplo para entender cómo funcionan las variables globales y cómo podemos conseguir que entren dentro de una función y ésta devuelva la variable global alterada.

https://repl.it/@valoro/JS-variables-globales

Observamos que en un primer momento el valor de a que obenemos por consola es 10. Pero si sustituimos f1() por a=f1(), el valor de a en consola será de 20. Y si además sustituimos f2() por a=f2() lo que logramos es que el valor de a en consola sea de 22.

Este ha sido un ejemplo de cómo podemos hacer que una variable global pueda ser usada por una función y devuelta por ésta con una modificación de su valor.

Variables globales usadas en funciones

Una variable definida fuera de cualquier función es una variable global cuyo ámbito de actuación abarca toda la página.

https://repl.it/@valoro/JS-variable-global-en-una-funcion1

Disponemos de una función denominada dobla que permite doblar el valor de la variable que le pasemos como parámetro.
  • Comenzamos con la variable a que inicialmente vale 100.
  • Al ejecutar la primera vez la función dobla conseguimos que devuelve el valor 200
  • Consultamos la variable global y sigue valiendo 100
  • Ejecutamos la función una segunda vez y obtenemos el valor 200

Esto es lógico y es lo que cabe esperar ya que al finalizar la función la variable global sigue valiendo 100.



La función en JavaScript puede ir en cualquier sitio, así que la hemos puesto al final.

Hagamos una variante en la función. Ahora la variable ya no se llamará c sino que se llemará a al igual que la variable global y además (importante) quitaremos el var que hemos usado dentro de la función.



En este segundo caso hemos logrado doblar dos veces el valor inicial de a por lo que ahora vale 400. Esto supone en la práctica que la función ha retornado el valor alterado de la variable global a.

Función anónima

Una función anónima es aquella que no lleva nombre de función. Lo que hacemos es crear una función sin nombre que asigna a una variable el valor que calcule.

https://repl.it/@valoro/JS-funcion-anonima1

 var a=function(){console.log("hola")};  
 a();  

Función anónima sin parámetros

También es posible crear una función anónima sin parámetros. Este ejemplo únicamente nos saluda.


 // Función anónima sin parámetros  
 var buenosdias=function(){  
  return "Hi";  
 }  
 document.write(buenosdias());  

Función anónima con un parámetro

En nuestro ejemplo queremos calcular el cuadrado de un número la función asigna el resultado a la variable cuadrado. La forma de invocar la función es poniendo cuadrado(3) para calcular 3 elevado a 2.

https://repl.it/@valoro/JS-funcion-anonima2


 // Función anónima es aquella que no tiene nombre  
 var cuadrado=function(num){  
  return num*num;  
 }  
 var resultado=cuadrado(3); // Así invocamos la función  
 document.write("Si elevamos 3 al cuadrado obtenemos: ", resultado);  
 document.write("<br>"+"3<sup>2</sup>="+resultado);  

Función anónima con varios parámetros

Veamos una función anónima con múltiples parámetros. En este ejemplo, calcularemos el voluman de un cono cuya fórmula es la siguiente.

Volumen cono = (1/3) * Área de la base circular * Altura =
= (1/3) * pi * radio al cuadrado * Altura =
= (1/3) * π * r2 * h

La función utiliza los parámetros radio y altura. Observe que al llamar a la función los parámetros se llaman r y h y que luego se reciben con nombres diferentes, se reciben como radio y altura. Para saber qué parámetro es cada uno de ellos nos guiamos por el orden de los parámetros primero va el radio (r) y luego la altura (h).

Creamos una variable denominada texto que se va concatenando con él usando += lo que permite ir añadiendo cada vez una porción más del string que estamos construyendo. Finalmente la variable texto será la que se imprima en pantalla.


https://repl.it/@valoro/JS-funcion-anonima-conVariosParametros

 // Función anónima con varios parámetros  
 var volumencono=function(radio,altura){  
  var volumen=(1/3)*altura*radio*radio*Math.PI;  
  return volumen;  
 }  
 var r=2; //radio  
 var h=5; //altura  
 texto="El volumen de un cono de radio ";  
 texto+=r;  
 texto+=" y altura ";  
 texto+=h;  
 texto+=" es: ";  
 document.write(texto,volumencono(r,h));  

Función con nombre vs función anónima

Existe una diferencia fundamental entre ambos tipos de funciones que tiene que ver con el lugar en el que se puede situar la función dentro del código.

La función con nombre puede ponerse en cualquier sitio. Se puede invocar antes de declararla, ya que JavaScript antes de ejecutar el códgio identifica todas las funciones que tengan nombre. Por el contrario una función anónima ha de ser declarada antes de ser invocada.

Primero vamos a invocar la función dia() y al final declaramos la función. Esto se puede hacer ya que la función dia es una función con nombre. Algunos programadores dejan para el final todas las funciones con nombre.


 dia();  
   
 function dia(){  
  var hoy=new Date();  
  document.write("Hoy es día: ",hoy.getDate());  
 }  

lunes, 18 de marzo de 2019

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.

martes, 1 de mayo de 2018

Pascal's triangle

Pascal's triangle is a triangular array named after Blaise Pascal. The triangle is compleated by the sum of the two numbers above it, if there's no number on the side its value is 0.

We used JS to make our own Pascal's triangle. The code we used:

index.html
 <!DOCTYPE html>  
 <html>  
  <head>  
   <meta charset="utf-8">  
   <meta name="viewport" content="width=device-width">  
   <title>repl.it</title>  
   <link href="index.css" rel="stylesheet" type="text/css" />  
  </head>  
  <body>  
   <h2>Pascal's triangle</h2>  
   <input type="number" id="main">  
   <button class="button" onclick="calculate()">Calculate</button>  
   <p id="potato"></p>  
   <script src="index.js"></script>  
  </body>  
 </html>  
index.js
 function calculate(){  
  window.n= document.getElementById("main").value;   
  var V=new Array(n);  
  var N=new Array(n);  
  var text='';  
  for (i=0;i<=n;i++){  
   V[i]=0;  
   N[i]=0;  
  }  
  V[1]=1; //This is the vertex  
  text+=V[1]+'<br>';  
  //We travel from row 2 to n  
  for (j=2;j<=n;j++){  
   //Let's create the new vector  
   for (i=1;i<=j;i++){  
    N[i]=V[i-1]+V[i];  
    text+=N[i]+' ';  
   }  
   text+='<br>';  
   for (i=0;i<=n;i++){  
    V[i]=N[i];  
   }  
  }  
  document.getElementById("potato").innerHTML = text; //Print everything  
 }  
The result

Try the result you're self: https://pascals-triangle--magnitopic.repl.co/

domingo, 17 de septiembre de 2017

Funciones en Python

Puede descargar el archivo: funcionSaluda.py

Las funciones en Python que podemos programar comienzan con def, luego el nombre de la función y entre paréntesis los argumentos que lleven separados por comas. También es frecuente que las funciones no lleven argumentos entonces simplemente se ponen los paréntesis (). Al final la función puede terminar con return si deseamos retornar un valor.
Los dos puntos : al final de la primera línea son importantes. Al pulsar enter en ese momento conseguiremos que la segunda línea quede indentada, lo cual es fundamental para que el intérprete de Python sepa que es línea y todas las demás que vayan indentadas pertenecen a la función. Recordemos que en Python no se usan llaves {} como en otros lenguajes.

Ejemplo 1

Veamos nuestra primera función que se llama saluda y no lleva argumentos, pero es imprescindible escribir los paréntesis (). Tampoco lleva un return al final de la función ya que esta no retorna ningún valor, sino que lo que hace es una acción, print.
Para llamar a la función o invocar a la función simplemente hemos de escribir su nombre y no olvidarnos de los paréntesis.

def saluda():  
  print("Hola, buenos días.")  
saluda()  

Ejemplo 2

Veamos ahora un caso donde si usamos argumentos y donde si retornamos un valor.

def producto(x,y):  
  return x*y  
resultado=producto(3,5)  
print(resultado)  

En el ejemplo anterior la función está formada por las dos primeras líneas. Deseamos calcular el producto de dos números x e y, que actúan como parámetros.
La tercera línea llama a la función pasándole como parámetros los valores:
  • x=3
  • y=5
Sabemos que estos son los valores asignados por la posición que ocupan. La x es la primera variable y la y la segunda.

Ejemplo 3

Preguntamos al usuario a quién quiere saludar. Mediante input recogemos el nombre que el usuario nos diga mediante teclado.

#Creamos una función que saluda a una persona  
def saluda(persona):  
 print("Hola ",persona)  
 print("Anímate a programar en Python.")  
   
nombre=str(input("Indique el nombre de la persona a la que quiere saludar: "))  
saluda(nombre)  

miércoles, 12 de julio de 2017

Comenzar la ejecución de un programa en Javascript al ir a una página

Existen dos posibilidades que permiten comenzar la ejecución de un script al abrir una página.
  • window.onload
  • document.onload

window.onload

Lo adecuado es llamar al archivo de Javascript desde el head, pero esto supone que en ocasiones se pueden llegar a ejecutar las instrucciones del script antes de que se haya terminado de cargar toda la página y si alguna línea del script que se está ejecutando necesita que exista algún elemento del body que aún no se ha cargado puede dar lugar a un error. Esto se podría solucionar llamando al archivo js justo al final del body, con ello nos aseguramos que ya se han cargado todas las estructuras html del body y que no se producirá ese tipo de error. Pero esto último no es una solución adecuada ya que el body se ha de reservar para la estructura html y no para llamar al script, cosa que se ha de hacer desde el head. Esto se soluciona poniendo la llamada al fichero js desde el head y usando window.onload que permite ejecutar la función que le indiquemos justo después de haber cargado en memoria todo el código html del body.

window.onload = nombre_funcion;

Si existen varias funciones que deseamos lanzar lo que procede es pedir a window.onload que ejecute una función principal y ésta se encargará de ir lanzando las demás en el orden adecuado.

 function principal(){  
     funcion1();  
     funcion2();  
     funcion3();  
   }  
 window.onload = principal;  

document.onload

Es similar al anterior. La diferencia estriba en que window.onload se activa cuando se ha cargado completamente el código html y se han llamado a todos los archivos externos, imágenes incluidas, lo cual puede tardar tiempo en algunos casos.

Por el contrario, document.onload se activa cuando se ha cargado el DOM y aún no se han cargado todos los archivos externos, imágenes incluidas. De esta forma se gana tiempo, ya que trabaja sin esperar a que lleguen todas las imágenes y demás archivos externos.

En algunos navegadores actualmente window.onload se dispara en cuanto se carga el DOM al igual que hace document.onload.

usando <body onload="myFunction()">

Puede ver un ejemplo en:

con el evento load

Ponemos la llamada al archivo de scipt en el head y luego en el código JS envolvemos todo el código entre las siguientes líneas.

Con una función de callback.

 window.addEventListener('load', function(){  
  //aquí va el código JS  
 });  

También se puede escribir lo anterior con formato de función de flecha.

 window.addEventListener('load', () => {  
  //aquí va el código JS  
 });  

De esta forma la ejecución del código JS se realizará después de que se hubiera cargado todo el DOM, y por lo tanto podemos hacer la llamada al archivo JS en el head del código HTML.

con jQuery

Es preferible trabajar con la librería jQuery que consigue el mismo objetivo y ellos se encargan de que sea compatible con todos los navegadores. Para ver como funciona consulte la siguiente entrada.

Conseguiremos nuestro objetivo que consiste en poder llamar al script desde el head y que éste se ejecute después de haberse mostrado completamente el documento DOM, para que el código JavaScript pueda interactuar con las etiquetas, los id y las claeses que ya han sido cargadas.