एक छोटा और संतुलित मोबाइल बनाएं

Question

आपको वज़न का एक गुच्छा दिया जाता है, और आपका काम उन वज़न का उपयोग करके एक छोटा संतुलित मोबाइल बनाना है।

इनपुट 9, समावेशी के माध्यम से 1 रेंज में पूर्णांक भार की एक सूची है। डुप्लिकेट हो सकता है।

आउटपुट एक मोबाइल की एससीआई तस्वीर है, जिसे जब लटका दिया जाता है, तो वह संतुलित होता है। शायद सबसे अच्छा उदाहरण द्वारा दिखाया गया है:

इनपुट

3 8 9 7 5

संभव उत्पादन

         |
   +-----+---------+
   |               |
+--+-+        +----+------+
|    |        |           |
8   ++--+     7           5
    |   |
    9   3

आपको एससीआई पात्रों का उपयोग करना चाहिए जैसा कि दिखाया गया है। क्षैतिज और ऊर्ध्वाधर खंड किसी भी लम्बाई के हो सकते हैं। मोबाइल का कोई भी हिस्सा (क्षैतिज या लंबवत) मोबाइल के किसी अन्य भाग को स्पर्श नहीं कर सकता है। सभी वज़न को कम से कम 1 के लम्बवत खंड से लटका दिया जाना चाहिए, और एक ऊर्ध्वाधर खंड होना चाहिए जहाँ से पूरा मोबाइल लटका हुआ है।

एक मोबाइल के आकार की कुल संख्या है +, -और |वर्ण इसे बनाने की आवश्यकता है। निचले आकार बेहतर हैं।

आप एक सेगमेंट में जितने चाहें उतने कनेक्शन डाल सकते हैं। उदाहरण के लिए:

इनपुट

2 3 3 5 3 9

संभव उत्पादन

           |
   +---+---+-----------+
   |   |               |
+--+-+ 5               9
|  | |
2  | 3
   |
  +++
  | |
  3 3

जीतने का कार्यक्रम वह है जो इनपुट के परीक्षण सेट के लिए सबसे कम औसत मोबाइल आकार उत्पन्न कर सकता है। हार्ड-कोडिंग को रोकने के लिए वास्तविक परीक्षण सुपर-सीक्रेट है, लेकिन यह कुछ इस तरह होगा:

8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 7
1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 7 7
3 4 4 4 4 5 5 5 5 6 6 6 6 7 7 7 7

Comments

भौतिकी भी शामिल है?

— आप

@ S.Mark: मुझे लगता है कि आप कह सकते हैं। शारीरिक रूप से कमजोर लोगों के लिए, total_weight_hung_from_point * distance_of_point_from_pivotधुरी बिंदु के दोनों किनारों पर समान होना चाहिए।

— कीथ रान्डेल

शायद आरेखों की जांच करना आसान बनाने के लिए, ताकि एक बार लगभग दो हाइफ़न के बराबर हो? यह खड़ा है, अपने आरेख संतुलन से बाहर देखो।

— थॉमस ओ

Answer 1

अजगर २।

मैं थोड़ा धोखा दे रहा हूं :

• मैं केवल एक क्षैतिज के साथ मोबाइल का निर्माण करता हूं। मुझे लगता है है (लेकिन मैं यह साबित नहीं किया है) कि दिए गए शर्तों के तहत इष्टतम मोबाइल वास्तव में हमेशा करता है केवल एक क्षैतिज है। संपादित करें: हमेशा सच नहीं; 2 2 9 1नब्ब के साथ नीचे टिप्पणी में एक प्रति-उदाहरण मिला है:

  Size 18:                Size 16:
     |                        |
  +-++--+-----+            +--++-+
  | |   |     |            |   | |
  2 9   2     1           -+-  9 1
                          | |
                          2 2
  

