Puedes intentar usar esto: https://goo.gl/JVMv2D

Estáis planteando mal el problema.

Se puede resolver con coste lineal llevando dos pivotes sobre s y t, avanzando solo el índice de s si el elemento coincide con el ítem a comprobar de t.


http://pastebin.com/hHcL5cEz


El juez lo acepta.

Saludos .

Buenas.

Lo que pides es un sistema de dinámica de tecleo o escritura, un método biométrico más.

Modelos gráficos como las redes bayesianas no se suelen utilizar en lo que buscas debido a la complejidad de modelar las redes en este caso, ¿cómo modelas la distribución conjunta entre las características que se usan normalmente?. Dejémoslas para aplicaciones donde sí estén claras dichas relaciones y puedan ser especificadas por expertos.

Centrémonos en utilizar otros sistemas de clasificación, hay muchos enfoques, es tu tarea determinar aquel que se comporte mejor, las características a utilizar y el preproceso en función de los datos que tengas.

Te dejo un ejemplo que hice hace unos dias, https://github.com/overxfl0w/Typing-Recognition . La idea es, para cada usuario, entrenar con un texto prefijado escrito varias veces y extraer el tiempo que mantiene pulsada cada tecla, el tiempo que pasa entre la pulsación de una tecla y la siguiente, tiempo entre soltado de una tecla y la siguiente, número de errores y lo que se te pueda ocurrir para discriminar (ojo, siempre que aporte información y no sea redundante con las anteriores).

Una vez extraídas las características ya es cuestión de visualizar la distribución en el espacio muestral y tomar ciertas decisiones sobre qué clasificadores utilizar y como preprocesar los datos. En mi caso uso support vector machine sin kernel ni márgenes blandos solo por probar ya que son de los sistemas que normalmente mejores resultados ofrecen (a cambio de cierto coste en el entrenamiento..).

He intentado hacerte un resumen de todo el proceso, no es cuestión de profundizar demasiado en un post porque todo lo que tienen por debajo este tipo de aplicaciones lleva unos cuantos años de estudio. Si estás interesado en estos temas, siempre que tengo tiempo publico entradas relacionadas en nuestro blog, http://indeseables.github.io/ , no estaría mal seguirlo . Espero haber ayudado.

Edit: Corregidos los enlaces

Buenas a todos, hacía tiempo que no me pasaba por aquí, siempre es un placer .

Después de un fin de semana de descanso de exámenes y aprovechando la temática del proyecto de fin de carrera pensé en aplicar la misma técnica que empleo para topic detection a detección de malware.

El proceso muy por encima consiste en extraer la "semántica" (mediante word2vec) de las instrucciones de un conjunto de programas de entrenamiento P (y por tanto de un programa completo, si modelamos por ejemplo la semántica de un programa como una combinación lineal de las semánticas de las instrucciones que lo componen) para construir una representación en un espacio continuo n-dimensional junto con otras características como por ejemplo las DLLS y las funciones de las que hace uso, una medida de empaquetamiento (ponderando la entropía y la aparición de secciones que dejan ciertos packers) entre otras que se pueden tener en cuenta (de momento solo son esas).

Una vez se tienen las representaciones vectoriales de las muestras de entrenamiento (prototipos) se emplea clasificación por vecinos más cercanos (NearestCentroid) para determinar si un determinado programa es malware o no (semántica del programa más cercana a las muestras malware o a las muestras no malware).

El código lo podéis clonar de su propio repo:
https://github.com/overxfl0w/WinMalwareDetect

Instalad primero las dependencias mediante el setup.py . Cuando estén instaladas tendréis que entrenar el sistema con vuestras propias muestras (no paso los ficheros de entrenamiento porque ocupan bastante si lo entrenas con muchas muestras) tenéis que meter muestras malware en ./Train/Malware y muestras no malware en ./Train/NoMalware y después indicarle al sistema que queréis entrenar, en el usage se muestra la forma de hacerlo, pero básicamente tenéis que lanzar lo siguiente:

python WinMalwareDetector.py --train ./Train/Malware ./Train/NoMalware prototypes.trained model_w2v.mm ffunctions.mm

Cuando el sistema esté entrenado, ya podéis clasificar ejecutables indicándole al sistema que queréis predecir la clase de una muestra:

python WinMalwareDetector.py --predict EJECUTABLE.exe 1 prototypes.trained modelw2v.mm ffmodel.mm

Los 3 últimos parámetros son los ficheros generados durante el entrenamiento (si le cambiáis el nombre acordaos de ellos), y el 3º (el de valor 1) es el número de vecinos a tener en cuenta en la clasificación, podéis probar más de 1 valor si sois curiosos y si no dejadlo así.

Esto es lo necesario para poner en marcha la clasificación, podéis comprobar la precisión y otras medidas del sistema sin tener que hacer el entrenamiento, solo poned las muestras malware y no malware donde dije y lanzad lo siguiente:

python WinMalwareDetector.py --statistics -lou 1 ./Train/Malware ./Train/NoMalware

Con ello indicamos al sistema que queremos sacar estadísticas, haciendo leaving one out, comprobando la precisión entrenando con todas las muestras menos 1 y esa usarla como test para ver si acierta o no, para toda muestra, usando para eso 1 vecino más cercano. Todos los resultados que indiquen porcentajes están entre 0 y 1 (multiplicadlo por 100 xD).


Para que veáis las salidas del programa en los casos que os he comentado adjunto un par de imágenes:

Estadísticas:   https://i.gyazo.com/ab564e8c37a18c121215dfe8232aed8d.png
Clasificación:  https://i.gyazo.com/25c564b92a186c5200fc7395efd2f552.png
Predicción:     https://i.gyazo.com/eadb249589f7f663e6eaf1aa41d180cb.png

