Đưa ra hai danh sách các số, một nguồn và một mẫu , sắp xếp lại nguồn để khớp với thứ tự tương đối của mẫu. Bất kỳ hai mục nhập của nguồn được sắp xếp lại nên so sánh giống như các mục nhập tại các vị trí tương tự của mẫu.

Ví dụ: đầu vào

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

nên tạo ra kết quả

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

So sánh vị trí đầu tiên và cuối cùng, kết quả có 11<13, khớp với 7<12mẫu.

Đầu vào: Hai danh sách số nguyên không trống có độ dài bằng nhau. Mỗi danh sách sẽ không có sự lặp lại. Tùy thuộc vào việc nguồn hay mẫu được đưa ra trước.

Đầu ra: Một danh sách sắp xếp lại các số nguồn để có cùng thứ tự tương tự như số mẫu.

Bảng xếp hạng:

var QUESTION_ID=62587,OVERRIDE_USER=20260;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/62587/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

CJam, 12 10 byte

{_$f#\$f=}

Đây là một hàm ẩn danh, sẽ lấy s pstack và để lại kết quả trên stack. Bản demo trực tuyến

Cảm ơn Martin Büttner cho 2 byte.

Mổ xẻ

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

J, 9 byte

/:^:2~/:~

Đây là một động từ dyadic lấy p và s làm đối số trái và phải. Dùng thử trực tuyến với J.js .

Chạy thử nghiệm

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

Làm thế nào điều này hoạt động

Giả sử chúng tôi đã xác định gán đầu vào trái và phải từ ví dụ thông qua

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

Sau đó:

• Tàu /:^:2~/:~là một cái móc của các động từ /:^:2~và /:~, vì vậy gọi

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

  thực thi

  p /:^:2~ /:~ s
  

• Trạng từ ~trong /:~là phản xạ , vì /:được sử dụng một cách đơn điệu. Như vậy, gọi

  /:~ s
  

  thực thi

  s /: s
  

• Trạng từ ~trong /:^:2~là thụ động , vì động từ /:^:2được sử dụng một cách ngẫu nhiên. Như vậy, gọi

  p /:^:2~ y
  

  thực thi

  y /:^:2 p
  

• Trạng từ ^:là sức mạnh . Như vậy, gọi

  y /:^:2 p
  

  thực thi

  y /: y /: p
  

Đặt tất cả lại với nhau, gọi

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

thực thi

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

Làm thế nào mà hoạt động

Dyadic /:được xếp loại bằng cách sử dụng , tức là x /:ytrả về các phần tử của x , được sắp xếp theo các giá trị tương ứng của y.

• s /: schỉ đơn giản là sắp xếp các yếu tố của s .

• (s /: s) /: psắp xếp các phần tử (được sắp xếp) của s theo các giá trị tương ứng của p .

• Việc chấm điểm hai lần về cơ bản sẽ tính toán các quy tắc của lý lẽ đúng của nó.

  Do đó, (s /: s) /: (s /: s) /: psắp xếp các phần tử (được sắp xếp) của s , bắt chước thứ tự các phần tử của p .

Toán học, 32 27 byte

Sort@#~Permute~Ordering@#2&

Ví dụ sử dụng:

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

Lần thử trước:

Sort[#][[Ordering@Ordering@#2]]&

J, 17 byte

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

Điều này đánh giá một động từ dyadic (có nghĩa là nhị phân). Nó có thể được gợi lên như sau:

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

Giải trình

Đây có thể không phải là giải pháp J ngắn nhất có thể, nhưng đó là một cách tiếp cận mới lạ.

                   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.

Bình thường, 10 byte

@LSvzxLSQQ

Dùng thử trực tuyến: Trình diễn

Giải trình

@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

Bình thường, 7 byte

XQSQSvz

Đây là một chương trình đầy đủ mong đợi các biểu diễn chuỗi của s và p trên hai dòng. Hãy thử trực tuyến.

Làm thế nào nó hoạt động

           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.

Con trăn 2, 51

lambda s,p,a=sorted:[a(s)[a(p).index(x)]for x in p]

Toán học 56 43 30 29 byte

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

Ordering@#2trả về thứ tự các số trong mẫu. Ordering@Ordering@#2đưa ra các vị trí mà các phần tử được sắp xếp trong nguồn sẽ chiếm.

Sort[#][[o@o@#2]]& trả về nguồn trong các vị trí cần thiết, cụ thể là những vị trí có cùng thứ tự tương tự như danh sách mẫu.

Kiểm tra

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}

CJam, 8 byte

{_$@$er}

Đây là một hàm ẩn danh mong đợi s và p (trên cùng) trên ngăn xếp và trả lại s được sắp xếp lại. Dùng thử trực tuyến trong trình thông dịch CJam .

Làm thế nào nó hoạt động

_      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.

J, 13 byte

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

Tôi vẫn gặp khó khăn trong việc quấn đầu quanh thành phần động từ của J, vì vậy tôi cảm thấy như một vài trong số đó @và[] có thể không cần thiết. Nếu một số người dùng J có kinh nghiệm hơn có thể cho tôi biết nếu điều này có thể được nén, điều đó sẽ rất tuyệt. :)

Động từ có thể được sử dụng như sau:

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

Giải trình

/:@/:@[{/:~@] 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.

APL, 17 12 byte

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

Nhờ @Dennis, điều này bây giờ rất thanh lịch.

Đây là một giải pháp 14 byte đẹp mà không sử dụng lập chỉ mục kép:

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

Thật không may, chúng tôi không thể lập chỉ mục các mảng từ trong các chuyến tàu trong APL.

Con trăn 2, 48

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

Một toàn cầu lớn của các chức năng. Điều này sử dụng phương pháp dịch phần tử của nhiều câu trả lời khác bằng từ điển.

Đầu vào được gắn dấu sao *lmong đợi các mẫu và nguồn theo thứ tự đó và biến chúng thành một danh sách l.

Ánh xạ sortedsắp xếp cả hai danh sách và dict(zip(_))biến một cặp danh sách thành một từ điển với các khóa từ danh sách đầu tiên khớp với các giá trị trong thứ hai, theo thứ tự tăng dần. Vì vậy, kết quả là iphần tử lớn nhất của mẫu được khớp với iphần tử lớn thứ-thứ nhất của nguồn.

Cuối cùng, chúng ta biến đổi mẫu ( l[0]) thông qua từ điển này bằng cách ánh xạ .getphương thức của nó .

Bash + coreutils, 55

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

Đầu vào được lấy dưới dạng hai tên tệp, cho nguồn và mẫu tương ứng:

$ ./imitord.sh source.txt pattern.txt 
11  
-5  
4   
-6  
9   
0   
13  
$ 

R, 38 byte

function(s,p)sort(s)[match(p,sort(p))]

Ruby, 51 byte

->s,p{s.map{|x|s.sort[p.sort.index(p[s.index x])]}}

Haskell, 65 byte

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

Ví dụ sử dụng: [-5,9,4,13,11,-6,0] # [7,-4,1,-8,4,-3,12]->[11,-5,4,-6,9,0,13] .

Làm thế nào nó hoạt động:

           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

R, 37 byte

function(s,p,o=order)s[o(s)][o(o(p))]

TeaScript, 15 byte

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

Điều này có đầu vào như là một mảng. Trình thông dịch hiện đang ngừng hoạt động vì tôi đang đưa ra trình thông dịch mới lạ mắt

Giải trình

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
  ]
)

Jelly , 6 byte, thách thức ngôn ngữ

Œ¿œ?Ṣ}

Hãy thử trực tuyến!

Điều này lấy mẫu, theo sau là nguồn, như hai đối số riêng biệt.

Giải trình

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

Haskell, 56 byte

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

Xác định hàm nhị phân %. Mỗi mục nhập pđược chuyển đổi thành mục nhập scó cùng thống kê đơn hàng, tức là thứ hạng tương đối trong danh sách của nó. Các số liệu thống kê theo thứ tự xtrong pđược tìm thấy bằng cách đếm những yếu tố nhỏ hơn nó ( sort p!!xtạo ra một khó chịu Maybe). Kết quả được lập chỉ mục vào sort s.

Một zip/lookupgiải pháp có cùng độ dài, ngoại trừ nó cho Justsố.

import Data.List
p%s=[lookup x$zip(sort p)(sort s)|x<-p]