Dato un input di una stringa che consiste in qualsiasi messaggio proveniente dalla nostra chat room del nostro sito dall'elenco descritto e collegato di seguito, emette un valore di verità o di falsità che tenta di prevedere se quel messaggio è stato contrassegnato o meno da 50 byte o meno.

È possibile utilizzare qualsiasi valore di verità o falsità , ma devono essere identici (cioè dovrebbero esserci solo due possibili risultati, una verità e una falsa). L'input verrà fornito come HTML non elaborato con le nuove righe rimosse e potrebbe contenere caratteri Unicode non ASCII. Se hai bisogno di input in qualcosa di diverso da UTF-8, ti preghiamo di dirlo nella tua risposta.

L'invio vincente a questa sfida sarà quello che prevede correttamente la più alta percentuale di messaggi di chat, fuori dall'elenco collegato di seguito. Se due invii dati hanno lo stesso tasso di successo, vincerà l'invio più breve.

Fornisci le istruzioni per eseguire il codice sull'intera serie di messaggi e calcolare la percentuale corretta. Idealmente, questo dovrebbe essere un po 'di codice boilerplate (non conteggiato per i tuoi 50 byte) che scorre attraverso i casi di test positivi e genera quanti di essi il tuo codice ha corretto e quindi fa lo stesso per i casi di test negativi. (Il punteggio complessivo può quindi essere calcolato manualmente tramite (correctPositive + correctNegative) / totalMessages.)

Affinché il tuo codice sia ragionevolmente testabile, deve essere completato in 5 minuti o meno per l'intero elenco di messaggi di chat su un hardware moderno ragionevole.

L'elenco completo dei messaggi di chat è disponibile qui ed è composto dagli ultimi 1000 messaggi speciali come casi di test veritieri e dagli ultimi 1000 messaggi non speciali come casi di test falsi. Si noti che ci sono due file nell'essenziale; scorrere a metà circa per i messaggi non speciali.

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

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

Ho provato un po 'di golf regex su suggerimento di @ MartinBüttner. Questo corrisponde a 704 messaggi speciali e non corrisponde a 739 messaggi non speciali.

Lo scopo ^.*( ... )è assicurarsi che ci sia sempre 0 o 1 corrispondenza, poiché Retina emette il numero di partite per impostazione predefinita. È possibile assegnare un punteggio al programma sui file di input anteponendo la m`modalità multilinea, quindi eseguendo

Retina stars.retina < starred.txt

e allo stesso modo per unstarred.txt.

Analisi / spiegazione

Ho generato i frammenti sopra (e molti altri) usando un programma, quindi ho selezionato quelli che volevo manualmente. Ecco alcune intuizioni sul perché i frammenti sopra funzionano:

• C: Partite PPCG,@CᴏɴᴏʀO'Bʀɪᴇɴ
• E: Partite @ETHproductions,@El'endiaStarman
• ;: Poiché i casi di test sono HTML, questo corrisponde <e>
• ಠ-ﭏ: Corrisponde a una gamma di caratteri Unicode, in particolare per ಠ_ಠe@Doorknob冰
• tar: Abbina le varianti di star, @El'endiaStarman(di nuovo) e anche quelle gravatarche compaiono nelle caselle one postate dai nuovi bot dei post
• ol: Corrisponde rel="nofollow"a molti link e caselle singole
• l.x: Partite @AlexA.,@trichoplax
• eo: Principalmente partite people, ma anche tre casi per@Geobits
• a.u: Principalmente partite graduation, status, featureeabuse
• pin: Corrispondenze pinge parole che terminano con ping. Abbina anche alcuni post in una discussione su pineapple, come esempio di overfitting.
• nu: Corrisponde a un miscuglio di parole, il più comune dei quali è number
• o.f: Partite golf,conf(irm|use)
• "$: Corrisponde a una doppia citazione come ultimo carattere, ad es @phase He means "Jenga."

Non [è niente di speciale - mi è rimasto solo un personaggio, quindi ho pensato di poterlo usare per abbinare un altro caso.

JavaScript ES6, 50 byte, 71,10%

Identifica correttamente 670 speciali e 752 non speciali.

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

Ora oltre la barriera del 70%, e battendo tutti tranne Retina!

Restituisce truese il messaggio contiene una di queste cose:

• Una parola di cui la seconda lettera è D, E, R, o v;
• tar(di solito star);
• ae ucon un carattere in mezzo;
• le xcon un carattere in mezzo (di solito alex);
• testo in corsivo;
• eooppure ol;
• a C, un punto e virgola o a ಠ.

Ecco alcune partite più fruttuose che non sembrano valere la pena di sbarazzarsi degli altri:

• nf
• nu
• yp
• n.m

Questo è diventato sempre più vicino alla risposta Retina, ma ho trovato la maggior parte dei miglioramenti da solo.

Provalo nella console di una di queste pagine: testi a stella , testi senza stelle

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

Ecco una versione alternativa. /a/.testè tecnicamente una funzione, ma non soddisfa i nostri criteri :

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

Questo ha ottenuto il 71,90% (697 stelle, 741 non stelle).

Ho eseguito alcune analisi sugli elenchi per vedere quali gruppi di regex corrispondono ai post più speciali e meno speciali. Le analisi sono disponibili in questo Gist . Finora ho controllato aae a.aabbinato. a.uscende a circa 50 con un punteggio di 28, ma è la partita più efficiente del suo formato ...

Pyth, 50 byte, 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

Questo esegue l'hashing dell'input in uno dei 322 bucket e sceglie il valore booleano in base a quel bucket.

punteggio

$ 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 byte, 65,55%

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

Questo controlla se il primo carattere è in un elenco specifico o la somma di tutti i punti di codice è maggiore di 8.672.

punteggio

$ 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 / Ottava, 17 byte 60,15%

Classifica correttamente 490 messaggi come fissati, 713 messaggi come non osservati

Versione corrente:

Sto solo controllando la lunghezza.

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

Vecchia versione:

Potrebbe essere tradotto in qualsiasi altra lingua. Controlla solo se il messaggio contiene o meno le parole asterisco .score: 59/911/52.5%

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

Risultati per i casi di test che utilizzano questo codice:

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 byte, punteggio complessivo di 0,5605 (56%).

Identifica correttamente 428 messaggi speciali e 693 messaggi non speciali. Il punteggio totale è (360+730)/2000=0.545.

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

Non aspettandosi di vincere, vedrò come si comporta. Sopra è il codice per un singolo messaggio, da eseguire con più usi questa versione modificata che restituisce la quantità di messaggi speciali:

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

Basta testarlo con STDIN essendo il testo non elaborato di entrambi i file. Restituisce vero se il messaggio contiene "stella" o se length + 1 mod 4 = 0.

JavaScript ES6, 0.615 = 61.5%

342 correttamente identificato come speciale, 888 correttamente identificato come non speciale, (342+888)/2000 = 0.615

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

Prova in questo modo su questo o questo :

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

_{ANCORA POTREI FARTI, MIO GRAZIOSO!}

Retina, 46 byte, 68,55

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

679 stelle: 692 non stelle

Passato a Retina per ottenere più regex in ... Ancora non fatto.

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

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

Programma che ho usato a scopo di test:

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