多键排序


20

给定一个索引列表和零个或多个整数列表,输出按升序排列的整数列表,键优先级来自第一个输入。

令键输入为[1, 0, 2],列表输入为[[5, 3, 4], [6, 2, 1], [5, 2, 1]]。这些列表需要按其第二元素,然后是第一个元素,然后是第三个元素,以升序排序:

  1. 首先,我们按index处的值排序1[[6, 2, 1], [5, 2, 1], [5, 3, 4]]
  2. 接下来,我们使用index处的值打破第一个排序的关系0[[5, 2, 1], [6, 2, 1], [5, 3, 4]]
  3. 最后,我们用索引处的vlues打破所有剩余的联系2(这实际上并没有改变任何东西,因为没有剩余的联系)。

细节

  • 排序是稳定的:如果两个元素相对于给定的排序键比较相等,则它们必须在输出中保持相同的相对顺序。例如,在给定的排序键下,如果AB相等,则输入was为[..., A, ..., B, ...]A必须放在B输出中。
  • 排序键永远不会引用输入列表之一中不存在的元素。
  • 不会重复排序键。因此,[1, 2, 1]不是排序键的有效列表。
  • 排序键未引用的任何元素均不计入排序顺序。只有初始相对顺序和排序键引用的元素的值才能确定输出顺序。
  • 您可以选择排序键是零索引还是一索引。
  • 排序键中将没有负值。如果选择使用单索引,则排序键中也不会有零。
  • 整数值不会超出您的语言的本机表示范围。如果您选择的语言具有本地固有的任意精度整数(例如Python)的能力,则输入整数可以存在任何整数值,但要受内存限制。

参考实现(Python 2)

#!/usr/bin/env python

keys = input()
lists = input()

print sorted(lists, key=lambda l:[l[x] for x in keys])

在线尝试

测试用例

格式:keys lists -> output。所有排序键均为零索引。

[1, 0, 2] [[5, 3, 4], [6, 2, 1], [5, 2, 1]] -> [[5, 2, 1], [6, 2, 1], [5, 3, 4]]
[1, 2] [[5, 3, 4], [6, 2, 1], [5, 2, 1]] -> [[6, 2, 1], [5, 2, 1], [5, 3, 4]]
[0, 1] [[1, 2], [2, 1]] -> [[1, 2], [2, 1]]
[1, 0] [[1, 2], [2, 1]] -> [[2, 1], [1, 2]]
[0] [[4], [10, 11, -88], [-2, 7]] -> [[-2, 7], [4], [10, 11, -88]]
[2] [[-1, -5, 8, -1, -4, -10, -5, 4, 4, 6, -8, 4, 2], [-7, 6, 2, -8, -7, 7, -3, 3, 0, -6, 1], [-9, 8, -5, -1, -7, -8, -5, -6, 5, -6, 6]] -> [[-9, 8, -5, -1, -7, -8, -5, -6, 5, -6, 6], [-7, 6, 2, -8, -7, 7, -3, 3, 0, -6, 1], [-1, -5, 8, -1, -4, -10, -5, 4, 4, 6, -8, 4, 2]]
[2, 1] [[9, 2, -2, -10, -6], [3, -4, -2]] -> [[3, -4, -2], [9, 2, -2, -10, -6]]
[2, 4, 8] [[5, -3, 4, -6, -1, -2, -2, -4, 5], [-2, -3, 6, -4, -1, -4, -4, -5, 8, 9, 9, -3, 3, -9, -3], [2, 0, 10, -10, -1, 2, -1, 5, -1, 10, -5], [-7, -8, -6, 7, 3, 8, 6, -7, -2, 0, -6, -4, 4, -3, 2, -3]] -> [[-7, -8, -6, 7, 3, 8, 6, -7, -2, 0, -6, -4, 4, -3, 2, -3], [5, -3, 4, -6, -1, -2, -2, -4, 5], [-2, -3, 6, -4, -1, -4, -4, -5, 8, 9, 9, -3, 3, -9, -3], [2, 0, 10, -10, -1, 2, -1, 5, -1, 10, -5]]
[1, 2, 3, 4, 5] [[-7, 3, -8, 3, 5, -1, 6, -6, 9, 8], [-9, -1, -7, -9, -10, -2, -8, -10, -10, -3], [5, 3, -6, -5, -4, -4, -8, 2], [9, -4, 1, -1, -3, -2], [-6, -10, 4, -10, 6, 6, -1, 3, 0, 0], [1, -2, -7, -6, -7, -7, -1, 0, -4, 3, 3], [7, -1, -7, 2, -2, 9, 7, 5, -6, -8], [1, -5, -3, -10, -7, 9, -8, -5, -1], [-9, 4, -1, -1, 2, 4]] -> [[-6, -10, 4, -10, 6, 6, -1, 3, 0, 0], [1, -5, -3, -10, -7, 9, -8, -5, -1], [9, -4, 1, -1, -3, -2], [1, -2, -7, -6, -7, -7, -1, 0, -4, 3, 3], [-9, -1, -7, -9, -10, -2, -8, -10, -10, -3], [7, -1, -7, 2, -2, 9, 7, 5, -6, -8], [-7, 3, -8, 3, 5, -1, 6, -6, 9, 8], [5, 3, -6, -5, -4, -4, -8, 2], [-9, 4, -1, -1, 2, 4]]
[8, 7, 3, 2, 4, 9, 1] [[8, -5, 1, -6, -1, -4, 6, 10, 10, 6, 9, 5], [4, -8, 6, -10, -2, -3, 2, -6, 9, 5, 4, 10, 2, 3], [10, -1, 3, 0, -4, 1, -5, -4, -1, -7, 9, -9, -1, -5, 7, 8, 9, 6, -3], [0, -9, -7, -2, 2, -5, 7, 4, 6, -4, 1, 8, -7, 10], [5, 6, -9, 0, -1, 5, 4, 7, 5, 10, 2, 5, 7, -9]] -> [[10, -1, 3, 0, -4, 1, -5, -4, -1, -7, 9, -9, -1, -5, 7, 8, 9, 6, -3], [5, 6, -9, 0, -1, 5, 4, 7, 5, 10, 2, 5, 7, -9], [0, -9, -7, -2, 2, -5, 7, 4, 6, -4, 1, 8, -7, 10], [4, -8, 6, -10, -2, -3, 2, -6, 9, 5, 4, 10, 2, 3], [8, -5, 1, -6, -1, -4, 6, 10, 10, 6, 9, 5]]

