ভাগ করুন এবং সুখী থাকুন। কে বিজয়ী অংশ সম্পর্কে যত্নশীল?

12

ঠিক আছে, যখন আমি আমার দুই স্ত্রীর জন্য উপহার কিনে থাকি, আমি চাই তারা আমার কাছে সমান গুরুত্বপূর্ণ বোধ করবে তবে নির্দিষ্ট বাজেটের সাথে কেনাকাটা করা খুব কঠিন hard পরিবর্তে, আমি একটি গুচ্ছ জিনিস কিনে এবং যথাসম্ভব সমান মান সহ তাদের দুটি গ্রুপে বিভক্ত করি। তারপরে বাকীটি ঠিক করার জন্য আমি একগুচ্ছ চকোলেট কিনেছি।

আমার কম্পিউটার যখন এটি করতে পারে তবে আমি সব হার্ড লিফটিং করতে চাই না। এবং আপনি না। সুতরাং এই সমস্যাটি সমাধান করুন যাতে পরের বার আপনার স্ত্রীর মধ্যে উপহারগুলি ভাগ করার প্রয়োজন হয় তবে আপনি জানেন যে এটি সহজ হবে।

ইনপুট

(এন * 2) উপাদানের 1 অ্যারে যেখানে এন * 2 টি প্রথম লাইনে নির্দিষ্ট করা আছে।
নিম্নলিখিত লাইনে অ্যারের উপাদানগুলি।

আউটপুট

2 এন অ্যারের প্রতিটি অ্যারে যেমন:
পার্থক্য (অ্যারে 1 এর উপাদানের যোগফল) এবং (অ্যারে 2 এর উপাদানের যোগফল) যতটা সম্ভব 0 এর কাছাকাছি।

উদাহরণ

ইনপুট

4
1 2 3 4

আউটপুট

1 4
2 3
diff=0

দাবি অস্বীকার : আমার দুটি স্ত্রী নেই have তবে আমার যখন খারাপ লাগে তখন আমি দু'জন স্ত্রী রাখে। এবং হঠাৎ, আমি কৃতজ্ঞ এবং খুশী যে আমার একটাই আছে। : ডি

popularity-contest 
— rahulroy9202
সূত্র
3
যেমনটি দাঁড়িয়েছে, "প্রতিটি এন এলিমেন্টের 2 টি অ্যারে" গ্রুপগুলিও আকারে সমান হতে বাধ্য করে। এটা কি উদ্দেশ্য? ইনপুট দলের জন্য মুহূর্তে উদাহরণস্বরূপ 1 1 1 1 1 5সঠিক উত্তর হবে 1 1 1| 1 1 5, যখন 1 1 1 1 1| 5আরও বুদ্ধি করতে হবে।
— shiona 8'14
অনুমান করুন সমস্যাটি যমজ এবং সম্ভবত অন্যান্য শিশু-নক্ষত্রগুলির ক্ষেত্রেও প্রযোজ্য। ক্রিসমাস আজ বেশিরভাগই 'তিনি আমার চেয়ে বেশি পেয়েছেন'-ইভেন্ট ...
— TheConstructor
1
@ শিওনা, হ্যাঁ, সমান আকারের উদ্দেশ্য। @ দ্য কনস্ট্রাক্টর, বাচ্চাদের মধ্যে বিভক্ত হওয়া দুই স্ত্রীর মধ্যে বিভক্ত হওয়ার মতো মজাদার নয়। : ডি
— rahulroy9202
ট্যাগ কোড-চ্যালেঞ্জের জন্য একটি উদ্দেশ্যমূলক বিজয়ী মানদণ্ড প্রয়োজন। এছাড়াও এটি সাবসেট সমষ্টি সমস্যার সাথে নিবিড়ভাবে সম্পর্কিত যা এখানে এখানে আগে জিজ্ঞাসা করা হয়েছিল।
— হাওয়ার্ড
@ সংখ্যার সাবসেটের জন্য গুরুত্বপূর্ণ পার্থক্য রয়েছে: আপনাকে দুটি সমান আকারের তালিকা তৈরি করতে হবে (কেবল সমান মূল্যবান নয়), আপনাকে সমস্ত উপাদান ব্যবহার করতে হবে, ...
— TheConstructor

উত্তর:

