Chà, khi tôi mua quà cho hai người vợ của mình, tôi muốn họ cảm thấy quan trọng như nhau đối với tôi, nhưng thật khó để đi mua sắm với ngân sách cố định. Thay vào đó, tôi mua một loạt các công cụ và chia chúng thành hai nhóm với giá trị bằng nhau nhất có thể. Sau đó, tôi mua một bó sô cô la để sửa phần còn lại.

Nhưng tôi không muốn làm tất cả những việc khó khăn khi máy tính của tôi có thể làm điều đó. Và bạn cũng không. Vì vậy, hãy giải quyết vấn đề này để lần sau bạn cần chia quà cho các bà vợ, bạn sẽ biết nó sẽ dễ dàng.

Đầu vào

1 mảng gồm các phần tử (N * 2) trong đó N * 2 được chỉ định trong dòng 1.
Các phần tử của mảng trong dòng sau.

Đầu ra

Mỗi mảng gồm 2 phần tử N sao cho:
Chênh lệch (Tổng các phần tử của mảng 1) và (Tổng các phần tử của mảng 2) càng gần với 0.

Thí dụ

Đầu vào

4
1 2 3 4 

Đầu ra

1 4
2 3
diff=0

Tuyên bố miễn trừ trách nhiệm : Tôi không có hai vợ. Nhưng khi tôi cảm thấy tồi tệ, tôi tưởng tượng có hai người vợ. Và đột nhiên, tôi biết ơn và hạnh phúc vì tôi chỉ có một. : D

Java

Cố gắng giải quyết vấn đề này theo hai giai đoạn:

1. Xây dựng hai danh sách có kích thước bằng nhau bằng cách thêm danh sách lớn nhất còn lại vào danh sách nhỏ hơn hiện tại và danh sách tiếp theo. Nói lại.
2. Xác định các mục từ cả hai danh sách có thể được chuyển đổi để giảm chênh lệch giá trị

Nhập như

8
1 2 3 4 5 6 7 8

đã được giải quyết sau giai đoạn 1 như vd

2 3 5 8
1 4 6 7
diff=0

và đầu vào như

6
1 4 5 6 7 8

sẽ cần cả hai giai đoạn để

1 5 8
4 6 7
diff=3

(sau giai đoạn một) trở thành kết quả của

1 6 8
4 5 7
diff=1

Mặc dù tôi có thể đảm bảo nỗ lực này sẽ luôn cung cấp giải pháp, tôi không thể chứng minh rằng một giải pháp tối ưu được tìm thấy trong mọi trường hợp. Với sự hạn chế của các danh sách có kích thước bằng nhau, tuy nhiên cảm giác khá thực tế rằng không có trường hợp góc nào bị bỏ lại phía sau. Hay chưng minh tôi sai ;-)

Chương trình trên 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

Hãy thử trực tuyến!

Đây là một cuộc thi phổ biến, nhưng điều đó không nhất thiết có nghĩa là ngôn ngữ chơi golf là không phù hợp. (Thực sự, tôi nên trả lời bằng Jelly vì các câu trả lời của Jelly có xu hướng nhận được số lượng upvote không tương xứng vì một số lý do bất kể ai gửi chúng hay chơi golf như thế nào, nhưng Brachylog dễ đọc hơn.)

Chúng tôi bắt đầu bằng cách lấy danh sách tất cả các hoán vị của đầu vào ( pᶠ) và chia mỗi ( ᵐ) thành hai phần bằng nhau ( ḍ; chúng tôi có thể cung cấp cho nó một chỉ mục nếu bạn có nhiều hơn hai người vợ vì một số lý do). Sau đó, chúng ta sắp xếp các hoán vị phân chia ( {…}ᵒ) bằng cách lấy tổng ( +) của mỗi ( ᵐ) một nửa, lấy chênh lệch tuyệt đối (nghĩa là o-"chênh lệch theo thứ tự") và sử dụng các khác biệt đó để xác định thứ tự sắp xếp. Kết quả tốt nhất là kết quả đầu tiên, vì vậy chúng tôi đứng đầu danh sách hđể có kết quả.

Toán học

Hình thức đầu vào

Chuỗi đầu vào sẽ được thực hiện thông qua STDIN. assetsđề cập đến số tiền được phân phối giữa các bà vợ (hoặc anh em sinh đôi). lengthlà số lượng tài sản.

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

Đối với các mục đích hiện tại, chúng tôi sẽ giả định rằng các tài sản bao gồm các số nguyên từ 1 đến 20.

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

Chế biến

(* 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]]]}}]

Là sự phân phối không công bằng? Vì vậy, chọn một cái khác.

@ Người xây dựng lưu ý rằng vợ 2 có thể tranh cãi về việc vợ 1 có tất cả tài sản tốt nhất. Vì vậy, những điều sau đây tạo ra tất cả các cổ phiếu "công bằng" (chênh lệch = chênh lệch thấp nhất) cho vợ 1; vợ 2 lấy tài sản còn lại; số không đề cập đến sự khác biệt về tài sản cho các bà vợ. Có 5448 cách để phân phối tài sản có trọng số từ 1 đến 20. Chỉ một vài dòng được hiển thị.

Định dạng là

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

