注文をまねる

24

sourceとpatternの 2つの数値リストを指定すると、パターンの相対的な順序に一致するようにソースを並べ替えます。再配列されたソースの2つのエントリは、パターンの同じ位置のエントリと同じ方法で比較する必要があります。

たとえば、入力

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、パターンで一致します。

入力：整数の2つの等しい長さの空でないリスト。各リストには繰り返しはありません。ソースまたはパターンが最初に与えられるかどうかはあなた次第です。

出力：パターン番号と同じ相対的な順序になるようにソース番号を再配置するリスト。

リーダーボード：

コードスニペットを表示

code-golf  sorting  permutations 
— xnor
ソース
関数/プログラムである必要がありますか、それとも式/スニペットで十分ですか？
— アダム
— マーティンエンダー

回答:

10

CJam、12 10バイト

{_$f#\$f=}

これは匿名関数でありs p、スタックを取得し、結果をスタックに残します。オンラインデモ

2バイトのMartinBüttnerに感謝します。

解剖

{         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
}
— ピーター・テイラー
ソース
{_$@$er}2バイト短くなります。
— デニス
@デニス、それは別の答えになるほど十分に異なる
— ピーターテイラー
そう思われる場合は、回答として投稿します。
— デニス
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

  • 副詞~では/:~ある再帰以来、/:monadically使用されています。したがって、呼び出し

    /:~ s

    実行する

    s /: s

  • 副詞~では/:^:2~あるの受動動詞があるため、/:^:2dyadically使用されています。したがって、呼び出し

    p /:^:2~ y

    実行する

    y /:^:2 p

  • 副詞^:は力です。したがって、呼び出し

    y /:^:2 p

    実行する

    y /: y /: p

すべてをまとめて、呼び出す

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

実行する

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

どのような作品

Dyadic /:はを使用してグレードアップされx /:yます。つまり、xの要素を返し、の対応する値に従ってソートされますy。

  • s /: ssの要素を単純にソートします。

  • (s /: s) /: ppの対応する値に従ってsの（ソートされた）要素をソートします。

  • 基本的に2回のグレーディングは、正しい引数の序数を計算します。

    したがって、sの(s /: s) /: (s /: s) /: p（ソートされた）要素をソートし、pの要素の順序を模倣します。

— デニス
ソース
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]]&
— 2012rcampion
ソース
@DavidCarraher修正！
— 2012rcampion
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.
— ズガルブ
ソース
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
— ジャクベ
ソース
XQSQSvz3バイト短くなります。
— デニス
@Dennis Dang。どうしてこんなことを考えなかったの？投稿しますか？
— ジャクベ
1
それがあなたのアプローチと十分に異なると考えるなら、必ず。
— デニス
6

Pyth、7バイト

XQSQSvz

これは、2行の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.
— デニス
ソース
5

Python 2、51

lambda s,p,a=sorted:[a(s)[a(p).index(x)]for x in p]
— フェールサム
ソース
私は混乱しています：なぜ3つのパラメーターがあるのですか？
— ピーターテイラー
@PeterTaylor 3番目のパラメーターにはデフォルト値があるため、2でのみ呼び出すことができます
— 。– feersum
@PeterTaylor別の行a=sortedを追加しても同じ効果があります。
— -xnor
ああ！私は誤解していました、そして、身体はで始まったと思いました=。
— ピーターテイラー
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}

— DavidC
ソース
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.
— デニス
ソース
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.
— マーティン・エンダー
ソース
11バイトの場合、dyadic /:を使用して{およびを削除できます。– @/:~@]/:/:@[
— Dennis
@Dennisありがとう、Zgarbはその間に2つしか必要としない別の11バイトのソリューションを見つけました/:が、まだ答えを更新することはできません（({~/:)&/:{[）。
— マーティンエンダー
4

APL、17 12バイト

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

@Dennisのおかげで、これは非常にエレガントになりました。

ダブルインデックスを使用しない、14バイトの優れたソリューションを次に示します。

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

残念ながら、APLの列車内から配列のインデックスを作成することはできません。

— 律法学者
ソース
4

Python 2、48

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

関数の大きな塊。これは、辞書を使用した他の多くの回答の要素翻訳アプローチを使用します。

スター付きの入力*lは、パターンとソースをこの順序で期待し、それらをリストに変えますl。

マッピングはsorted両方のリストをソートdict(zip(_))し、最初のリストのキーが2番目のリストのキーと昇順で一致するリストのペアを辞書に変換します。したがって、結果はi、パターンのi-番目に大きい要素がソースの-番目に大きい要素と一致することです。

最後に、メソッドをl[0]マッピングする.getことにより、この辞書を介してパターン（）を変換します。

— xnor
ソース
3

Bash + coreutils、55

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

入力は、それぞれソースとパターンの2つのファイル名として取得されます。

$ ./imitord.sh source.txt pattern.txt 
11  
-5  
4   
-6  
9   
0   
13  
$
— デジタル外傷
ソース
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
— ニミ
ソース
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
  ]
)
— ダウンゴート
ソース
私は説明をひどく誤解しているか、またはこれが機能しません...私はそれが私がそれがすると思うことに従ってPipでそれをコード化13 9 -6 4 11 -5 0し、サンプル入力のために得ました。？
— DLosc
2

ゼリー、6バイト、言語のポストデートチャレンジ

Œ¿œ?Ṣ}

オンラインでお試しください！

これは、2つの個別の引数としてパターンとそれに続くソースを受け取ります。

説明

Œ¿œ?Ṣ}
Œ¿      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それよりも小さい要素をカウントすることで見つかります（sort p!!x迷惑な結果をもたらしますMaybe）。結果はにインデックス付けされsort sます。

zip/lookupそれが与える以外解決策は、同じ長さであるJust数字を。

import Data.List
p%s=[lookup x$zip(sort p)(sort s)|x<-p]
— xnor
ソース
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.