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

domingo, 11 de octubre de 2020

Tangram con MiniWin

En el siguiente ejemplo se van a recrear las piezas de un tangram empleando triángulos rectángulos para formarlas.

Esto implica crear una o varias funciones para dibujar los triángulos rectángulos. En este caso se optó por usar cuatro funciones llamadas:

  • tipoA
  • tipoB
  • tipoC
  • tipoD

Estas podrían ser "inline", pero se optó por funciones convencionales, las funciones serían:

/*Trabajando con 4 tipos de triángulos rectángulos*/
void tipoA(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1+ta-i,y1+i,x1+ta,y1+i);	
	}
}
void tipoB(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1,y1+i,x1+i,y1+i);	
	}
}
void tipoC(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1+i,y1+i,x1+ta,y1+i);	
	}
}
void tipoD(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1,y1+i,x1+ta-i,y1+i);	
	}
}

Donde cada función corresponde a:

Tipo A Tipo B
    *
   **
  ***
 ****
*****
*
**
***
****
*****
Tipo C Tipo D
*****
 ****
  ***
   **
    *
*****
****
***
**
*

El código completo sería:

#include "miniwin.h"
using namespace miniwin;

const int DIM = 200; // Valor medio del ancho

/*Funciones */
void tipoA(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1+ta-i,y1+i,x1+ta,y1+i);	
	}
}
void tipoB(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1,y1+i,x1+i,y1+i);	
	}
}
void tipoC(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1+i,y1+i,x1+ta,y1+i);	
	}
}
void tipoD(int x1, int y1, int ta){
	for(int i=0; i<=ta; i++){		
		linea(x1,y1+i,x1+ta-i,y1+i);	
	}
}

int main(){
	vredimensiona(2*DIM, 2*DIM);	
	color_rgb(0, 0, 0);
	rectangulo_lleno(0, 0, 2*DIM, 2*DIM);
	
	/*Pieza 1*/
	color(AZUL);
	tipoB(0,0,DIM);
	tipoD(0,DIM,DIM);
	
	/*Pieza 2*/
	color_rgb(255, 150, 0);	
	tipoC(0,0,DIM);
	tipoD(DIM,0,DIM);	
	
	/*Pieza 3*/
	color(VERDE);	
	tipoA(DIM*1.5,0,DIM/2);
	rectangulo_lleno(DIM*1.5,DIM/2,2*DIM,DIM);
	tipoD(DIM*1.5,DIM,DIM/2);
	
	/*Pieza 4*/
	color(ROJO);	
	tipoA(DIM,DIM,DIM);
	
	/*Pieza 5*/
	color(MAGENTA);	
	tipoA(0,DIM*1.5,DIM/2);
	tipoB(DIM/2,DIM*1.5,DIM/2);
	
	/*Pieza 6*/
	color(AMARILLO);	
	tipoA(DIM/2,DIM,DIM/2);
	tipoB(DIM,DIM,DIM/2);
	tipoC(DIM/2,DIM*1.5,DIM/2);
	tipoD(DIM,DIM*1.5,DIM/2);
	
	/*Pieza 7*/
	color_rgb(100,0,155);	
	tipoA(DIM,DIM/2,DIM/2);
	tipoC(DIM,DIM,DIM/2);
	
	refresca();
	return 0;

}

El resultado visual sería:




domingo, 6 de septiembre de 2020

Introducción a C++

Estructura básica

Para escribir un programa en C++ se debe considerar la siguiente estructura básica:


// Función principal
int main()
{
   /*
     El código c++ se coloca en esta sección
   */
   return 0;
}

En la primera línea se coloca la referencia a las bibliotecas que empleará el programa. Los comentarios pueden ser de dos tipos:

  • De línea: empleando //
  • De bloque: empleando /* y */

Entrada y salida de datos

Para escribir un programa en C++ se debe considerar la siguiente estructura básica:

#include <iostream>
using namespace std;

int main()
{
   //Declaración de variables
   int num;
   
   //Entrada de datos
   cin >> num;
   
   //Salida de datos
   cout << "Número: " << num;
   return 0;
}

