Bene, quando compro regali per le mie due mogli, voglio che si sentano ugualmente importanti per me, ma è difficile fare shopping con budget fissi. Invece, compro un sacco di cose e le divido in due gruppi con il valore più uguale possibile. Poi compro un mucchio di cioccolatini per sistemare il resto.

Ma non voglio fare tutto il duro lavoro quando il mio computer può farlo. E neanche tu. Quindi risolvi questo problema in modo che la prossima volta che dovrai dividere i regali tra le tue mogli, sai che sarebbe facile.

Ingresso

1 matrice di (N * 2) elementi in cui N * 2 è specificato nella prima riga.
Gli elementi dell'array nella riga seguente.

Produzione

2 array di N elementi ciascuno tale che:
Differenza di (somma degli elementi dell'array 1) e (somma degli elementi dell'array 2) è il più vicino possibile a 0.

Esempio

Ingresso

4
1 2 3 4 

Produzione

1 4
2 3
diff=0

Disclaimer : non ho due mogli. Ma quando mi sento male, immagino di avere due mogli. E improvvisamente, sono grato e felice di averne solo uno. : D

Giava

Cercare di risolvere questo problema in due fasi:

1. Costruisci due elenchi di dimensioni uguali aggiungendo il rimanente più grande all'elenco attualmente più piccolo e il successivo all'altro. Ripetere.
2. Identificare gli elementi da entrambi gli elenchi che possono essere commutati per ridurre la differenza di valore

Inserisci come

8
1 2 3 4 5 6 7 8

è già risolto dopo la fase 1 come ad es

2 3 5 8
1 4 6 7
diff=0

e inserisci come

6
1 4 5 6 7 8

avrà bisogno di entrambe le fasi in modo che

1 5 8
4 6 7
diff=3

(dopo la prima fase) diventa il risultato di

1 6 8
4 5 7
diff=1

Mentre posso garantire che questo tentativo fornirà sempre una soluzione, non posso dimostrare che in tutti i casi si trova una soluzione ottimale. Con la restrizione di elenchi di dimensioni uguali, tuttavia, sembra abbastanza realistico che non ci siano casi angolari lasciati alle spalle. Dimostra che ho torto ;-)

Programma su ideone.com

import java.util.*;

/**
 * Created to solve http://codegolf.stackexchange.com/q/23461/16293 .
 */
public class EqualSums {

    public static void main(String[] args) {
        final Scanner s = new Scanner(System.in);
        // Read number of elements to divide
        final int count = s.nextInt();
        if (count % 2 == 1) {
            throw new IllegalStateException(count + " can not be divided by 2. Consider adding a 0 value.");
        }
        // Read the elements to divide
        final SortedList valueStack = new SortedList(count);
        for (int i = 0; i < count; i++) {
            valueStack.add(s.nextLong());
        }

        final SortedList targetOne = new SortedList(count / 2);
        final SortedList targetTwo = new SortedList(count / 2);
        // Divide elements into two groups
        addInPairs(targetOne, targetTwo, valueStack);
        // Try to ensure groups have equal value
        retaliate(targetOne, targetTwo);

        // Output result
        System.out.println(targetOne);
        System.out.println(targetTwo);
        System.out.println("diff=" + Math.abs(targetOne.getSum() - targetTwo.getSum()));
    }

    private static void addInPairs(SortedList targetOne, SortedList targetTwo, SortedList valueStack) {
        SortedList smallerTarget = targetOne;
        SortedList biggerTarget = targetTwo;
        while (!valueStack.isEmpty()) {
            // Add biggest remaining value to small target
            smallerTarget.add(valueStack.removeLast());

            // Add second biggest remaining value to big target
            biggerTarget.add(valueStack.removeLast());

            // Flip targets if roles have changed
            if (smallerTarget.getSum() > biggerTarget.getSum()) {
                final SortedList temp = smallerTarget;
                smallerTarget = biggerTarget;
                biggerTarget = temp;
            }
        }

    }

