हंगेरियन वर्णमाला क्रम

19

जो लोग बहुत अधिक चुनौती चाहते हैं, उनके लिए पुराने स्पेनिश वर्णमाला क्रम में , आइए एक नजर डालते हैं कि हंगेरियन वर्णमाला कैसे क्रमबद्ध होती है।

ए, ए, बी, सी, सी, डी, डीज़, डीज़, ई, ई, एफ, जी, जी, एच, आई, आई, जे, के, एल, लि, एम, एन, एन, ओ, ओ, यू ö, ő, p, q, r, s, sz, t, ty, u, ú, ü, w, v, w, x, y, z, zs

वास्तव में, q, w, xऔर yहंगरी के शब्दों में उपयोग नहीं किया जाता है, लेकिन वे एकल शब्दों और विदेशी नामों के लिए शामिल किए गए हैं। विदेशी उच्चारण वाले पात्र जो हंगेरियाई वर्णमाला (जैसे ñ) का हिस्सा नहीं हैं, गैर-उच्चारण वाले लोगों के समान प्राथमिकता है, लेकिन हम उन्हें इस चुनौती के लिए अवहेलना करते हैं।

नियम, संक्षेप:

  • डिग्राफ्स ( cs, szआदि) और ट्रिग्राफ ( dzs) को माना जाता है क्योंकि वे अपने आप पत्र थे।
cudar
cukor
cuppant
csalit
csata
  • एक ही संयुक्ताक्षर या trigraph एक शब्द में एक दूसरे के बाद दो बार सीधे होती है, तो वे एक सरल तरीके से लिखा जाता है: sszके बजाय szsz, ddzsके बजाय dzsdzsलेकिन वर्णमाला के क्रम के लिए गैर सरलीकृत आदेश प्रयोग किया जाता है। उदाहरण के लिए kasza< kaszinó< kassza, क्योंकि kasszaके रूप में प्रयोग किया जाता है k+ a+ sz+ sz+ aआदेश की खातिर। कभी-कभी आप यौगिक शब्दों के मामले में एक शब्द में गैर-अनुबंधित संस्करण पा सकते हैं।
kasza
kaszinó
kassza
kaszt
nagy
naggyá
nagygyakorlat
naggyal
nagyít
  • पूंजीकरण कोई फर्क नहीं पड़ता, अपवाद के साथ जब दो शब्द बिल्कुल बिना कैपिटलाइज़ेशन के समान होंगे, जिस स्थिति में निचला मामला पत्र प्राथमिकता है
jácint
Jácint
Zoltán
zongora
  • उच्चारण चिह्न स्वर की छोटी और लंबी संस्करण एक ही प्राथमिकता दी जाती है ( a - á, e -é, i - í, o - ó, ö - ő, u - ú ü - ű), एक भी अपवाद के साथ: अगर दो शब्दों अन्यथा बिल्कुल वैसा ही होगा, लघु स्वर प्राथमिकता दीर्घ स्वरों से अधिक है। ध्यान दें, कि umlaut ( öऔर ü) के साथ स्वर पूरी तरह से oऔर से अलग वर्ण हैं u।
Eger
egér
író
iroda
irónia
kerek
kerék
kérek
szúr
szül
  • हाइफ़न या रिक्त स्थान (उदाहरण के लिए, यौगिक शब्दों, नामों आदि में) को पूरी तरह से अनदेखा कर दिया जाता है
márvány
márványkő
márvány sírkő
Márvány-tenger
márványtömb

काम

आपका प्रोग्राम / फ़ंक्शन स्ट्रिंग्स प्राप्त करता है, जो हंगेरियाई वर्णमाला (दोनों निचले और ऊपरी मामले) के पात्रों से बना है, लेकिन एक स्ट्रिंग में रिक्त स्थान या हाइफ़न हो सकते हैं। सादगी के लिए, माइनस साइन (ASCII 45) को हाइफ़न के रूप में इस्तेमाल किया जा सकता है। ध्यान दें कि कुछ अक्षर (जैसे ő) ASCII का हिस्सा नहीं हैं। आप अपनी इच्छानुसार किसी भी एन्कोडिंग का उपयोग कर सकते हैं, यदि यह सभी आवश्यक वर्णों का समर्थन करता है।