一些测试用例似乎令人讨厌。
致命

@Fatalize它们的目的是涵盖排序关键字与列表长度相比很少的情况以及排序关键字很多的情况。
Mego 16/09/29

1
@Fatalize这就是我们进行复制和粘贴的原因。如有必要,请使用Retina将格式更改为可以使用的格式。
mbomb007'9

如果这是我们语言中的自然数据类型(即矩阵),我们是否可以假设所有行的长度都相同?
路易斯·门多

@LuisMendo否。您必须能够支持锯齿状的阵列。
Mego 2016年

Answers:


6

果冻,4字节

⁴ị$Þ

在线尝试!


1
您是否了解其工作原理?
JamEngulfer

@JamEngulfer:应该已经在答案中指定了,但是:Þ是“用指定的排序键排序”,⁴ị使用第二个命令行参数对数组重新排序(产生一个类似于问题的排序键),并$覆盖优先级,以便程序正确解析。

5

CJam,13个字节

{W%{{X=}$}fX}

一个未命名的块,它期望列表的列表和优先级列表位于堆栈的顶部,并用排序的列表列表替换它们。

在线尝试!(作为测试套件。)

说明

可以通过稳定地对从优先级最低的键到优先级最高的键的整个列表进行重复排序,来实现决胜局排序。

W%      e# Reverse priority list.
{       e# For each priority X...
  {     e#   Sort the lists by the result of this block...
    X=  e#     Extract the Xth element from the current list.
  }$
}fX

4

Ruby,35个字节

->k,a{a.sort_by{|e|e.values_at *k}}

在eval.in上查看:https ://eval.in/652574


4

Haskell,38个字节

import Data.List
sortOn.flip(map.(!!))

用法示例:( sortOn.flip(map.(!!)) ) [2,1] [[9,2,-2,-10,-6], [3,-4,-2]]-> [[3,-4,-2],[9,2,-2,-10,-6]]

非点数:f k v=sortOn(\x->map(\y->x!!y)k)v


4

Mathematica,22个 19字节