Trình trước đó có thể được tìm thấy trong số các chỉnh sửa. Nó là không hiệu quả hơn nhiều, dựa trên nó làm Permutations.

J

Có một bảng cheat của tất cả các nguyên thủy J tại liên kết này , trong trường hợp bạn muốn theo dõi tại nhà. Hãy nhớ rằng: J thường được đọc từ phải sang trái, vì vậy đó 3*2+1là 7, không phải 9. Mỗi động từ (J cho hàm) đều là đơn âm, vì vậy ở phía trước like f y, hoặc dyadic, nên ở giữa like 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

Ghi chú và giải thích:

• u/có nghĩa là "gấp ulại", do đó thực hiện thao tác nhị phân trên mỗi phần tử trong danh sách. Vì vậy, ví dụ: +/có nghĩa là Fold Plus , hoặc Sum ; <.là Ít hơn , <./có nghĩa là Gấp Ít hơn hoặc Tối thiểu .

• u"1có nghĩa là "thực hiện utrên các ô 1 chiều", tức là trên mỗi hàng. Thông thường các động từ trong J là nguyên tử hoặc áp dụng cho toàn bộ đối số. Điều này áp dụng cho cả hai đối số nếu động từ được sử dụng một cách ngẫu nhiên (với hai đối số). Hãy xem xét những điều sau đây:

     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
  

• #:là một động từ mở rộng một số thành biểu diễn nhị phân của nó. Khi bạn sử dụng nó trong một danh sách có nhiều hơn một phần tử, nó cũng sẽ căn chỉnh tất cả các số một cách chính xác, do đó #:i.2^nsẽ giúp bạn có được mọi chuỗi nhị phân có độ dài n.

• /., khi được sử dụng một cách tự nhiên, được gọi là Khóa . Nó sử dụng các yếu tố của danh sách ở phía bên trái làm khóa và những yếu tố ở phía bên phải làm giá trị. Nó nhóm lại từng nhóm giá trị chia sẻ một khóa và sau đó thực hiện một số thao tác trên chúng.

  Trong trường hợp ]/., hoạt động chỉ là động từ danh tính, vì vậy không có gì đặc biệt xảy ra ở đó, nhưng thực tế /.sẽ phân vùng danh sách cho chúng tôi là bit quan trọng. Đây là lý do tại sao chúng tôi tạo danh sách nhị phân: để cho mỗi danh sách ( "1), chúng tôi có thể phân chia quà tặng cho các bà vợ theo tất cả các cách có thể.

• 1!:1]1và 1!:2&2là các hoạt động đọc và ghi tương ứng. Phần 1!:nlà động từ và số khác là xử lý tập tin. 1là console trong, 2là console out, và 3 4 5stdin, stdout, và stderr. Chúng tôi cũng sử dụng ".khi đọc để chuyển đổi chuỗi đầu vào thành số.

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

Kiểm tra

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


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

MATLAB

Đây là giải pháp của tôi:

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

Ví dụ, danh sách hiện tại trong mã nguồn của tôi dẫn đến:

for_jennifer =

     8     2     5     1


for_kate =

     4     7     2     3

đó là cả 16.

Nếu tôi chơi mã của mình, điều đó ít thú vị hơn, tôi sẽ nhận được 132 ký tự không được đánh giá cao. Đánh bại nó;)

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

Cảnh báo: Mã rất bẩn
Nó thử mọi hoán vị có thể có của mảng đầu vào.

Mẫu Ideone cho 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!');

Con trăn

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]

hoặc một chút golfized:

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]

Hoặc thậm chí xa hơn nữa, vì một nửa dòng chỉ là trang điểm. (giả sử tôi chỉ có thể kết xuất mảng bên trong thô, vì điều này không được chỉ định trong op) Bạn có thể bỏ printphần vỏ tương tác (ví dụ) và thêm một [::-1](vào cuối, sau [0]) nếu bạn thực sự muốn khác biệt cuối cùng.

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]

(kết quả trong (0, ((1, 2, 7, 8), (3, 4, 5, 6))))

Tuy nhiên, điều này chỉ là tàn bạo tất cả các kết hợp có thể nhìn thấy, và không nên được coi là hiệu quả từ xa. Tuy nhiên, nếu danh sách có độ dài bằng nhau không thành vấn đề, thì điều này cũng sẽ hoạt động (trên các mảng lớn):

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

Ví dụ, với mã dưới đây, nó chạy với hầu như không có sự khác biệt nào: 500k trên 10 ^ 10 giá trị tối đa không phải là nhiều, có thể nói. Điều này cũng nhanh hơn rất nhiều: nơi mà các mã khác có thể sẽ không hoàn thành trong vòng một năm (và điều đó rất lạc quan), điều này diễn ra trong khoảng nửa giây, mặc dù tốc độ của bạn có thể thay đổi.

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

Biết chữ Haskell

> import Data.List
> import Data.Function

Tôi đã sử dụng danh sách đơn nguyên để tách nó ra.

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

Sau đó, chúng tôi thực hiện một rater.

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

Và sau đó một chức năng sẽ giảm thiểu sự khác biệt.

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

Và một cái gì đó kết hợp tất cả.

> bestDivison=best . divide

Tiếp theo một trình phân tích cú pháp.

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

Và một định dạng đầu ra.

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

Và bây giờ là chương trình

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

Thí dụ:

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

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