4

জাভা

এই সমস্যাটি দুটি পর্যায়ে সমাধান করার চেষ্টা করা হচ্ছে:

  1. বর্তমানের ছোট তালিকায় অবশিষ্ট বৃহত্তমটিকে এবং অন্যটির পরবর্তীটিতে দুটি সমান আকারের তালিকা তৈরি করুন। পদ্ধতি পুনরাবৃত্তি করুন।
  2. উভয় তালিকার আইটেমগুলি সনাক্ত করুন যা মানের পার্থক্য হ্রাস করতে স্যুইচ করা যায়

ইনপুট পছন্দ

8
1 2 3 4 5 6 7 8

ইতিমধ্যে উদাহরণস্বরূপ প্রথম পর্বের পরে ইতিমধ্যে সমাধান করা হয়েছে

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 6 8
4 5 7
diff=1

যদিও আমি এই গ্যারান্টি দিতে পারি যে এই প্রচেষ্টা সর্বদা একটি সমাধান সরবরাহ করবে, আমি প্রমাণ করতে পারি না যে সব ক্ষেত্রেই একটি অনুকূল সমাধান পাওয়া যায়। সমান আকারের তালিকাগুলির সীমাবদ্ধতার সাথে এটি বেশ বাস্তববাদী মনে হয় যে পিছনে কোনও কোণার মামলা নেই। আমাকে ভুল প্রমাণিত কর ;-)

আইডোন.কম এ প্রোগ্রাম on

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(' ');
            }
        }
    }
}
— TheConstructor
সূত্র
3

ব্র্যাচল্যাগ 2

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

এটি অনলাইন চেষ্টা করুন!

এটি একটি জনপ্রিয়তা প্রতিযোগিতা, তবে এর অর্থ এই নয় যে গল্ফিংয়ের ভাষাগুলি একটি খারাপ ফিট। (সত্যিই, আমার জেলির উত্তর দেওয়া উচিত ছিল কারণ জেলি উত্তরগুলি যে কোনও কারণে তাদের জমা দেয় বা তারা কতটা গল্ফ হয় তা নির্বিশেষে কিছু কারণে অসমসংখ্যক উপাখ্যান পেয়ে থাকে তবে ব্র্যাচ্ল্যাগ আরও পাঠযোগ্য)

আমরা ইনপুট ( pᶠ) এর সমস্ত অনুমোদনের তালিকা গ্রহণ করে এবং প্রতিটি ( ᵐ) দুটি সমান টুকরো টুকরো করে বিভক্ত ḍকরতে শুরু করি ( ; যদি কোনও কারণে আপনার আরও দু'জন স্ত্রী থাকতেন তবে আমরা এটিকে সাবস্ক্রিপ্ট দিতে পারি)। তারপরে আমরা প্রতিটি ( ) অর্ধের {…}ᵒযোগফল ( +) অর্থে ᵐনিখুঁত পার্থক্য (অর্থাত্ o-"অর্ডার করা পার্থক্য") গ্রহণ করে এবং এই তফাতগুলি ব্যবহার করে সাজানোর ক্রম সংজ্ঞায়িত করে বিভক্ত ক্রমগুলি অর্ডার করি। সেরা ফলাফল প্রথমটি, সুতরাং আমরা hফলাফলটি পেতে তালিকার শীর্ষস্থানীয় ।

2

ম্যাথামেটিকাল

ইনপুট ফর্ম

ইনপুট স্ট্রিংটি 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]]]}}]

r20

বিতরণ কি অন্যায্য? সুতরাং, অন্য একটি চয়ন করুন।

@ দ্য কনস্ট্রাক্টর নোট করেছেন যে স্ত্রী 2 এই প্রতিযোগিতা করতে পারে যে স্ত্রী 1 সর্বোত্তম সম্পত্তি পেয়েছে। সুতরাং নীচে স্ত্রীর 1 টির জন্য "মেলা" (পার্থক্য = সর্বনিম্ন পার্থক্য) এর সমস্ত ভাগ উত্পাদন করে; স্ত্রী 2 বাকী সম্পত্তি পান; শূন্য স্ত্রীর সম্পদের পার্থক্য বোঝায়। 1 থেকে 20 এর মধ্যে ওজনের সম্পদ বিতরণ করার জন্য 5448 টি উপায় রয়েছে Only মাত্র কয়েকটি লাইন প্রদর্শিত হয়।

