Dada a entrada de uma string que consiste em qualquer mensagem da sala de bate-papo do site, extraída da lista descrita e vinculada abaixo, gera um valor verdadeiro ou falso, tentando prever se essa mensagem foi estrelada ou não em 50 bytes ou menos.

Você pode usar quaisquer valores de verdade ou falsidade , mas eles devem ser idênticos (ou seja, deve haver apenas duas saídas possíveis, uma verdade e uma falsidade). A entrada será fornecida como HTML bruto com as novas linhas removidas e pode conter caracteres Unicode não ASCII. Se você precisar de algo diferente de UTF-8, diga-o na sua resposta.

A submissão vencedora a este desafio será a que prevê a maior porcentagem de mensagens de bate-papo corretamente, fora da lista vinculada abaixo. Se dois envios dados tiverem a mesma taxa de sucesso, o envio mais curto vencerá.

Forneça instruções para executar seu código em todo o conjunto de mensagens e calcular a porcentagem correta. Idealmente, esse deve ser um pouco de código padrão (não contado em seus 50 bytes) que percorre os casos de teste positivos e gera quantos deles seu código ficou correto e, em seguida, faz o mesmo para os casos de teste negativos. (A pontuação geral pode ser calculada manualmente via (correctPositive + correctNegative) / totalMessages.)

Para que seu código seja razoavelmente testável, ele deve ser concluído em 5 minutos ou menos para toda a lista de mensagens de bate-papo em um hardware moderno razoável.

A lista completa de mensagens de bate-papo pode ser encontrada aqui e consiste nas 1000 últimas mensagens com estrela como casos de teste de verdade e nas 1000 últimas mensagens sem estrela como casos de teste de falsificação. Observe que existem dois arquivos na lista principal; role até a metade para as mensagens não marcadas com estrela.

Retina , 50 bytes, 71,8% 72,15%

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

Tentei jogar golfe regex por sugestão de @ MartinBüttner. Corresponde a 704 mensagens com estrela e não a 739 mensagens com estrela.

A ^.*( ... )é para se certificar de que há sempre 0 ou 1 jogo, já que Retina emite o número de correspondências por padrão. Você pode pontuar o programa nos arquivos de entrada, acrescentando o m`modo multilinha e executando

Retina stars.retina < starred.txt

e da mesma forma para unstarred.txt.

Análise / explicação

Gerei os trechos acima (e muitos mais) usando um programa, depois selecionei os que eu queria manualmente. Aqui estão algumas intuições sobre o funcionamento dos trechos acima:

• C: Jogos PPCG,@CᴏɴᴏʀO'Bʀɪᴇɴ
• E: Jogos @ETHproductions,@El'endiaStarman
• ;: Como os casos de teste são HTML, isso corresponde <e>
• ಠ-ﭏ: Corresponde a um intervalo de caracteres Unicode, com destaque para ಠ_ಠe@Doorknob冰
• tar: Jogos variações star, @El'endiaStarman(novamente) e também gravataro que aparece nos oneboxes enviadas por novas mensagens bots
• ol: Corresponde rel="nofollow"a vários links e oneboxes
• l.x: Jogos @AlexA.,@trichoplax
• eo: Corresponde principalmente people, mas também três casos para@Geobits
• a.u: Principalmente corresponde graduation, status, featureeabuse
• pin: Correspondências pinge palavras terminadas em ping. Também corresponde a algumas postagens em uma discussão sobre pineapple, como um exemplo de ajuste excessivo.
• nu: Corresponde a um conjunto misto de palavras, a mais comum delas number
• o.f: Jogos golf,conf(irm|use)
• "$: Corresponde a aspas duplas como último caractere, por exemplo @phase He means "Jenga."

Não [há nada de especial - eu só tinha um personagem sobrando, então achei que poderia usá-lo para combinar com mais um caso.

JavaScript ES6, 50 bytes, 71,10%

Identifica corretamente 670 com estrela e 752 sem estrela.

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

Agora, atravessando a barreira dos 70% e derrotando todos, exceto a Retina!

Retorna truese a mensagem contiver uma destas coisas:

• Uma palavra de que a segunda letra é D, E, R, ou v;
• tar(geralmente star);
• ae ucom um caractere no meio;
• le xcom um caractere no meio (geralmente alex);
• texto em itálico;
• eoou ol;
• a C, ponto-e-vírgula ou a ಠ.

Aqui estão mais algumas partidas frutíferas que parecem não valer a pena se livrar de outras pessoas:

• nf
• nu
• yp
• n.m

Isso vem se aproximando cada vez mais da resposta da Retina, mas eu mesmo encontrei a maioria das melhorias.

Teste-o no console de uma dessas páginas: textos em estrela , textos sem estrela

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);

Aqui está uma versão alternativa. /a/.testé tecnicamente uma função, mas não atende aos nossos critérios :

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

A pontuação é de 71,90% (697 com estrela e 741 sem estrela).

Fiz algumas análises nas listas para ver quais grupos de expressões regulares correspondem às postagens mais estreladas e menos estreladas. As análises podem ser encontradas nesta lista . Até agora, eu verifiquei aae a.acorrespondências. a.ucaiu em torno de # 50 com uma pontuação de 28, mas é a combinação mais eficiente de seu formato ...

Pitão, 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

Isso faz o hash da entrada em um dos 322 buckets e escolhe o Booleano, dependendo desse bucket.

Pontuação

$ 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>|

Isso verifica se o primeiro caractere está em uma lista específica ou se a soma de todos os pontos de código é maior que 8.672.

Pontuação

$ 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 / Oitava, 17 bytes 60,15%

Classifica corretamente 490 mensagens como iniciadas, 713 mensagens como iniciadas

Versão Atual:

Apenas verificando o comprimento.

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

Versão antiga:

Pode ser traduzido para qualquer outro idioma. Apenas verifica se a mensagem contém as palavras com estrela ou não.score: 59/911/52.5%

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

Resultados para casos de teste 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, pontuação geral de 0,5605 (56%).

Identifica corretamente 428 mensagens com estrela e 693 mensagens sem estrela. A pontuação total é (360+730)/2000=0.545.

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

Não esperando ganhar, vou ver como ele funciona. Acima está o código para uma única mensagem, para executar com uso múltiplo nesta versão modificada que retorna a quantidade de mensagens com estrela:

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

Apenas teste-o com STDIN, sendo o texto bruto de qualquer arquivo. Retorna true se a mensagem contiver "estrela" ou se length + 1 mod 4 = 0.

JavaScript ES6, 0,615 = 61,5%

342 corretamente identificados como com estrela, 888 corretamente identificados como com estrela, (342+888)/2000 = 0.615

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

Teste como este sobre este ou esta :

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

_{AINDA POSSO OBTER VOCÊ, MINHA BONITA!}

Retina, 46 bytes, 68,55

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

679 estrela: 692 estrela

Mudei para Retina para obter mais algumas expressões regulares ... Ainda não foi feito.

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

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

Programa que eu usei para fins de teste:

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|ಠ");