Eh bien, quand j'achète des cadeaux pour mes deux épouses, je veux qu'elles se sentent tout aussi importantes pour moi, mais c'est difficile de faire du shopping avec des budgets fixes. Au lieu de cela, j'achète un tas de choses et les divise en deux groupes avec une valeur aussi égale que possible. Ensuite, j'achète un tas de chocolats pour réparer le reste.

Mais je ne veux pas faire tout ce qui est difficile quand mon ordinateur peut le faire. Et vous non plus. Alors résolvez ce problème afin que la prochaine fois que vous aurez besoin de partager des cadeaux entre vos épouses, vous sachiez que ce sera facile.

Contribution

1 tableau d'éléments (N * 2) où N * 2 est spécifié sur la 1ère ligne.
Les éléments du tableau dans la ligne suivante.

Production

2 tableaux de N éléments chacun tels que: La
différence de (Somme des éléments du tableau 1) et (Somme des éléments du tableau 2) est aussi proche que possible de 0.

Exemple

Contribution

4
1 2 3 4 

Production

1 4
2 3
diff=0

Avertissement : je n'ai pas deux femmes. Mais quand je me sens mal, j'imagine avoir deux femmes. Et soudain, je suis reconnaissant et heureux de n'en avoir qu'un. :RÉ

Java

Essayer de résoudre ce problème en deux phases:

1. Construisez deux listes de taille égale en ajoutant la plus grande à la liste actuellement plus petite et la suivante l'une à l'autre. Répéter.
2. Identifiez les éléments des deux listes qui peuvent être commutés pour réduire la différence de valeur

Entrée comme

8
1 2 3 4 5 6 7 8

est déjà résolu après la phase 1 comme par exemple

2 3 5 8
1 4 6 7
diff=0

et entrez comme

6
1 4 5 6 7 8

aura besoin des deux phases pour que

1 5 8
4 6 7
diff=3

(après la première phase) devient le résultat de

1 6 8
4 5 7
diff=1

Bien que je puisse garantir que cette tentative fournira toujours une solution, je ne peux pas prouver qu'une solution optimale est trouvée dans tous les cas. Avec la restriction des listes de taille égale, il semble cependant tout à fait réaliste de ne laisser aucun cas de coin. Prouve moi le contraire ;-)

Programme sur 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

Essayez-le en ligne!

Il s'agit d'un concours de popularité, mais cela ne signifie pas nécessairement que les langues de golf ne conviennent pas. (Vraiment, j'aurais dû répondre dans Jelly parce que les réponses à Jelly ont tendance à obtenir un nombre disproportionné de votes positifs pour une raison quelconque, peu importe qui les soumet ou comment ils jouent, mais Brachylog est plus lisible.)

Nous commençons par prendre la liste de toutes les permutations de l'entrée ( pᶠ), et en divisant chacune ( ᵐ) en deux morceaux égaux ( ḍ; nous pourrions lui donner un indice si vous aviez plus de deux femmes pour une raison quelconque). Ensuite, nous ordonnons les permutations divisées ( {…}ᵒ) en prenant la somme ( +) de chaque ( ᵐ) moitié, en prenant la différence absolue (c'est o--à- dire la "différence ordonnée") et en utilisant ces différences pour définir l'ordre de tri. Le meilleur résultat est le premier, donc nous prenons la tête de la liste avec hpour obtenir le résultat.

Mathematica

Formulaires de saisie

La chaîne d'entrée doit être prise via STDIN. assetsfait référence aux montants à répartir entre les épouses (ou les jumeaux). lengthest le nombre d'actifs.

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

Aux fins des présentes, nous supposerons que les actifs sont constitués des entiers de 1 à 20.

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

En traitement