বিন্যাসটি হ'ল 

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।

— DavidC
সূত্র
ম্যাথমেটিকাকে এমন কাজের জন্য সুন্দর বলে মনে হয়। একটি শেষ কথা হ'ল আসল স্ত্রীরা সম্ভবত যুক্তি দিতেন যেহেতু 5 অতি মূল্যবান আইটেমগুলি একটি স্ট্যাকের মধ্যে রয়েছে। (হ্যাঁ মঞ্জুর হয়েছে, 1 থেকে 20 এর সাথে যুক্তির জন্য জায়গা ছাড়া কোনও সমাধান নেই)
— TheConstructor
@ প্রকৃতপক্ষে, সম্পদ বিতরণ করার বেশ কয়েকটি উপায় রয়েছে। আমি একটি সংযোজন কিছু উপায় তালিকাভুক্ত। দ্রষ্টব্য: কেবলমাত্র এক স্ত্রীর সম্পদ তালিকাভুক্ত; অন্য পরিপূরক পায়।
— ডেভিডসি
আমি যেমন করি তেমন একটি কারণ আমার ইনটিনাল স্ট্যাকগুলি বানাতে বেছে নিলাম: তাই সাধারণত দুটি সর্বাধিক মূল্যবান জিনিস একই স্ট্যাকের উপর থাকে না। আপনার প্রাথমিক সমাধানটি প্রমাণ করে যে 21 টি যোগফলের সাথে 10 জোড়া সংখ্যার রয়েছে; আপনি স্পষ্টতই পরপর জোড়া বেছে নিন।
— দ্য কনস্ট্রাক্টর
হ্যাঁ, আমি আপনার পদ্ধতির যুক্তির প্রশংসা করি।
— ডেভিডসি
2

জে

আপনি ঘরে বসে অনুসরণ করতে চান তবে এই লিঙ্কটিতে সমস্ত জে আদিমতার একটি চিট শীট রয়েছে । মনে রাখবেন: জে সাধারণত ডান থেকে বামে পড়া হয়, সুতরাং এটি 3*2+17, নয় Every। প্রতিটি ক্রিয়া (ফাংশনটির জন্য জে) হয় মনাদিক, সুতরাং সামনে যেমন f y, বা ডায়াডিক হয় তাই লাইকের মাঝে থাকে 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ওভার", সুতরাং তালিকার প্রতিটি উপাদানের উপর বাইনারি অপারেশন করুন। সুতরাং উদাহরণস্বরূপ: +/মানে ভাঁজ প্লাস , অথবা যোগফল ; <.হয় কম তাই হয়, <./মানে কম ভাঁজ , অথবা নূন্যতম ।

  • u"1মানে " u1-মাত্রিক কক্ষগুলিতে সঞ্চালন করুন", অর্থাৎ প্রতিটি সারিতে। সাধারণত জেতে ক্রিয়াগুলি হয় পারমাণবিক, বা পুরো যুক্তিতে প্রয়োগ হয়। ক্রিয়াটি dyadally ব্যবহার করা হয় (দুটি যুক্তি সহ) যদি এটি উভয় যুক্তির ক্ষেত্রে প্রযোজ্য। নিম্নোক্ত বিবেচনা কর:

       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 ব্যবহার করা হয়, তখন তাকে কী বলে । এটি তালিকার উপাদানগুলি বাম পাশে কী হিসাবে এবং ডানদিকে থাকা মানকে ব্যবহার করে। এটি প্রতিটি মানকে এক সাথে ভাগ করে দেয় যা একটি কী ভাগ করে এবং তারপরে সেগুলি কিছু পরিচালনা করে।

    এর ক্ষেত্রে ]/., অপারেশনটি কেবল পরিচয় ক্রিয়া, তাই সেখানে বিশেষভাবে কিছুই ঘটছে না, তবে /.আমাদের তালিকাকে ভাগ করে নেবে এই বিষয়টি গুরুত্বপূর্ণ বিষয়। এ কারণেই আমরা বাইনারি তালিকাগুলি তৈরি করি: যাতে প্রতিটি তালিকার জন্য ( "1), আমরা স্ত্রীর জন্য সমস্ত সম্ভাব্য উপায়ে উপহারগুলি প্রকাশ করতে পারি।

  • 1!:1]1এবং 1!:2&2যথাক্রমে পঠন এবং লিখনের কাজ রয়েছে। 1!:nঅংশ ক্রিয়া এবং অন্যান্য সংখ্যা ফাইল হ্যান্ডেল। 1কনসোল ইন, 2কনসোল আউট, এবং 3 4 5স্টিডিন, স্টাডআউট এবং স্ট্ডার। আমরা ".পড়ার সময়ও ব্যবহার করি যাতে আমরা ইনপুট স্ট্রিংগুলিকে সংখ্যায় রূপান্তর করি।

