Sie sollten ein Programm oder eine Funktion schreiben, die die Sprache eines bestimmten Wortes bestimmt.

Die Aufgabe besteht darin, einige der 5000 häufigsten Wörter in 4 Sprachen zu erkennen:

• Englisch
• Deutsche
• Italienisch
• ungarisch

Die Wortlisten finden Sie in diesem GitHub-Repository.

In 40% der bereitgestellten Testfälle dürfen Sie Fehler machen . Dh Sie können 8000 der 20000 Eingänge falsch kategorisieren.

Einzelheiten

• Die Listen enthalten a-zalso zB nur Wörter mit Kleinbuchstaben won'tund möchtesind nicht enthalten.
• Einige Wörter werden in mehreren Sprachen angezeigt, was bedeutet, dass Ihr Code die erwartete Ausgabe nicht immer richtig erraten kann.
• Der Einfachheit halber können Sie alle Testfälle als eine Liste herunterladen . In jeder Zeile gibt eine Zahl die Sprache des Wortes an. ( 1für Englisch, 2für Deutsch, 3für Italienisch und 4für Ungarisch.)
• Standardlücken sind nicht zulässig.
• Das Verwenden von Wortlisten und ähnlichen Daten, die von Ihrer Programmiersprache bereitgestellt werden, ist verboten.

Eingang

• Eine Zeichenfolge, die nur englische Kleinbuchstaben (az) enthält.
• Der Zeilenumbruch ist optional.

Ausgabe

• Sie können die Wörter kategorisieren, indem Sie für jede Sprache eine eindeutige und konsistente (immer gleiche) Ausgabe bereitstellen. (ZB 1für Englisch, 2für Deutsch, 3für Italienisch und 4für Ungarisch.)

Dies ist Codegolf, also gewinnt das kürzeste Programm oder die kürzeste Funktion.

Verwandte Code Golf Frage: Ist das überhaupt ein Wort?

^{Die Wortlisten stammen von wiktionary.org und 101languages.net.}

Netzhaut , 51 Bytes

.*[aeio]$
1
A`en$|ch|ei|au
^$
2
A`[jkz]|gy|m$
\D+
4

Ich habe mir die Regexes ausgedacht und @ MartinBüttner hat die Umstellung auf / Golfen in Retina so ... Hurra für die Teamleistung?

Die Zuordnung erfolgt 1 -> Italian, 2 -> German, (empty) -> Hungarian, 4 -> English, wobei der Betrag in jede Kategorie eingeordnet ist 4506 + 1852 + 2092 + 3560 = 12010.

Probieren Sie es online! | Geänderte mehrzeilige Version

Erläuterung

Zuallererst ist das äquivalente Python ungefähr so:

import re
def f(s):
  if re.search("[aeio]$", s):
    return 1
  if re.search("en$|ch|ei|au", s):
    return 2
  if re.search("[jkz]|gy|m$", s):
    return ""
  return 4

Lass mich das einfach sagen o$ ein ausgezeichneter Indikator für Italienisch ist.

Die Retina-Version ist ähnlich, wobei Paare von Linien Ersatzstufen bilden. Zum Beispiel die ersten beiden Zeilen

.*[aeio]$
1

Ersetzt Übereinstimmungen der ersten Zeile durch den Inhalt der zweiten.

Die nächsten drei Zeilen machen dasselbe, aber A`wenn Sie den Anti-Grep-Modus von Retina verwenden - Anti-Grep (angegeben mit ) entfernt die Zeile, wenn sie mit dem angegebenen regulären Ausdruck übereinstimmt, und die folgenden zwei Zeilen ersetzen eine leere Zeile durch die gewünschte Ausgabe.

A`en$|ch|ei|au
^$
2

Die folgende Zeile verwendet wieder anti-grep, ersetzt jedoch nicht die leere Zeile und gibt die feste Ausgabe für Ungarisch aus.

