एक आदेश का अनुकरण करें

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 
— XNOR
स्रोत
यह एक फ़ंक्शन / प्रोग्राम होना चाहिए, या एक अभिव्यक्ति / स्निपेट पर्याप्त है?
— Adám
— मार्टिन एंडर

जवाबों:

10

सीजाम, 12 10 बाइट्स

{_$f#\$f=}

यह एक अनाम फ़ंक्शन है, जो s pस्टैक पर ले जाता है और स्टैक पर परिणाम छोड़ता है। ऑनलाइन डेमो

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
}
— पीटर टेलर
स्रोत
{_$@$er}दो बाइट्स कम है।
— डेनिस
@ डेनिस, यह एक अलग जवाब देने के लिए अलग है
— पीटर टेलर
यदि आप ऐसा सोचते हैं, तो मैं इसे उत्तर के रूप में पोस्ट करूंगा।
— डेनिस
10

जे, 9 बाइट्स

/:^:2~/:~

यह एक डाईएडिक क्रिया है जो बाएं और दाएं तर्कों के रूप में पी और एस लेती है। इसे Jjs के साथ ऑनलाइन आज़माएं ।

परीक्षण चालन

   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

कैसे है कि काम करता है

डायैडिक /:का उपयोग करके ग्रेड अप किया जाता है , अर्थात, एक्सx /:y के तत्वों को रिटर्न करता है , जिसके संबंधित मूल्यों के अनुसार क्रमबद्ध किया गया है ।y

  • s /: sबस एस के तत्वों को हल करता है ।

  • (s /: s) /: pपी के संगत मूल्यों के अनुसार एस के (सॉर्ट किए गए) तत्वों को सॉर्ट करें ।

  • दो बार ग्रेडिंग अनिवार्य रूप से अपने सही तर्क के अध्यादेशों की गणना करता है।

    इस प्रकार, (s /: s) /: (s /: s) /: pके (क्रमबद्ध) तत्वों सॉर्ट करता रों , के तत्वों के आदेश की नकल पी ।

— डेनिस
स्रोत
9

