introduzione

Questo sito sta rapidamente creando un enorme set di dati di frammenti di codice, quindi facciamo qualcosa con esso!

Ecco un file di dati . Contiene 9.066 coppie uniche di lingua + frammento per 113 lingue, tutte tratte da questo sito. Il formato è separato da tabulazioni (snippet TAB lingua), con tutte le nuove righe negli snippet sostituite <LF>e tutte le schede sostituite con 4 spazi. Esistono almeno 5 frammenti per ogni lingua.

[aggiornamento: ho apportato una piccola modifica al file di dati per unire alcune versioni di Python & RegExp che ho perso prima - il link sopra è stato aggiornato]

Sfida

Scrivi un programma o una funzione che accetta uno snippet di codice e genera la lingua in cui è scritto (vedi sotto per i dettagli). La dimensione totale della tua fonte + tutti i dati richiesti deve essere di 300 byte o meno, e il tuo programma deve produrre la lingua corretta quando viene dato il suo codice sorgente. Vince la massima precisione (risposte più corrette nel set di dati sopra).

Regole

• La dimensione totale del codice sorgente, delle risorse e di eventuali flag di compilazione / runtime richiesti non deve superare i 300 byte.
• La tua risposta verrà testata rispetto al set di dati sopra; verrà assegnato uno dei valori "Snippet" come input e il suo output verrà confrontato con l'output "corretto" in base al set di dati. Questo verrà ripetuto per tutte le voci nel set di dati e il numero finale di risposte corrette è il tuo punteggio.
• Puoi scegliere la codifica di input - assumerò UTF-8, quindi se hai bisogno di un'altra codifica specificala nella tua risposta.
• Non è necessario utilizzare la <LF>sostituzione per le nuove righe; se la tua voce prevede di ricevere newline come newline letterali (carattere 10), specificalo nella tua risposta.
• La tua voce deve generare la lingua in cui pensa sia scritto lo snippet di input. Per evitare la necessità di comprimere molte stringhe di lingua, consentirò le mappature (se vuoi produrre 3 per "Java", va bene); basta notare le mappature nella tua risposta.
• Puoi avere solo 1 mapping di output per ogni lingua (cioè se 3 significa "Java", non puoi avere anche 4 che significa "Java").
• Quando viene fornito il proprio codice sorgente, il programma deve produrre la risposta corretta (deve generare la lingua in cui è scritto).
• Non è necessario supportare tutte le lingue nel set di dati e, se lo si desidera, è possibile supportare altre lingue (ad esempio, se la voce non è in una delle lingue nel set di dati).
• Il tuo programma deve essere deterministico (fornire lo stesso input due volte deve produrre lo stesso output).

Tie-rottura

• I vincoli saranno decisi riducendo il set di dati fino a quando una voce vince. Il set di dati verrà ridotto rimuovendo tutti gli snippet per la lingua più popolare (ovvero i legami vengono interrotti dalla precisione delle lingue più rare). Ad esempio, se A e B ottengono il 70% dell'intero set di dati, tutti i frammenti di Python verranno rimossi. Se A e B ora ottengono entrambi un punteggio del 60%, CJam verrà rimosso. Se A ora segna il 50% ma B segna il 55%, B è il vincitore.
• Se si ottiene una precisione del 100%, i legami saranno decisi utilizzando un secondo set di dati (cieco) contenente più campioni per le stesse lingue.

Esempio 1

Lo script Python:

print("python")

Questo script produce correttamente "python" quando viene fornito il proprio codice sorgente, quindi è valido. Nel set di dati, segna 1008/9066 = 11,1%

Esempio 2

La funzione JavaScript:

function f(s){return /function/.test(s)?1:2}

Con i mapping 1 → javascript, 2 → python. Ancora una volta produce con successo 1 ("javascript") per la propria fonte e sul set di dati ottiene 1092/9066 = 12,0%

Da dove provengono i dati?

Ho creato una query SEDE per estrarre campioni dalle sfide [code-golf] su questo sito. Dalle risultanti 10.000 risposte, ho usato uno script Python messo insieme per trovare il nome del codice e della lingua per ciascuno, quindi ho filtrato qualsiasi lingua con meno di 5 esempi. I dati non sono puliti al 100% (so che ci sono alcuni frammenti non di codice estratti), ma dovrebbero essere abbastanza buoni.

Ispirato a questa sfida di prima dell'anno: chi l'ha detto? Elezioni presidenziali 2016

Anche parzialmente correlato a Qual è la lingua?

C, 297 byte, 43.194351% corrispondente (v2)

Questa è la prima sfida non golfistica a cui ho partecipato. Sorprendentemente, le lingue golfistiche sono in realtà piuttosto facili da separare, con circa il 60% di precisione di corrispondenza per lingua.

Il codice richiede l'immissione come stringa UTF-8, i risultati si basano sulla versione 2 del set di dati fornito. Questo codice non richiede <LF>di essere sostituito con le nuove righe effettive.

#define S(x)!!strstr(p,#x)
f(char*p){return S(#d)?:S(voi)?0:S(mai)|S(utc)?:S(mbd)|S(impor)|S(input)|S(def)|S(rang)?2:S(log)|S(fun)|S(=>)|S(lert)?3:S(<?)?4:S(echo)|S(sed)?5:S(+++)?6:S(<-)?7:S($_)|S(say)?8:S(\342)|S(\303)?9:S(->)|S(map)?10:S(@#)|S(]])|S([#)?11:S(V)|S(Q)?12:S(Z)|S(Y)?13:S(.)?14:15;}

Tabella di mappatura:

 0. java
 1. c
 2. python
 3. javascript
 4. php
 5. bash
 6. brainf*
 7. haskell
 8. perl
 9. apl
10. ruby
11. wolfram
12. pyth
13. matl
14. golfscript
15. cjam

La percentuale si basa sui miei risultati / calcolo totale: 3916 risultati / 9066 totali.

Python 3, 271 278 byte, 25,049636% corrispondente (v2, non verificato)

def f(c):
 try:compile(c,'','exec');return 5
 except:
  for j in range(9):
   if any(l in c for l in [['echo'],['require'],['Main','string'],['document','alert','var ','function'],['String'],['def ','lambda','print '],['main','int','char'],['+++','<<<'],[]][j]):break
 return j

carta geografica:

0 = bash
1 = ruby
2 = c#
3 = javascript
4 = java
5 = python
6 = c
7 = brainf*
8 = cjam

molto meglio del golf (probabilmente ancora non eccezionale), finalmente ha rotto la barriera del 25%! Gli input sono stati <LF>sostituiti con newline ( \n)