आपको लाइनों को सही ढंग से ऑर्डर करना होगा और परिणाम प्रदर्शित / वापस करना होगा।

आप परीक्षण के लिए उपरोक्त उदाहरणों के किसी भी बेतरतीब ढंग से ऑर्डर किए गए सबसेट का उपयोग कर सकते हैं।

संपादित करें:

कृपया किसी भी अंतर्निहित या अन्य तरीके का उपयोग न करें जो पहले से ही अपने द्वारा हंगेरियाई वर्णानुक्रम को जानता है। यह प्रतियोगिता को व्यर्थ कर देगा, और सबसे अच्छी नियमित अभिव्यक्ति या सर्वश्रेष्ठ कोड गोल्फिंग ट्रिक्स खोजने से सभी चुनौती लेगा।

EDIT2:

Isaacg द्वारा पूछे गए स्पष्टीकरण को स्पष्ट करने के लिए: "दो तार जो केवल पूंजीकरण और लंबे बनाम छोटे स्वरों से भिन्न होते हैं, लेकिन दोनों तरीकों में भिन्न होते हैं": हालांकि आधिकारिक दस्तावेज़ में कोई भी नियम इस प्रश्न को स्पष्ट रूप से संबोधित नहीं करता है, एक उदाहरण जो लंबाई के बिंदुओं के भीतर पाया जाता है। स्वर का पूंजीकरण से अधिक महत्व है।

code-golf  string  sorting 
— vsz
स्रोत
@FryAmTheEggman आप कहां देखते हैं?
— मॉर्गन थ्रैप
9
यार, मैं भी हमारे उचित वर्णमाला क्रम को याद नहीं कर सकता। मैं यह कैसे कार्यक्रम करने जा रहा हूँ? ;)
— एंड्रास डीक
1
मैं एक बाउंड-टू-फेल काउंटरप्लेम्प के साथ आने की कोशिश कर रहा हूं, जहां एक स्पष्ट डिग्राफ वास्तव में दो अक्षर हैं, जैसे malacsültया nyílászáró। मुझे आश्चर्य है कि अगर कोई हो (लेकिन आपको इसकी जांच के लिए एक शब्दावली की आवश्यकता होगी, जो संभवतः इस चुनौती का हिस्सा नहीं है)
— एंड्रास डीक
1
कोई उदाहरण नहीं है जिसमें
— dzs शामिल हों
1
— सर्गियोल

जवाबों:

4

पर्ल, 250

के लिए +11 शामिल है -Mutf8 -CS।

use Unicode::Normalize;$r="(?=cs|zs|dz|sz|[glnt]y)";print map/\PC*
/g,sort map{$d=$_;s/d\Kd(zs)|(.)\K$r\2(.)/\L$+\E$&/gi;s/d\Kzs/~$&/gi;s/$r.\K./~$&/gi;s/(\p{Ll}*)(\w?)\s*-*/\U$1\L$2/g;$c=$_;$b=$_=NFD lc;y/̈̋/~~/d;join$;,$_,$b,$c,$d}<>

का उपयोग करता है डेकोरेट-तरह-undecorate मुहावरा (उर्फ Schwartzian रूपांतरण ), और बहुस्तरीय छंटाई † , जहां स्तर हैं:

  • L1: आधार अक्षरों की तुलना करें, डायक्ट्रीक्स, केस और कुछ विराम चिह्नों को अनदेखा करें।
  • L2: आधार पत्रों और डिक्टेटिक्स की तुलना करें, मामले और कुछ विराम चिह्नों को अनदेखा करें।
  • L3: आधार अक्षर, डायक्रिटिक्स और केस की तुलना करें, कुछ विराम चिह्नों को अनदेखा करें।
  • Ln: टाई-ब्रेकिंग बाइट-स्तरीय तुलना।

