Dada la entrada de una cadena que consiste en cualquier mensaje de la sala de chat de nuestro sitio tomado de la lista descrita y vinculada a continuación, genera un valor verdadero o falso que intenta predecir si ese mensaje fue destacado o no en 50 bytes o menos.

Puede usar cualquier valor verdadero o falso , pero deben ser idénticos (es decir, solo debe haber dos resultados posibles, uno verdadero y otro falso). La entrada se dará como HTML sin formato con nuevas líneas eliminadas, y puede contener caracteres Unicode que no sean ASCII. Si necesita una entrada en algo que no sea UTF-8, dígalo en su respuesta.

La presentación ganadora para este desafío será la que predice el porcentaje más alto de mensajes de chat correctamente, fuera de la lista vinculada a continuación. Si dos presentaciones dadas tienen la misma tasa de éxito, la presentación más corta ganará.

Proporcione instrucciones para ejecutar su código en todo el conjunto de mensajes y calcular el porcentaje correcto. Idealmente, esto debería ser un poco de código repetitivo (sin contar para sus 50 bytes) que recorre los casos de prueba positivos y genera cuántos de ellos su código se corrigió y luego hace lo mismo para los casos de prueba negativos. (La puntuación general se puede calcular manualmente a través de (correctPositive + correctNegative) / totalMessages).

Para que su código sea razonablemente verificable, debe completarse en 5 minutos o menos para la lista completa de mensajes de chat en hardware razonable de hoy en día.

La lista completa de mensajes de chat se puede encontrar aquí , y consta de los 1000 últimos mensajes destacados como casos de prueba verdaderos y los 1000 últimos mensajes sin estrellas como casos de prueba falsos. Tenga en cuenta que hay dos archivos en la esencia; desplácese hasta la mitad hacia abajo para ver los mensajes sin estrellas

Retina , 50 bytes, 71.8% 72.15%