• मैं सिर्फ बेवकूफाना क्रूरता करता हूं:

  1. दिए गए वज़न को बेतरतीब ढंग से हिलाया जाता है।
  2. एक समय में दो वज़न को मोबाइल पर सबसे अच्छी स्थिति में रखा जाता है जैसे कि यह संतुलित रहता है।
  3. यदि परिणामी मोबाइल पहले की तुलना में बेहतर है, तो उसे याद रखें।
  4. कुल्ला और दोहराएं, जब तक कि पूर्व-निर्धारित संख्या सेकंड तक न हो।

आपके नमूना इनपुट के लिए मेरे परिणाम; प्रत्येक को 5 सेकंड के लिए चलाया गया था (मुझे पता है कि यह छोटे लोगों के लिए हास्यास्पद है - बस सभी संभावित क्रमों से गुजरना तेज होगा)। ध्यान दें कि चूंकि एक यादृच्छिक तत्व है, इसलिए बाद के रन बेहतर या बदतर परिणाम प्राप्त कर सकते हैं।

3 8 9 7 5
Tested 107887 mobiles, smallest size 20:
        |
+-+-----+-+--+
| |     | |  |
5 3     7 9  8

2 3 3 5 3 9
Tested 57915 mobiles, smallest size 23:
      |
+--+-++--+-+---+
|  | |   | |   |
3  5 9   3 3   2

8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 7
Tested 11992 mobiles, smallest size 50:
                |
+-+-+-+--+-+-+-+++-+-+--+-+-+-+-+
| | | |  | | | | | | |  | | | | |
8 8 8 8  8 8 8 8 8 8 8  7 8 8 8 8

1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 7 7
Tested 11119 mobiles, smallest size 62:
                    |
+-+-+-+-+-+--+-+-+-+++-+-+-+--+-+-+-+-+-+
| | | | | |  | | | | | | | |  | | | | | |
2 7 5 6 6 8  3 2 3 7 9 7 8 1  1 7 9 5 4 4

3 4 4 4 4 5 5 5 5 6 6 6 6 7 7 7 7
Tested 16301 mobiles, smallest size 51:
                |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| | | | | | | | | | | | | | | | |
4 6 5 7 7 4 6 5 3 5 6 4 7 6 7 5 4

कोड (क्रिया, क्योंकि यह कोड गोल्फ नहीं है):

import time, random

def gcd(a, b):
    while b > 0:
        a, b = b, a % b
    return a

class Mobile(object):
    def __init__(self):
        self.contents = [None];
        self.pivot = 0;

    def addWeights(self, w1, w2):
        g = gcd(w1, w2)
        m1 = w2 / g
        m2 = w1 / g
        mul = 0
        p1 = -1
        while True:
            if p1 < 0:
                mul += 1
                p1 = mul * m1
                p2 = -mul * m2
            else:
                p1 *= -1
                p2 *= -1
            if self.free(p1) and self.free(p2):
                self.add(w1, p1)
                self.add(w2, p2)
                return

    def add(self, w, pos):
        listindex = self.pivot - pos 
        if listindex < 0:
            self.contents = [w] + (abs(listindex) - 1) * [None] + self.contents
            self.pivot += abs(listindex)
        elif listindex >= len(self.contents):
            self.contents += (listindex - len(self.contents)) * [None] + [w]
        else:
            self.contents[listindex] = w

    def at(self, pos):
        listindex = self.pivot - pos
        if 0 <= listindex < len(self.contents):
            return self.contents[listindex]
        return None

    def free(self, pos):
        return all(self.at(pos + d) is None for d in (-1, 0, 1))

    def score(self):
        return 1 + 2 * len(self.contents) - self.contents.count(None)

    def draw(self):
        print self.pivot * " " + "|"
        print "".join("+" if c is not None or i == self.pivot else "-" for i, c in enumerate(self.contents))
        print "".join("|" if c is not None else " " for c in self.contents)
        print "".join(str(c) if c is not None else " " for c in self.contents)

    def assertBalance(self):
        assert sum((i - self.pivot) * (c or 0) for i, c in enumerate(self.contents)) == 0


weights = map(int, raw_input().split())

best = None
count = 0

# change the 5 to the number of seconds that are acceptable
until = time.time() + 5

