सबसे खराब मामला मैनहट्टन बहिष्कार

20

वर्गों के एच ग्रिड द्वारा एक डब्ल्यू की कल्पना करें जो टॉरॉयड रूप से लपेटता है। आइटम ग्रिड पर इस प्रकार रखे गए हैं।

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

यहाँ एक त्रिज्या 5 बहिष्करण क्षेत्र है:

त्रिज्या 5 बहिष्करण क्षेत्र

यहां एक और त्रिज्या 5 बहिष्करण क्षेत्र है, इस बार किनारों के पास इसलिए लपेटने वाला व्यवहार स्पष्ट है:

रैपिंग त्रिज्या 5 बहिष्करण क्षेत्र

इनपुट

तीन पूर्णांक:

  • डब्ल्यू : ग्रिड की चौड़ाई (सकारात्मक पूर्णांक)
  • एच : ग्रिड की ऊंचाई (सकारात्मक पूर्णांक)
  • आर : बहिष्करण क्षेत्र की त्रिज्या (गैर-नकारात्मक पूर्णांक)

उत्पादन

एक पूर्णांक N , जो कि सबसे छोटी संख्या में आइटम है जिसे किसी भी अन्य मान्य प्लेसमेंट को रोकने के लिए रखा जा सकता है।

विवरण

  • शून्य का एक त्रिज्या 1 वर्ग का एक बहिष्करण क्षेत्र देता है (जिस पर एक आइटम रखा गया था)।
  • एन का एक त्रिज्या उस क्षेत्र को बाहर करता है जिसे एन ऑर्थोगोनल चरणों में पहुंचाया जा सकता है (याद रखें कि किनारों को धड़ से लपेटें)।

आपका कोड R = 0 के तुच्छ मामले के लिए काम करना चाहिए , लेकिन W = 0 या H = 0 के लिए काम करने की आवश्यकता नहीं है ।

आपका कोड उस मामले से भी निपटना चाहिए जहां R > W या R > H है ।

समय सीमा और परीक्षण के मामले

आपका कोड सभी परीक्षण मामलों से निपटने में सक्षम होना चाहिए, और प्रत्येक परीक्षण मामले को 5 मिनट के भीतर पूरा करना होगा। यह आसान होना चाहिए (उदाहरण जावास्क्रिप्ट समाधान प्रत्येक परीक्षण मामले के लिए कुछ सेकंड लेता है)। चरम सीमा बल दृष्टिकोण को बाहर करने के लिए समय सीमा मुख्य रूप से है। उदाहरण दृष्टिकोण अभी भी काफी क्रूर बल है।

यदि आपका कोड एक मशीन पर 5 मिनट के भीतर पूरा हो जाता है, लेकिन दूसरे पर नहीं जो काफी करीब होगा।

प्रपत्र इनपुट में परीक्षण के मामले : आउटपुट के रूप मेंW H R : N

5 4 4 : 1
5 4 3 : 2
5 4 2 : 2
5 4 1 : 5

7 5 5 : 1
7 5 4 : 2
7 5 3 : 2
7 5 2 : 4

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

 7  6  4 : 2
 7  6  2 : 4
11  7  4 : 3
11  9  4 : 4
13 13  6 : 3
11 11  5 : 3
15 14  7 : 2
16 16  8 : 2

विचारों के साथ कल्पना और खेलने में मदद करने के लिए स्निपेट

कोड स्निपेट दिखाएं

उदाहरण (ungolfed) समाधान

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

कोड स्निपेट दिखाएं

code-golf  geometry  grid  packing 
— trichoplax
स्रोत
4
बहुत बढ़िया कोड स्निपेट!
— स्ट्रेच मैनीक्योर
@StretchManiac धन्यवाद :) मैं जावास्क्रिप्ट सीखने की कोशिश कर रहा हूँ ताकि किसी भी प्रतिक्रिया का स्वागत हो
— ट्रिकोप्लाक्स
1
यह एक बहुत अच्छा स्निपेट है। मुझे वह रंग योजना भी पसंद है। क्या यह एक पैलेट से है?
— मील
@ मीलों आपको धन्यवाद - रंगों का केवल अनुमान लगाया जाता है और फिर ठीक से थोड़ा सा ट्यून किया जाता है (लेकिन ज्यादा नहीं - वे अभी भी 6 के बजाय सभी 3 वर्ण रंग कोड हैं)। आप स्निपेट कोड में लाइनों के तीसरे ब्लॉक में उपयोग किए गए रंगों को देख सकते हैं।
— ट्राइकोप्लाक्स

जवाबों:

5

पायथन 2, 216 182 बाइट्स

def f(W,H,R):L={(i%W,i/W)for i in range(W*H)};M={(x,y)for x,y in L if min(x,W-x)+min(y,H-y)>R};g=lambda s:min([1+g(s-{((a+x)%W,(b+y)%H)for x,y in L-M})for a,b in s]or[1]);return g(M)

इनपुट की तरह f(16,16,8)। @ ट्राइकोप्लेक्स के नमूने के रूप में बहुत अधिक एल्गोरिथ्म का उपयोग करता है , लेकिन सेट के साथ। शुरू में मैंने पहले आइटम को जगह नहीं दी थी (0, 0), लेकिन इसने पिछले कुछ मामलों में इसे चोक कर दिया।

ऊपर के सभी मामले 10 सेकंड के भीतर पूरे हो जाते हैं, अच्छी तरह से सीमा के तहत। वास्तव में, मामले काफी छोटे होते हैं कि मेरे पास कम कुशल होने के लिए एक छोटा कमरा था, जिससे मुझे एक चेक हटाने की अनुमति मिली जो डुप्लिकेट राज्यों के लिए जाँच की।