    private static void retaliate(SortedList targetOne, SortedList targetTwo) {
        long difference;
        boolean changed;
        outer:
        do {
            difference = Math.abs(targetOne.getSum() - targetTwo.getSum());
            if (difference == 0) {
                return;
            }
            changed = false;
            // Try to find two values, that reduce the difference by changing them between targets
            for (Long valueOne : targetOne) {
                for (Long valueTwo : targetTwo) {
                    final Long tempOne = targetOne.getSum() + valueTwo - valueOne;
                    final Long tempTwo = targetTwo.getSum() - valueTwo + valueOne;
                    if (Math.abs(tempOne - tempTwo) < difference) {
                        targetOne.remove(valueOne);
                        targetTwo.add(valueOne);
                        targetTwo.remove(valueTwo);
                        targetOne.add(valueTwo);
                        changed = true;
                        continue outer;
                    }
                }
            }
        } while (changed);
    }

    public static class SortedList extends AbstractList<Long> {

        private final ArrayList<Long> list;
        private long sum = 0;

        public SortedList(int count) {
            list = new ArrayList<>(count);
        }

        // the next functions access list-field directly
        @Override
        public Long get(int index) {
            return list.get(index);
        }

        @Override
        public boolean add(final Long t) {
            final int i = Collections.binarySearch(list, t);
            if (i < 0) {
                // No equal element present
                list.add(-i - 1, t);
            } else {
                list.add(afterLastEqual(i, t), t);
            }
            sum += t;
            return true;
        }

        @Override
        public Long remove(int index) {
            final Long old = list.remove(index);
            sum -= old;
            return old;
        }

        @Override
        public int size() {
            return list.size();
        }

        // the next functions access list-field only through the functions above this point
        // to ensure the sum is well kept

        public long getSum() {
            return sum;
        }

        private int afterLastEqual(final int start, Object o) {
            int found = start;
            while (found < size() && o.equals(get(found))) {
                found++;
            }
            return found;
        }

        private int beforeFirstEqual(final int start, final Object o) {
            int found = start;
            while (found >= 0 && o.equals(get(found))) {
                found--;
            }
            return found;
        }

        @Override
        public int indexOf(Object o) {
            try {
                final int i = Collections.binarySearch(this, (Long) o);
                if (i >= 0) {
                    return beforeFirstEqual(i, o) + 1;
                }
            } catch (ClassCastException e) {
                // Object was not instance of Long
            }
            return -1;
        }

        @Override
        public int lastIndexOf(Object o) {
            try {
                final int i = Collections.binarySearch(this, (Long) o);
                if (i >= 0) {
                    return afterLastEqual(i, o) - 1;
                }
            } catch (ClassCastException e) {
                // Object was not instance of Long
            }
            return -1;
        }

        @Override
        public boolean remove(Object o) {
            if (o == null) {
                return false;
            }
            final int i = indexOf(o);
            if (i >= 0) {
                remove(i);
                return true;
            }
            return false;
        }

        public Long removeLast() {
            return remove(size() - 1);
        }

        public Long removeFirst() {
            return remove(0);
        }

        @Override
        public String toString() {
            Iterator<Long> it = iterator();
            if (!it.hasNext()) {
                return "";
            }

            StringBuilder sb = new StringBuilder();
            for (; ; ) {
                Long e = it.next();
                sb.append(e);
                if (!it.hasNext()) {
                    return sb.toString();
                }
                sb.append(' ');
            }
        }
    }
}

Brachylog 2

pᶠḍᵐ{+ᵐo-}ᵒh

Provalo online!

Questa è una gara di popolarità, ma ciò non significa necessariamente che le lingue del golf non siano adatte. (Davvero, avrei dovuto rispondere in Jelly perché le risposte di Jelly tendono ad ottenere un numero sproporzionato di voti per qualche motivo, indipendentemente da chi li presenta o da come sono stati giocati, ma Brachylog è più leggibile.)