^.*([[CE;ಠ-ﭏ]|tar|ol|l.x|eo|a.u|pin|nu|o.f|"$)

Probé un poco de golf regex a sugerencia de @ MartinBüttner. Esto coincide con 704 mensajes destacados y no coincide con 739 mensajes sin estrellas.

El ^.*( ... )objetivo es asegurarse de que siempre haya 0 o 1 coincidencia, ya que Retina genera el número de coincidencias de forma predeterminada. Puede calificar el programa en los archivos de entrada anteponiendo el m`modo multilínea y luego ejecutando

Retina stars.retina < starred.txt

y del mismo modo para unstarred.txt.

Análisis / explicación

Generé los fragmentos anteriores (y muchos más) usando un programa, luego seleccioné los que quería manualmente. Aquí hay una idea de por qué funcionan los fragmentos anteriores:

• C: Partidos PPCG,@CᴏɴᴏʀO'Bʀɪᴇɴ
• E: Partidos @ETHproductions,@El'endiaStarman
• ;: Debido a que los casos de prueba son HTML, esto coincide <y>
• ಠ-ﭏ: Coincide con una gama de caracteres Unicode, principalmente para ಠ_ಠy@Doorknob冰
• tar: Coincide con las variaciones de star, @El'endiaStarman(nuevamente) y también gravatarque aparece en los oneboxes publicados por nuevos bots
• ol: Coincidencias rel="nofollow"que se encuentran en muchos enlaces y oneboxes
• l.x: Partidos @AlexA.,@trichoplax
• eo: Principalmente coincide people, pero también tres casos para@Geobits
• a.u: Principalmente partidos graduation, status, featureyabuse
• pin: Coincidencias pingy palabras que terminan en ping. También coincide con algunas publicaciones en una discusión sobre pineapple, como un ejemplo de sobreajuste.
• nu: Coincide con una mezcla de palabras, la más común de las cuales es number
• o.f: Partidos golf,conf(irm|use)
• "$: Coincide con una comilla doble como último carácter, p. Ej. @phase He means "Jenga."

No [tiene nada de especial: solo me quedaba un personaje, así que pensé que podría usarlo para combinar un caso más.

JavaScript ES6, 50 bytes, 71.10%

Identifica correctamente 670 destacados y 752 no destacados.

x=>/ .[DERv]|tar|a.u|l.x|<i|eo|ol|[C;ಠ]/.test(x)

¡Ahora a través de la barrera del 70% y superando a todos excepto a Retina!

Devuelve truesi el mensaje contiene alguna de estas cosas:

• Una palabra de la que es la segunda letra D, E, R, o v;
• tar(generalmente star);
• ay ucon un char en el medio;
• ly xcon un personaje intermedio (generalmente alex);
• texto en cursiva;
• eoo ol;
• a C, un punto y coma o a ಠ.

Aquí hay algunas coincidencias más fructíferas que no parecen valer la pena deshacerse de otros:

• nf
• nu
• yp
• n.m

Esto se ha ido acercando cada vez más a la respuesta de Retina, pero he encontrado la mayoría de las mejoras por mi cuenta.

Pruébelo en la consola de una de estas páginas: textos en estrella , textos sin estrella

var r=document.body.textContent.replace(/\n<br/g,"<br").split("\n").slice(0,-1);
var s=r.filter(function(x){return/ .[DERv]|tar|a.u|l.x|<i|eo|ol|[C;ಠ]/.test(x)}).length;
console.log("Total:",r.length,"Matched:",s,"Not matched:",r.length-s);

Aquí hay una versión alternativa. /a/.testes técnicamente una función, pero no cumple con nuestros criterios :

/ .[ERv]|a.u|l.x|<i|eo|yp|ol|nf|tar|[C;ÿ-ff]/.test

Este puntaje es 71.90% (697 con estrella, 741 sin estrella).

He estado realizando algunos análisis en las listas para ver qué grupos de expresiones regulares coinciden con las publicaciones más destacadas y menos destacadas. Los análisis se pueden encontrar en este Gist . Hasta ahora, he comprobado aay a.acoincide. a.uestá en torno al # 50 con una puntuación de 28, pero es la combinación más eficiente de su formato ...

Pyth, 50 bytes, 67.9%

0000000: 21 40 6a 43 22 03 91 5d d3 c3 84 d5 5c df 46 69 b5 9d  !@jC"..]....\.Fi..
0000012: 42 9a 75 fa 74 71 d9 c1 79 1d e7 5d fc 25 24 63 f8 bd  B.u.tq..y..].%$c..
0000024: 1d 53 45 14 d7 d3 31 66 5f e8 22 32 43 7a              .SE...1f_."2Cz

Esto divide la entrada en uno de los 322 depósitos y elige el valor booleano en función de ese depósito.

Tanteo

$ xxd -c 18 -g 1 startest.pyth
0000000: 72 53 6d 21 40 6a 43 22 03 91 5d d3 c3 84 d5 5c df 46  rSm!@jC"..]....\.F
0000012: 69 b5 9d 42 9a 75 fa 74 71 d9 c1 79 1d e7 5d fc 25 24  i..B.u.tq..y..].%$
0000024: 63 f8 bd 1d 53 45 14 d7 d3 31 66 5f e8 22 32 43 64 2e  c...SE...1f_."2Cd.
0000036: 7a 38                                                  z8
$ echo $LANG
en_US
$ pyth/pyth.py startest.pyth < starred.txt
[[345, False], [655, True]]
$ pyth/pyth.py startest.pyth < unstarred.txt
[[703, False], [297, True]]

CJam, 45 bytes, 65.55%

l_c"\"#&'(-.19<CEFHIJLMOPSTXY[_qಠ"e=\1b8672>|

Esto verifica si el primer carácter está en una lista específica o si la suma de todos los puntos de código es mayor que 8,672.

Tanteo

$ cat startest.cjam
1e3{l_c"\"#&'(-.19<CEFHIJLMOPSTXY[_qಠ"e=\1b8672>|}*
$ java -jar cjam-0.6.5.jar startest.cjam < starred.txt | fold -1 | sort | uniq -c
    308 0
    692 1
$ java -jar cjam-0.6.5.jar startest.cjam < unstarred.txt | fold -1 | sort | uniq -c
    619 0
    381 1

Matlab / Octave, 17 bytes 60.15%

Clasifica correctamente 490 mensajes como fijos, 713 mensajes como no fijos

Versión actual:

Solo comprobando la longitud.

f=@(w)numel(w)>58

Versión antigua:

Podría ser traducido a cualquier otro idioma. Simplemente comprueba si el mensaje contiene las palabras estrella o no.score: 59/911/52.5%

f=@(w)nnz(strfind(lower(w),'star'))>0 %

Resultados para casos de prueba usando este código:

slCharacterEncoding('UTF-8');

fid = fopen('codegolf_starred_messages_starred.txt');
line = fgetl(fid);
starred = 0;
while ischar(line)
    if f(line);
        starred = starred +1;
    end

    disp(line)
    line = fgetl(fid);
end
fclose(fid);


fid = fopen('codegolf_starred_messages_unstarred.txt');
line = fgetl(fid);
unstarred = 0;
while ischar(line)
    if ~f(line);
        unstarred = unstarred +1;
    end

    disp(line)
    line = fgetl(fid);
end
fclose(fid);

disp(['  correctly classified as *ed: ',num2str(starred)])
disp(['correctly classified as un*ed: ',num2str(unstarred)])
disp(['                  total score: ',num2str((starred+unstarred)/20),'\%'])

CJam, 32 bytes, puntaje general de 0.5605 (56%).

Identifica correctamente 428 mensajes destacados y 693 mensajes no destacados. La puntuación total es (360+730)/2000=0.545.

l_el"sta"/,1>\,)4%!|

Sin esperar ganar, veré cómo funciona. Arriba está el código para un solo mensaje, para ejecutar con uso múltiple esta versión modificada que devuelve la cantidad de mensajes destacados:

1000{l_el"star"/,1>\,)6%!|}fA]:+

Simplemente pruébelo con STDIN como texto sin formato de cualquier archivo. Devuelve verdadero si el mensaje contiene "estrella" o si length + 1 mod 4 = 0.

JavaScript ES6, 0.615 = 61.5%

342 correctamente identificados como destacados, 888 correctamente identificados como no destacados, (342+888)/2000 = 0.615

x=>-~x.search(/(bo|le)x|sta|ಠ|ツ/i)

Prueba así en esto o en esto :

r=document.body.innerHTML.replace(/<\/*pre>/g,"").split`
`.filter(x=>-~x.search`(bo|le)x|sta|ಠ|ツ`).length

_{¡TODAVÍA PUEDO OBTENERTE, MI BONITA!}

Retina, 46 bytes, 68.55

^.*([zj_C;&¡-ff]|sta|san|soc|bo|eo|xk|l.x|<.>)

679 estrellas: 692 sin estrellas

Cambió a Retina para obtener más expresiones regulares en ... Todavía no está hecho.

C # 6.0 (.NET Framework 4.6), 50 bytes, 63,60%

bool s(string i)=>Regex.IsMatch(i,"ol|tar|l.x|ಠ");

Programa que utilicé para fines de prueba:

void Main()
{
    var starred = @"C:\starred.txt";
    var unstarred = @"C:\unstarred.txt";

    var linesStarred = File.ReadAllLines(starred);
    var linesUnstarred = File.ReadAllLines(unstarred);

    var cls = linesStarred.Count();
    var clsc = 0;

    foreach (var line in linesStarred)
    {
        if ( s(line) ) clsc++;
    }

    var clu = linesUnstarred.Count();
    var cluc = 0;

    foreach (var line in linesUnstarred)
    {
        if (!s(line)) cluc++;
    }

    $"Starred {clsc}/{cls} correct ({(clsc/cls*100):0.00}%)".Dump();
    $"Unstarred {cluc}/{clu} correct ({(cluc /clu*100):0.00}%)".Dump();
    $"{(((clsc+cluc)/(decimal)(cls+clu))*100):0.00}".Dump();
}

bool s(string i)=>Regex.IsMatch(i,"ol|tar|l.x|ಠ");