(गोल्फिंग मदद के लिए @trichoplax को धन्यवाद)

विस्तारित:

def f(W,H,R):
  # All cells
  L={(i%W,i/W)for i in range(W*H)}                 

  # Mask: Complement of exclusion zone around (0, 0) 
  M={(x,y)for x,y in L if min(x,W-x)+min(y,H-y)>R}

  # Place recursively
  g=lambda s:min([1+g(s-{((a+x)%W,(b+y)%H)for x,y in L-M})for a,b in s]or[1])
  return g(M)
— Sp3000
स्रोत
2

पायथन 3, 270 262 260 251 246 226

(Sp3000 के लिए धन्यवाद:

  • -~ इसके बजाय +1 , जो मुझे अंतिम पंक्ति के बाद एक स्थान खोने देता है return ।
  • चारों ओर अति सुंदर कोष्ठक खोना W*H ।
  • lambdas ...
  • सब कुछ एक लाइन पर रखना।
  • अजगर मॉडुलो %नकारात्मक संख्या के लिए सकारात्मक परिणाम देता है, एक और 20 बाइट्स को बचाने के लिए)

यह पायथन 3 में रखे गए प्रश्न का जावास्क्रिप्ट उदाहरण उत्तर है।

चारों ओर इतने सारे फ़ंक्शन तर्कों को पारित करने से बचने के लिए, मैंने गणना फ़ंक्शन के अंदर दो सहायक कार्यों को स्थानांतरित कर दिया है ताकि वे इसके दायरे को साझा करें। मैंने इंडेंटेशन की लागत से बचने के लिए इनमें से प्रत्येक कार्य को एक पंक्ति में सम्मिलित किया है।

व्याख्या

यह काफी क्रूर बल दृष्टिकोण पहले आइटम को (0, 0) पर रखता है, और फिर सभी बहिष्कृत वर्गों को चिह्नित करता है। यह तब तक सभी शेष वैध वर्गों में एक आइटम रखता है जब तक कि सभी वर्गों को बाहर नहीं किया जाता है, और आवश्यक वस्तुओं की न्यूनतम संख्या लौटाता है।

गोल्फ कोड:

def C(W,H,R):r=range;M=lambda g:min([M(G(g,x,y))for x in r(W)for y in r(H)if g[x+W*y]]or[-1])+1;G=lambda g,x,y:[g[a+W*b]if min((x-a)%W,(a-x)%W)+min((y-b)%H,(b-y)%H)>R else 0for b in r(H)for a in r(W)];return-~M(G([1]*W*H,0,0))

अघोषित कोड:

def calculate(W, H, R):
    starting_min = W * H + 1
    cells = [0] * (W * H)
    grid_state = grid_with_item_added(cells, 0, 0, W, H, R)
    return min_from_here(grid_state, starting_min, W, H, R) + 1

def min_from_here(grid_state, starting_min, W, H, R):
    no_cells = True
    min = starting_min
    for x in range(W):
        for y in range(H):
            if grid_state[x + W * y] == 0:
                no_cells = False
                new_grid_state = grid_with_item_added(grid_state, x, y, W, H, R)
                m = min_from_here(new_grid_state, starting_min, W, H, R)
                if m < min:
                    min = m

    if no_cells:
        return 0
    else:
        return min + 1

def grid_with_item_added(grid_state, x, y, W, H, R):
    grid = grid_state[:]
    for a in range(W):
        for b in range(H):
            if manhattan_distance(a, b, x, y, W, H) <= R:
                grid[a + W * b] = 1

    return grid

def manhattan_distance(a, b, c, d, W, H):
    horizontal = min(abs(W + c - a) % W, abs(W + a - c) % W)
    vertical = min(abs(H + d - b) % H, abs(H + b - d) % H)
    return horizontal + vertical


if __name__ == '__main__':
    import sys
    arguments = sys.argv[1:]
    if len(arguments) < 3:
        print('3 arguments required: width, height and radius')
    else:
        print(calculate(int(arguments[0]), int(arguments[1]), int(arguments[2])))

अनगोल्ड कोड एक फ़ंक्शन को परिभाषित करता है और इसमें कमांड लाइन से कॉल करने की अनुमति देने के लिए कोड भी शामिल होता है। गोल्फ कोड केवल फ़ंक्शन को परिभाषित करता है, जो मानक कोड गोल्फ सवालों के लिए पर्याप्त है ।

यदि आप कमांड लाइन से गोल्फ कोड का परीक्षण करना चाहते हैं, तो यहां कमांड लाइन हैंडलिंग शामिल है (लेकिन गोल्फ नहीं):

कमांड लाइन परीक्षण योग्य गोल्फ कोड

def C(W,H,R):r=range;M=lambda g:min([M(G(g,x,y))for x in r(W)for y in r(H)if g[x+W*y]]or[-1])+1;G=lambda g,x,y:[g[a+W*b]if min((x-a)%W,(a-x)%W)+min((y-b)%H,(b-y)%H)>R else 0for b in r(H)for a in r(W)];return-~M(G([1]*W*H,0,0))

if __name__ == '__main__':
    import sys
    arguments = sys.argv[1:]
    if len(arguments) < 3:
        print('3 arguments required: width, height and radius')
    else:
        print(C(int(arguments[0]), int(arguments[1]), int(arguments[2])))
— trichoplax
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.