Datos primitivos

  • bool: El tipo de dato bool, tiene un tamaño de 8 bits y un rango entre 0 y 1 (falso o verdadero).
  • int: El tipo de dato int, tiene un tamaño de 32 bits y un rango entre -2147483648 y 2147483647. Este se usa para números enteros (sin decimales). Sus variantes son:
    • short int: Tiene un tamaño de 16 bits y un rango entre -32768 y 32767.
    • unsigned short int: Tiene un tamaño de 16 bits y un rango entre 0 y 65535.
    • unsigned int: Tiene un tamaño de 32 bits y un rango entre 0 y 4294967295.
    • long long int: Tiene un tamaño de 64 bits y un rango entre -9223372775808 y 9223375775807.
    • unsigned long long int: Tiene un tamaño de 64 bits y un rango entre 0 y 2 elevado a la potencia 64.
  • float: Tiene un tamaño de 32 bits, es usado comúnmente en números con 6 o menos cifras decimales. Tiene un rango entre 1,17549*(e^-38) hasta 3,40282*(e^+38).
  • double: Tiene un tamaño de 64 bits, es usado para números de menos de 15 cifras decimales. Tiene un rango entre 2,22507*(e^-308) hasta 1,79769*(e^308).
    • long double: Tiene un tamaño de 96 bits y una precisión de 18 cifras decimales. Tiene un rango entre 3,3621*(e^-4932) hasta 1,18973*(e^4932).
  • char: Son variables de tipo vector que almacenan cualquier caracter y puede estar con o sin signo.
#include <iostream>
using namespace std;

int main()
{
	//Variables
	int num = 2;
	float dec1 = 3.14;
	double dec2 = -2.1213;
	bool val = false;
	char cad = 'a';
	return 0;
}

viernes, 19 de junio de 2020

Biblioteca gráfica ImageGD en PHP

PHP tiene su propia librería gráfica (al 2020 aún en desarrollo) que permite generar gráficos rectangulares, circulares, lineales y textuales. Además, usar colores en el formato RGB para estos.

Sobre esta biblioteca el manual de PHP menciona:
"PHP no está limitado a crear únicamente salidas HTML. También se puede usar para crear y manipular ficheros de imágenes en una variedad de diferentes formatos de imagen, incluyendo GIF, PNG, JPEG, WBMP y XPM. Aún más práctico es que PHP puede transferir flujos de imagen directamente al navegador. Necesitará compilar PHP con la biblioteca de funciones de imágenes GD para que esto funcione. GD y PHP también pueden requierir otras bibliotecas, dependiendo de los formatos de imagen con los que se quiera trabajar".
Esta biblioteca permite crear imágenes de tipo:
  • JPEG
  • GIF
  • PNG
  • SWF
  • TIFF
  • JPEG2000


Creando una imagen con "imagecreatetruecolor"

<?php

# Definir el tipo de contenido de la página
header("content-type:image/png");

#Crear la imagen con dimensiones de 200px por lado
$imagen = imagecreatetruecolor(200, 200);

# Mostrar la imagen en formato PNG
imagepng($imagen);

# Liberar memoria
imagedestroy($imagen);

?>


Creando colores con "imagecolorallocate"

<?php

# Permite definir un color RGB
$colorRojo= imagecolorallocate($imagen, 255, 0, 0);

# Permite definir un color RGB
$colorBlanco= imagecolorallocate($imagen, 255, 255, 255);

# Permite definir un color RGB
$colorAmarillo= imagecolorallocate($imagen, 255, 255, 0);

?>


Creando figuras

Tenemos diversos métodos para crear figuras con y sin relleno como:


Figuras sin relleno
  • imagearc — Dibuja un arco parcial
  • imageellipse — Dibuja una elipse
  • imagepolygon — Dibuja un polígono
  • imagerectangle — Dibuja un rectángulo
Figuras con relleno
  • imagefilledarc — Dibuja un arco parcial y rellenarlo
  • imagefilledellipse — Dibuja una elipse con relleno
  • imagefilledpolygon — Dibuja un polígono con relleno
  • imagefilledrectangle — Dibuja un rectángulo con relleno


<?php