Iniziamo prendendo l'elenco di tutte le permutazioni dell'input ( pᶠ) e dividendo ciascuna ( ᵐ) in due pezzi uguali ( ḍ; potremmo dargli un pedice se avessi più di due mogli per qualche motivo). Quindi ordiniamo le permutazioni divise ( {…}ᵒ) prendendo la somma ( +) di ciascuna ( ᵐ) metà, prendendo la differenza assoluta (cioè o-"differenza ordinata") e usando quelle differenze per definire l'ordinamento. Il miglior risultato è il primo, quindi prendiamo il capo della lista con hper ottenere il risultato.

matematica

Moduli di input

La stringa di input deve essere acquisita tramite STDIN. assetssi riferisce agli importi da distribuire tra le mogli (o gemelli). lengthè il numero di attività.

assets=ToExpression[Rest[s=StringSplit[input]]]
length=ToExpression[First[s]]

Ai fini attuali, assumeremo che le attività siano costituite da numeri interi compresi tra 1 e 20.

assets=Range[20];
length=Length[Range[20]]

in lavorazione

(* find all possible distributions to one wife; the other presumably gets the remaining assets *)
r=Subsets[assets,{length/2}];

(*order them according to the difference with respect to the total of half of the assets. 
Remove the first set of assets.  One wife will get these.*)
s=SortBy[r/.{{a__Integer}:> {{a},Abs[Tr[Range[20]/2]-Tr[{a}]]}},Last][[1]];