आंतरिक रूप से, ␜(ASCII 0x1C फील्ड सेपरेटर - जिसका मान इस चुनौती के लिए वर्णमाला में किसी भी वर्ण से कम है) का उपयोग स्तर विभाजक के रूप में किया जाता है।

इस कार्यान्वयन की कई सीमाएँ हैं, उनमें से:

  • विदेशी पात्रों के लिए कोई समर्थन नहीं।
  • अनुबंधित जेमिनीटेड (लंबे) डिग्राफ / ट्रिग्राफ और व्यंजन + डिग्राफ / ट्रिग्राफ के बीच में अंतर नहीं कर सकते, उदाहरण के लिए: könnyű को <k> <ö> <ny> <ay> <ű> के रूप में टकरा जाना चाहिए , जबकि tizennyolc को <t> <t> के रूप में टकरा जाना चाहिए। i> <z> <e> <n> <n> <o> <l> <c> ; házszám 'पता = house (ház) संख्या (szám)' को <h> <á> <z> <sz> <á> <m> और के रूप में * <h> <á> <zs> <z> के रूप में टकराना चाहिए <á> <m> । ‡
  • अनुबंधित लंबी डिग्गियों के लिए कोलाजेशन सुसंगत नहीं है (लेकिन यह स्थिर है): हम समान स्तर ( ssz < n szsz, ..., zszs < n zzs ) पर असहमति जताते हैं ; glibc छोटे रूपों को पूर्ण रूपों ( ssz <szsz, ..., zzs <zszs ) से पहले टकराता है, L3 केस और वेरिएंट ( sssz < 3 ssz, ..., zszs) पर शुरू होने वाले लघु रूपों से पहले ICU लंबे रूपों को जोड़ता है। 3 zz )

विस्तारित संस्करण:

use Unicode::Normalize;

$r="(?=cs|zs|dz|sz|[glnt]y)";   # look-ahead for digraphs

print map/\PC*\n/g,             # undecorate
  sort                          # sort
  map{                          # decorate

          $d=$_;                # Ln: identical level

          # expand contracted digraphs and trigraphs
          s/d\Kd(zs)|(.)\K$r\2(.)/\L$+\E$&/gi;

          # transform digraphs and trigraphs so they 
          #  sort correctly
          s/d\Kzs/~$&/gi;s/$r.\K./~$&/gi;

          # swap case, so lower sorts before upper
          # also, get rid of space, hyphen, and newline
          s/(\p{Ll}*)(\w?)\s*-*/\U$1\L$2/g;

          $c=$_;                # L3: Case

          $b=$_=NFD lc;         # L2: Diacritics

          # transform öő|üű so they sort correctly
          # ignore diacritics (acute) at this level
          y/\x{308}\x{30b}\x{301}/~~/d;

                                # L1: Base characters
          join$;,$_,$b,$c,$d
  }<>