while time.time() < until:
    count += 1
    m = Mobile()

    # create a random permutation of the weights
    perm = list(weights)
    random.shuffle(perm)

    if len(perm) % 2:
        # uneven number of weights -- place one in the middle
        m.add(perm.pop(), 0)

    while perm:
        m.addWeights(perm.pop(), perm.pop())

    m.assertBalance() # just to prove the algorithm is correct :)
    s = m.score()
    if best is None or s < bestScore:
        best = m
        bestScore = s

print "Tested %d mobiles, smallest size %d:" % (count, best.score())
best.draw()

Comments

@ नब: 9 से अधिक वजन संभव नहीं है। जैसा कि 1 9 2 8यह उत्पन्न करता है 1-------8+-9--2; मेरे सिर के ऊपर से मैं कुछ भी बेहतर नहीं कर सकता (लेकिन मैं उस पर भरोसा नहीं करेगा) - क्या आपके पास कुछ है?

— बेलफा

@balpha: जब मैंने पहले टिप्पणी की थी, तो कोई बात नहीं। मैंने किसी कारण से सोचा कि आप उन्हें 1-9 और 2-8 पर रोक सकते हैं, लेकिन जाहिर है कि वे जोड़े खुद को संतुलित नहीं करते हैं!

— नब

ठीक है, यहाँ एक है कि वास्तव में कई परतों के साथ बेहतर हो सकता है: 2 2 9 1यानी (2 + 2) * 3 = 9 + 1 * 3 16 आकार के लिए 2-9+--2----1जिसके बजाय 18 है। मुझे लगता है कि वहाँ एक सीमा है (शायद 5 या 6) ) जिसके बाद एक एकल क्षैतिज पंक्ति हमेशा इष्टतम होती है।

— नब

@ नब: हां; यह वास्तव में एक अच्छा प्रति-उदाहरण है।

— बाल्फा

@ नब, 2-2-+9-113 के स्कोर के साथ संतुलन के साथ एक बार (4*2+2*2 = 9*1+1*3)। इसलिए मुझे नहीं लगता कि कोई एक अच्छा प्रतिरूप है।

— कीथ रान्डेल

Answer 2

वैसे यह एक पुराना सवाल है, लेकिन मैंने अभी इसे शीर्ष सवालों के टैब में देखा है इसलिए यहां मेरा (इष्टतम) समाधान है:

#include <stdio.h>
#include <limits.h>
#include <math.h>
#include <stdlib.h>

int main(int argc, const char *const *argv) {
    if(argc < 2) {
        fprintf(stderr,
            "Balances weights on a hanging mobile\n\n"
            "Usage: %s <weight1> [<weight2> [...]]\n",
            argv[0]
        );
        return 1;
    }
    int total = argc - 1;
    int values[total];
    int maxval = 0;
    for(int n = 0; n < total; ++ n) {
        char *check = NULL;
        long v = strtol(argv[n+1], &check, 10);
        if(v <= 0 || v > INT_MAX || *check != '\0') {
            fprintf(stderr,
                "Weight #%d (%s) is not an integer within (0 %d]\n",
                n + 1, argv[n+1], INT_MAX
            );
            return 1;
        }
        values[n] = (int) v;
        if(values[n] > maxval) {
            maxval = values[n];
        }
    }
    int maxwidth = (int) log10(maxval) + 1;
    for(int n = 0; n < total; ++ n) {
        int width = (int) log10(values[n]) + 1;
        fprintf(stdout,
            "%*s\n%*d\n",
            (maxwidth + 1) / 2, "|",
            (maxwidth + width) / 2, values[n]
        );
    }
    return 0;
}

नियमों को देखने से मुझे यकीन है कि यह धोखा नहीं है, हालांकि ऐसा लगता है कि यह ऐसा है। यह सभी दी गई संख्याओं को केवल एक ऊर्ध्वाधर श्रृंखला में 2 * number_of_inputs की कुल लागत के लिए आउटपुट करेगा (जो कि न्यूनतम संभव है क्योंकि प्रत्येक संख्या के ऊपर एक बार होना चाहिए, इससे कोई फर्क नहीं पड़ता कि लेआउट क्या है)। यहाँ एक उदाहरण है:

