Tri par fusion

Dans ce défi, vous allez implémenter le sous-programme de fusion de tri par fusion. Plus précisément, vous devez créer une fonction ou un programme ou un verbe ou similaire qui prend deux listes, chacune triée par ordre croissant, et les combine en une liste triée par ordre croissant. Exigences:

- Votre algorithme doit prendre un temps asymptotiquement linéaire dans la taille de l'entrée. Veuillez cesser de donner des solutions O (n ^ 2).

• Vous ne pouvez pas utiliser de fonctions intégrées capables de trier une liste, ou de fusionner une liste, ou quelque chose comme ça. Discrétion de l'auteur.
• Le code doit être capable de gérer des éléments répétés.
• Ne vous inquiétez pas des listes vides.

Exemples:

merge([1],[0,2,3,4])
[0,1,2,3,4]

merge([1,5,10,17,19],[2,5,9,11,13,20])
[1, 2, 5, 5, 9, 10, 11, 13, 17, 19, 20]

Il s'agit de code-golf , alors que le code le plus court gagne!

Rebmu ( 35 32 caractères)

u[iG^aNXa[rvA]apGtkFaM?fA]apGscA

Tester

>> rebmu/args [u[iG^aNXa[rvA]apGtkFaM?fA]apGscA] [[1 5 10 17 19] [2 5 9 11 13 20]] 
== [1 2 5 5 9 10 11 13 17 19 20]

>> rebmu/args [u[iG^aNXa[rvA]apGtkFaM?fA]apGscA] [[2 5 9 11 13 20] [1 5 10 17 19]] 
== [1 2 5 5 9 10 11 13 17 19 20]

Sur

Rebmu est un dialecte de Rebol qui permet de «mushing» de code régulier pour les situations qui nécessitent de la brièveté. Insensible, le code fonctionne un peu comme:

u [                     ; until
    i g^ a nx a [       ; if greater? args next args
       rv a             ; reverse args
    ]                   ; (we want the block containing the next value first)

    ap g tk f a         ; append output take first args
    m? f a              ; empty? first args
]                       ; (first block is now empty)

ap g sc a               ; append output second args
                        ; (add the remainder of the second)

Je crois que cela satisfait l' exigence O (n) car le bloc jusqu'à est au plus en boucle autant de fois que la longueur de l'entrée (et le reverseseul change l'ordre du conteneur des blocs d'entrée, pas les blocs eux-mêmes). L'utilisation takeest peut-être une liberté, mais reste un impact d'efficacité mineur.

Rebol ( 83 75 caractères)

Un tout petit peu différent: dans Rebol, les chemins sont une expression plus courte que firstou second. aest le bloc d'entrée contenant les deux blocs:

until[if a/2/1 < a/1/1[reverse a]append o:[]take a/1 tail? a/1]append o a/2

Solutions OP:

Haskell 49 44 40

k@(p:r)%l@(q:s)|p>=q=q:k%s|0<1=l%k
a%_=a

Python 131 105 101 101 99 93

Merci à @Evpok:

f=lambda u,v:v and(v[-1]<u[-1]and f(v,u)or[b.append(a)for a,b in[(v.pop(),f(u,v))]]and b)or u

Python (79)

from itertools import*
def m(*a):
 while any(a):yield min(compress(a,a)).pop(0)

Python (95, si nous ne sommes pas autorisés à retourner un générateur)

from itertools import*
def m(*a):
 r=[]
 while any(a):r+=[min(compress(a,a)).pop(0)]
 return r

Itertools est la solution à tous les problèmes du monde.

Bonus: les deux fonctionnent sur un nombre arbitraire de listes et s'inquiètent des listes vides (comme dans, ils prendront avec plaisir 2 listes vides et retourneront une liste vide, ou prendront 1 liste vide et 1 liste non vide, et ils renverront celui qui n'est pas vide. Une autre fonctionnalité ajoutée des 2 non-cédés: ils s'exécuteront également sans argument, et retourneront simplement une liste vide.)

Non golfé:

from itertools import *  # Import all items from itertools
def m(*a):               # Define the function m, that takes any number of arguments, 
                         #  and stores those arguments in list a
    r=[]                 # Create an empty list r                         
    while any(a):        # While any element in a returns True as value:
        b=compress(a,a)  # Remove any element from a that isn't True (empty lists)
                         #  The example in the official documentation is this one:
                         #  compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
        c=min(b)         # Sort the lists by first value, and take the first one of these.
        d=c.pop(0)       # Take the first element from c
        r.append(d)      # Append this first element to r
    return r             # Gives back r

C - 75

Cela fonctionne sur des NULLtableaux terminés de int *, bien que cela fonctionnerait aussi bien pour les pointeurs vers d'autres types en substituant la fonction de comparaison appropriée **b < **a(par exemple, strcmp(*b, *a) < 0).