# Definir el tipo de contenido de la página
header("content-type:image/png");

#Crear la imagen con dimensiones de 200px por lado
$imagen = imagecreatetruecolor(200, 200);

# Permite definir un color RGB
$colorAmarillo= imagecolorallocate($imagen, 255, 255, 0);
$colorRojo= imagecolorallocate($imagen, 255, 0, 0);

# Gráfica de un rectángulo
imagerectangle($imagen, 10, 10, 190, 190, $colorAmarillo);

# Gráfica de un rectángulo con color de relleno
imagefilledrectangle($imagen, 40, 40, 160, 160, $colorRojo); 

# Mostrar la imagen en formato PNG
imagepng($imagen);

# Liberar memoria
imagedestroy($imagen);

?>


IMAGELINE

Esta función permite la creación de líneas con la siguiente sintaxis:
imageline($image, $x1, $y1, $x2, $y2, $color);
  • image: Un recurso image, es devuelto por una de las funciones de creación de imágenes, como imagecreatetruecolor().
  • x1: Coordenada x del primer punto.
  • y1: Coordenada y del primer punto.
  • x2: Coordenada x del segundo punto.
  • y2: Coordenada y del segundo punto.
  • color: El color de la línea. Un identificador de color creado con imagecolorallocate().
<?php

header("Content-Type: image/png");
$imagen = imagecreatetruecolor(400, 400);
$color = imagecolorallocate($imagen, 255, 255, 0);

# imageline($image, $x1, $y1, $x2, $y2, $color);
imageline($imagen, 12, 33, 300, 200, $color);

# Mostrar la imagen en formato PNG
imagepng($imagen);

# Liberar memoria
imagedestroy($imagen);

?>


IMAGERECTANGLE

Esta función permite la creación de rectágulos con la siguiente sintaxis:
imagerectangle ($image, $x1, $y1, $x2, $y2, $color);
  • image: Un recurso image, es devuelto por una de las funciones de creación de imágenes, como imagecreatetruecolor().
  • x1: Coordenada x de partida.
  • y1: Coordenada y de partida.
  • x2: Coordenada x de llegada.
  • y2: Coordenada y de llegada.
  • color: El color de la línea. Un identificador de color creado con imagecolorallocate().
<?php

header("Content-Type: image/png");
$imagen = imagecreatetruecolor(400, 400);
$color = imagecolorallocate($imagen, 255, 255, 0);

# imagerectangle ($image, $x1, $y1, $x2, $y2, $color);
imagerectangle ($imagen, 12, 33, 300, 200, $color);

# Mostrar la imagen en formato PNG
imagepng($imagen);

# Liberar memoria
imagedestroy($imagen);

?>


IMAGEREARC

Esta función permite la creación de arcos y circunferencias con la siguiente sintaxis:
imagearc($image, $cx, $cy, $ancho, $largo, $inicio, $fin, $color);
  • image: Un recurso image, es devuelto por una de las funciones de creación de imágenes, como imagecreatetruecolor().
  • cx: Coordenada x del centro.
  • cy: Coordenada y del centro.
  • largo: largo del arco.
  • ancho: ancho del arco.
  • inicio: ángulo de inicio en grados sexagésimales.
  • fin: ángulo de fin en grados sexagésimales.
  • color: El color de la línea. Un identificador de color creado con imagecolorallocate()
<?php

header("Content-Type: image/png");
$imagen = imagecreatetruecolor(400, 400);
$color = imagecolorallocate($imagen, 255, 255, 0);

# imagearc($image, $cx, $cy, $an, $la, $ini, $fin, $col);
imagearc ($imagen, 200, 200, 100, 100,0, 360, $color);

# Mostrar la imagen en formato PNG
imagepng($imagen);

# Liberar memoria
imagedestroy($imagen);

?>




jueves, 11 de junio de 2020

Sesiones en PHP

El manual PHP indica sobre el soporte de las sesiones en PHP: "El soporte para sesiones en PHP consiste en una manera de preservar ciertos datos a través de accesos posteriores, lo que permite crear aplicaciones más personalizadas y mejorar el atractivo de un sitio web."


