对于那些希望比旧的西班牙字母顺序更具挑战性的人，让我们看一下匈牙利字母的顺序。

a，á，b，c，cs，d，dz，dzs，e，é，f，g，gy，h，i，í，j，k，l，ly，m，n，ny，o，o， ö，ő，p，q，r，s，sz，t，ty，u，ú，ü，ű，v，w，x，y，z，zs

^{实际上，q，w，x而y不是在匈牙利词连用，但它们包含了外来语和外国名字。不属于匈牙利字母（如ñ）的外来带重音符号的字符与不带重音的字符具有相同的优先级，但是我们对此挑战视而不见。}

规则总结如下：

• 有向图（cs，sz，等）和三字符（dzs）被认为是因为他们对自己的信件。

cudar
cukor
cuppant
csalit
csata

• 如果同一图或三部曲在一个单词中彼此直接出现两次，则它们将以简化方式书写：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 - ú ü - ű），有一个例外：如果两个词本来是完全一样的，短元音比长元音具有优先权。请注意，与元音（元音ö和ü）是由完全不同的人物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的一部分。如果支持所有必需的字符，则可以使用任何所需的编码。

您必须正确排列行并显示/返回结果。

您可以使用上述示例的任何随机排序的子集进行测试。

编辑：

请不要使用任何本身已经知道匈牙利字母顺序的内置方式或其他方式。这将使比赛毫无意义，并从寻找最佳正则表达式或最佳代码高尔夫技巧中接受所有挑战。

编辑2：

为了澄清isaacg提出的澄清要求：“两个字符串仅在大小写和长元音与短元音上有所不同，但在两种方式上都不同”：尽管官方文档中没有任何规则明确地解决此问题，但在长度上有一个例子元音的重要性比大写更重要。

佩尔（Perl），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}<>

使用decorate-sort-unecorate成语（AKA Schwartzian Transform）和多层排序^†，其中级别为：

• L1：比较基本字母，忽略变音符号，大小写和标点符号。
• L2：比较基本字母和变音符号，忽略大小写和标点符号。
• L3：比较基本字母，变音符号和大小写，忽略一些标点符号。
• Ln：抢七式字节级比较。

在内部，␜（ASCII 0x1C字段分隔符-该值小于此挑战中字母的任何字符）用作级别分隔符。

此实现有很多限制，其中包括：

• 不支持外来字符。
• 无法区分缩略的加长的有向图/有向图和辅音+有向图/有向图，例如：könnyű应该归类为<k> <ö> <ny> <ny> <ű>，而tizennyolc应该归类为<t> < i> <z> <e> <n> <ny> <o> <l> <c> ; házszám '地址=房屋（ház）编号（szám）'应为<h> <á> <z> <sz> <á> <m>而不是* <h> <á> <zs> <z> <á> <m>。^‡
• 收缩的长有向图的排序规则并不一致（但是很稳定）：我们在相同级别上消除歧义（ssz < _n szsz，...，zszs < _n zzs）; glibc在完整形式（ssz <szsz，...，zzs <zszs）之前对短形式进行排序，ICU在L3 Case和Variants（szsz < ₃ ssz，...，zszs < ₃ zzs）

扩展版本：

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

†。一些著名的多级排序规则算法是Unicode排序规则算法（UCA，Unicode UTS＃10），ISO 14651（在ISO ITTF站点上可用），ISO TR 30112的LC_COLLATE部分（在ISO / IEC JTC1 /上可用的草稿）。SC35 / WG5 home），已过时（ISO / IEC JTC1 / SC22 / WG20 home可用）和LC_COLLATE 已过时。

‡。正确执行此操作将需要字典。ICU将非固定/非有向图/非有向图视为大写字母的组，例如：ccS < ₃ CcS < ₃ c Cs < ₃ c CS < ₃ C Cs < ₃ cS < ₃ cs < ₃ Cs < ₃ CS < ₃ ccs < ₃ Ccs < ₃ CCS

Java 8，742字节

如果不计算类定义，则可以再减少3个字节来命名函数，s而不是减少sort16个字节。

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

取消高尔夫：

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

我正在使用Java的List-type和order()-function，但是比较器都是我的。

Python 3、70

由于shooqie，节省了8个字节。

我喜欢Python。：D

需要一个字符串列表。

from locale import*;setlocale(0,'hu')
f=lambda x:sorted(x,key=strxfrm)