./mobile 3 8 9 7 5

पैदा करता है:

|
3
|
8
|
9
|
7
|
5

जो बिल्कुल सही संतुलन में है।

---

_{मैं मूल रूप से इस चुनौती की भावना में कुछ और करने की कोशिश कर रहा था, लेकिन यह जल्दी से पता चला कि यह अभी भी इस संरचना से दूर अनुकूलित है}

Comments

शायद मेरे विवरण से स्पष्ट नहीं है, लेकिन आप |एक वजन के नीचे से कनेक्ट नहीं कर सकते ।

— कीथ रान्डेल

@KeithRandall आह ठीक है; इसे ध्यान में रखते हुए मुझे इसे ठीक से हल करना होगा।

— डेव

Answer 3

यहाँ एक समाधान है जो जानवर सबसे छोटी एकल पंक्ति समाधान को मजबूर करता है। कोड सभी क्रमपरिवर्तन पर आधारित है और प्रत्येक के लिए द्रव्यमान के केंद्र की गणना करता है। यदि द्रव्यमान के केंद्र में पूर्णांक निर्देशांक हैं, तो हमें एक समाधान मिला है।

सभी क्रमपरिवर्तन की कोशिश करने के बाद, हम वेट और रिट्रीट के अपने वर्तमान सेट में मिक्स सेगमेंट (मास 0 ​​के वजन के बराबर) जोड़ते हैं।

प्रोग्राम को चलाने के लिए, करें python balance.py 1 2 2 4।

#!/usr/bin/env python3
import itertools, sys

# taken from http://stackoverflow.com/a/30558049/436792
def unique_permutations(elements):
    if len(elements) == 1:
        yield (elements[0],)
    else:
        unique_elements = set(elements)
        for first_element in unique_elements:
            remaining_elements = list(elements)
            remaining_elements.remove(first_element)
            for sub_permutation in unique_permutations(remaining_elements):
                yield (first_element,) + sub_permutation

def print_solution(cm, values):
    print(('  ' * cm) + '|')
    print('-'.join(['-' if v == 0 else '+'  for v in values]))
    print(' '.join([' ' if v == 0 else '|'  for v in values]))
    print(' '.join([' ' if v == 0 else str(v) for v in values]))