Crear sesiones

Para mantener seguridad al inicio de sesión, por ejemplo. Se opta por el uso de sesiones, ya que estos valores son almacenados en el servidor y no la computadora del usuario.

Para crear una sesión:
<?php
   
   # Iniciar sesión
   session_start();

   # Declarar los identificadores de sesión y sus valores
   $_SESSION["sesion"]="hola";
   $_SESSION["valor"]=12;

?>

$_SESSION (y todas las variables registradas) son serializadas internamente por PHP.

Operaciones con sesiones
<?php

   # Iniciar sesión
   session_start();

   # Crear sesión
   $_SESSION["valor"]=12;

   # Ver el valor de una sesión
   echo $_SESSION["valor"];

   # Actualizar el valor de una sesión
   $_SESSION["valor"]=100;

   # Cerrar sesión
   unset ( $_SESSION["valor"] ); //Liberar memoria
   session_destroy(); //Cerra la sesión propiamente dicha

?>

Usos de las sesiones

"PHP permite el uso de sesiones, valores que podemos usar para autentificar a un usuario, debe ser una medida adicional al encriptado en la base de datos para iniciar sesión"


SESIÓN PARA INICIO DE SESIÓN

<?php

   /* Colocar dentro del método de autentificación de usuario */

   if (validar()=true){
      # Creamos una sesión
      session_star(); 
      # Creamos una clave
      $_SESSION[ "acceso" ]="E14007a"; 
      # Enviamos a la página de inicio
      header ("location: inicio.php"); 
   } else {
      # Creamos una sesión para evitar conflicto al cerrar la sesión
      session_star();
      # Destruimos la sesión
      session_destroy(); 
      # Lo retornamos a la página de login
      header ("location: login.php");
   }

?>


VALIDAR EL INICIO DE SESIÓN

<?php

   # Iniciamos sesión
   session_start();

   # si la sesion es diferente a la iniciada
   if($_SESSION[ "acceso" ] != "E14007a";){ 
      # Destruimos la sesión
      session_destroy();
      # Lo retornamos a la página de login
      header ("location: login.php");
   }
?>

<!-- CÓDIGO HTML -->

Cookies en PHP

Las cookies pueden ser borradas, aceptadas, ignoradas o bloqueadas según se desee, para esto se debe configurar convenientemente el navegador web.

Del punto de vista lingüístico, el término Cookie es un anglicismo para las "galletas informáticas", estas pueden ser borradas, aceptadas, ignoradas o bloqueadas por el cliente mediante la configuración del navegador web.

Tienen diversas aplicaciones como:
  • Como un contador de visitas al sitio web.
  • Un contenedor de información que se almacena en el computador cliente y puede ser consultado por el servidor. Por ejemplo, un carrito de compras virtual.
  • Hacer seguimiento al cliente. Por ejemplo, gustos de navegación, spyware, etc.
  • Uso con intenciones malignas. Por ejemplo, las Zombie cookies.


Crear COOKIES

Para crear una cookie básica se necesita dos parámetros: el nombre de la cookie y el valor asignado. Se debe crear antes de cargar el documento HTML.
<?php
   setcookie("texto", "Bienvenido a PHP");
   setcookie("contador", 12);
   setcookie("acumulado", 33.5);
?>

Del ejemplo anterior hemos creado 3 cookies que almacenan un valor tipo cadena, tipo entero y tipo decimal. Estos se almacenan en la computadora del usuario de modo que no consumen recursos del servidor.

Llamar COOKIES

Todas las cookies se almacenan en $_COOKIE que tiene forma de array, de forma que se les llama mediante su identificador y ese valor se puede almacenar en una variable o mostrar.
<?php

   //Creamos el cookie en un archivo
   setcookie("contador", 12);

?>
<?php
   //Llamamos al cookie desde otro archivo
   $dato = $_COOKIE["contador"];

   echo $dato; //Mostrara en pantalla 12
?>


Parámetros en una cookie

