Mensajes

Estamos haciendo un proyecto para la universidad. Consiste en desarrollar una aplicación web. Yendo al grano, a mi me toca hacer la parte front end, en concreto un formulario de registro. El problema es que estamos usando un Framework del que no tengo ni idea, no se por donde meterle mano. Si alguien me pudiera ayudar... Os dejo imágenes. El framework es Play Framework 2.6.X.

Web del framework: https://www.playframework.com/documentation/2.6.x/Home

https://ibb.co/geXd1x
https://ibb.co/gmTJ1x
https://ibb.co/dbt7uH

[empty :: Set aempty = EmptyisEmpty :: Set a -> BoolisEmpty Empty = Trueinsert :: (Ord a) => a -> Set a -> Set ainsert x Empty = Node x Emptyinsert x (Node y s) | x < y = Node x (Node y s) | x == y = Node y s | otherwise = Node y (insert x s)-- checks if an element is in set or notisElem :: (Ord a) => a -> Set a -> BoolisElem = undefined-- removes an element from a setdelete :: (Ord a) => a -> Set a -> Set adelete = undefined]

empty :: Set a
empty  = Empty

isEmpty :: Set a -> Bool
isEmpty Empty = True

insert :: (Ord a) => a -> Set a -> Set a
insert x Empty  = Node x Empty
insert x (Node y s)
| x < y        = Node x (Node y s)
| x == y       = Node y s
| otherwise    = Node y (insert x s)

-- checks if an element is in set or not
isElem :: (Ord a) => a -> Set a -> Bool
isElem = undefined

-- removes an element from a set
delete :: (Ord a) => a -> Set a -> Set a
delete = undefined

Me falta el isElem y delete, que no consigo verlo. Gracias.

[public static <T extends Comparable<? super T>> int partir(T v[], T pivote, int izq, int der) { int i = izq-1; // busqueda por la izquierda int j = der+1; // busqueda por la derecha T aux; while (i < j){ // mientras no se crucen las busquedas do{ j--; }while (v[j].compareTo(pivote) > 0); do{ i++; }while (v.compareTo(pivote) < 0); if (i < j){ // si no se han cruzado aux = v; // los intercambia v = v[j]; v[j] = aux; } } return j; }]

Ese codigo sería para una búsqueda normal, comparando uno a uno. Eso es facil de hacer poniendo un simple contador que cuando llegue a K salga del bucle y devuelva el valor obtenido. El contador iria aumentando a medida que se vaya encontrando un valor superior en el array.

Lo que me pide el ejercicio es que a partir de la funcion partir, que es la siguiente:

public static <T extends Comparable<? super T>> int partir(T v[], T pivote, int izq, int der) {
      int i = izq-1; // busqueda por la izquierda
      int j = der+1; // busqueda por la derecha
      T aux;
      while (i < j){ // mientras no se crucen las busquedas
       do{
          j--;
       }while (v[j].compareTo(pivote) > 0);
      
       do{
          i++;
       }while (v.compareTo(pivote) < 0);
      
       if (i < j){ // si no se han cruzado
          aux = v; // los intercambia
          v = v[j];
          v[j] = aux;
       }
      }      
      return j;
   }

(es la parte de encontrar el pivote y dividir el array en dos trozos, para luego repetir la operacion (el divide y venceras de toda la vida)), me pide encontrar el k-esimo elemento sin ordenar el array y utilizando ese codigo. Se que es complicado, por eso lo pregunto por aqui jeje.

El ejercicio me pide buscar el elemento k-esimo en un array no ordenado pero como si el array estuviese ordenado, es decir:

Para el array ejemplo v = 3 4 5 2 6 8 y k = 2 el programa debe devolver v[3] = 2 pues si el array estuviese ordenado el segundo elemento seria el 2.

Este es el enunciado en cuestion:

·Aprovechando el método partir implementado en el primer apartado, completar en la
clase BuscaElem la implementación eficiente del método kesimoRec que tome como
parámetros un vector v (desordenado) y tres enteros, y encuentre el elemento que debería
estar en la posición k (si este estuviera ordenado, pero sin ordenar el vector) de dicho
vector desde izq a der.

Es una busqueda QuickSort. El metodo partir es un metodo implementado en otro apartado que funciona correctamente (para QuickSort).