Unisci ordinamento

In questa sfida, implementerai la subroutine di unione dell'ordinamento di tipo merge. In particolare, è necessario creare una funzione o programma o verbo o simile che accetta due elenchi, ognuno ordinato in ordine crescente e li combina in un elenco ordinato in ordine crescente. Requisiti:

- L'algoritmo deve richiedere una quantità di tempo asintoticamente lineare nella dimensione dell'input. Per favore, smetti di dare O (n ^ 2) soluzioni.

• Non è possibile utilizzare alcuna funzione integrata in grado di ordinare un elenco, unire un elenco o qualcosa del genere. Discrezione dell'autore.
• Il codice dovrebbe essere in grado di gestire elementi ripetuti.
• Non preoccuparti per gli elenchi vuoti.

Esempi:

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]

Questo è code-golf , quindi può vincere il codice più corto!

Rebmu ( 35 32 caratteri)

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

Test

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

Di

Rebmu è un dialetto di Rebol che consente il "mushing" del codice normale per situazioni che richiedono brevità. Unmushed, il codice funziona in qualche modo come:

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)

Credo che questo soddisfi il requisito O (n) in quanto il blocco fino a quando non è al massimo in loop quante volte la lunghezza dell'input (e l' reverseunico cambia l'ordine del contenitore dei blocchi di input, non i blocchi stessi). utilizzandotake è forse una libertà, ma è ancora un piccolo colpo di efficienza.

Rebol ( 83 75 caratteri)

Solo un po 'diverso: in Rebol, i percorsi sono un'espressione più breve di firsto second. aè il blocco di input contenente i due blocchi:

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

Le soluzioni di 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

Grazie 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

Python (79)

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

Python (95, se non ci è permesso di restituire un generatore)

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

Itertools è la soluzione per tutti i problemi del mondo.

Bonus: entrambi funzionano su un numero arbitrario di elenchi e si preoccupano degli elenchi vuoti (come in, prenderanno felicemente 2 elenchi vuoti e restituiranno un elenco vuoto o prenderanno 1 elenco vuoto e 1 elenco non vuoto, e restituiranno quello non vuoto. Un'altra caratteristica aggiunta dei 2 non ceduti: funzioneranno anche senza argomenti e restituiranno solo un elenco vuoto.)

Ungolfed:

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

Questo funziona su NULLarray terminati di int *, sebbene funzionerebbe ugualmente bene per puntatori ad altri tipi sostituendo la funzione di confronto appropriata per **b < **a(ad esempio, strcmp(*b, *a) < 0).

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

Ungolfed:

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

Golfscript, 29 27 30 29 26 byte

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

o

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

Come funziona

Il comando

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

verrà elaborato come segue:

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

L'output è:

[1 2 3 4]

J - 42 33

Versione modificata da qui + il commento di @algorithmshark

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

kantepone il capo dell'array giusto alle code unite di entrambi gli array. k~è lo stesso, ma con array capovolti. (>&{.)sta confrontando le teste. Il codice genererà un errore se uno degli array è vuoto, in tal caso restituiamo solo la loro concatenazione ,.

JavaScript (ES6), 69 79 byte

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

Come funziona

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)

Ho scritto questo prima di vedere i commenti di OP sui runtime di altre risposte, quindi questa è un'altra soluzione che è O (n) in algoritmo ma non implementazione.

Haskell, 35 byte

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

Haskell, 30 byte (non concorrenti)

Questa versione non competitiva garantisce un runtime lineare solo se ae bpresenta elementi disgiunti; altrimenti funziona ancora correttamente ma può usare il tempo quadratico.

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

PHP 91 98 91 byte

modifica # 1: Vuoto $brichiede una condizione aggiuntiva tra parentesi graffe (+7).
modifica n. 2: golf minori
modifica n. 3: aggiunta seconda versione

abbastanza diretto. La parte più bella è il ternario all'interno del array_shift
(che fallisce se lo provi senza i ricci)

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

ungolfed

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

test

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

Vai, 124 caratteri

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

Stesso tipo di approccio degli OP.

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

Questa implementazione limita i riferimenti dell'array di input. A parte questo, è piuttosto semplice: mentre entrambi gli array hanno qualcosa, spostarsi dalla parte inferiore delle due. Quindi restituisce il bit unito unito a tutti i bit rimanenti (rimarrà solo uno di @ $ x o @ $ y). Straight-up perl5, 87 caratteri:

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

Usando il perl 5.14.0 e il suo nuovo turno di arrayref: 78 caratteri + 1 penalità di carattere = 79 caratteri:

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

Java: 144

Questo è piuttosto semplice. Una funzione che accetta due array e ne restituisce uno, la versione unita, golfizzata e senza wrapper di compilazione:

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

Ungolfed (con wrapper compilabile e eseguibile):

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

Esecuzioni di esempio:

$ 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

Eventuali suggerimenti per accorciare sarebbero apprezzati.

Scala, 97 byte

Soluzione ricorsiva con O (n). Per abbreviare il codice, a volte un'operazione viene eseguita commutando i 2 parametri intercambiabili, ovvero f (a, b) chiama 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)

Ungolfed:

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

Spiegazione:

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

L'algoritmo termina in n + 1iterazioni, dove nè la lunghezza dell'elenco più breve in input.

(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 (di nuovo 64, se non sono consentiti generatori.):

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

Un adattamento della mia risposta Python .

Python - 69 byte

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

Se l'ordine di input e output scendesse, questo potrebbe essere ridotto a 61 byte :

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

E più in basso fino a 45 byte se i generatori sono ammessi:

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

Perl 6: 53 caratteri

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

Passa dal valore più piccolo ao bha il valore più piccolo, fino a quando aXOR b( a^b) è true. Quindi restituisce tutto ciò che rimane, appiattendo ( []) le matrici nell'elenco ( a[],b[]).

Supponendo che lo spostamento dall'inizio di un array sia O (n), il caso peggiore è due confronti e uno spostamento per elemento, quindi l'algoritmo è O (n).

JavaScript (ES5) 90 86 90 byte

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) Spostato il ternario nella condizione di ciclo for. Idea rubata a Dennis.

edit: (86 -> 90) Array rimosso per il cast delle stringhe, poiché infrange il requisito 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)

Ingresso:

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

Produzione:

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

Ungolfed:

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
)

Probabilmente potrebbe fare di meglio.

R, 80

Stessa soluzione di Scala e di altre lingue. Non sono così sicuro che x [-1] sia 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 byte

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

Funzione anonima, memorizza la lunghezza dei due elenchi di input nelle variabili me n, quindi ogni iterazione del Doloop Sowè un elemento di uno degli elenchi che incrementano il contatore per quell'elenco ( iper il primo, kper il secondo) di uno. Se uno dei contatori supera la lunghezza dell'elenco, l' Ifistruzione sarà sempre Sowl'elemento dell'altro elenco. Dopo le n+moperazioni, tutti gli elementi sono stati curati.Reapo meglio, parte [[2,1]]del suo output è un elenco di elementi nell'ordine in cui sono statiSow n.

Non sono sicuro degli interni (l'accesso a una parte di una lista è O(1)un'operazione o meno), ma i tempi sembravano abbastanza lineari sulla mia macchina rispetto alla lunghezza della lista di input.