두 아내를 위해 선물을 사면 나에게도 똑같이 중요하다고 생각하지만 정해진 예산으로 쇼핑하기는 어렵습니다. 대신, 나는 많은 물건을 사고 가능한 한 동일한 가치를 가진 두 그룹으로 나눕니다. 그런 다음 나머지를 고치기 위해 초콜릿을 많이 사요.

그러나 내 컴퓨터가 할 수있을 때 열심히 열심히하고 싶지 않습니다. 그리고 당신도 마찬가지입니다. 그러므로이 문제를 해결하여 다음에 아내 사이에 선물을 나누어야 할 때, 그것이 쉬울 것임을 알 수 있습니다.

입력

첫 번째 줄에 N * 2가 지정된 (N * 2) 요소의 1 개 배열.
다음 줄의 배열 요소

산출

2 개의 N 원소 배열 각각 :
(배열 1의 원소 합) 및 (배열 2의 원소 합)의 차이는 가능한 한 0에 가깝다.

예

입력

4
1 2 3 4 

산출

1 4
2 3
diff=0

면책 조항 : 나는 두 명의 아내가 없습니다. 하지만 기분이 나빠지면 두 명의 아내가 있다고 상상합니다. 그리고 갑자기, 나는 오직 하나만 가지고 있다는 것에 감사하고 행복합니다. :디

자바

이 문제를 두 단계로 해결하려고합니다.

1. 나머지 가장 큰 목록을 현재 작은 목록에 추가하고 다른 다음 목록을 추가하여 동일한 크기의 목록 두 개를 작성하십시오. 반복.
2. 값의 차이를 줄이기 위해 전환 할 수있는 두 목록에서 항목을 식별하십시오.

같은 입력

8
1 2 3 4 5 6 7 8

예를 들어 1 단계 이후에 이미 해결되었습니다.

2 3 5 8
1 4 6 7
diff=0

그리고 같은 입력

6
1 4 5 6 7 8

두 단계가 필요하므로

1 5 8
4 6 7
diff=3

(1 단계 이후)의 결과가됩니다

1 6 8
4 5 7
diff=1

이 시도가 항상 솔루션을 제공한다고 보장 할 수는 있지만 모든 경우에 최적의 솔루션이 있음을 증명할 수는 없습니다. 그러나 동일한 크기의 목록을 제한하면 남은 코너 사례가 없다는 것이 매우 현실적입니다. 내가 틀렸다는 것을 증명 해봐 ;-)

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

온라인으로 사용해보십시오!

이것은 인기 콘테스트이지만 반드시 골프 언어가 적합하지 않다는 것을 의미하지는 않습니다. (정말로, 젤리 답변은 누가 제출했는지 또는 골프를 쳤는지에 관계없이 어떤 이유로 든 불쾌한 수의 공짜를 얻는 경향이 있기 때문에 젤리로 대답해야했지만 Brachylog는 더 읽기 쉽습니다.)

입력 ( pᶠ) 의 모든 순열 목록을 가져 와서 각각 ( ᵐ)을 두 개의 동일한 조각으로 나누는 것으로 시작합니다 ( ḍ; 어떤 이유로 아내가 두 명 이상인 경우 아래 첨자를 줄 수 있음). 그런 다음 각 반 ( ) 반의 {…}ᵒ합 ( +)을 ᵐ취하고 절대 차이 (즉 o-, "순차 차이")를 취하고 이러한 차이를 사용하여 정렬 순서를 정의하여 분할 순열 ( )을 정렬합니다. 가장 좋은 결과는 첫 번째 결과이므로 목록 h을 가져와 결과를 얻습니다.

매스 매 티카

입력 양식

입력 문자열은 STDIN을 통해 가져옵니다. assets아내 (또는 쌍둥이) 사이에 분배 될 양을 나타냅니다. length자산 수입니다.

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

본 목적을 위해 자산은 1에서 20까지의 정수로 구성되어 있다고 가정합니다.

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

가공

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

배포가 불공평합니까? 따라서 다른 것을 선택하십시오.

@The Constructor는 아내 2가 아내 1이 모든 최고의 자산을 가지고 있다는 사실에 이의를 제기 할 수 있다고 지적합니다. 따라서 다음은 아내 1에 대한 모든 "공정"(차이 = 최저 차이) 주식을 생성합니다. 아내 2는 남은 자산을 얻는다. 0은 아내의 자산 차이를 나타냅니다. 가중치가 1에서 20까지 인 자산을 분배하는 방법은 5448 가지입니다. 몇 줄만 표시됩니다.

형식은

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

