यह शब्द किस भाषा का है?

Question

आपके पास एक प्रोग्राम या फ़ंक्शन लिखना चाहिए जो किसी दिए गए शब्द की भाषा निर्धारित करता है।

कार्य 4 भाषाओं में 5000 सबसे आम शब्दों में से कुछ को पहचानना है:

• अंग्रेज़ी
• जर्मन
• इतालवी
• हंगेरी

शब्द सूची इस GitHub भंडार में पाई जा सकती है।

आपको प्रदान किए गए परीक्षण मामलों के 40% में गलती करने की अनुमति है । यानी आप 20000 इनपुट में से 8000 को मिसकैरेज कर सकते हैं।

विवरण

• सूचियों में केवल लोअरकेस अक्षरों के साथ शब्द होते हैं, a-zजैसे कि won'tऔर möchteशामिल नहीं हैं।
• कुछ शब्द कई भाषाओं में दिखाई देते हैं जिसका अर्थ है कि आपका कोड हमेशा अपेक्षित आउटपुट का सही अनुमान नहीं लगा सकता है।
• सुविधा के लिए आप सभी परीक्षण मामलों को एक सूची के रूप में डाउनलोड कर सकते हैं । प्रत्येक पंक्ति में एक संख्या शब्द की भाषा को इंगित करती है। ( 1अंग्रेजी के लिए, 2जर्मन के लिए, 3इतालवी के लिए और 4हंगेरियन के लिए।)
• मानक खामियों को अस्वीकार कर दिया जाता है।
• शब्द सूची का उपयोग करना आपकी प्रोग्रामिंग भाषा द्वारा प्रदान किया गया समान डेटा निषिद्ध है।

इनपुट

• एक स्ट्रिंग जिसमें केवल अंग्रेजी अक्षर (az) होते हैं।
• अनुगामी न्यूलाइन वैकल्पिक है।

उत्पादन

• आप प्रत्येक भाषा के लिए एक अलग और सुसंगत (हमेशा समान) आउटपुट प्रदान करके शब्दों को वर्गीकृत कर सकते हैं। (जैसे 1अंग्रेजी के लिए, 2जर्मन के लिए, 3इतालवी के लिए और 4हंगेरियन के लिए।)

यह कोड गोल्फ है इसलिए सबसे छोटा कार्यक्रम या फ़ंक्शन जीतता है।

संबंधित कोड गोल्फ प्रश्न: यह भी एक शब्द है?

^{शब्द सूची wiktionary.org और 101languages.net से ली गई थी।}

Comments

क्या आप सुनिश्चित हैं कि सूचियाँ सही हैं? मुझे पूरा यकीन है कि मैं जर्मन में कभी नहीं सुना। सभी संभव भाषाओं के साथ एक सरणी का उत्पादन करता है? उदाहरण के लिए, जाहिरा तौर पर सभी भाषाओं में है, इसलिए यह {1,2,3,4}

— Eumel

@Eumel पहले दो अंग्रेजी शब्द अन्य सूचियों में कहीं मौजूद हो सकते हैं क्योंकि भाषाओं के ग्रंथों में अंग्रेजी वाक्यांश हो सकते हैं जो शब्द सूची उत्पन्न करने के लिए उपयोग किए गए थे। आपका इनपुट केवल एक भाषा में वर्गीकृत किया जा सकता है। (व्हिच का अर्थ है कि इस प्रश्न में उल्लेख किया गया है कि "आपका कोड हमेशा अपेक्षित आउटपुट का सही अनुमान नहीं लगा सकता है।")

— यादृच्छिक योग

सूचियों में केवल लोअरकेस अक्षर वाले शब्द हैं ... यह पूरी तरह सच नहीं है। all_languagesफ़ाइल (पूंजीकृत शब्द के दर्जनों शामिल हैं Mr, Gutenberg"- |, आदि) और गैर-शब्द" "(रिक्त स्ट्रिंग) और"]]। मुझे लगता है कि पूर्व को कम करना और बाद को हटाना ठीक है?

— r3mainer

@squeamishossifrage कैच के लिए धन्यवाद। अंग्रेजी सूचियों को अपडेट किया। (~ 60 अपरकेस शब्द और 2 गैर-शब्द थे।)

— यादृच्छिक

क्यों dicritics निकालें? यदि लक्ष्य उन भाषाओं को अलग करना है, जिनके पास विकृतिविद्या नहीं है, तो उन भाषाओं का उपयोग क्यों न करें जिनके पास बाल चिकित्सा नहीं है?

— पैट

Answer 1

रेटिना , 51 बाइट्स

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

मैं रीगेक्स के साथ आया और @ मार्टिनबटनर ने रेटिना में / गोल्फिंग में रूपांतरण किया ... टीम प्रयास के लिए हुर्रे?