SortBy[Extract/@#]&

使用基于1的索引。此未命名函数为curried,因此调用约定为:

SortBy[Extract/@#]&[{2, 1, 3}][{{5, 3, 4}, {6, 2, 1}, {5, 2, 1}}]

Mathematica SortBy可以列出一系列功能,在这种情况下,各个功能都可以用作连续的决胜局,所以这正是我们想要的。我们需要做的就是创建一个函数列表,这些函数返回相应的list元素。可以使用来完成ExtractExtract通常是一个Extract[list, index]返回列表元素的二进制函数。但是,如果单用,则Extract[index]返回一个函数,该函数index从传递给它的列表中检索元素。换句话说,可以对的index参数Extract进行处理。我们通过映射Extract给定的索引列表来利用此功能,从而创建所需的功能列表。


Extract/@#应该Extract/@(#+1)吗?输入的索引从0开始
。– JungHwan Min

2
@JHM“您可以选择排序键是零索引还是一索引。”
Martin Ender

我站得住了。
JungHwan Min

(毫不奇怪)优雅!但是考虑到您正在1索引,不[{1, 0, 2}]应该[{2, 1, 3}]在您的示例中吗?实际上,当前似乎是按第一个元素,然后是head,然后是第二个元素进行排序。
格雷格·马丁

@GregMartin对不起,复制/粘贴失败。
马丁·恩德

3

Python,50个字节

lambda l,k:sorted(l,key=lambda x:[x[y]for y in k])

这是参考实现的简单版本。l是lists参数,k是sort keys参数。l可以是任意迭代的,只要其元素可以用整数(例如列表,元组或int键控的dict)下标即可。k可以是任意迭代的。


3

Brachylog,29个字节

tT,?hg:Tz:{:2f}o:ta
heI,?t:Im

在线尝试!

说明

我们使用o - Order可以与附加谓词一起使用的事实作为输入:我们通过对每个[Keys, a list]元素使用按其出现顺序a list在索引处的元素列表来对列表进行a key排序Keys

                          Input = [Keys, List of lists]

tT,                       Call the Keys T
   ?hg:T                  Create the list [[T], List of lists]
        z                 Zip [T] with the list of lists
         :{   }o          Order by the output of this predicate
                :ta       Keep only the last element of each sublist in the Output

           :2f            Find all outputs of the predicate below

heI,                      Take a key I
    ?t:Im                 Output is the Ith element of the sublist

3

CJam(12字节)

{{1$\f=}$\;}

在线演示。这是一个匿名块(函数),它按测试用例给出的顺序接受参数,并将排序后的值保留在堆栈中。它依赖于$稳定的内置排序,但是官方解释器保证了这一点。

解剖

{          e# Define a block. Stack: orders values-to-sort
  {        e#   Sort by...
    1$\f=  e#     Copy orders from the stack, and map array lookup
  }$
  \;       e#   Pop the orders to leave just sorted-values
}

3

J,6个字节

]/:{&>

键是零索引的。LHS是键的列表,而RHS是值的数组。由于J不支持参差不齐的数组,因此必须将每个数组都装箱。

用法

   f =: ]/:{&>
   < 1 0 2
┌─────┐
│1 0 2│
└─────┘
   5 3 4 ; 6 2 1 ; 5 2 1
┌─────┬─────┬─────┐
│5 3 4│6 2 1│5 2 1│
└─────┴─────┴─────┘
   (< 1 0 2) f  5 3 4 ; 6 2 1 ; 5 2 1
┌─────┬─────┬─────┐
│5 2 1│6 2 1│5 3 4│
└─────┴─────┴─────┘
   (< 1 2) f  5 3 4 ; 6 2 1 ; 5 2 1
┌─────┬─────┬─────┐
│6 2 1│5 2 1│5 3 4│
└─────┴─────┴─────┘
   (< 0) f 4 ; 10 11 _88 ; _2 7
┌────┬─┬─────────┐
│_2 7│4│10 11 _88│
└────┴─┴─────────┘

说明

]/:{&>  Input: keys (LHS), values (RHS)
   {&>  Select from values at each index in keys
]       Get the values
 /:     Sort up the values using the ones selected with the keys

2

JavaScript(ES6),55个字节

(k,l)=>k.reduceRight((l,i)=>l.sort((a,b)=>a[i]-b[i]),l)

ECMAscript标准不保证基础排序是稳定的,因此下面的68字节代码不作此假设:

(k,l)=>l.sort(g=(a,b,i=0)=>i<k.length?a[k[i]]-b[k[i]]||g(a,b,i+1):0)

2

Pyth,5个 4字节

@LDF

在线尝试:演示测试套件

感谢@Maltysen提供了一个字节。

说明:

@LDFQ   Q (=input) added implicitly. 
  D     sort a list of lists by
@L         the sublists generated by some indices
   FQ   executes ^ with the the input as parameter

我真的很惊讶这工作。这是一个非常奇怪的语法。


我想你可以通过更换保存QEF
Maltysen

@Maltysen谢谢。我认为只有使用常规的一令牌方法才有可能。
雅库比

1
糖的规则非常明确且前后不一致,不幸的是,最好的办法就是尝试特定事物是否起作用。
Maltysen '16

2

JavaScript(ES6)46

k=>l=>l.sort((a,b)=>k.some(i=>v=a[i]-b[i])&&v)

在排序期间的每个比较中,扫描关键索引以找到正确的顺序

测试

f=k=>l=>l.sort((a,b)=>k.some(i=>v=a[i]-b[i])&&v)

;`[1, 0, 2] [[5, 3, 4], [6, 2, 1], [5, 2, 1]] -> [[5, 2, 1], [6, 2, 1], [5, 3, 4]]
[1, 2] [[5, 3, 4], [6, 2, 1], [5, 2, 1]] -> [[6, 2, 1], [5, 2, 1], [5, 3, 4]]
[0, 1] [[1, 2], [2, 1]] -> [[1, 2], [2, 1]]
[1, 0] [[1, 2], [2, 1]] -> [[2, 1], [1, 2]]
[0] [[4], [10, 11, -88], [-2, 7]] -> [[-2, 7], [4], [10, 11, -88]]
[2] [[-1, -5, 8, -1, -4, -10, -5, 4, 4, 6, -8, 4, 2], [-7, 6, 2, -8, -7, 7, -3, 3, 0, -6, 1], [-9, 8, -5, -1, -7, -8, -5, -6, 5, -6, 6]] -> [[-9, 8, -5, -1, -7, -8, -5, -6, 5, -6, 6], [-7, 6, 2, -8, -7, 7, -3, 3, 0, -6, 1], [-1, -5, 8, -1, -4, -10, -5, 4, 4, 6, -8, 4, 2]]
[2, 1] [[9, 2, -2, -10, -6], [3, -4, -2]] -> [[3, -4, -2], [9, 2, -2, -10, -6]]
[2, 4, 8] [[5, -3, 4, -6, -1, -2, -2, -4, 5], [-2, -3, 6, -4, -1, -4, -4, -5, 8, 9, 9, -3, 3, -9, -3], [2, 0, 10, -10, -1, 2, -1, 5, -1, 10, -5], [-7, -8, -6, 7, 3, 8, 6, -7, -2, 0, -6, -4, 4, -3, 2, -3]] -> [[-7, -8, -6, 7, 3, 8, 6, -7, -2, 0, -6, -4, 4, -3, 2, -3], [5, -3, 4, -6, -1, -2, -2, -4, 5], [-2, -3, 6, -4, -1, -4, -4, -5, 8, 9, 9, -3, 3, -9, -3], [2, 0, 10, -10, -1, 2, -1, 5, -1, 10, -5]]
[1, 2, 3, 4, 5] [[-7, 3, -8, 3, 5, -1, 6, -6, 9, 8], [-9, -1, -7, -9, -10, -2, -8, -10, -10, -3], [5, 3, -6, -5, -4, -4, -8, 2], [9, -4, 1, -1, -3, -2], [-6, -10, 4, -10, 6, 6, -1, 3, 0, 0], [1, -2, -7, -6, -7, -7, -1, 0, -4, 3, 3], [7, -1, -7, 2, -2, 9, 7, 5, -6, -8], [1, -5, -3, -10, -7, 9, -8, -5, -1], [-9, 4, -1, -1, 2, 4]] -> [[-6, -10, 4, -10, 6, 6, -1, 3, 0, 0], [1, -5, -3, -10, -7, 9, -8, -5, -1], [9, -4, 1, -1, -3, -2], [1, -2, -7, -6, -7, -7, -1, 0, -4, 3, 3], [-9, -1, -7, -9, -10, -2, -8, -10, -10, -3], [7, -1, -7, 2, -2, 9, 7, 5, -6, -8], [-7, 3, -8, 3, 5, -1, 6, -6, 9, 8], [5, 3, -6, -5, -4, -4, -8, 2], [-9, 4, -1, -1, 2, 4]]
[8, 7, 3, 2, 4, 9, 1] [[8, -5, 1, -6, -1, -4, 6, 10, 10, 6, 9, 5], [4, -8, 6, -10, -2, -3, 2, -6, 9, 5, 4, 10, 2, 3], [10, -1, 3, 0, -4, 1, -5, -4, -1, -7, 9, -9, -1, -5, 7, 8, 9, 6, -3], [0, -9, -7, -2, 2, -5, 7, 4, 6, -4, 1, 8, -7, 10], [5, 6, -9, 0, -1, 5, 4, 7, 5, 10, 2, 5, 7, -9]] -> [[10, -1, 3, 0, -4, 1, -5, -4, -1, -7, 9, -9, -1, -5, 7, 8, 9, 6, -3], [5, 6, -9, 0, -1, 5, 4, 7, 5, 10, 2, 5, 7, -9], [0, -9, -7, -2, 2, -5, 7, 4, 6, -4, 1, 8, -7, 10], [4, -8, 6, -10, -2, -3, 2, -6, 9, 5, 4, 10, 2, 3], [8, -5, 1, -6, -1, -4, 6, 10, 10, 6, 9, 5]]`
.split('\n').map(row=>{
  var [keys,list,expected]=row.split(/] -?>? ?\[/)
  keys=eval(keys+']');
  list=eval('['+list+']');
  expected=eval('['+expected);
  var result=f(keys)(list);
  var ok=result.join`|`==expected.join`|`;
  console.log(ok?'OK':'KO',keys+' '+list.join`|`+' -> ' +expected.join`|`,ok?'':result.join`|`)
})


2

PHP,212170字节

function m(&$i,$k){foreach($i as$a=>$y)for($b=-1;++$b<$a;){for($p=0;$p<count($k)&!$r=$i[$b][$x=$k[$p++]]-$i[$b+1][$x];);if($r>0){$s=$i[$b+1];$i[$b+1]=$i[$b];$i[$b]=$s;}}}

PHP 不再内置稳定排序;选择较旧的版本无法使用所需的规范进行递归回调。但是没关系:使用递归回调迭代器会花费很多;所以我什至没有检查是否可以做到这一点。

内部循环可以用另一个代替foreach; 这样可以节省一些字节。但是,如果不检查$b<$a(或$b<count($i)),将导致无限循环。有了这张支票,foreach成本与交换获胜一样多。

我首先递归进行比较;但是迭代可以节省大量字节:

分解

// bubble sort
function m(&$i,$k)
{
    foreach($i as$a=>$y)
        for($b=-1;++$b<$a;)
        {
            // comparison:
            for($p=0;$p<count($k)                       // loop through keys
                &
                !$r=$i[$b][$x=$k[$p++]]-$i[$b+1][$x]    // while element equals its successor
            ;);
            // if element is larger than its successor, swap them
            if($r>0)
            {
                $s=$i[$b+1];$i[$b+1]=$i[$b];$i[$b]=$s;
            }
        }
}

您的整体if($r>0){$s=$i[$b+1];$i[$b+1]=$i[$b];$i[$b]=$s;}可以写成$r>0&&$i[$b+1]^=$i[$b]^=$i[$b+1]^=$i[$b];,从而节省了7个字节。这将使用XOR交换并滥用短路评估来模拟if(){ ... }。仅当且仅 当时才执行交换$r>0。这使用了(有时)与数据库相同的技巧。通常,您会看到mysqli_connect( ... ) or die('Cannot connect');
伊斯梅尔·米格尔

@IsmaelMiguel XOR交换不适用于数组。它可以节省10个字节,因为我可以将其设置为$b循环的后置条件。;)
Titus

我测试了XOR交换并成功了(我没有测试其余的代码)。我编写了2个测试用例:sandbox.onlinephpfunctions.com/code/…(您编码)和sandbox.onlinephpfunctions.com/code/…(异或交换)。根据text-compare.com,输出是相同的。
伊斯梅尔·米格尔

@IsmaelMiguel要测试该功能,您应该执行它:m($i,$k);var_dump和之前插入,您的版本将产生垃圾。
泰特斯(Titus)

://我什至没有注意到我没有执行该功能...:/但这是一个很棒的主意!
伊斯梅尔·米格尔

1

R 40字节

for(i in rev(il)){dd=dd[order(dd[,i]),]}

说明:

列表列表最好用R中的data.frame表示:

ll2 = list(c(5,3,4), c(5,3,7), c(6,2,1), c(6,1,3), c(5,2,1))
dd = data.frame(do.call(rbind, ll2))
dd
      X1 X2 X3
    1  5  3  4
    2  5  3  7
    3  6  2  1
    4  6  1  3
    5  5  2  1

如果索引列表为il(索引从1开始):

il = list(1, 2, 3)

可以使用以下代码进行排序:

for(i in rev(il)){dd = dd[order(dd[,i]),]}

输出:

dd
  X1 X2 X3
5  5  2  1
1  5  3  4
2  5  3  7
4  6  1  3
3  6  2  1


1

拍框218字节

(λ(il ll)(define qsl(λ(l i)(if(null? l)l(let*((h(first l))(t(rest l))(g(λ(ff)(filter(λ(x)(ff(list-ref x i)
(list-ref h i)))t))))(append(qsl(g <)i)(list h)(qsl(g >=)i))))))(for((i(reverse il)))(set! ll(qsl ll i)))ll)

取消高尔夫(il =索引列表; ll =列表列表; qsl =列表列表的快速排序; h =头(第一个元素); t =尾巴(剩余或其余元素); g =可修改的过滤器fn):

(define qsl
  (λ(l i)
    (if (null? l)
        l
        (let* ((h (first l))
               (t (rest  l))
               (g (λ(ff) (filter (λ(x) (ff (list-ref x i) (list-ref h i))) t))))
          (append (qsl (g <) i)
                  (list h)
                  (qsl (g >=) i)
                  )))))
(define f
  (λ(il ll)
    (for ((i (reverse il)))
      (set! ll (qsl ll i)))
    ll))

测试:

(f (list 0 1 2) (list (list 5 3 4) (list 5 3 7) (list 6 2 1) (list 6 1 3) (list 5 2 1)))
(f [list 1 2] [list [list 5 3 4] [list 6 2 1] [list 5 2 3]])

输出:

'((5 2 1) (5 3 4) (5 3 7) (6 1 3) (6 2 1))
'((6 2 1) (5 2 3) (5 3 4))

1

PHP,139字节

使用新的太空飞船操作员并使用usort

<?$a=$_GET[a];function c($x,$y,$i=0){$k=$_GET[k];return$x[$k[$i]]-$y[$k[$i]]?:($k[++$i]?c($x,$y,$i):0);}usort($a,c);echo json_encode($a);

代替 $x[$k[$i]]<=>$y[$k[$i]]可以$x[$k[$i]]-$y[$k[$i]]在大于7-2字节的PHP版本下使用

像在真实库中一样创建自己的索引197字节的版本

<?$m=min(array_map(min,$a=$_GET[a]));foreach($a as$p=>$v){$k="";foreach($s=$_GET[s]as$f){$k.=str_pad($v[$f]-$m,5,0,0);}$k.=str_pad($p,5,0,0);$r[$k]=$v;}ksort($r);echo json_encode(array_values($r));

您可以尝试使用<?function c($x,$y,$i=0){$k=$_GET[k];return $x[$k[$i]]<=>$y[$k[$i]]?:($k[++$i]?c($x,$y,$i):0);}usort($a=$_GET[a],c);echo json_encode($a);$_GET是一个超全球性的:这意味着它已经遍及全球。删除global$k;,将分配移到函数内部,即可完成操作。另外,由于正在使用$_GET,因此必须使用<?。这样,您可以节省10个字节。它将(希望)工作。
伊斯梅尔·米格尔

@IsmaelMiguel我觉得自己是个白痴,我没有看到仅在函数内部使用全局变量。
约尔格Hülsermann

PHP sort函数使用quicksort;那是不稳定的。除此之外,您可以使用-代替来保存两个字节,<=>并使用匿名回调保存两个字节usort
泰特斯(Titus)

@Titus由于c($x,$y,$i)在函数主体的末尾,无法使用匿名函数。
Ismael Miguel

@JörgHülsermann不用担心,我们都会犯傻错误。
Ismael Miguel

0

Clojure,29个字节

#(sort-by(fn[c](mapv c %))%2)

Nicely sort-by很稳定,并且知道如何对向量进行排序,向量可以作为函数运行。([4 6 9 7] 2)9(基于0的索引)。

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.