void m(int**a,int**b,int**c){while(*a||*b)*c++=!*a||*b&&**b<**a?*b++:*a++;}

Non golfé:

void merge(int **a, int **b, int **c)
{
    while(*a || *b)
        *c++ = !*a || *b && **b < **a
            ? *b++
            : *a++;
}

Golfscript, 29 27 30 29 26 octets

~{.0=@.0=@<{}{\}if(@@.}do;~]p

ou

~{.0=@.0=@>{\}*(@@.}do;~]p

Comment ça fonctionne

La commande

golfscript merge.gs <<< '[2 3] [1 4]'

sera traité comme suit:

~            # Interpret the input string.
             #
             # STACK: [2 3] [1 4]
{            #
    .@=0.@=0 # Duplicate the two topmost arrays of the stack and extract their first 
             # elements. This reverses the original order of the first copy.
             #
             # STACK: [1 4] [2 3] 2 1
             #
    >        # Check if the respective first elements of the arrays are ordered.
             #
             # STACK: [1 4] [2 3] 1
             #
    {\}*     # If they are not, swap the arrays. This brings the array with the smallest
             # element to the top of the stack.
             #
             # STACK: [2 3] [1 4]
             #
    (@@      # Shift the first element of the array on top of the stack and rotate it
             # behind the arrays.
             #
             # STACK: 1 [2 3] [4]
             #
    .        # Duplicate the topmost array.
             #
             # STACK: 1 [2 3] [4] [4]
             #
}do          # Repeat this process if the array is non-empty.
             #
             # STACK: 1 [2 3] [4] -> 1 2 [4] [3] -> 1 2 3 [4] []
             #
;~           # Delete the empty array from the stack and dump the non-empty array.
             #
             # STACK: 1 2 3 4
             #
]p           # Combine all elements on the stack into a single array, the to a string and
             # print.

La sortie est:

[1 2 3 4]

J - 42 33

Version modifiée d' ici + le commentaire de @algorithmshark

k=:(m}.),~0{]
m=:k~`k@.(>&{.) ::,

kajoute la tête du tableau de droite aux queues fusionnées des deux tableaux. k~est le même, mais avec des tableaux inversés. (>&{.)compare les têtes. Le code générera une erreur si l'un des tableaux est vide, dans ce cas, nous renvoyons uniquement leur concaténation ,.

JavaScript (ES6), 69 79 octets

f=(a,b,c=[])=>(x=a[0]<b[0]?a:b).length?f(a,b,c.concat(x.shift())):c.concat(a,b)

Comment ça fonctionne

f = (a, b, c = []) =>          // `f' is a function that takes arguments `a', `b' and `c' -
                               // `c' defaults to `[]' - which returns the following
                               // expression:
                               //
 (x = a[0] < b[0] ? a : b)     // Store the array among `a' and `b' with the smaller first 
                               // element in `x'.
                               //
 .length ?                     // If it's non-empty,
                               //
  f(a, b, c.concat(x.shift())) // append the first element of array `x' to array `c' and run
                               // `f' again;
                               //
  : c.concat(a,b)              // otherwise, append the arrays `a' and `b' to `c'.
                               //
)

Python (63) (69) (71)

def m(a,b):
 if a[0]>b[0]:a,b=b,a
 return[a.pop(0)]+(m(a,b)if a else b)

J'ai écrit ceci avant de voir les commentaires d'OP sur les temps d'exécution d'autres réponses, c'est donc une autre solution qui est O (n) dans l'algorithme mais pas la mise en œuvre.

Haskell, 35 octets

a#b@(c:d)|a<[c]=b#a|0<1=c:a#d
a#_=a

Haskell, 30 octets (non concurrent)

Cette version non concurrente ne garantit que l'exécution linéaire si aet bont des éléments disjoints; sinon, il fonctionne toujours correctement mais peut utiliser le temps quadratique.

a#b|a<b=b#a|c:d<-b=c:a#d
a#_=a

PHP 91 98 91 octets

edit # 1: Vide $bnécessite une condition supplémentaire dans les accolades (+7).
modifier # 2: golfs mineurs
modifier # 3: ajouté une deuxième version