(* 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 distribution est-elle injuste? Alors, choisissez-en un autre.

@Le constructeur note que l'épouse 2 peut contester le fait que l'épouse 1 a obtenu tous les meilleurs atouts. Ainsi, ce qui suit produit toutes les parts «justes» (différence = différence la plus faible) pour l'épouse 1; l'épouse 2 obtient les actifs restants; le zéro fait référence à la différence d'actifs pour les épouses. Il existe 5448 façons de répartir les actifs pondérés de 1 à 20. Seules quelques lignes sont affichées.

Le format est

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 soumission antérieure se trouve parmi les modifications. Il est beaucoup plus inefficace, car il s'appuie sur lui Permutations.

J

Il y a une feuille de triche de toutes les primitives J sur ce lien , au cas où vous voudriez suivre à la maison. Rappelez-vous: J est généralement lu de droite à gauche, c'est-à- 3*2+1dire 7, et non 9. Chaque verbe (J pour fonction) est soit monadique, donc devant comme f y, ou dyadique, donc entre les deux 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

Notes et explications:

• u/signifie "replier u", donc effectuez l'opération binaire sur chaque élément de la liste. Ainsi, par exemple: +/signifie Fold Plus ou Sum ; <.est Lesser Of , donc <./signifie Fold Lesser Of , ou Minimum .

• u"1signifie "effectuer usur des cellules à 1 dimension", c'est-à-dire sur chaque ligne. Normalement, les verbes de J sont soit atomiques, soit s'appliquent à tout l'argument. Cela s'applique aux deux arguments si le verbe est utilisé dyadiquement (avec deux arguments). Considérer ce qui suit:

     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
  

• #:est un verbe qui développe un nombre dans sa représentation binaire. Lorsque vous l'utilisez sur une liste avec plus d'un élément, il alignera également tous les nombres correctement, de sorte que #:i.2^nvous obtiendrez chaque chaîne binaire de longueur n.

• /., lorsqu'il est utilisé dyadiquement, est appelé Key . Il utilise les éléments de la liste du côté gauche comme clés et ceux du côté droit comme valeurs. Il regroupe chaque ensemble de valeurs qui partagent une clé, puis effectue une opération sur celles-ci.

  Dans le cas de ]/., l'opération n'est que le verbe d'identité, donc rien de tout à fait spécial ne s'y passe, mais le fait de /.partitionner la liste pour nous est l'élément le plus important. C'est pourquoi nous créons les listes binaires: pour que pour chaque liste ( "1), nous puissions répartir les cadeaux pour les épouses de toutes les manières possibles.

• 1!:1]1et 1!:2&2sont les opérations de lecture et d'écriture, respectivement. La 1!:npartie est le verbe et l'autre nombre est le descripteur de fichier. 1est console en 2entrée, console en sortie, et 3 4 5sont stdin, stdout et stderr. Nous utilisons également ".lors de la lecture afin de convertir les chaînes d'entrée en nombres.

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

Tester

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


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

MATLAB

Voici ma solution:

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

Par exemple, la liste actuelle de mon code source se traduit par:

for_jennifer =

     8     2     5     1


for_kate =

     4     7     2     3

qui est à la fois 16.

Si je joue à mon code, ce qui est moins amusant, je reçois 132 caractères très optimisés. Bas ça ;)

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

Avertissement: code très sale
Il essaie toutes les permutations possibles du tableau d'entrée.

Échantillon Ideone pour 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!');

Python:

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]

ou un peu golfifié:

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]

Ou encore plus golfifié, car la moitié des lignes n'est que du maquillage. (en supposant que je peux simplement vider le tableau interne brut, car cela n'est pas spécifié dans l'op) Vous pouvez laisser de côté le print(par exemple) le shell interactif, et ajouter un [::-1](à la toute fin, après [0]) si vous voulez vraiment le diff dernier.

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]

(résultats en (0, ((1, 2, 7, 8), (3, 4, 5, 6))))

Cependant, cela ne fait que renforcer brutalement toutes les combinaisons possibles et ne doit pas être considéré comme efficace à distance. Cependant, si la liste étant de longueurs égales n'a pas d'importance, cela fonctionnerait également (sur les grands tableaux):

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

Avec le code en dessous, par exemple, il fonctionne à peine avec une différence: 500k sur 10 ^ 10 valeur maximale n'est pas beaucoup, pour ainsi dire. C'est aussi beaucoup plus rapide: là où l'autre code ne se terminerait probablement pas dans moins d'un an (et c'est très optimiste), cela s'exécute en environ une demi-seconde, même si votre kilométrage peut varier.

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

Alphabet Haskell

> import Data.List
> import Data.Function

J'ai utilisé la monade de liste pour la diviser.

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

Ensuite, nous faisons un évaluateur.

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

Et puis une fonction qui minimisera la différence.

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

Et quelque chose qui les combine tous.

> bestDivison=best . divide

Ensuite un analyseur.

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

Et un formateur de sortie.

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

Et maintenant le programme

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

Exemple:

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

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