A`[jkz]|gy|m$

Zum Schluss die letzten beiden Zeilen

\D+
4

ersetzt eine nicht leere nichtstellige Zeile durch 4. Alle Ersetzungen können nur erfolgen, wenn keine vorherige Ersetzung aktiviert wurde, wodurch eine if/else ifKette simuliert wird.

LabVIEW, 29 LabVIEW-Grundelemente und 148.950 Bytes

Durchläuft die Sprachen und fügt den Iterator in ein Array ein, wenn das Wort vorhanden ist. Dies wird durch die innere Schleife überprüft, indem die i-te Zeile ausgewählt und ausgeführt wird= . In LabVIEW gibt es nur dann ein true, wenn die Strings genau gleich sind.

Nehmen Sie nun das erste Element des Ausgabe-Arrays, damit Englisch über den Rest geht.

Die Ausgabe ist vorerst 0für Englisch, 1Deutsch, 2Italienisch und 3Ungarisch.

Java, 3416 Byte, 62%

Dies ist meine Lösung, ich analysiere die Liste der gegebenen Wörter und finde 60 Bigramme und Trigramme für jede Sprache. Jetzt überprüfe ich meine n-Gramme gegen Wort und wähle Sprache mit den meisten n-Grammen im Wort.

public class Classificator {

    String[][] triGr = {
            {"ing","ion","ent","tio","ted","nce","ter","res","ati","con","ess","ate","pro","ain","est","ons","men","ect","red","rea","com","ere","ers","nte","ine","her","ble","ist","tin","for","per","der","ear","str","ght","pre","ver","int","nde","the","igh","ive","sta","ure","end","enc","ned","ste","dis","ous","all","and","anc","ant","oun","ten","tra","are","sed","cti"},
            {"sch","che","ver","gen","ten","cht","ich","ein","ste","ter","hen","nde","nge","ach","ere","ung","den","sse","ers","and","eit","ier","ren","sen","ges","ang","ben","rei","est","nen","nte","men","aus","der","ent","hei","her","lle","ern","ert","uch","ine","ehe","auf","lie","tte","ige","ing","hte","mme","end","wei","len","hre","rau","ite","bes","ken","cha","ebe"},
            {"ent","are","ato","nte","ett","ere","ion","chi","con","one","men","nti","gli","pre","ess","att","tto","par","per","sta","tra","zio","and","iam","end","ter","res","est","nto","tta","acc","sci","cia","ver","ndo","amo","ant","str","tro","ssi","pro","era","eri","nta","der","ate","ort","com","man","tor","rat","ell","ale","gio","ont","col","tti","ano","ore","ist"},
            {"sze","ere","meg","ett","gye","ele","ond","egy","enn","ott","tte","ete","unk","ban","tem","agy","zer","esz","tet","ara","nek","hal","dol","mon","art","ala","ato","szt","len","men","ben","kap","ent","min","ndo","eze","sza","isz","fog","kez","ind","ten","tam","nak","fel","ene","all","asz","gon","mar","zem","szo","tek","zet","elm","het","eve","ssz","hat","ell"}

                    };
    static String[][] biGr = {
        {"in","ed","re","er","es","en","on","te","ng","st","nt","ti","ar","le","an","se","de","at","ea","co","ri","ce","or","io","al","is","it","ne","ra","ro","ou","ve","me","nd","el","li","he","ly","si","pr","ur","th","di","pe","la","ta","ss","ns","nc","ll","ec","tr","as","ai","ic","il","us","ch","un","ct"},
        {"en","er","ch","te","ge","ei","st","an","re","in","he","ie","be","sc","de","es","le","au","se","ne","el","ng","nd","un","ra","ar","nt","ve","ic","et","me","ri","li","ss","it","ht","ha","la","is","al","eh","ll","we","or","ke","fe","us","rt","ig","on","ma","ti","nn","ac","rs","at","eg","ta","ck","ol"},
        {"re","er","to","ar","en","te","ta","at","an","nt","ra","ri","co","on","ti","ia","or","io","in","st","tt","ca","es","ro","ci","di","li","no","ma","al","am","ne","me","le","sc","ve","sa","si","tr","nd","se","pa","ss","et","ic","na","pe","de","pr","ol","mo","do","so","it","la","ce","ie","is","mi","cc"},
        {"el","en","sz","te","et","er","an","me","ta","on","al","ar","ha","le","gy","eg","re","ze","em","ol","at","ek","es","tt","ke","ni","la","ra","ne","ve","nd","ak","ka","in","am","ad","ye","is","ok","ba","na","ma","ed","to","mi","do","om","be","se","ag","as","ez","ot","ko","or","cs","he","ll","nn","ny"}

                    };

    public int guess(String word) {

        if (word.length() < 3) {
            return 4; // most words below 2 characters on list are hungarians
        }
        int score[] = { 0, 0, 0, 0 };
        for (int i = 0; i < 4; i++) {
            for (String s : triGr[i]) {
                if (word.contains(s)) {
                    score[i] = score[i] + 2;
                }
            }
            for (String s : biGr[i]) {
                if (word.contains(s)) {
                    score[i] = score[i] + 1;
                }
            }
        }
        int v = -1;
        int max = 0;
        for (int i = 0; i < 4; i++) {
            if (score[i] > max) {
                max = score[i];
                v = i;
            }
        }
        v++;
        return v==0?Math.round(4)+1:v;
    }
}

und das ist mein Testfall

public class Test {

    Map<String, List<Integer>> words = new HashMap<String, List<Integer>>();

    boolean validate(String word, Integer lang) {
        List<Integer> langs = words.get(word);
        return langs.contains(lang);
    }

    public static void main(String[] args) throws FileNotFoundException {

        FileReader reader = new FileReader("list.txt");
        BufferedReader buf = new BufferedReader(reader);
        Classificator cl = new Classificator();
        Test test = new Test();
        buf.lines().forEach(x -> test.process(x));
        int guess = 0, words = 0;
        for (String word : test.words.keySet()) {
            int lang = cl.guess(word);
            if (lang==0){
                continue;
            }
            boolean result = test.validate(word, lang);
            words++;
            if (result) {
                guess++;
            }
        }
        System.out.println(guess+ " "+words+ "    "+(guess*100f/words));
    }

    private void process(String x) {
        String arr[] = x.split("\\s+");
        String word = arr[0].trim();
        List<Integer> langs = words.get(word);
        if (langs == null) {
            langs = new ArrayList<Integer>();
            words.put(word, langs);
        }
        langs.add(Integer.parseInt(arr[1].trim()));

    }

}