Imiter une commande

24

Étant donné deux listes de nombres, une source et un modèle , réorganisez la source pour qu'elle corresponde à l'ordre relatif du modèle. Deux entrées de la source réorganisée doivent se comparer de la même manière que les entrées à ces mêmes positions du motif.

Par exemple, l'entrée

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

devrait produire le résultat

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

En comparant les première et dernière positions, le résultat a 11<13, ce qui correspond 7<12au motif.

Entrée: deux listes d'entiers non vides de longueur égale. Chaque liste n'aura pas de répétition. C'est à vous de décider si la source ou le motif est donné en premier.

Sortie: une liste qui réorganise les numéros de source pour avoir le même ordre relatif que les numéros de modèle.

Classement:

Afficher l'extrait de code

code-golf  sorting  permutations 
— xnor
source
Doit-il s'agir d'une fonction / d'un programme, ou une expression / un extrait suffit-il?
— Adám
— Martin Ender

Réponses:

10

CJam, 12 10 octets

{_$f#\$f=}

Il s'agit d'une fonction anonyme qui prend s pla pile et laisse le résultat sur la pile. Démo en ligne

Merci à Martin Büttner pour 2 octets.

Dissection

{         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
source
{_$@$er}est de deux octets plus court.
— Dennis
@Dennis, c'est assez différent pour être une réponse distincte
— Peter Taylor
Si vous le pensez, je le posterai comme réponse.
— Dennis
10

J, 9 octets

/:^:2~/:~

Il s'agit d'un verbe dyadique qui prend p et s comme arguments gauche et droit. Essayez en ligne avec J.js .

Essai

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

Comment ça marche

Supposons que nous ayons défini les entrées gauche et droite de l'exemple via

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

Ensuite:

  • Le train /:^:2~/:~est un crochet des verbes /:^:2~et /:~donc appeler

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

    exécute

    p /:^:2~ /:~ s

  • L'adverbe ~en /:~est réflexif , puisqu'il /:est utilisé de façon monadique. Ainsi, appeler

    /:~ s

    exécute

    s /: s

  • L'adverbe ~en /:^:2~est passif , puisque le verbe /:^:2est utilisé en dyade. Ainsi, appeler

    p /:^:2~ y

    exécute

    y /:^:2 p

  • L'adverbe ^:est le pouvoir . Ainsi, appeler

    y /:^:2 p

    exécute

    y /: y /: p

Mettre tout cela ensemble, appeler

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

exécute

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

Comment ça marche

Dyadique /:est gradué en utilisant , c'est-à-dire, x /:yrenvoie les éléments de x , triés selon les valeurs correspondantes de y.

  • s /: strie simplement les éléments de l' art .

  • (s /: s) /: ptrie les éléments (triés) de s selon les valeurs correspondantes de p .

  • Grading up deux fois calcule essentiellement les ordinaux de son bon argument.

    Ainsi, (s /: s) /: (s /: s) /: ptrie les éléments (triés) de s , imitant l'ordre des éléments de p .

— Dennis
source
9

Mathematica, 32 27 octets

Sort@#~Permute~Ordering@#2&

Exemple d'utilisation:

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

Tentative précédente:

Sort[#][[Ordering@Ordering@#2]]&
— 2012rcampion
source
@DavidCarraher Fixed!
— 2012rcampion
1
+1 J'ai découvert cette même solution 4 minutes après toi! Vous pouvez enregistrer quelques octets:o = Ordering; (Sort@#)[[o@o@#2]] &
— DavidC
Belle nouvelle solution via Permute! Utilisation très utile des permutations.
— DavidC
7

J, 17 octets

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

Cela équivaut à un verbe dyadique (signifiant binaire). Il peut être évoqué comme suit:

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

Explication

Ce n'est peut-être pas la solution J la plus courte possible, mais c'est une nouvelle approche.

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

Pyth, 10 octets

@LSvzxLSQQ

Essayez-le en ligne: Démonstration

Explication

@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
source
XQSQSvzest de trois octets plus court.
— Dennis
@Dennis Dang. Pourquoi n'ai-je pas pensé à cela? Voulez-vous l'afficher?
— Jakube
1
Si vous le considérez suffisamment différent de votre approche, bien sûr.
— Dennis
6

Pyth, 7 octets

XQSQSvz

Il s'agit d'un programme complet qui attend des représentations de chaînes de s et p sur deux lignes. Essayez-le en ligne.

Comment ça marche

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

Python 2, 51

lambda s,p,a=sorted:[a(s)[a(p).index(x)]for x in p]
— feersum
source
Je suis confus: pourquoi y a-t-il trois paramètres?
— Peter Taylor
@PeterTaylor Le troisième paramètre a une valeur par défaut, il peut donc être appelé avec seulement 2.
— feersum
@PeterTaylor L'ajout d'une ligne distincte a=sortedaurait le même effet.
— xnor
Aaaaaah! J'étais en train de mal interpréter, et j'ai pensé que le corps avait commencé à =.
— Peter Taylor
5

Mathematica 56 43 30 29 octets

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

Ordering@#2renvoie l'ordre des nombres dans le modèle. Ordering@Ordering@#2donne les positions que les éléments triés dans la source doivent occuper.

Sort[#][[o@o@#2]]& renvoie la source dans les positions requises, à savoir celles qui ont le même ordre relatif que la liste de modèles.

Essai

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

CJam, 8 octets

{_$@$er}

Il s'agit d'une fonction anonyme qui attend s et p (le plus haut) sur la pile et pousse les s réorganisés en retour. Essayez-le en ligne dans l' interpréteur CJam .

Comment ça marche

_      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
source
4

J, 13 octets

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

J'ai toujours du mal à envelopper ma tête autour de la composition des verbes de J, donc je me sens comme certains d'entre eux @et []peut-être inutile. Si un utilisateur J plus expérimenté pouvait me faire savoir si cela pouvait être compressé, ce serait bien. :)

Le verbe peut être utilisé comme suit:

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

Explication

/:@/:@[{/:~@] 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
source
Vous pouvez utiliser dyadic /:pour vous en débarrasser {et un @, pour 11 octets:/:~@]/:/:@[
— Dennis
@Dennis Merci, Zgarb a trouvé une autre solution de 11 octets en attendant qui n'en a besoin que de deux /:, mais je n'ai pas encore mis à jour la réponse ( ({~/:)&/:{[).
— Martin Ender
4

APL, 17 12 octets

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

Grâce à @Dennis, c'est désormais très élégant.

Voici une belle solution de 14 octets qui n'utilise pas la double indexation:

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

Malheureusement, nous ne pouvons pas indexer les tableaux à partir des trains dans APL.

— lirtosiast
source
4

Python 2, 48

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

Un grand globe de fonctions. Cela utilise l'approche de traduction des éléments de nombreuses autres réponses à l'aide d'un dictionnaire.

L'entrée *lsuivie attend les motifs et la source dans cet ordre et les transforme en liste l.

Le mappage sortedtrie les deux listes et dict(zip(_))transforme une paire de listes en dictionnaire avec les clés de la première liste correspondant aux valeurs de la seconde, dans l'ordre croissant. Ainsi, le résultat est que le i-ème plus grand élément du motif est mis en correspondance avec le i-ème plus grand élément de la source.

Enfin, nous transformons le motif ( l[0]) via ce dictionnaire en cartographiant sa .getméthode.

— xnor
source
3

Bash + coreutils, 55

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

L'entrée est considérée comme deux noms de fichier, pour la source et le motif respectivement:

$ ./imitord.sh source.txt pattern.txt 
11  
-5  
4   
-6  
9   
0   
13  
$
— Traumatisme numérique
source
3

R, 38 octets

function(s,p)sort(s)[match(p,sort(p))]
— flodel
source
C'est une belle approche. N'aurait pas pensé à utiliser match.
— Alex A.
3

Rubis, 51 octets

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

Haskell, 65 octets

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

Exemple d'utilisation: [-5,9,4,13,11,-6,0] # [7,-4,1,-8,4,-3,12]-> [11,-5,4,-6,9,0,13].

Comment ça marche:

           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
source
2

R, 37 octets

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

TeaScript, 15 octets

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

Cela prend l'entrée comme un tableau. L'interprète est actuellement en panne parce que je mets en place le nouvel interprète de fantaisie

Explication

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
source
Soit je comprends mal l'explication, soit cela ne fonctionne pas ... Je l'ai codée dans Pip selon ce que je pense, et j'ai obtenu 13 9 -6 4 11 -5 0pour l'entrée d'échantillon. ??
— DLosc
2

Jelly , 6 octets, défi de postdates de langue

Œ¿œ?Ṣ}

Essayez-le en ligne!

Cela prend le modèle, suivi de la source, comme deux arguments distincts.

Explication

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

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

Définit une fonction binaire %. Chaque entrée dans pest transformée en entrée de savec la même statistique d'ordre, c'est-à-dire le rang relatif dans sa liste. La statistique d'ordre de xin pest trouvée en comptant les éléments plus petits qu'elle ( sort p!!xproduit un ennuyeux Maybe). Le résultat est indexé dans sort s.

Une zip/lookupsolution a la même longueur, sauf qu'elle donne des Justnombres.

import Data.List
p%s=[lookup x$zip(sort p)(sort s)|x<-p]
— xnor
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.