Los parámetros que podemos pasar son:
  • Clave: el nombre de la cookie.
  • Valor: el valor de la cookie.
  • Duración: el tiempo que la cookie está activa.
  • Ruta: el lugar donde se almacena la cookie.
  • Dominio: el servidor donde se almacena la cookie.
  • Protocolo de seguridad: la cookie se puede transmitir por HTTPS.
  • Uso solo de HTTP: la cookie solo es accesible por http y no por otros como javaScript por ejemplo

Cookie con tiempo y sin tiempo

Se puede indicar la duración de una Cookie, si no lo hacemos esta se destruye al cerrar el navegador.

<?php
   /*Sin tiempo*/
   setcookie("nombre","argos") ;
   /* Duración: hasta que se cierre el navegador*/

   /*Con tiempo*/
   setcookie("apodo","perrosaurio", time() + 30*24*60*60) ; 
   /* Duración: 1 mes
      Con Time() iniciamos en cero, y le agregamos un mes en segundos, 
      no afecta si el usuario cierra el navegador
   */
?>


Cookie con ruta

Se puede indicar una ubicación para almacenar las Cookies.
<?php

   #Con ruta simple
   setcookie("apodo","perrosaurio", time() + 30*24*60*60, "/"); 
   //Se guarda en el directorio raíz

   #Con ruta específica
   setcookie("apodo","perrosaurio", time() + 30*24*60*60, "/cookie"); 
   // Se guarda en la carpeta cookie dentro del directorio raíz

?>

Cookie con dominio

Se puede indicar una ruta distinta a la del computador del cliente para almacenar la información:
<?php

   #Con dominio
   setcookie("nombre","argos", time() + 1000, "/c", "www.argosperro.com") ;

   /*
    * Duración: 1000 segundos
    * Carpeta: "c" dentro del directorio del dominio
    * Dominio donde se almacena: www.argosperro.com
   */

?>

Cookie con protocolos HTTPS y HTTP

Se puede implementar protocolos seguros para las Cookies mediante el siguiente formato.
<?php

   #Si queremos usar un protocolo seguro, hacemos:

   setcookie("galleta", "Hola", time()+1000, "/", "www.gatofeliz.com", true, true);

   /*
    * El primer valor en "true" activa el protocolo seguro
    * El segundo "true" evita que se usen protocolos diferentes al HTTP
    * Es necesario establecer un dominio al cual mandar los valores
   */

?>



martes, 19 de mayo de 2020

Arreglos con JavaScript

Arrays en JavaScript

Los arrays son colecciones de datos, multiples datos almacenados en una sola variable, para definir un arreglo se debe colocar sus elementos dentro de corchetes y separados por comas.
Se puede crear arreglos de dos formas:
Creando

//Primera forma:
let listA = ["Argos","Pelusa","Shirley"];
//Segunda forma:
let listB = new Array("Argos","Pelusa","Shirley");


Recorriendo un Array

// Tenemos el siguiente arreglo de Strings que contiene 3 elementos:
let mascotas = ["Argos","Pelusa","Shirley"];

// Podemos capturar un valor (El primer valor siempre es [0]):
alert(mascotas[ 1 ]); //mostrará Pelusa en un alert

//Recorrer el arreglo e imprimirlo en consola
for ( let i of mascotas ) {
   console.log(i);
}

Modificando un valor

Para modificar un valor simplemente se usa el operador de asignación indicando entre corchetes la ubicación del elemento

// Tenemos el siguiente arreglo de Strings que contiene 3 elementos:
let mascotas = ["Argos","Pelusa","Shirley"];

// Cambiando un valor:
mascota[ 2 ] = "Gardfield" //Cambiará "Shirley" por Gardfield


Métodos de Array

Encontramos los siguientes:

  • join()
  • toString()
  • pop()
  • push()
  • shift()
  • unshift()
  • length()

let list = new Array("Argos", "Pelusa", "Shirley");

// -- toString()
// Devolverá un String donde los elementos se separan por comas:
let textual = list.toString(); 
console.log(textual); // "Argos,Pelusa,Shirley"

// -- join() --
// Devolverá un String donde los elementos se separan por el parámetro indicado:
let separadores = list.join("#"); 
console.log(separadores); // "Argos#Pelusa#Shirley"

