模仿订购

24

给定两个数字列表，一个源和一个模式，对源重新排序以匹配模式的相对顺序。重新排序的源中的任何两个条目应与模式在相同位置的条目进行比较。

例如，输入

s = [-5, 9, 4, 13, 11, -6, 0]
p = [7, -4, 1, -8, 4, -3, 12]

应该产生结果

    [11, -5, 4, -6, 9, 0, 13]

比较第一个和最后一个位置，结果有11<13，7<12在模式中匹配。

输入：两个等长的非空整数列表。每个列表都不会重复。是否首先给出源或模式由您决定。

输出：重新排列源编号以使其与图案编号具有相同相对顺序的列表。

排行榜：

显示代码段

code-golf  sorting  permutations 
— 异或
source
它一定是一个函数/程序，还是一个表达式/片段就足够了？
— 2015年
— 马丁·恩德

Answers:

10

CJam，12个 10字节

{_$f#\$f=}

这是一个匿名函数，它接管s p堆栈并将结果保留在堆栈上。在线演示

感谢MartinBüttner提供了2个字节。

解剖

{         e# Define an anonymous function
  _$f#    e# Use a copy of the pattern to map each element to its sort index
  \$      e# Sort the source
  f=      e# Map each sort index to the corresponding source element
}
— 彼得·泰勒
source
{_$@$er}是短两个字节。
— 丹尼斯
@Dennis，这足够不同，可以单独回答
— Peter Taylor
如果您这样认为，我会将其发布为答案。
— 丹尼斯
10

J，9个字节

/:^:2~/:~

这是一个二进位动词，采用p和s作为左右参数。使用J.js在线尝试。

测试运行

   7 _4 1 _8 4 _3 12 (/:^:2~/:~) _5 9 4 13 11 _6 0
11 _5 4 _6 9 0 13

如何运作

说我们定义了通过示例分配的左右输入

p =: 7 _4 1 _8 4 _3 12
s =: _5 9 4 13 11 _6 0

然后：

  • 火车/:^:2~/:~是动词/:^:2~和的钩子/:~，所以称

    p (/:^:2~/:~) s

    执行

    p /:^:2~ /:~ s

  • ~in 的副词/:~是反身的，因为它/:是一元使用的。因此，

    /:~ s

    执行

    s /: s

  • ~in 的副词/:^:2~是被动的，因为该动词/:^:2被动态使用。因此，

    p /:^:2~ y

    执行

    y /:^:2 p

  • 副词^:是力量。因此，

    y /:^:2 p

    执行

    y /: y /: p

放在一起，打电话

p (/:^:2~/:~) s

执行

(s /: s) /: (s /: s) /: p

怎么说作品

使用来对 Dyadic /:进行分级，即x /:y返回x的元素，并根据x的相应值对其进行排序y。

  • s /: s只需对s的元素进行排序。

  • (s /: s) /: p根据p的对应值对s的（排序的）元素进行排序。

  • 两次累加实质上就是计算其正确参数的序数。

    因此，(s /: s) /: (s /: s) /: p对s的（排序的）元素进行排序，模仿p的元素的顺序。

— 丹尼斯
source
9

Mathematica，32 27字节

Sort@#~Permute~Ordering@#2&

用法示例：

Sort@#~Permute~Ordering@#2 &[{-5, 9, 4, 13, 11, -6, 0}, {7, -4, 1, -8, 4, -3, 12}]
(* {11, -5, 4, -6, 9, 0, 13} *)

先前尝试：

Sort[#][[Ordering@Ordering@#2]]&
— 2012年
source
@DavidCarraher固定！
— 2012rcampion 2015年
1
+1我在您4分钟后发现了同样的解决方案！您可以保存几个字节：o = Ordering; (Sort@#)[[o@o@#2]] &
— DavidC
可爱的新解决方案，通过Permute！排列的非常有用的使用。
— DavidC
7

J，17个字节

(A.^:_1/:~)~A.@/:

这将评估为二进位（意思是二进制）动词。可以这样唤起：

  _5 9 4 13 11 _6 0 ((A.^:_1/:~)~A.@/:) 7 _4 1 _8 4 _3 12
11 _5 4 _6 9 0 13

说明

这可能不是最短的J解决方案，但这是一种新颖的方法。

                   Left input is x, right input is y.
            A.@/:  The index of the permutation P that sorts y. /: gives the
                   permutation itself, and A. gives its index in the sorted
                   list of all its permutations.
       /:~         x sorted in ascending order. We are applying the x-sorting
                   permutation to x itself.
(A.^:_1   )~       The inverse of the permutation P applied to the sorted
                   version of x. Since P maps y to its sorted version, its
                   inverse maps the sorted version to y, and thus sorted x to
                   the correct output.
— 兹加布
source
6

Pyth，10个字节

@LSvzxLSQQ

在线尝试：演示

说明

@LSvzxLSQQ implicit: z = first input line as string
                     Q = second input line evaluated
       SQ  sorted(Q)
     xLSQQ find the index for each element of Q in sorted(Q)
  Svz      sorted(evaluated z)
@LSvz      take the element in ^ for each index
— 雅库比
source
XQSQSvz短三个字节。
— 丹尼斯
@丹尼斯·当 我为什么不明白这一点？您要发布吗？
— 2015年
1
如果您认为它与您的方法完全不同，那么可以肯定。
— 丹尼斯
6

Pyth，7个字节

XQSQSvz

这是一个完整的程序，期望在两行上使用s和p的字符串表示形式。在线尝试。

怎么运行的

           Store the first line of input (rep. of s) in z.
           Evaluate the second line of input and store the result (p) in Q.
  SQ       Sort the elements of p.
    Svz    Evaluate the repr. of s and sort its elements.
XQ         Perform transliteration on p.
           This replaces the lowest element of p with the lowest element of s, etc.
— 丹尼斯
source
5

Python 2，51

lambda s,p,a=sorted:[a(s)[a(p).index(x)]for x in p]
— 费瑟姆
source
我很困惑：为什么会有三个参数？
— 彼得·泰勒
@PeterTaylor第三个参数具有缺省值，所以它可以只用2被调用
— feersum
@PeterTaylor添加单独的一行a=sorted将具有相同的效果。
— xnor 2015年
啊！我很par愧，以为尸体始于=。
— 彼得·泰勒
5

Mathematica 56 43 30 29字节

o=Ordering;Sort[#][[o@o@#2]]&

Ordering@#2返回模式中数字的顺序。 Ordering@Ordering@#2给出源中已排序元素应占据的位置。

Sort[#][[o@o@#2]]& 在所需位置返回源，即与模式列表具有相同相对顺序的位置。

测试中

o=Ordering;Sort[#][[o@o@#2]]&[{-5, 9, 4, 13, 11, -6, 0}, {7, -4, 1, -8, 4, -3, 12}]

{11，-5，4，-6，9，0，13}

— 戴维
source
5

CJam，8个字节

{_$@$er}

这是一个匿名函数，期望s和p（最顶部）在堆栈上，并将重新排序的s推回。在CJam解释器中在线尝试。

怎么运行的

_      e# Push a copy of p.
 $     e# Sort it.
  @    e# Rotate s on top of p and the sorted p.
   $   e# Sort s.
    er e# Perform transliteration.
       e# This replaces the lowest element of p with the lowest element of s, etc.
— 丹尼斯
source
4

J，13个字节

/:@/:@[{/:~@]

我仍然无法绕着J的动词作曲，所以我觉得有些像这样@，[]可能是不必要的。如果一些经验丰富的J用户可以让我知道是否可以压缩它，那就太好了。:)

该动词可以如下使用：

   7 _4 1 _8 4 _3 12 (/:@/:@[{/:~@]) _5 9 4 13 11 _6 0
11 _5 4 _6 9 0 13

说明

/:@/:@[{/:~@] NB. Left input is the pattern, right input is the source.
        /:~@] NB. Sort the source.
/:@/:@[       NB. Compute the ordering of the ordering of the pattern.
       {      NB. Use those as indices into the sorted source.
— 马丁·恩德
source
您可以使用dyadic /:来删除{和一个@11字节的a：/:~@]/:/:@[
— Dennis
@Dennis谢谢，Zgarb同时找到了另一个11字节的解决方案，该解决方案只需要两个/:，但是我还没有办法更新答案（({~/:)&/:{[）。
— 马丁·恩德
4

APL，17 12字节

{⍺[⍋⍺][⍋⍋⍵]}

感谢@Dennis，现在它非常优雅。

这是一个不错的14字节解决方案，它不使用双索引：

{⍺[(⍋⍋⍺)⍳⍋⍋⍵]}

不幸的是，我们无法在APL的火车中对数组进行索引。

— 小鱼
source
4

Python 2，48

lambda*l:map(dict(zip(*map(sorted,l))).get,l[0])

大量的功能。这使用字典的许多其他答案的元素翻译方法。

已加星标的输入*l按该顺序期望模式和源，并将它们转换为list l。

映射sorted对两个列表进行排序，然后dict(zip(_))将一对列表转换成字典，其中第一个列表中的键与第二个中的值以升序匹配。因此，结果是i模式的i-th最大元素与源的-th最大元素匹配。

最后，我们l[0]通过映射字典的.get方法来转换模式（）。

— 异或
source
3

Bash + coreutils，55岁

nl $2|sort -nk2|paste <(sort -n $1) -|sort -nk2|cut -f1

输入被当作两个文件名，分别用于源和模式：

$ ./imitord.sh source.txt pattern.txt 
11  
-5  
4   
-6  
9   
0   
13  
$
— 数字创伤
source
3

R，38个字节

function(s,p)sort(s)[match(p,sort(p))]
— 弗洛德尔
source
这是一个很好的方法。不会想用match。
— Alex A.
3

Ruby，51个字节

->s,p{s.map{|x|s.sort[p.sort.index(p[s.index x])]}}
— 达涅罗
source
2

Haskell，65个字节

import Data.List
s#p=[sort s!!i|b<-p,(i,e)<-zip[0..]$sort p,b==e]

用法示例：[-5,9,4,13,11,-6,0] # [7,-4,1,-8,4,-3,12]-> [11,-5,4,-6,9,0,13]。

怎么运行的：

           b<-p                              -- for every b in p
               ,(i,e)<-zip[0..]$sort p       -- walk through the sorted list of p 
                                             -- paired with it's index ->
                                             -- (index,element) or (i,e)
                                      ,b==e  -- for those cases where b equals e
 sort s!!i                                   -- take the i-th element from the
                                             -- sorted list s
— 妮米
source
2

R，37个字节

function(s,p,o=order)s[o(s)][o(o(p))]
— 保罗
source
2

TeaScript，15个字节

ys¡m™x[yi(l)])

这将输入作为数组。该口译员目前无法使用，因为我要放上新的口译员

说明

y      // Second input
 s¡    // Sort it = s()
m™     // Map over it = m(#
  x[      // Num in first input at index...
    yi(l) // Current char's index in y
  ]
)
— 下山羊
source
我可能是对解释的严重误解，或者这是行不通的……我根据自己的想法在Pip中对其进行了编码，并获得13 9 -6 4 11 -5 0了示例输入。??
— DLosc
2

果冻，6个字节，语言发布日期挑战

Œ¿œ?Ṣ}

在线尝试！

这将模式和源代码作为两个单独的参数。

说明

Œ¿œ?Ṣ}
Œ¿      Generate an integer that describes the order of {the first input}
  œ?    Use that integer to reorder
    Ṣ}  the sorted version of the second {input}
1

Haskell，56个字节

import Data.List
p%s=[sort s!!(length$filter(<x)p)|x<-p]

定义一个二进制函数%。输入中的每个条目p都转换为s具有相同顺序统计量的条目，即其列表中的相对排名。通过对小于xin p的元素进行计数来发现in 的顺序统计量（sort p!!x会产生烦人的结果Maybe）。结果索引到中sort s。

一个zip/lookup解决方案是相同的长度，除了它给出Just数字。

import Data.List
p%s=[lookup x$zip(sort p)(sort s)|x<-p]
— 异或
source
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.