Ordenar fusión

En este desafío, implementará la subrutina de fusión del tipo de fusión. Específicamente, debe crear una función o programa o verbo o similar que tome dos listas, cada una ordenada en orden creciente, y las combine en una lista ordenada en orden creciente. Requisitos:

- Su algoritmo debe tomar una cantidad de tiempo asintóticamente lineal en el tamaño de la entrada. Por favor, deje de dar soluciones O (n ^ 2).

• No puede usar ninguna función incorporada capaz de ordenar una lista, o fusionar una lista, o algo así. Discreción del autor.
• El código debe poder manejar elementos repetidos.
• No te preocupes por las listas vacías.

Ejemplos:

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]

Este es el código de golf , ¡así que gane el código más corto!

Rebmu ( 35 32 caracteres)

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

Prueba

>> 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]

Acerca de

Rebmu es un dialecto de Rebol que permite 'mezclar' el código regular para situaciones que requieren brevedad. Impecable, el código funciona algo así como:

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)

Creo que esto satisface el requisito de O (n) , ya que el bloque hasta se repite tantas veces como la longitud de la entrada (y reversesolo cambia el orden del contenedor de los bloques de entrada, no los bloques en sí). Usar takees quizás una libertad, pero sigue siendo un golpe de eficiencia menor.

Rebol ( 83 75 caracteres)

Solo un poquito diferente: en Rebol, las rutas son una expresión más corta que firsto second.aes el bloque de entrada que contiene los dos bloques:

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

Soluciones de 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 99 93

Gracias a @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

Pitón (79)

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

Python (95, si no se nos permite devolver un generador)

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

Itertools es la solución para todos los problemas mundanos.

Bonificación: los dos trabajan en un número arbitrario de listas, y SE PREOCUPAN por las listas vacías (como en, felizmente tomarán 2 listas vacías y devolverán una lista vacía, o tomarán 1 lista vacía y 1 lista no vacía, y devolverán el no vacío. Otra característica adicional de los 2 no cedidos: también se ejecutarán sin argumentos, y solo devolverán una lista vacía).

Sin 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

Esto opera en NULLmatrices terminadas de int *, aunque funcionaría igualmente bien para punteros a otros tipos al sustituir la función de comparación apropiada para **b < **a(por ejemplo, strcmp(*b, *a) < 0).

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

Sin 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 bytes

~{[email protected]=@<{}{\}if(@@.}do;~]p

o

~{[email protected]=@>{\}*(@@.}do;~]p

Cómo funciona

El comando

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

se procesará de la siguiente manera:

~            # 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.

El resultado es:

[1 2 3 4]

J - 42 33

Versión modificada desde aquí + el comentario de @algorithmshark

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

kantepone la cabecera de la matriz derecha a las colas fusionadas de ambas matrices. k~es lo mismo, pero con las matrices invertidas. (>&{.)está comparando las cabezas. El código arrojará un error si una de las matrices está vacía, en ese caso solo devolveremos su concatenación ,.

JavaScript (ES6), 69 79 bytes

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

Cómo funciona

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'.
                               //
)

Pitón (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)

Escribí esto antes de ver los comentarios de OP sobre tiempos de ejecución de otras respuestas, por lo que esta es otra solución que es O (n) en el algoritmo pero no en la implementación.

Haskell, 35 bytes

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

Haskell, 30 bytes (no competitivos)

Esta versión no competitiva solo garantiza un tiempo de ejecución lineal si ay btiene elementos disjuntos; de lo contrario, todavía se ejecuta correctamente, pero puede usar tiempo cuadrático.

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

PHP 91 98 91 bytes

edit # 1: Empty $brequiere una condición adicional en las llaves (+7).
editar # 2: campos de golf menores
editar # 3: segunda versión agregada

muy claro. La mejor parte es el ternario dentro del array_shift
(que falla si lo intentas sin los rizos)

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

o

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

sin 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;
}

prueba

$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>';

Go, 124 caracteres

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

El mismo tipo de enfoque que los OP.

perl, 87 caracteres / perl 5.14, 78 + 1 = 79 caracteres

Esta implementación registra las referencias de la matriz de entrada. Aparte de eso, es bastante sencillo: si bien ambas matrices tienen algo, cambie la parte inferior de las dos. Luego, devuelva el bit combinado junto con los bits restantes (solo quedará uno de @ $ x o @ $ y). Perl5 recto, 87 caracteres:

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

Usando perl 5.14.0 y su nuevo cambio de arrayref: 78 caracteres + 1 penalización de char = 79 caracteres:

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

Java: 144

Esto es bastante sencillo. Una función que toma dos matrices y devuelve una, la versión fusionada, golfizada y sin envoltorio de compilación:

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;}

Sin golf (con envoltorio ejecutable y compilable):

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;
    }
}

Ejecuciones de ejemplo:

$ 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

Cualquier consejo para acortar sería apreciado.

Scala, 97 bytes

Solución recursiva con O (n). Para acortar el código, a veces se realiza una operación cambiando los 2 parámetros intercambiables, es decir, f (a, b) llama a 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)

Sin 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↓¨⍺⍵}

Explicación:

{⍺⍵∊⍨⊂⍬                               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 bytes

El algoritmo termina en n + 1iteraciones, donde nes la longitud de la lista más corta en la entrada.

(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, nuevamente, si no se permiten generadores):

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

Una adaptación de mi respuesta de Python .

Python - 69 bytes

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

Si el orden de entrada y salida descendiera, esto podría acortarse a 61 bytes :

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

Y más abajo a 45 bytes si se permiten generadores:

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

Perl 6: 53 caracteres

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

Pasar de cualquiera de ao btiene el valor más pequeño, hasta aXOR b( a^b) es verdadera. Luego devuelva lo que quede, aplanar ( []) las matrices en la lista (a[],b[] ).

Suponiendo que el cambio desde el comienzo de una matriz es O (n), el peor de los casos es dos comparaciones y un cambio por elemento, por lo que el algoritmo es O (n).

JavaScript (ES5) 90 86 90 bytes

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

editar: (90 -> 86) Se movió el ternario a la condición de bucle for. Idea robada de Dennis.

editar: (86 -> 90) Se eliminó la distribución de matriz a cadena, ya que rompe el requisito de 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)

Entrada:

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

Salida:

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

Sin 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
)

Probablemente podría hacerlo mejor.

R, 80

La misma solución que en Scala y otros idiomas. No estoy tan seguro de que x [-1] sea 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 bytes

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

La función anónima almacena la longitud de las dos listas de entrada en las variables my n, luego, cada iteración del Dobucle Sowes un elemento de una de las listas que incrementa el contador de esa lista ( ipara el primero, kpara el segundo) en uno. Si uno de los contadores excede la longitud de la lista, la Ifinstrucción siempre será Sowel elemento de la otra lista. Después de las n+moperaciones, todos los elementos han sido atendidos. Reapo más bien parte [[2,1]]de su salida es una lista de elementos en el orden en que han sido Sown.

No estoy seguro de las partes internas (está accediendo a una parte de una lista, una O(1)operación o no), pero los tiempos se veían bastante lineales en mi máquina con respecto a la longitud de la lista de entrada.