गणितज्ञ, ३२ २ 32 बाइट्स

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 फिक्स्ड!
— २०१२ आर्कम्पियन
1
+1 मैंने आपके बाद 4 मिनट में यही समाधान खोजा! आप बाइट्स के एक जोड़े को बचा सकते हैं:o = Ordering; (Sort@#)[[o@o@#2]] &
— डेविड नोव
के माध्यम से लवली नया समाधान Permute! क्रमपरिवर्तन का बहुत उपयोगी उपयोग।
— डेविड नोव
7

जे, 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

व्याख्या

यह सबसे छोटा संभव जे समाधान नहीं हो सकता है, लेकिन यह एक उपन्यास दृष्टिकोण है।

                   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.
— Zgarb
स्रोत
6

अजगर, 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
— Jakube
स्रोत
XQSQSvzतीन बाइट्स कम है।
— डेनिस
@ डेनिस डांग। मैंने यह क्यों नहीं किया? क्या आप इसे पोस्ट करना चाहते हैं?
— याकूब
1
यदि आप इसे अपने दृष्टिकोण से पर्याप्त रूप से अलग मानते हैं, तो सुनिश्चित करें।
— डेनिस
6

अजगर, 7 बाइट्स

XQSQSvz

यह एक पूर्ण कार्यक्रम है जो दो पंक्तियों पर एस और पी के स्ट्रिंग प्रतिनिधित्व की अपेक्षा करता है । इसे ऑनलाइन आज़माएं।

यह काम किस प्रकार करता है

           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

अजगर २, ५१

lambda s,p,a=sorted:[a(s)[a(p).index(x)]for x in p]
— feersum
स्रोत
मैं उलझन में हूँ: तीन पैरामीटर क्यों हैं?
— पीटर टेलर
@PeterTaylor तीसरे पैरामीटर का एक डिफ़ॉल्ट मान है, इसलिए इसे केवल 2 के साथ ही कॉल किया जा सकता है
— feersum
@PeterTaylor एक अलग लाइन जोड़ने का एक a=sortedही प्रभाव होगा।
— 21
Aaaaaah! मैं गलत सोच रहा था, और सोचा कि शरीर शुरू हुआ =।
— पीटर टेलर
5

मैथेमेटिका 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

सीजेएम, 8 बाइट्स

{_$@$er}

यह एक अनाम फ़ंक्शन है जो स्टैक पर s और p (सबसे ऊपर) की अपेक्षा करता है और बदले में reordered 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

जे, 13 बाइट्स

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

मुझे अभी भी जे की क्रिया रचना के आसपास अपना सिर लपेटने में परेशानी हो रही है, इसलिए मुझे लगता है कि उनमें से कुछ @और []अनावश्यक हो सकते हैं। यदि कुछ और अनुभवी 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 बाइट्स के लिए और ए /:से छुटकारा पाने के लिए डाइएडिक का उपयोग कर सकते हैं :{@/:~@]/:/:@[
— डेनिस
@ डेनिस धन्यवाद, ज़र्गब ने इस बीच एक और 11-बाइट समाधान पाया है जिसे केवल दो की आवश्यकता है /:, लेकिन मुझे अभी तक उत्तर को अपडेट करने के लिए दौर नहीं मिला है ( ({~/:)&/:{[)।
— मार्टिन एंडर
4

एपीएल, 17 12 बाइट्स

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

@ डेनिस के लिए धन्यवाद, यह अब बहुत सुंदर है।

यहाँ एक अच्छा 14-बाइट समाधान है जो दोहरे अनुक्रमण का उपयोग नहीं करता है:

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

दुर्भाग्य से, हम एपीएल में ट्रेनों के भीतर से एरेज़ को इंडेक्स नहीं कर सकते हैं।

— lirtosiast
स्रोत
4

अजगर 2, 48

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

कार्यों का एक बड़ा ग्लोब। यह एक शब्दकोश का उपयोग करते हुए कई अन्य उत्तरों के तत्व अनुवाद दृष्टिकोण का उपयोग करता है।

तारांकित इनपुट *lउस क्रम में पैटर्न और स्रोत की अपेक्षा करता है, और उन्हें एक सूची में बदल देता है l।

मानचित्रण sortedदोनों सूचियों को क्रमबद्ध करता है, और सूचियों की dict(zip(_))एक जोड़ी को पहली सूची से कुंजी के साथ एक शब्दकोश में बदल देता है, दूसरे में मूल्यों के साथ मेल खाता है, आरोही क्रम में। तो, परिणाम यह है कि iपैटर्न का वह iसबसे बड़ा तत्व स्रोत के -th सबसे बड़े तत्व के साथ मेल खाता है ।

अंत में, हम l[0]इस .getविधि के माध्यम से इसकी विधि का मानचित्रण करके पैटर्न ( ) को रूपांतरित करते हैं ।

— XNOR
स्रोत
3

बाश + कोरुटिल्स, 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  
$
— डिजिटल आघात
स्रोत
3

आर, 38 बाइट्स

function(s,p)sort(s)[match(p,sort(p))]
— flodel
स्रोत
यह एक अच्छा तरीका है। उपयोग करने के लिए नहीं सोचा होगा match।
— एलेक्स ए।
2

हास्केल, 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
— nimi
स्रोत
2

टीस्क्रिप्ट, 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
  ]
)
— Downgoat
स्रोत
या तो मैं स्पष्टीकरण को बुरी तरह से गलत समझ रहा हूं, या यह काम नहीं करता है ... मैंने इसे पिप में कोड किया है जो मुझे लगता है कि यह करता है, और 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

हास्केल, 56 बाइट्स

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

एक बाइनरी फ़ंक्शन को परिभाषित करता है %। प्रत्येक प्रविष्टि अपनी सूची में समान क्रम सांख्यिकीय, अर्थात् सापेक्ष रैंक pके sसाथ प्रविष्टि में बदल जाती है । के आदेश आँकड़ों xमें 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
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.