(*The other wife's assets will be the complement.  The difference is carried over from the sorting routine. *)
Grid[{{Grid[{s[[1]],Complement[assets,s[[1]]]}]},{"difference = "<>ToString[s[[2]]]}}]

La distribuzione è ingiusta? Quindi, scegline un altro.

@Il costruttore nota che la moglie 2 può contestare il fatto che la moglie 1 abbia ottenuto tutti i migliori beni. Quindi quanto segue produce tutte le azioni "giuste" (differenza = differenza più bassa) per la moglie 1; la moglie 2 ottiene i beni rimanenti; lo zero si riferisce alla differenza di attività per le mogli. Esistono 5448 modi per distribuire gli asset ponderati da 1 a 20. Vengono visualizzate solo alcune righe.

Il formato è

s=SortBy[r/.{{a__Integer}:> {{a},Abs[Tr[Range[20]/2]-Tr[{a}]]}},Last];
z=Cases[s,{_List,x_}/;x==s[[1,2]]];
Short[z,10]
Length[z]

{{{} 1,2,3,4,5,16,17,18,19,20, 0}, {{} 1,2,3,4,6,15,17,18,19,20, 0}, {{} 1,2,3,4,7,14,17,18,19,20, 0}, {{1,2,3,4,7,15,16,18,19,20 }, 0}, {{} 1,2,3,4,8,13,17,18,19,20, 0}, {{1,2,3,4,8,14,16,18,19 , 20}, 0}, {{} 1,2,3,4,8,15,16,17,19,20, 0}, {{1,2,3,4,9,12,17,18 , 19,20}, 0}, {{} 1,2,3,4,9,13,16,18,19,20, 0}, {{1,2,3,4,9,14,15 , 18,19,20}, 0}, {{} 1,2,3,4,9,14,16,17,19,20, 0}, {{1,2,3,4,9,15 , 16,17,18,20}, 0}, {{} 1,2,3,4,10,11,17,18,19,20, 0}, {{1,2,3,4,10 , 12,16,18,19,20}, 0}, <<5420>>, {{5,6,7,8,9,11,13,14,15,17}, 0}, {{5 , 6,7,8,9,12,13,14,15,16}, 0}, {{} 5,6,7,8,10,11,12,13,14,19, 0}, { {} 5,6,7,8,10,11,12,13,15,18, 0}, {{} 5,6,7,8,10,11,12,13,16,17, 0} , {{} 5,6,7,8,10,11,12,14,15,17, 0}, {{} 5,6,7,8,10,11,13,14,15,16, 0}, {{} 5,6,7,9,10,11,12,13,14,18, 0}, {{5,6,7,9,10,11,12,13,15,17 }, 0}, {{} 5,6,7,9,10,11,12,14,15,16, 0}, {{5,6,8,9,10,11,12,13,14 , 17}, 0}, {{} 5,6,8,9,10,11,12,13,15,16, 0}, {{5,7,8,9,10,11,12,13,14,16}, 0}, {{} 6,7,8,9,10,11,12,13,14,15, 0}}

5448

La presentazione precedente può essere trovata tra le modifiche. È molto più inefficiente, basandosi su quello che fa Permutations.

J

C'è un cheat sheet di tutte le primitive J su questo link , nel caso in cui tu voglia seguire a casa. Ricorda: J viene generalmente letto da destra a sinistra, quindi 3*2+1è 7, non 9. Ogni verbo (J per la funzione) è o monadico, quindi davanti come f y, o diadico, così tra come simile x f y.

N =: (". 1!:1 ] 1) % 2          NB. number of items per wife
S =: ". 1!:1 ] 1                NB. list of items to distribute

bins =: #: i. 2 ^ 2*N           NB. all binary strings of length 2n
even =: bins #~ N = +/"1 bins   NB. select those with row-sum 1

NB. all distributions of equal numbers of items to each wife
NB. resultant shape: a list of 2xN matrices
NB. this /. adverb is where all the magic happens, see below
dist =: even ]/."1 S

diff =: | -/"1 +/"1 dist        NB. difference in wives' values
idx  =: (i. <./) diff           NB. index of the lowest difference

1!:2&2 idx { dist               NB. print the winning distribution of items
1!:2&2 'diff=', idx { diff      NB. and the difference of that distribution

Note e spiegazioni:

• u/significa "piega u", quindi esegui l'operazione binaria su ciascun elemento nell'elenco. Quindi, per esempio: +/significa Fold Plus o Sum ; <.è Minore di , quindi <./significa Piega Minore di o Minimo .

• u"1significa "eseguire usu celle monodimensionali", cioè su ogni riga. Normalmente i verbi in J sono atomici o si applicano all'intero argomento. Questo vale per entrambi gli argomenti se il verbo viene usato in modo diaadico (con due argomenti). Considera quanto segue:

     i. 2 3        NB. just a 2x3 matrix of numbers
  0 1 2
  3 4 5
     +/   i. 2 3   NB. Sum the items
  3 5 7
     +/"1 i. 2 3   NB. Sum the items of each row
  3 12
  

• #:è un verbo che espande un numero nella sua rappresentazione binaria. Quando lo usi in un elenco con più di un elemento, allinea anche correttamente tutti i numeri, in modo da #:i.2^nottenere ogni stringa binaria di lunghezza n.

• /., se usato in modo diaadico, si chiama Key . Utilizza gli elementi dell'elenco sul lato sinistro come chiavi e quelli sul lato destro come valori. Raggruppa ogni set di valori che condividono una chiave e quindi esegue alcune operazioni su di essi.

  Nel caso di ]/., l'operazione è solo il verbo di identità, quindi non sta succedendo nulla di completamente speciale, ma il fatto che /.partizionerà l'elenco per noi è il bit importante. Questo è il motivo per cui creiamo le liste binarie: in modo che per ciascuna lista ( "1), possiamo dividere i doni per le mogli in tutti i modi possibili.

• 1!:1]1e 1!:2&2sono le operazioni di lettura e scrittura, rispettivamente. La 1!:nparte è il verbo e l'altro numero è l'handle del file. 1è console in, 2è console in uscita e 3 4 5sono stdin, stdout e stderr. Usiamo anche ".durante la lettura in modo da convertire le stringhe di input in numeri.

Clojure

(defn divide [n]
 (loop [lv [] rv [] d (reverse (sort n))]
  (if (empty? d)
   [lv rv]
   (if (> (reduce + lv) (reduce + rv))
     (if (>= (count lv ) (count rv))
       (recur lv (conj rv (first d)) (into [] (rest d)))
       (recur (conj lv (last d)) rv (pop d))) 
     (if (<= (count lv ) (count rv))
       (recur (conj lv (first d)) rv (into [] (rest d)) )
       (recur lv (conj rv (last d)) (pop d)))))))


 (defn display [[f s]]
   (println f)
   (println s)
   (println (str "Diff " (- (reduce + f) (reduce + s)))))

Test

 (->> 
 [5 1 89 36 2 -4 20 7]
 divide 
 display)


 =: [89 -4 1 2]
    [36 20 7 5]
    Diff 20

MATLAB

Ecco la mia soluzione:

%input array
presents=zeros(2,8);
presents(1,1)=8; %number of presents
presents(2,:)=[1 2 7 4 5 3 2 8]; %list of presents

%calculate the cumulative sum of all permutations
%its all about the gift values
how_many=presents(1,1);
options=perms(presents(2,:);
subtotals=cumsum(options,2);

%find the first index where the difference between the two parts is minimal
%makes both wives happy!!
[~, double_happiness] = min(abs(sum(presents(2,:))/2-subtotals(:,how_many/2)));

%create the present lists for Jennifer and Kate :)
for_jennifer=options(double_happiness,1:how_many/2)
for_kate=options(double_happiness,how_many/2+1:end)

Ad esempio, il presente elenco nel mio codice sorgente risulta in:

for_jennifer =

     8     2     5     1


for_kate =

     4     7     2     3

che è entrambi 16.

Se gioco il mio codice, il che è meno divertente, ottengo 132 caratteri non ottimizzati. Battilo ;)

function f(p);o=perms(p(:,2));s=cumsum(o,2);[~,d]=min(abs(sum(p(:,2))/2-s(:,p(1,1)/2)));a={o(d,1:p(1,1)/2);o(d,p(1,1)/2+1:end)};a{:}

PHP

Avvertenza: codice molto sporco
Prova tutte le possibili permutazioni dell'array di input.

Esempio Ideone per 4/1 2 3 4: http://ideone.com/gIi174

<?php
// Discard the first input line! It's useless :)
fgets(STDIN);
$numbers = explode(' ', rtrim(fgets(STDIN)));
$valuePerWife = array_sum($numbers) / 2;

// Taken from here: http://stackoverflow.com/a/13194803/603003
// Credits to dAngelov: http://stackoverflow.com/users/955185/dangelov
function pc_permute($items, $perms = array( )) {
    if (empty($items)) {
        $return = array($perms);
    }  else {
        $return = array();
        for ($i = count($items) - 1; $i >= 0; --$i) {
             $newitems = $items;
             $newperms = $perms;
         list($foo) = array_splice($newitems, $i, 1);
             array_unshift($newperms, $foo);
             $return = array_merge($return, pc_permute($newitems, $newperms));
         }
    }
    return $return;
}


foreach (pc_permute($numbers) as $permutation) {
    $sum = 0;
    $rest = [];

    for ($i=0; $i<count($permutation); $i++) {
        $sum += $permutation[$i];
        if ($sum == $valuePerWife) {
            $rest = array_slice($permutation, $i + 1);
            break;
        }
    }

    if (array_sum($rest) == $valuePerWife) {
        echo implode(' ', array_slice($permutation, 0, $i + 1)), "\n";
        echo implode(' ', array_slice($permutation, $i + 1)), "\n";
        echo 'diff=0';
        exit;
    }
}
exit('DIDNT FOUND ANY COMBINATION!');

Pitone:

import itertools as t
raw_input()
a=[int(i) for i in raw_input().split()]
a=list(t.permutations(a))
b=len(a[0])/2
c=[(d[b:],d[:b]) for d in a]
d=[abs(sum(d[b:])-sum(d[:b])) for d in a]
e=zip(d,c)
e.sort()
print " ".join([str(i) for i in e[0][1][0]])
print " ".join([str(i) for i in e[0][1][1]])
print "diff",e[0][0]

o un po 'golfificato:

import itertools as t
b=int(raw_input())/2
e=[(abs(sum(d[b:])-sum(d[:b])),(d[b:],d[:b])) for d in t.permutations([int(i) for i in raw_input().split()])]
e.sort()
f=e[0]
g=f[1]
print " ".join([str(i) for i in g[0]]),"\n"," ".join([str(i) for i in g[1]]),"\n","diff=",f[0]

O ancora più golfificato, poiché metà delle linee è solo trucco. (supponendo che sia possibile eseguire il dump dell'array interno non elaborato, poiché ciò non è specificato nell'op) È possibile lasciare printin (ad esempio) la shell interattiva e aggiungere un [::-1](alla fine, dopo [0]) se proprio si desidera l'ultimo diff.

import itertools as t
b=int(raw_input())/2
print sorted([(abs(sum(d[b:])-sum(d[:b])),(d[b:],d[:b])) for d in t.permutations([int(i) for i in raw_input().split()])])[0]

(risultati in (0, ((1, 2, 7, 8), (3, 4, 5, 6))))

Questo, tuttavia, sta solo rinforzando tutte le combinazioni possibili e non dovrebbe essere considerato a distanza efficiente. Tuttavia, se l'elenco di lunghezza uguale non ha importanza, funzionerebbe anche (su array di grandi dimensioni):

raw_input()
a,b=[],[]
for i in sorted([int(i) for i in raw_input().split()])[::-1]:
    b.append(i)
    if sum(b)>sum(a): b,a=a,b
print a,b,abs(sum(b)-sum(a))

Con il codice sotto questo, ad esempio, funziona con una differenza a malapena: 500k su 10 ^ 10 valore massimo non è molto, per così dire. Anche questo è molto più veloce: dove l'altro codice probabilmente non finirà in meno di un anno (e questo è molto ottimistico), funziona in circa mezzo secondo, anche se il tuo chilometraggio può variare.

def raw_input():
    import random
    return " ".join([str(random.randint(1,10**10)) for _ in range(10000)])

raw_input()
a,b=[],[]
for i in sorted([int(i) for i in raw_input().split()])[::-1]:
    b.append(i)
    if sum(b)>sum(a): b,a=a,b
print a,b,abs(sum(b)-sum(a))

Letterato Haskell

> import Data.List
> import Data.Function

Ho usato la monade lista per dividerla.

> divide []=return ([], [])
> divide (x:xs)=do
>   (w1, w2) <- divide xs
>   [(x:w1, w2), (w1, x:w2)]

Quindi facciamo un voto.

> rating (w1, w2)=abs $ (sum w1) - (sum w2)

E poi una funzione che minimizzerà la differenza.

> best = minimumBy (compare `on` rating) . filter (\(x,y)->length x == length y)

E qualcosa che li unisce tutti.

> bestDivison=best . divide

Avanti un parser.

> parse::String->[Int]
> parse=fmap read . words

E un formattatore di output.

> output (w1,w2)=unlines [unwords (map show w1)
>                        , unwords ( map show w2)
>                        , "diff="++(show $ abs $ (sum w1) - (sum w2))]

E ora il programma

> main = do
>   getLine --Ignored, I don't need the arrays length
>   input <- fmap parse getLine
>   putStrLn "" --For readability
>   putStrLn $ output $ bestDivison input

Esempio:

λ <*Main>: main
8
5 1 89 36 2 -4 20 7

5 36 20 7
1 89 2 -4
diff=20