assez simple. La plus belle partie est le ternaire à l'intérieur du array_shift
(qui échoue si vous l'essayez sans les curlys)

function m($a,$b){for($c=[];$a|$b;)$c[]=array_shift(${$a&(!$b|$a[0]<$b[0])?a:b});return$c;}

ou

function m($a,$b){for($c=[];$a|$b;)$c[]=array_shift(${$a?!$b|$a[0]<$b[0]?a:b:b});return$c;}

non golfé

function m($a,$b)
{
    $c=[];
    while($a||$b)
    {
        $c[] = array_shift(${
            $a&&(!$b||$a[0]<$b[0])
                ?a
                :b
        });
#       echo '<br>', outA($a), ' / ', outA($b) , ' -> ', outA($c);
    }
    return $c;
}

tester

$cases = array (
    [1],[0,2,3,4], [0,1,2,3,4],
    [1,5,10,17,19],[2,5,9,11,13,20], [1, 2, 5, 5, 9, 10, 11, 13, 17, 19, 20],
    [1,2,3],[], [1,2,3],
    [],[4,5,6], [4,5,6],
);
function outA($a) { return '['. implode(',',$a). ']'; }
echo '<table border=1><tr><th>A</th><th>B</th><th>expected</th><th>actual result</th></tr>';
while ($cases)
{
    $a = array_shift($cases);
    $b = array_shift($cases);
#   echo '<hr>', outA($a), ' / ', outA($b) , ' -> ', outA($c);
    $expect = array_shift($cases);
    $result=m($a,$b);
    echo '<tr><td>',outA($a),'</td><td>',outA($b),'</td><td>', outA($expect), '</td><td>', outA($result),'</td></tr>';
}
echo '</table>';

Aller, 124 caractères

func m(a,b[]int)(r[]int){for len(a)>0{if len(b)==0||a[0]>b[0]{a,b=b,a}else{r=append(r,a[0]);a=a[1:]}};return append(r,b...)}

JavaScript - 133

function m(a,b){c=[];for(i=j=0;i<a.length&j<b.length;)c.push(a[i]<b[j]?a[i++]:b[j++]);return c.concat(a.slice(i)).concat(b.slice(j))}

Même type d'approche que les PO.

perl, 87 caractères / perl 5.14, 78 + 1 = 79 caractères

Cette implémentation encombre les références de tableau d'entrée. En dehors de cela, c'est assez simple: alors que les deux tableaux ont quelque chose, désactivez le bas des deux. Retournez ensuite le bit fusionné joint à tous les bits restants (il ne restera qu'un seul parmi @ $ x ou @ $ y). Perl5 droit, 87 caractères:

sub M{($x,$y,@o)=@_;push@o,$$x[0]>$$y[0]?shift@$y:shift@$x while@$x&&@$y;@o,@$x,@$y}

En utilisant Perl 5.14.0 et son nouveau décalage de référence de tableau: 78 caractères + 1 pénalité de caractère = 79 caractères:

sub M{($x,$y,@o)=@_;push@o,shift($$x[0]>$$y[0]?$y:$x)while@$x&&@$y;@o,@$x,@$y}

Java: 144

C'est assez simple. Une fonction qui prend deux tableaux et renvoie un, la version fusionnée, golfée et sans wrapper de compilation:

int[]m(int[]a,int[]b){int A=a.length,B=b.length,i,j;int[]c=new int[A+B];for(i=j=0;i+j<A+B;c[i+j]=j==B||i<A&&a[i]<b[j]?a[i++]:b[j++]);return c;}

Non golfé (avec un wrapper compilable et exécutable):

class M{
    public static void main(String[]args){
        int[]a=new int[args[0].split(",").length];
        int i=0;
        for(String arg:args[0].split(","))
            a[i++]=Integer.valueOf(arg);
        int[]b=new int[args[1].split(",").length];
        int j=0;
        for(String arg:args[1].split(","))
            b[j++]=Integer.valueOf(arg);
        int[]c=(new M()).m(a,b);
        for(int d:c)
            System.out.printf(" %d",d);
        System.out.println();
    }
    int[]m(int[]a,int[]b){
        int A=a.length,B=b.length,i,j;
        int[]c=new int[A+B];
        for(i=j=0;i+j<A+B;c[i+j]=j==B||i<A&&a[i]<b[j]?a[i++]:b[j++]);
        return c;
    }
}

Exemples d'exécutions:

$ javac M.java
$ java M 10,11,12 0,1,2,20,30
 0 1 2 10 11 12 20 30
$ java M 10,11,12,25,26 0,1,2,20,30
 0 1 2 10 11 12 20 25 26 30

Tout conseil à raccourcir serait apprécié.

Scala, 97 octets

Solution récursive avec O (n). Pour raccourcir le code, une opération est parfois effectuée en commutant les 2 paramètres interchangeables, c'est-à-dire que f (a, b) appelle f (b, a).

type L=List[Int];def f(a:L,b:L):L=if(a==Nil)b else if(a(0)<=b(0))a(0)::f(a.drop(1),b) else f(b,a)

Non golfé:

type L=List[Int]

def f(a:L, b:L) : L =
  if (a == Nil)
    b 
  else 
    if (a(0) <= b(0))
      a(0) :: f(a.drop(1), b) 
    else
      f(b,a)

APL (32)

{⍺⍵∊⍨⊂⍬:⍺,⍵⋄g[⍋g←⊃¨⍺⍵],⊃∇/1↓¨⍺⍵}

Explication:

{⍺⍵∊⍨⊂⍬                               if one or both of the arrays are empty
        :⍺,⍵                           then return the concatenation of the arrays
             ⋄g[⍋g←⊃¨⍺⍵]              otherwise return the sorted first elements of both arrays
                          ,⊃∇/        followed by the result of running the function with
                               1↓¨⍺⍵}  both arrays minus their first element

LISP, 117 octets

L'algorithme se termine par des n + 1itérations, où nest la longueur de la liste la plus courte en entrée.

(defun o(a b)(let((c(car a))(d(car b)))(if(null a)b(if(null b)a(if(< c d)(cons c(o(cdr a)b))(cons d(o a(cdr b))))))))

PYG (50)

def m(*a):
 while An(a):yield Mn(ItCo(a,a)).pop(0)

PYG (64, encore une fois, si aucun générateur n'est autorisé.):

def m(*a):
 r=[]
 while An(a):r+=[(Mn(ItCo(a,a)).pop(0)]
 return r

Une adaptation de ma réponse Python .

Python - 69 octets

def m(A,B):
    C=[]
    while A and B:C+=[[A,B][A>B].pop(0)]
    return C+A+B

Si l'ordre d'entrée et de sortie décroissait, cela pourrait être raccourci à 61 octets :

def m(A,B):
    C=[]
    while A+B:C+=[[A,B][A<B].pop(0)]
    return C

Et plus loin jusqu'à 45 octets si les générateurs sont autorisés:

def m(A,B):
    while A+B:yield[A,B][A<B].pop(0)

Perl 6:53 caractères

sub M(\a,\b){{shift a[0]>b[0]??b!!a}...{a^b},a[],b[]}

Passez de la valeur la plus petite aou bla plus petite jusqu'à ce que aXOR b( a^b) soit vrai. Retournez ensuite tout ce qui reste, flattening ( []) les tableaux dans la liste ( a[],b[]).

En supposant que le décalage depuis le début d'un tableau est O (n), le pire des cas est deux comparaisons et un décalage par élément, donc l'algorithme est O (n).

JavaScript (ES5) 90 86 90 octets

function f(a,b){for(o=[];(x=a[0]<b[0]?a:b).length;)o.push(x.shift());return o.concat(a,b)}

edit: (90 -> 86) Déplacement du ternaire dans la condition de boucle for. Idée volée à Dennis.

edit: (86 -> 90) Suppression du tableau en chaîne, car cela rompt l' exigence O (n) .

Mathematica, 137 135

m[a_,b_]:=(l=a;Do[Do[If[b[[f]]<=l[[s]],(l=Insert[l,b[[f]],s];Break[]),If[s==Length@l,l=l~Append~b[[f]]]],{s,Length@l}],{f,Length@b}];l)

Contribution:

m[{2,2,4,6,7,11},{1,2,3,3,3,3,7}]

Production:

{1, 2, 2, 2, 3, 3, 3, 3, 4, 6, 7, 7, 11}

Non golfé:

mergeList[a_, b_] := (
    list = a;
    Do[
        Do[(
            If[
                b[[f]] <= list[[s]],
                (list = Insert[list, b[[f]], s]; Break[]),
                If[
                    s == Length@list,
                    list = list~Append~b[[f]]
                ]
        ]),
        {s, Length@list}
    ],
    {f, Length@b}
    ];
    list
)

Pourrait probablement faire mieux.

R, 80

Même solution que dans Scala et dans d'autres langues. Je ne suis pas sûr que x [-1] soit O (1).

f=function(a,b)if(length(a)){if(a[1]<=b[1])c(a[1],f(a[-1],b))else f(b,a)}else b

Mathematica, 104 octets

Reap[{m,n}=Length/@{##};i=k=1;Do[If[k>n||TrueQ[#[[i]]<#2[[k]]],Sow@#[[i++]],Sow@#2[[k++]]],n+m]][[2,1]]&

Fonction anonyme, stocke la longueur des deux listes d'entrée dans les variables mpuis n, à chaque itération de la Doboucle, Sowun élément de l'une des listes incrémentant le compteur de cette liste ( ipour la première, kpour la seconde) d'une unité . Si l'un des compteurs dépasse la longueur de la liste, l' Ifinstruction sera toujours Sowl'élément de l'autre liste. Après les n+mopérations, tous les éléments ont été pris en charge. Reapou plutôt une partie [[2,1]]de sa sortie est une liste d'éléments dans l'ordre où ils ont étéSow n.

Je ne suis pas sûr des internes (accède à une partie d'une liste, une O(1)opération ou non), mais les délais semblaient assez linéaires sur ma machine en ce qui concerne la longueur de la liste d'entrée.