— algorithmshark
সূত্র
1
জেতে উত্তর জমা দেওয়ার জন্য +1 এবং এটি বোধগম্য হওয়ার জন্য সর্বনিম্ন চেষ্টা করুন।
— স্তরের নদী সেন্ট
1

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

পরীক্ষা 

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


 =: [89 -4 1 2]
    [36 20 7 5]
    Diff 20
— মামুন
সূত্র
ফলাফল সেটগুলি সমান আকারের হওয়া উচিত এবং প্রতিটি সেটের অভ্যন্তরের মানগুলির মধ্যে পার্থক্য মুদ্রণ করা উচিত। আদর্শের উপর দ্রুত পরীক্ষার ফলাফল বিচার করে আপনি উভয়
— পয়েন্টই
ফলাফল মুদ্রণের জন্য প্রদর্শন পদ্ধতি যুক্ত করুন।
— মামুন
ফলাফল এখন সমান আকার সেট
— মামুন
জন্য [1 4 5 6 7 8]আপনার প্রোগ্রাম গণনা [8 5 4] [7 6 1] Diff 3যেখানে পরিষ্কারভাবে 1 থাকবেই পার্থক্য সঙ্গে সমাধান।
— দ্য কনস্ট্রাক্টর
1

ম্যাটল্যাব

এখানে আমার সমাধান:

%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 অক্ষর পাই get যে বীট ;)

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{:}
— mmumboss
সূত্র
ইনপুট অ্যারে অবশ্যই বর্গক্ষেত্র হতে হবে।
— ডেভিডসি
না, বর্গ নয়? তবে এখন আমি দেখছি আইটেমের সংখ্যাটি প্রথম সারিতে হওয়া উচিত। আমি এটা পরিবর্তন করব।
— মিমমবস
0

পিএইচপি

সতর্কতা: খুব নোংরা কোড
এটি ইনপুট অ্যারের প্রতিটি সম্ভাব্য ক্রমুবর্তন চেষ্টা করে।

আইডিয়নের নমুনা 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!');
— ComFreek
সূত্র
0

পাইথন:

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]

অথবা আরও গল্ফাইফাইড, যেহেতু অর্ধেক রেখাগুলি কেবল মেকআপ হয়। (ধরে নিলাম আমি কেবল কাঁচা অভ্যন্তরীণ অ্যারেটি ফেলে দিতে পারি, কারণ এটি অপারেটে নির্দিষ্ট করা হয়নি) আপনি printইন্টারেক্টিভ শেলটি (উদাহরণস্বরূপ) এড়িয়ে যেতে পারেন এবং আপনি যদি সত্যিই চান তবে একটি যুক্ত করতে পারেন [::-1](একেবারে শেষে, পরে [0]) ডিফ শেষ।

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 k 10 সর্বাধিক মানের উপরে 500k খুব বেশি নয়, তাই বলে। এটিও অনেক দ্রুত: যেখানে অন্য কোডটি সম্ভবত এক বছরের অধীনে শেষ হয় না (এবং এটি খুব আশাবাদী), এটি আপনার মাইলেজ পরিবর্তিত হতে পারে, যদিও এটি প্রায় অর্ধেক সেকেন্ডে চলে।

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))
— সিনথেটিকা
সূত্র
প্রশ্ন: কেন এটি সিডব্লিউ পোস্ট?
— হাইপারনিউট্রিনো
0

সাহিত্যিক হাস্কেল

> 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
— PyRulez
সূত্র
ফলাফল সেটগুলি সমান আকারের হওয়া উচিত
— TheConstructor
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.