input = list(map(int, sys.argv[1:]))
mass = sum(input)
while True:
    n = len(input)
    permutations = filter(lambda p: p[0] != 0 and p[n-1] != 0, unique_permutations(input))
    for p in permutations:
        cm = 0
        for i in range(n):
            cm += p[i] * i;
        if (cm % mass == 0):
            print_solution(cm//mass, p)
            sys.exit(0)
    input.append(0)

जो इन बेहतरीन समाधानों का उत्पादन करता है:

    |
+-+-+-+-+
| | | | |
8 3 9 5 7


    |
+-+-+-+-+-+
| | | | | |
9 2 3 5 3 3

                |
+-+-+-+-+-+-+---+-+-+-+-+-+-+-+-+
| | | | | | |   | | | | | | | | |
8 8 8 8 8 8 8   8 8 8 8 8 8 8 8 7


                        |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| | | | | | | | | | | | | | | | | | | |
1 1 2 2 3 3 4 4 8 8 5 5 6 6 7 7 7 7 9 9


                  |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| | | | | | | | | | | | | | | | |
3 4 4 4 4 5 5 5 5 6 7 6 7 7 7 6 6

Answer 4

अजगर ३

यह किसी भी परीक्षण मामलों पर इष्टतम से 1 से अधिक बदतर नहीं है, मुझे विश्वास है, और 5 सेकंड में ऐसा करता है।

मूल रूप से, मैं एक एकल बार दृष्टिकोण का उपयोग करता हूं। मैं बेतरतीब ढंग से इनपुट का आदेश देता हूं, फिर एक बार में एक बार में वजन डालें। प्रत्येक तत्व को या तो उस स्थिति में रखा जाता है जो दोनों तरफ के अतिरिक्त वजन को कम करता है, या उस दृष्टिकोण से दूसरी सबसे अच्छी स्थिति है, पूर्व 75% समय और बाद के 25% समय का उपयोग करते हुए। फिर, मैं जांच करता हूं कि क्या मोबाइल अंत में संतुलित है, और अब तक मिले सबसे अच्छे मोबाइल से बेहतर है। मैं सबसे अच्छा स्टोर करता हूं, फिर खोज के 5 सेकंड के बाद इसे रोक देता हूं और प्रिंट करता हूं।

परिणाम, 5 सेकंड में:

py mobile.py <<< '3 8 7 5 9'
Best mobile found, score 15:
    |    
+-+-+-+-+
| | | | |
8 7 3 5 9
py mobile.py <<< '2 2 1 9'
Best mobile found, score 13:
   |    
+-++-+-+
| |  | |
1 9  2 2
py mobile.py <<< '2 3 3 5 3 9'
Best mobile found, score 18:
      |    
+-+-+-+-+-+
| | | | | |
2 3 3 5 9 3
py mobile.py <<< '8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 7'
Best mobile found, score 49:
                |               
+-+--+-+-+-+-+-+++-+-+-+-+-+-+-+
| |  | | | | | | | | | | | | | |
7 8  8 8 8 8 8 8 8 8 8 8 8 8 8 8
\py mobile.py <<< '1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 7 7'
Best mobile found, score 61:
                    |                   
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+--+
| | | | | | | | | | | | | | | | | | |  |
1 7 7 5 4 3 1 9 6 7 8 2 2 9 3 7 6 5 8  4
py mobile.py <<< '3 4 4 4 4 5 5 5 5 6 6 6 6 7 7 7 7'
Best mobile found, score 51:
                |                
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| | | | | | | | | | | | | | | | |
4 4 6 7 7 4 5 7 6 6 5 4 6 3 5 5 7

कोड:

import random
import time

class Mobile:
    def __init__(self):
        self.contents = {}
        self.lean = 0

    def usable(self, loc):
        return not any(loc + k in self.contents for k in (-1,0,1))
    def choose_point(self, w):
        def goodness(loc):
            return abs(self.lean + w * loc)
        gl = sorted(list(filter(self.usable,range(min(self.contents.keys() or [0]) - 5,max(self.contents.keys() or [0]) + 6))), key=goodness)
        return random.choice((gl[0], gl[0], gl[0], gl[1]))

    def add(self, w, loc):
        self.contents[loc] = w
        self.lean += w*loc

    def __repr__(self):
        width = range(min(self.contents.keys()), max(self.contents.keys()) + 1)
        return '\n'.join((''.join(' ' if loc else '|' for loc in width),
                          ''.join('+' if loc in self.contents or loc == 0 else '-' for loc in width),
                          ''.join('|' if loc in self.contents else ' ' for loc in width),
                          ''.join(str(self.contents.get(loc, ' ')) for loc in width)))

    def score(self):
        return max(self.contents.keys()) - min(self.contents.keys()) + len(self.contents) + 2

    def my_score(self):
        return max(self.contents.keys()) - min(self.contents.keys()) + 1

best = 1000000
best_mob = None
in_weights = list(map(int,input().split()))
time.clock()
while time.clock() < 5:
    mob = Mobile()
    for insert in random.sample(in_weights, len(in_weights)):
        mob.add(insert, mob.choose_point(insert))
    if not mob.lean:
        if mob.score() < best:
            best = mob.score()
            best_mob = mob

print("Best mobile found, score %d:" % best_mob.score())
print(best_mob)

इन समाधानों में से केवल एक जो मुझे लगता है कि सबॉप्टिमल सबसे लंबा है, जिसका यह समाधान है, जिसे मैंने 10 मिनट के बाद पाया:

Best mobile found, score 60:
                   |                   
+-+-+-+-+-+-+-+-+-+++-+-+-+-+-+-+-+-+-+
| | | | | | | | | | | | | | | | | | | |
3 2 9 4 7 8 1 6 9 8 7 1 6 2 4 5 7 3 5 7