†। कुछ प्रसिद्ध बहु-स्तरीय कोलाज एल्गोरिदम यूनिकोड कॉलेशन एल्गोरिथ्म (यूसीए, यूनिकोड यूटीएस # 10) , आईएसओ 14651 ( आईएसओ आईटीटीएफ साइट पर उपलब्ध ) आईएसओ टीआर 30112 में एलसी_कोलेट भागों ( आईएसओ / आईईसी जेटीसी 1 पर उपलब्ध ड्राफ्ट) हैं। SC35 / WG5 घर ) जो ISO / IEC TR 14652 ( ISO / IEC JTC1 / SC22 / WG20 घर पर उपलब्ध है ) और POSIX पर LC_COLLATE का पालन ​​करता है ।

‡। इसे सही ढंग से करने पर शब्दकोश की आवश्यकता होगी। अजीब तरह से आईसीयू व्यवहार करता है पूंजीकृत समूहों गैर संकुचन / गैर-द्वि आलेख / गैर trigraphs, जैसे के रूप में: सीसीएस < 3 सीसीएस < 3 सी सी < 3 ग सीएस < 3 सी सी < 3 सीएस < 3 सीएस < 3 सी < 3 सीएस < 3 ccs < 3 Ccs < 3 CCS

— ninjalj
स्रोत
आपको मेरे विस्तार RegExp का उपयोग करके कुछ बाइट्स को बचाने में सक्षम होना चाहिए।
— TheConstructor
6

जावा 8, 742 बाइट्स

यदि क्लास-डेफिनिशन की गिनती न हो, तो फंक्शन का नामकरण या 16 बाइट्स के sबजाय अन्य 3 बाइट्स को कम कर सकते हैं sort।

public class H{String d="cs|dzs?|gy|ly|sz|ty|zs";void sort(java.util.List<String>l){l.sort((a,b)->{String o="-a-á-b-cs-dzs-e-é-f-gy-h-i-í-j-k-ly-m-ny-o-ó-ö-ő-p-q-r-sz-ty-u-ú-ü-ű-v-w-x-y-zs-";int i=c(r(a),r(b),r(o));return i!=0?i:(i=c(a,b,o))!=0?i:b.charAt(0)-a.charAt(0);});}String r(String a){for(int i=0;i<8;i++)a=a.toLowerCase().replace("ááéíóőúű".charAt(i),"aaeioöuü".charAt(i));return a;}int c(String a,String b,String o){a=n(a);b=n(b);while(!"".equals(a+b)){int i=p(a,o),j=p(b,o);if(i!=j)return i-j;a=a.substring(i%4);b=b.substring(j%4);}return 0;}int p(String a,String o){a=(a+1).replaceAll("("+d+"|.).*","-$1");return o.indexOf(a)*4+a.length()-1;}String n(String a){return a.toLowerCase().replaceAll("(.)(?=\\1)("+d+")| |-","$2$2");}}

इस तरह इस्तेमाल किया जा सकता है:

new H().sort(list);

परीक्षण सूट:

public static void main(String[] args) {
    test(Arrays.asList("cudar", "cukor", "cuppant", "csalit", "csata"));
    test(Arrays.asList("kasza", "kaszinó", "kassza", "kaszt", "nagy", "naggyá", "nagygyakorlat", "naggyal",
            "nagyít"));
    test(Arrays.asList("jácint", "Jácint", "Zoltán", "zongora"));
    test(Arrays.asList("Eger", "egér", "író", "iroda", "irónia", "kerek", "kerék", "kérek", "szúr", "szül"));
    test(Arrays.asList("márvány", "márványkő", "márvány sírkő", "Márvány-tenger", "márványtömb"));
}

private static void test(final List<String> input) {
    final ArrayList<String> random = randomize(input);
    System.out.print(input + " -> " + random);
    new H().sort(random);
    System.out.println(" -> " + random + " -> " + input.equals(random));
}

private static ArrayList<String> randomize(final List<String> input) {
    final ArrayList<String> temp = new ArrayList<>(input);
    final ArrayList<String> randomOrder = new ArrayList<>(input.size());
    final Random r = new Random();
    for (int i = 0; i < input.size(); i++) {
        randomOrder.add(temp.remove(r.nextInt(temp.size())));
    }
    return randomOrder;
}

उपज

[cudar, cukor, cuppant, csalit, csata] -> [csata, cudar, cuppant, csalit, cukor] -> [cudar, cukor, cuppant, csalit, csata] -> true
[kasza, kaszinó, kassza, kaszt, nagy, naggyá, nagygyakorlat, naggyal, nagyít] -> [naggyá, kassza, kaszinó, nagygyakorlat, nagyít, nagy, kaszt, kasza, naggyal] -> [kasza, kaszinó, kassza, kaszt, nagy, naggyá, nagygyakorlat, naggyal, nagyít] -> true
[jácint, Jácint, Zoltán, zongora] -> [Zoltán, jácint, zongora, Jácint] -> [jácint, Jácint, Zoltán, zongora] -> true
[Eger, egér, író, iroda, irónia, kerek, kerék, kérek, szúr, szül] -> [egér, Eger, kerék, iroda, író, kerek, kérek, szúr, irónia, szül] -> [Eger, egér, író, iroda, irónia, kerek, kerék, kérek, szúr, szül] -> true
[márvány, márványkő, márvány sírkő, Márvány-tenger, márványtömb] -> [márványtömb, márványkő, Márvány-tenger, márvány sírkő, márvány] -> [márvány, márványkő, márvány sírkő, Márvány-tenger, márványtömb] -> true

Ungolfed:

public class HungarianOrder {

    String d = "cs|dzs?|gy|ly|sz|ty|zs";

    void sort(java.util.List<String> l) {
        l.sort((a, b) -> {
            String o = "-a-á-b-cs-dzs-e-é-f-gy-h-i-í-j-k-ly-m-ny-o-ó-ö-ő-p-q-r-sz-ty-u-ú-ü-ű-v-w-x-y-zs-";
            int i = c(r(a), r(b), r(o));
            return i != 0 ? i
                    : (i = c(a, b, o)) != 0 ? i
                            : b.charAt(0) - a.charAt(0);
        });
    }

    // toLower + remove long accent
    String r(String a) {
        for (int i = 0; i < 8; i++)
            a = a.toLowerCase().replace("ááéíóőúű".charAt(i), "aaeioöuü".charAt(i));
        return a;
    }

    // iterate over a and b comparing positions of chars in o
    int c(String a, String b, String o) {
        a = n(a);
        b = n(b);
        while (!"".equals(a + b)) {
            int i = p(a, o), j = p(b, o);
            if (i != j)
                return i - j;
            a = a.substring(i % 4);
            b = b.substring(j % 4);
        }
        return 0;
    }

    // find index in o, then looking if following characters match
    // return is index * 4 + length of match; if String is empty or first character is unknown -1 is returned
    int p(String a, String o) {
        a = (a+1).replaceAll("("+d+"|.).*", "-$1");
        return o.indexOf(a) * 4 + a.length() - 1;
    }

    // expand ddz -> dzdz and such
    String n(String a) {
        return a.toLowerCase().replaceAll("(.)(?=\\1)("+ d +")| |-", "$2$2");
    }
}

मैं जावा का उपयोग कर रहा हूँ List-प्रकार और इसके order()-function, लेकिन तुलनित्र सब मेरा है।

— TheConstructor
स्रोत
प्रभावशाली! मुझे लगता है कि आपको सूची को निर्दिष्ट करने <String>और कुछ चेतावनियों की कीमत पर कुछ पात्रों को बचाने में सक्षम होना चाहिए ?
— जोश
@ जोश नहीं, यह दो कलाकारों का निर्माण करेगा क्योंकि जावा Objectतब और बी के प्रकार के रूप में होगा । मैं शायद क्लास-जेनेरिक-पैरामीटर को परिभाषित करने से दूर हो सकता हूं String, हालांकि। इसके अलावा, मुझे सबसे छोटा कोड होने की उम्मीद नहीं है। ;-)
— द कंस्ट्रक्टर
3

