Bir siparişi taklit etmek

24

Bir kaynak ve bir model olan iki sayı listesi göz önüne alındığında, kaynağı modelin göreli sırasına göre yeniden düzenleyin. Yeniden sıralanan kaynağın herhangi iki girişi, modelin aynı konumlarındaki girişlerle aynı şekilde karşılaştırılmalıdır.

Örneğin, giriş

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

sonucu üretmeli

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

İlk ve son konumları karşılaştırarak, sonuç modelde 11<13eşleşen sonucuna sahiptir 7<12.

Giriş: İki eşit uzunlukta boş olmayan tam sayı listesi. Her listenin tekrarı olmayacak. Önce kaynak veya desenin verilip verilmemesi size kalmış.

Çıktı: Kaynak numaralarını, desen numaralarıyla aynı göreli sıralamaya sahip olacak şekilde düzenleyen bir liste.

Liderler Sıralaması:

Kod pasajını göster

code-golf  sorting  permutations 
— XNOR
kaynak
Bir işlev / program mı olmalı, yoksa bir ifade / snippet yeterli mi?
— Kasım’da
— Martin Ender

Yanıtlar:

10

CJam, 12 10 bayt

{_$f#\$f=}

Bu, s pyığına geçen ve sonucu yığına bırakan adsız bir işlevdir . Çevrimiçi demo

Martin Büttner'e 2 bayt için teşekkürler .

teşrih

{         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
}
— Peter Taylor
kaynak
{_$@$er}iki bayt daha kısa.
— Dennis
@Dennis, ayrı bir cevap olacak kadar farklı
— Peter Taylor
Öyle düşünüyorsan, cevap olarak gönderirim.
— Dennis
10

J, 9 bayt

/:^:2~/:~

Bu, p ve s'yi sol ve sağ argümanlar olarak alan ikilemli bir fiildir . J.Js ile çevrimiçi deneyin .

Test sürüşü

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

Bu nasıl çalışır

Örnekten sol ve sağ giriş atanan tanımladığımızı

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

Sonra:

  • Tren /:^:2~/:~fiilleri bir kanca olduğunu /:^:2~ve /:~arama yüzden,

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

    yürütür

    p /:^:2~ /:~ s

  • Zarf ~içinde /:~olduğu dönüşlü beri, /:monadik kullanılır. Böylece, arayarak

    /:~ s

    yürütür

    s /: s

  • Zarf ~içinde /:^:2~olan pasif fiil beri, /:^:2dyadically kullanılır. Böylece, arayarak

    p /:^:2~ y

    yürütür

    y /:^:2 p

  • Zarf ^:olduğu güç . Böylece, arayarak

    y /:^:2 p

    yürütür

    y /: y /: p

Hepsini bir araya getirmek, arayarak

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

yürütür

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

Nasıl bu işler

Diyadik /:olduğunu kullanılarak dereceli yani, x /:yelemanlarını döndürür x , karşılık gelen değerlerine göre düzenlenmiş y.

  • s /: s basitçe öğelerini sıralar s'nin .

  • (s /: s) /: ps (sıralanmış) öğelerini sıralar , karşılık gelen p değerlerine göre .

  • İki kere derecelendirmek, esas olarak, doğru argümanının sırasını hesaplar.

    Böylece, s'nin(s /: s) /: (s /: s) /: p (sıralanmış) elemanlarını sıralar, p'nin elemanlarının sırasını taklit eder .

— Dennis
kaynak
9

Mathematica, 32 27 bayt

Sort@#~Permute~Ordering@#2&

Örnek kullanım:

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

Önceki deneme:

Sort[#][[Ordering@Ordering@#2]]&
— 2012rcampion
kaynak
@DavidCarraher Sabit!
— 2012rampamp
1
+1 Sizden 4 dakika sonra bu aynı çözümü keşfettim! Birkaç byte tasarruf edebilirsiniz:o = Ordering; (Sort@#)[[o@o@#2]] &
— DavidC
Güzel yeni çözüm Permute! Permütasyonların çok yararlı kullanımı.
— DavidC
7

J, 17 bayt

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

Bu, iki didik (yani ikili) bir fiili değerlendirir. Aşağıdaki gibi uyarılabilir:

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

açıklama

Bu, mümkün olan en kısa J çözümü olmayabilir, ancak yeni bir yaklaşım.

                   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
kaynak
6

Pyth, 10 bayt

@LSvzxLSQQ

Çevrimiçi deneyin: Gösteri

açıklama

@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
kaynak
XQSQSvzüç bayt daha kısa.
— Dennis
@Dennis Dang. Neden bunu düşünmedim? Göndermek ister misiniz?
— Jakube
1
Yaklaşımınızdan yeterince farklı olduğunu düşünüyorsanız, elbette.
— Dennis
6

Pyth, 7 bayt

XQSQSvz

Bu, s ve p dizelerinin iki satırda gösterilmesini bekleyen tam bir programdır . Çevrimiçi deneyin.

Nasıl çalışır

           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.
— Dennis
kaynak
5

Python 2, 51

lambda s,p,a=sorted:[a(s)[a(p).index(x)]for x in p]
— feersum
kaynak
Kafam karıştı: neden üç parametre var?
— Peter Taylor
@PeterTaylor Üçüncü parametre varsayılan bir değere sahiptir, bu nedenle sadece 2 ile çağrılabilir.
— feersum
@PeterTaylor Ayrı bir satır eklemek a=sortedaynı etkiye sahip olacaktır.
— 21'de
Aaaaaah! Yanlış kanştım ve vücudun başladığını düşündüm =.
— Peter Taylor
5

Mathematica 56 43 30 29 bayt

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

Ordering@#2desendeki sayıların sırasını döndürür. Ordering@Ordering@#2Kaynaktaki sıralanmış elemanların işgal etmesi gereken pozisyonları verir.

Sort[#][[o@o@#2]]& kaynağı, istenen konumlarda (ör. kalıp listesiyle aynı göreli sıralamaya sahip olanlar) döndürür.

Test yapmak

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
kaynak
5

CJam, 8 bayt

{_$@$er}

Bu, Anonim işlevler beklemekte olan s ve s yığında (en üst) ve yeniden sıralanmış iter s karşılığında. CJam tercümanında çevrimiçi olarak deneyin .

Nasıl çalışır

_      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.
— Dennis
kaynak
4

J, 13 bayt

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

Kafamı J'nin fiil kompozisyonu etrafında sararken hala sorun yaşıyorum, bu yüzden bazılarını hissediyorum @ ve []gereksiz olabilir. Daha deneyimli bir J kullanıcısı eğer bu sıkıştırılabilirse bana haber verebilirse, bu harika olurdu. :)

Fiil aşağıdaki gibi kullanılabilir:

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

açıklama

/:@/:@[{/:~@] 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.
— Martin Ender
kaynak
11 bayt için /:kurtulup, {a dyadic kullanabilirsiniz @:/:~@]/:/:@[
— Dennis
@Dennis Teşekkürler, Zgarb bu arada sadece iki kişiye ihtiyaç duyan 11 baytlık bir çözüm buldu /:, ancak henüz cevabı güncellemeye yetkim yok ( ({~/:)&/:{[).
— Martin Ender
4

APL, 17 12 bayt

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

@Dennis sayesinde bu şimdi çok zarif.

İşte çift indeksleme kullanmayan 14 baytlık güzel bir çözüm:

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

Maalesef, APL’deki trenlerin içinden dizileri indeksleyemiyoruz.

— lirtosiast
kaynak
4

Python 2, 48

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

Fonksiyonların büyük bir glob. Bu, sözlük kullanarak birçok cevabın eleman çevirisi yaklaşımını kullanır.

Yıldız işaretli giriş *l, desenleri ve kaynağı bu sırada bekler ve bunları bir listeye dönüştürür l.

Haritalama, sortedher iki listeyi de sıralar ve dict(zip(_))bir çift listeyi, ikinci sıradaki değerlerle eşleşen ilk listeden gelen anahtarlarla artan sırada bir sözlüğe dönüştürür. Sonuç olarak i, modelin en ibüyük elemanı kaynağın en büyük elemanı ile eşleşir .

Son olarak, metodunu l[0]eşleştirerek pattern ( ) 'i bu sözlük üzerinden dönüştürürüz .get.

— XNOR
kaynak
3

Bash + coreutils, 55

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

Girdi, sırasıyla kaynak ve kalıp için iki dosya adı olarak alınır:

$ ./imitord.sh source.txt pattern.txt 
11  
-5  
4   
-6  
9   
0   
13  
$
— Dijital Travma
kaynak
3

R, 38 bayt

function(s,p)sort(s)[match(p,sort(p))]
— flodel
kaynak
Bu güzel bir yaklaşım. Kullanmayı düşünmezdim match.
— Alex A.
3

Ruby, 51 bayt

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

Haskell, 65 bayt

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

Kullanım örneği: [-5,9,4,13,11,-6,0] # [7,-4,1,-8,4,-3,12]-> [11,-5,4,-6,9,0,13].

Nasıl çalışır:

           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
— niml'i
kaynak
2

R, 37 bayt

function(s,p,o=order)s[o(s)][o(o(p))]
— aPaulT
kaynak
2

TeaScript, 15 bayt

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

Bu, diziyi girdi olarak alır. Tercüman şu anda kapalı çünkü yeni tercüman kullanıyorum

açıklama

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
kaynak
Ya açıklamaları çok yanlış anlıyorum ya da bu işe yaramıyor ... Yaptıklarını düşündüğüme göre Pip'e kodladım 13 9 -6 4 11 -5 0ve numune girişi için aldım . ??
— DLosc
2

Jöle , 6 byte, dil sonlandırma tarihi mücadelesi

Œ¿œ?Ṣ}

Çevrimiçi deneyin!

Bu, kalıbı, onu takip eden ve iki ayrı argüman olarak alır.

açıklama

Œ¿œ?Ṣ}
Œ¿      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 bayt

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

İkili fonksiyonunu tanımlar %. Girilen her giriş , aynı sırada istatistik polan girişe dönüştürülür s, yani listesindeki göreceli rütbe. Sırası istatistik xin po (daha küçük elemanlar sayılarak bulunan sort p!!xrahatsız edici bir üretir Maybe). Sonuç indekslenir sort s.

Bir zip/lookupçözüm, Justsayıları vermesi dışında aynı uzunluktadır .

import Data.List
p%s=[lookup x$zip(sort p)(sort s)|x<-p]
— XNOR
kaynak
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.