Buenas compañeros.
*Mensaje Omitido*

El ejercicio consiste en decir, dadas dos fechas, cual es anterior, haciendo comprobaciones anteriores para saber si son correctas,contando años bisiestos.

Si la primera fecha es incorrecta la salida será: Primera fecha incorrecta.
Si la segunda fecha es incorrecta la salida será: Segunda fecha incorrecta.
Si son iguales: Representan el mismo día.
Si la primera fecha es anterior a la segunda: La primera es anterior.
Si la segunda fecha es anterior a la primera: La segunda es anterior.

Mi solución es la siguiente:

import java.util.*;
 
public class fechaCorrecta
{
    public byte dia = 0,mes = 0;
    public short anyo = 0;  
 
    public fechaCorrecta(byte dia,byte mes,short anyo)
    {
        this.dia = dia;
        this.mes = mes;
        this.anyo = anyo;
    }
 
    public boolean compruebaFecha()
    {
        boolean esBisiesto;
        esBisiesto = (this.anyo % 4 == 0 && this.anyo % 100 != 0) || ( this.anyo % 400 == 0);
        switch(mes)
        {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                if(this.dia < 0 || this.dia > 31) return false;
                else return true;
            case 4:
            case 6:
            case 9:
            case 11:
                if(this.dia < 0 || this.dia > 30) return false;
                else return true;
            case 2:
                if(esBisiesto)
                {
                    if(this.dia < 0 || this.dia > 29) return false;
                    else return true;
                }
                else
                {
                    if(this.dia < 0 || this.dia > 28) return false;
                    else return true;
                }
            }
            return false;
    }
 
    public boolean equals(Object o)
    {
        return (o instanceof fechaCorrecta) && (this.dia == ((fechaCorrecta)o).dia) && (this.mes == ((fechaCorrecta)o).mes) && (this.anyo == ((fechaCorrecta)o).anyo);
    }
 
    public boolean compruebaMenorUno(fechaCorrecta fechaDos)
    {
        return (this.anyo < fechaDos.anyo) || (this.anyo == fechaDos.anyo && this.mes < fechaDos.mes) || (this.anyo == fechaDos.anyo && this.mes == fechaDos.mes && this.dia < fechaDos.dia);
    }
 
    public static void main(String args[])
    {
        Scanner entradaTeclado = new Scanner(System.in).useLocale(Locale.US);
        byte diaUno = 0,mesUno = 0,diaDos = 0,mesDos = 0;
        short anyoUno = 0,anyoDos = 0;
        diaUno = entradaTeclado.nextByte();
        mesUno = entradaTeclado.nextByte();
        anyoUno = entradaTeclado.nextShort();
        diaDos = entradaTeclado.nextByte();
        mesDos = entradaTeclado.nextByte();
        anyoDos = entradaTeclado.nextShort();
        fechaCorrecta fechaUno = new fechaCorrecta(diaUno,mesUno,anyoUno);
        fechaCorrecta fechaDos = new fechaCorrecta(diaDos,mesDos,anyoDos);
 
        if(!fechaUno.compruebaFecha()) System.out.print("Primera fecha incorrecta.");
        else 
        {
            if(!fechaDos.compruebaFecha()) System.out.print("Segunda fecha incorrecta.");
            else
            {
                if(fechaUno.equals(fechaDos)) System.out.print("Representan el mismo día");
                else
                {
                     if(fechaUno.compruebaMenorUno(fechaDos)) System.out.print("La primera es anterior.");
                     else System.out.print("La segunda es anterior.");
                }
            }
        }
    }
}

Todos los casos que yo he probado a mano me han dado resultados correctos, sin embargo a la hora de entregarlo en el portal de autocorrección de la universidad me marca errores por codificación ( siendo los resultados numéricos correctos ). Le he enviado un correo al profesor y me ha contestado que ve un fallo gordo en una comparación que falla por haberla puesto como asignación.

No veo ningún fallo así de gordo, de hecho esos los marca el compilador, ¿ a que creéis que hace referencia?

Un saludo

https://polimedia.upv.es/catalogo/

Cada vez más universidades están adaptando el conocido OCW (Open Course Ware) implementan sus propias plataformas con videos sobre las materias impartidas.

Si no me equivoco ese es uno de los principales problemas, los slots no pueden recibir argumentos.
El tiempo que estuve con qt no pude conseguir pasarlos xD.

algunaDiez = False
notas = 0
acumuladorNotas = 0
cuentaNotas = 0
while notas != -1:
	notas = input("Nota> ")
	if notas != -1: 	
		acumuladorNotas += notas
		cuentaNotas += 1
	if notas == 10: algunaDiez = True
print "La media aritmetica de " + str(cuentaNotas) + " notas introducidas es : "  + str((acumuladorNotas/cuentaNotas))
if algunaDiez == True:
	print "Alguna de ellas era un diez"
else: 
	print "No ha habido ningun 10"
 

Hasta ahí la media aritmética lo de cuantos han sacado x notas te toca currartelo a ti ya  .
Una forma de todas las posibles podría ser crear un diccionario tal que así:
{"Sobresaliente":x,"Notable":y...}
Y con una serie de condicionales que comprueben el rango de la nota aumenten los contadores.

Si no, 6 variables contadores y con el mismo condicional que antes las aumentas.

algunaDiez = False
notas = 0
while notas != -1:
	notas = input("Nota> ")
	if notas == 10: algunaDiez = True
if algunaDiez == True:
	print "Alguna de ellas era un diez"
else: 
	print "No ha habido ningun 10"
 

Suponiendo que las notas introducidas son válidas, puedes implementarlo fácilmente con un par de condicionales