Bạn nên viết một chương trình hoặc chức năng xác định ngôn ngữ của một từ nhất định.

Nhiệm vụ là nhận ra một số trong số 5000 từ phổ biến nhất trong 4 ngôn ngữ:

• Tiếng Anh
• tiếng Đức
• người Ý
• người Hungary

Danh sách từ có thể được tìm thấy trong kho GitHub này.

Bạn được phép phạm sai lầm trong 40% các trường hợp kiểm tra được cung cấp . Tức là bạn có thể phân loại 8000 trong số 20000 đầu vào.

Chi tiết

• Các danh sách chỉ chứa các từ có chữ thường a-z, ví dụ won'tvà möchtekhông được bao gồm.
• Một vài từ xuất hiện trong nhiều ngôn ngữ có nghĩa là mã của bạn không thể luôn đoán chính xác đầu ra dự kiến.
• Để thuận tiện, bạn có thể tải xuống tất cả các trường hợp thử nghiệm dưới dạng một danh sách . Trong mỗi dòng, một số chỉ ngôn ngữ của từ. ( 1đối với tiếng Anh, 2tiếng Đức, 3tiếng Ý và 4tiếng Hungary.)
• Sơ hở tiêu chuẩn là không được phép.
• Sử dụng danh sách từ dữ liệu tương tự của chúng tôi được cung cấp bởi ngôn ngữ lập trình của bạn đều bị cấm.

Đầu vào

• Một chuỗi chỉ chứa các chữ cái tiếng Anh viết thường (az).
• Trailing newline là tùy chọn.

Đầu ra

• Bạn có thể phân loại các từ bằng cách cung cấp một đầu ra riêng biệt và nhất quán (luôn giống nhau) cho mỗi ngôn ngữ. (Ví dụ: 1tiếng Anh, 2tiếng Đức, 3tiếng Ý và 4tiếng Hungary.)

Đây là mã golf nên chương trình hoặc chức năng ngắn nhất sẽ thắng.

Mã câu hỏi liên quan đến golf: Đây có phải là một từ?

^{Danh sách từ được lấy từ wiktionary.org và 101lacular.net.}

Võng mạc , 51 byte

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

Tôi đã đưa ra các biểu thức chính quy và @ MartinBüttner đã thực hiện chuyển đổi sang / chơi gôn ở Retina để ... vượt qua nỗ lực của đội?

Ánh xạ là 1 -> Italian, 2 -> German, (empty) -> Hungarian, 4 -> English, với số lượng được phân loại trong mỗi loại4506 + 1852 + 2092 + 3560 = 12010 .

Hãy thử trực tuyến! |Phiên bản đa dòng sửa đổi

Giải trình

Trước hết, Python tương đương là như thế này:

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

Hãy để tôi nói rằng đó o$là một xuất sắc chỉ số của Ý.

Phiên bản Retina tương tự, với các cặp đường tạo thành các giai đoạn thay thế. Ví dụ: hai dòng đầu tiên

.*[aeio]$
1

thay thế các trận đấu của dòng đầu tiên bằng nội dung của dòng thứ hai.

Ba dòng tiếp theo cũng làm như vậy, nhưng sử dụng chế độ chống grep của Retina - anti-grep (được chỉ định với A`) sẽ xóa dòng nếu khớp với regex đã cho và hai dòng sau là sự thay thế từ một dòng trống thành đầu ra mong muốn.

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

Dòng sau sử dụng lại chống grep, nhưng không thay thế dòng trống, tạo đầu ra cố định cho tiếng Hungary.

A`[jkz]|gy|m$

Cuối cùng, hai dòng cuối cùng

\D+
4

thay thế một dòng không chữ số không trống bằng 4. Tất cả các sự thay thế chỉ có thể xảy ra nếu không có sự thay thế nào được kích hoạt trước đó, mô phỏng một if/else ifchuỗi.

LabVIEW, 29 LabVIEW Nguyên thủy và 148.950 Byte

quay vòng qua các ngôn ngữ và đặt iterator vào một mảng nếu từ đó ở đó. Điều này được kiểm tra bởi vòng lặp bên trong, chọn dòng thứ i và thực hiện= . Trong LabVIEW, nó chỉ cung cấp một sự thật nếu các Chuỗi hoàn toàn giống nhau.

Bây giờ lấy phần tử đầu tiên của mảng đầu ra để tiếng Anh vượt qua phần còn lại.

Đầu ra bây giờ là 0tiếng Anh, 1tiếng Đức, 2tiếng Ý và 3tiếng Hungary.

Java, 3416 byte, 62%

đây là giải pháp của tôi, tôi phân tích danh sách các từ đã cho và tìm thấy 60 dấu phẩy lớn nhất và bát quái cho mỗi ngôn ngữ. Bây giờ tôi đang kiểm tra n-gram của mình so với từ và chọn ngôn ngữ có hầu hết n-gram trong từ.

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

và đây là bản thử nghiệm của tôi

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

    }

}