// -- pop() --
list.pop(); //Elimina el último elemento
console.log(list.toString()); //Argos,Pelusa

// -- push() --
list.push("Nerón"); // Agrega un elemento al final
console.log(list.toString()); //Argos,Pelusa,Nerón

// -- shift() --
list.shift(); //Elimina el primer elemento
console.log(list.toString()); //Pelusa,Nerón

// -- unshift() --
list.unshift("Rambito"); // Agrega un elemento al inicio
console.log(list.toString()); //Rambito,Pelusa,Nerón

// -- length --
let longitud = list.length; // Devuelve el tamaño del arreglo
list[list.length] = "Blacky" // Agrega un elemento al final (alternativa a push)
console.log(list.toString()); //Rambito,Pelusa,Nerón,Blacky

// -- splice()
// El primer valor indica la cantidad de nuevos elementos
// El segundo valor la cantidad de elementos eliminados
// Los demás valores son los que se agregarán
list.splice(2, 0, "Lalo", "Koda");
console.log(list.toString()); //Rambito,Pelusa,Lalo,Koda,Nerón,Blacky

// -- sort()
// Ordena el Array (trata a todos los elementos como String)
list.sort();
console.log(list.toString()); //Blacky,Koda,Lalo,Nerón,Pelusa,Rambito

// Se puede almacenar los elementos eliminados asignando a una variable
let eliminados = list.splice(2, 3, "Fede", "Fido");
console.log(eliminados.toString()); // Lalo,Nerón,Pelusa
console.log(list.toString());       // Blacky,Koda,Fede,Fido,Rambito

// ** CONCATENAMIENTO **
// -- concat()
let arr1 = ["Paul", "Isacc"];
let arr2 = ["Fernanda", "Luz", "Abel"];
let arr3 = ["Ramón", "Vicky"];

//Crea un Array que combina los 3 anteriores.
let personas = arr1.concat(arr2, arr3);
console.log(personas.toString()); //Paul,Isacc,Fernanda,Luz,Abel,Ramón,Vicky


Métodos REDUCE, FILTER y MAP

Simplifican el trabajo con los arreglos al no tener que recorrerlos explicitamente, creando menos variables y usando la sintaxis de funciones arrow

REDUCE permite reducir todos los elementos del arreglo a un solo elemento. Como una concatenación de elementos o suma de valores

let nombres = ["Dana", "Dina", "Dona"];
let numeros = [10, 20, 30, 40, 50];

/* ======== REDUCE ========*/
let suma = numeros.reduce((a,v)=>a+v);
console.log(suma); //150

let texto = nombres.reduce((a,v)=>a + " - " + v );
console.log(texto); //Dana - Dina - Dona

FILTER permite reducir crear un arreglo con los elementos que cumplan con la condición indicada.

let valores = [10, 13, 21, 7, 85];
let apellidos  = ["Quispe", "Salinas", "Rosas", "Garcia", "Baltodano"];

/* ======== FILTER ========*/
//Filtramos solo los múltiplos de 5
let multiplos = valores.filter(n => n % 5 === 0);
console.log(multiplos.toString()); // 10,85

//Filtramos solo los apellidos con 6 letras o menos
let apellidosCortos = apellidos.filter(e => e.length <= 6);
console.log(apellidosCortos.toString()); // Quispe,Rosas,Garcia

MAP permite crear un arreglo a partir de los elementos del arreglo inicial.

let sueldos = [950, 1000, 1500, 1200, 3000];

/* ======== MAP ========*/
//Obtener el descuento por AFP del 9% de todos los sueldos
let afp = sueldos.map(n => n * 0.09);
console.log(afp.toString()); // 85.5,90,135,108,270


NOTA Es posible combinar los métodos previos. Por ejemplo:

let datos = [10, 13, 21, 7, 85, 14, 2];

//Obtener la suma de los valores pares
let sumaPar = datos.filter(n => n % 2 === 0).reduce((a, v) => a + v);
console.log(sumaPar); // 26

//Crear un arreglo solo con los valores impares
let impares = datos.filter(n => n % 2 === 1).map(n => n);
console.log(impares.toString()); //13,21,7,85