मैपिंग है 1 -> Italian, 2 -> German, (empty) -> Hungarian, 4 -> English, प्रत्येक श्रेणी में वर्गीकृत राशि के साथ 4506 + 1852 + 2092 + 3560 = 12010।

इसे ऑनलाइन आज़माएं! | संशोधित बहुस्तरीय संस्करण

व्याख्या

सबसे पहले, समकक्ष पायथन कुछ इस तरह है:

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

मुझे केवल यह कहना चाहिए कि इतालवी o$का एक उत्कृष्ट संकेतक है।

रेटिना संस्करण समान है, जिसमें प्रतिस्थापन चरण बनाने वाली लाइनों के जोड़े हैं। उदाहरण के लिए, पहली दो पंक्तियाँ

.*[aeio]$
1

दूसरी की सामग्री के साथ पहली पंक्ति के मैचों को बदलता है।

अगली तीन लाइनें ऐसा ही करती हैं, लेकिन रेटिना के एंटी-जीआरपी मोड का उपयोग करते हुए - एंटी-ग्रीप (निर्दिष्ट A`) लाइन को हटा देता है यदि यह दिए गए रेगेक्स से मेल खाता है, और निम्न दो लाइनें वांछित आउटपुट से खाली लाइन से प्रतिस्थापन है।

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

निम्न पंक्ति फिर से एंटी-जीआरपी का उपयोग करती है, लेकिन हंगरी के लिए निश्चित आउटपुट देते हुए, खाली लाइन को प्रतिस्थापित नहीं करती है।

A`[jkz]|gy|m$

अंत में, अंतिम दो पंक्तियाँ

\D+
4

एक गैर-रिक्त गैर-अंकीय रेखा के साथ बदलता है 4। सभी प्रतिस्थापन केवल तभी हो सकते हैं यदि कोई पिछला प्रतिस्थापन सक्रिय नहीं है, एक if/else ifश्रृंखला का अनुकरण करता है।

Answer 2

LabVIEW, 29 LabVIEW प्राइमिटिव और 148.950 बाइट्स

भाषाओं के माध्यम से चक्र और शब्द होने पर पुनरावृत्त को एक सरणी में रखता है। यह आंतरिक लूप द्वारा चेक किया जाता है, ith लाइन उठाता है और कर रहा है =। LabVIEW में यह केवल एक सच देता है यदि स्ट्रिंग्स बिल्कुल समान हैं।

अब आउटपुट ऐरे का पहला तत्व लें, ताकि बाकी हिस्से में इंग्लिश आ जाए।

अभी का आउटपुट 0अंग्रेजी के लिए, 1जर्मन के लिए, 2इतालवी के लिए और 3हंगेरियन के लिए है।

Comments

मैं LabView से परिचित नहीं हूं, लेकिन आप मानों (शब्द सूचियों) को कैसे संग्रहीत करते हैं और उन्हें LabView Primitives में कैसे परिलक्षित किया जाता है? मेटा एंट्री कहती है: " कांस्टेंट: स्ट्रिंग्स 1 लैबव्यू प्राइमेटिव प्रति कैरेक्टर हैं "। क्या यह उस आदिम गिनती में भारी वृद्धि नहीं करेगा?

— 19

मैं एक फ़ाइल से लोड करता हूं जो निर्देशिका पथ + स्ट्रिंग के साथ पथ का निर्माण करता है + लोड फ़ाइल। भंडारण आंतरिक रूप से किया जाता है और तारों द्वारा पारित हो जाता है।

— यूमेल

मैं गलत हो सकता हूं, लेकिन मुझे लगता है कि चुनौती का मूल यह है कि वर्डलिस्ट को कैसे संपीड़ित / संग्रहीत किया जाए। इसलिए बाहरी फ़ाइल से लोड करना बंद किया जा सकता है। ओपी से इस बारे में पूछेंगे। :)

— १

यदि आप किसी बाहरी फ़ाइल का उपयोग करते हैं, तो यह आपके कोड आकार में जोड़ा जाना चाहिए क्योंकि यह आपके समाधान का एक हिस्सा है।

— 19

मैं इस धारणा के तहत था कि जो दिए जाने वाले थे, लेकिन बीमार ने उन्हें np

— Eumel

Answer 3

जावा, 3416 बाइट्स, 62%

यह मेरा समाधान है, मैं दिए गए शब्दों की सूची का विश्लेषण करता हूं और प्रत्येक भाषा के लिए 60 सबसे अधिक कॉमन्स बिगोग्राम और ट्रिगर्स ढूंढता हूं। अब मैं शब्द के खिलाफ अपने n- ग्राम की जाँच कर रहा हूं, और शब्द में अधिकांश n-ग्राम के साथ भाषा चुन रहा हूं।

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

और यह मेरी परीक्षा है

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

    }

}