अजगर 3, 70

Shooqie के लिए 8 बाइट्स सहेजे गए।

मैं अजगर से प्यार करता हूं। : डी

तार की सूची की अपेक्षा करता है।

from locale import*;setlocale(0,'hu')
f=lambda x:sorted(x,key=strxfrm)
— मॉर्गन थ्राप्प
स्रोत
3
क्या यह एक मानक खामी नहीं है?
— ११:१३
1
@vsz नहीं जहाँ तक मुझे पता है। बिल्ट-इन का उपयोग करना बहुत सारी चुनौतियों का हिस्सा है।
— मॉर्गन थ्रैप
1
@vsz यह एक मानक मानक के रूप में गिने जाने वाले मानक खामियों पर नीचे-वोट अनुपात में बहुत कम है, आपको इसे स्पष्ट रूप से प्रतिबंधित करना होगा।
— FryAmTheEggman
1
ठीक है, कर दिया। मैंने स्पष्ट रूप से इस पर प्रतिबंध लगाने पर विचार किया लेकिन मुझे यह स्पष्ट होना चाहिए कि यह पूरी चुनौती को एक बिंदु बना देगा। असुविधा के लिए मुझे खेद है।
— ११'१६ को १६:१६
1
from locale import* बहुत सारे बाइट्स बचाता है
— शूकी
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.