Dada una tabla de enteros T[0 .. N-1] (es decir, una tabla de tamaño N):

	Diremos que es ordenada estrictamente creciente si para cada elemento T[i], el inmediato siguiente, T[i+1] es ESTRICTAMENTE mayor que T[i]. 
	Diremos que es ordenada creciente si para cada elemento T[i], el inmediato siguiente, T[i+1] es mayor o igual que T[i].
	Diremos que es ordenada estrictamente decreciente si para cada elemento T[i], el inmediato siguiente, T[i+1] es ESTRICTAMENTE menor que T[i]. 
	Diremos que es ordenada decreciente si para cada elemento T[i], el inmediato siguiente, T[i+1] es menor o igual que T[i].
	Diremos que es no ordenada si no es ninguna de las anteriores.

A continuación encontrarás el diseño de la acción TipoDeOrden, que recibe como parámetros de entrada una tabla T, y que tiene como parámetro de salida 
una variable de tipo tupla result. La tupla result contendrá:

- Un entero que indica el tipo de orden dentro de la tabla:
	1: ordenada estrictamente creciente.
	2: ordenada creciente
	3: ordenada estrictamente decreciente.
	4: ordenada decreciente
	0: no ordenada.
	-1: Desconocido
- Un entero indicando el valor máximo dentro de la tabla
- Un entero indicando el valor mínimo dentro de la tabla

La declaración de la tupla será:

tupla result es
	tipo: entero;
	max: entero;
	min: entero;
ftupla

Algunos ejemplos de juegos de pruebas:

	Dada T = {1 2 4 5 67 89 90}, TipoDeOrden  calcula <1, 90, 1>
	Dada T = {1 2 4 4 67 89 90}, TipoDeOrden  calcula <2, 90, 1>
	Dada T = {99 90 80 70 60 1}, TipoDeOrden calcula <3, 99, 1>
	Dada T = {99 90 80 80 70 60 60}, TipoDeOrden calcula <4, 99,60>
	Dada T = {4 1 2 4  67 8 89 90 12}, TipoDeOrden calcula <0, 90, 1>


Se pide que diseñes una acción principal que lea el vector, llame a la acción TipoDeOrden y escriba los valores que calcula  esta acción 
(contenidos en el parámetro de salida). Construid un programa en JAVA que resuelva el problema y que conste de la accion principal, las acciones 
que os proporcionamos y la clase requerida para declarar la tupla.

   acción TipoDeOrden (ent T:  tabla [0..N-1] de enteros,  ent/sal r: result)
	{Pre: N es el número de componentes de T, N>=3}
	{Post: r.tipo = tipo de orden dentro de la tabla,
	     r.max = valor máximo de los elementos de la tabla,
	     r.min = valor mínimo de los elementos de la tabla}
	var
	      i: entero;
	fvar
	i = 0;
	r.tipo = -1;
	r.max = T[0];
	r.min = T[0];

	{Inv: 0<= i <= N-1, r contiene el tipo, valor máximo y mínimo de T [0..i-1]}
	mientras (i<=N-2) hacer
	    Orden (T, i, r);
	    si (T[i] > r.max) entonces r.max = T[i]; fsi
	    si (T[i] < r.min) entonces r.min = T[i]; fsi
	     i = i + 1;
	fmientras
	si (T[i] > r.max) entonces r.max = T[i]; fsi
	si (T[i] < r.min) entonces r.min = T[i]; fsi
  facción 

  acción Orden (ent T1: tabla [0..N-1] de enteros, ent  i: entero, ent/sal  r: result)
	{Pre:}
	{Post: r.tipo contiene el tipo de orden de T[0..i+1]}
	si (T1[i] < T1[i+1]) entonces
	  si (r.tipo = 1 o r.tipo = -1) entonces r.tipo = 1
	  sino si (r.tipo = 2 o r.tipo = -1) entonces r.tipo =2
	          sino r.tipo = 0
	          fsi
	  fsi
	fsi

	si (T1[i] > T1[i+1]) entonces
	  si (r.tipo = 3 o r.tipo = -1) entonces r.tipo = 3
	  sino si (r.tipo = 4 o r.tipo = -1) entonces r.tipo =4
	          sino r.tipo = 0
	          fsi
	  fsi
	fsi

	si (T1[i] = T1[i+1]) entonces
	  si (r.tipo = 1 o r.tipo = -1) entonces r.tipo = 2
	  sino si (r.tipo = 3 o r.tipo = -1) entonces r.tipo =4
	          sino si (r.tipo = 2 o r.tipo = -1) entonces r.tipo = 2
	                  sino si (r.tipo = 4 o r.tipo = -1) entonces r.tipo = 4
	                          sino r.tipo = 0
	                          fsi
        	           fsi
	           fsi
	  fsi
	fsi
facción