사전 제출물은 편집 내용 중에서 찾을 수 있습니다. 에 비해 훨씬 비효율적입니다 Permutations.

제이

이 링크 에는 모든 J 프리미티브에 대한 치트 시트가 있습니다. 기억하십시오 : J는 일반적으로 오른쪽에서 왼쪽으로 읽히므로 3*2+19가 아닌 7입니다. 모든 동사 (함수의 경우 J)는 모나 딕이므로 앞과 같 f y거나 dyadic 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

참고 및 설명 :

• u/"접기"를 의미 u하므로 목록의 각 요소에 대해 이진 연산을 수행하십시오. 예를 들어 : Fold Plus 또는 Sum을+/ 의미합니다 . 이다 의 적은 , 그래서 수단 의 적은 접어 또는 최소 .<.<./

• u"1" u1 차원 셀에서 수행 ", 즉 모든 행에서 수행됨을 의미합니다. 일반적으로 J의 동사는 원 자성이거나 전체 인수에 적용됩니다. 동사가 두 개의 인수를 갖는 dyadically로 사용되는 경우 두 인수에 모두 적용됩니다. 다음을 고려하세요:

     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
  

• #:숫자를 이진 표현으로 확장하는 동사입니다. 하나 이상의 요소가있는 목록에서 사용하면 모든 숫자가 올바르게 정렬되므로 #:i.2^n모든 길이의 이진 문자열을 얻을 수 있습니다 n.

• /.dyadically 사용될 때 Key 라고 합니다. 왼쪽에있는 목록의 요소를 키로 사용하고 오른쪽에있는 요소를 값으로 사용합니다. 키를 공유하는 각 값 세트를 그룹화 한 후 그에 대한 조작을 수행합니다.

  의 경우 ]/.연산은 ID 동사 일 뿐이므로 특별한 것은 발생하지 않지만 /.우리를 위해 목록을 분할 하는 사실 은 중요한 부분입니다. 이것이 우리가 이진 목록을 만드는 이유입니다. 그래서 각 목록 ( "1)에 대해 가능한 모든 방법으로 아내를위한 선물을 나눌 수 있습니다.

• 1!:1]1그리고 1!:2&2읽기 및 쓰기 동작이다. 1!:n부분은 동사이고 다른 숫자는 파일 핸들입니다. 1콘솔 입력, 2콘솔 출력, 3 4 5stdin, stdout 및 stderr입니다. 또한 ".읽을 때 입력 문자열을 숫자로 변환하기 위해 사용합니다.

클로저

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

테스트

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


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

MATLAB

내 해결책은 다음과 같습니다.

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

예를 들어 내 소스 코드의 현재 목록은 다음과 같습니다.

for_jennifer =

     8     2     5     1


for_kate =

     4     7     2     3

둘 다 16입니다.

내가 덜 재미있는 코드를 골프화하면 최적화되지 않은 132 개의 문자를 얻게됩니다. 이길;)

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

경고 : 매우 더러운 코드
입력 배열의 가능한 모든 순열을 시도합니다.

Ideone 샘플에 대한 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!');

파이썬 :

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]

또는 약간의 골프화 :

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]

또는 절반 라인은 메이크업 일뿐이므로 더 골프를칩니다. (이것은 op에 지정되어 있지 않기 때문에 원시 내부 배열을 덤프 할 수 있다고 가정합니다 print) 대화식 쉘을 그대로두고 [::-1](마지막 끝에 [0]) 추가 할 수 있습니다 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]

(결과 (0, ((1, 2, 7, 8), (3, 4, 5, 6))))

그러나 이것은 가능한 모든 조합을 무차별 적으로 수행하기 때문에 원격으로 효율적으로 간주해서는 안됩니다. 그러나 동일한 길이의 목록이 중요하지 않은 경우 (대형 배열에서) 작동합니다.

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

예를 들어이 코드를 사용하면 거의 차이가 거의 없습니다. 최대 10 ^ 10의 500k는별로 중요하지 않습니다. 이것은 훨씬 빠릅니다. 다른 코드가 1 년 안에 끝나지 않을 것입니다 (매우 낙관적 인 경우), 마일리지가 다를 수 있지만 약 0.5 초 안에 실행됩니다.

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

문학 하스켈

> import Data.List
> import Data.Function

목록 모나드를 사용하여 분할했습니다.

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

그런 다음 평가자를 만듭니다.

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

그런 다음 차이를 최소화하는 기능입니다.

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

그리고 그것들을 모두 결합한 것.

> bestDivison=best . divide

다음은 파서입니다.

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

그리고 출력 포맷터.

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

그리고 지금 프로그램

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

예:

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

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