यह सामान्य प्रकार का अनुक्रम प्रश्न है, जैसा कि OEIS अनुक्रम A038666 पर लागू होता है । वह यह है कि निम्नलिखित में से कोई एक करें:

ब्रह्मांड की गर्मी से मृत्यु तक कोई भी या कोई इनपुट स्वीकार नहीं करते हैं, और A038666 आउटपुट करते हैं।
इनपुट के रूप में एक सकारात्मक पूर्णांक को स्वीकार करें, और A038666 के $n$ वें पद या इसके पहले $n$ शब्दों को आउटपुट करें । (का उपयोग कर $0$ - के बजाय $1$ -indexing, तो निश्चित रूप से आप भी उत्पादन करने के लिए है 1पर 0इनपुट।)

$n$ A038666 की वें अवधि आयतों के बीच कम से कम ऐसा क्षेत्र है जो आकार के गैर-अतिव्यापी वर्गों को शामिल है $1\times1,2\times2,\dots n\times n$ यदि आप उपयोग कर रहे हैं $1$ -indexing।

उदाहरण:

सबसे छोटे क्षेत्रफल वाले आयत में माध्यम से $1\times1$ आकार के गैर-अतिव्यापी वर्ग हो सकते हैं, जिनमें आयाम : $4\times4$ $7\times5$

4 4 4 4 3 3 3
4 4 4 4 3 3 3
4 4 4 4 3 3 3
4 4 4 4 2 2 1
x x x x 2 2 x

इसलिए, $a(4)=7\times5=35$ ( $1$ -indexed)।

इसी तरह, माध्यम से $1\times1$ आकार के गैर-अतिव्यापी वर्गों वाले सबसे कम क्षेत्रफल वाले आयत के आयाम , इसलिए ( -indexed)। $17\times17$ $39\times46$ $a(17)=39\times46=1794$ $1$

code-golf packing

— msh210
स्रोत

10

जावास्क्रिप्ट (ईएस 6), 172 बाइट्स

@JonathanAllan द्वारा सुझाए गए धीमे लेकिन छोटे संस्करण का सुझाव (मूल उत्तर में 4 बाइट्स की बचत):

f=(n,A,S=(n,c)=>n>=0?c(n)||S(n-1,c):0)=>S(A,w=>(F=(l,n)=>n?S(w-n,x=>S(A/w-n,y=>l.some(([X,Y,W])=>X<x+n&X+W>x&Y<y+n&Y+W>y)?0:F([...l,[x,y,n]],n-1))):A%w<1)([],n))?A:f(n,-~A)

इसे ऑनलाइन आज़माएं!

मूल उत्तर, 209 183 178 174 बाइट्स

अनुक्रम के $N$ ^वें शब्द को लौटाता है , 1-अनुक्रमित।

f=(n,A,S=(n,c)=>n>=0?c(n)||S(n-1,c):0)=>S(A,w=>A%w?0:(F=(l,n)=>n?S(w-n,x=>S(A/w-n,y=>l.some(([X,Y,W])=>X<x+n&X+W>x&Y<y+n&Y+W>y)?0:F([...l,[x,y,n]],n-1))):1)([],n))?A:f(n,-~A)

इसे ऑनलाइन आज़माएं!

टिप्पणी की गई

हेल्पर फ़ंक्शन

हम पहले एक सहायक समारोह को परिभाषित $S$ जो एक कॉलबैक फ़ंक्शन का आह्वान $c$ के लिए $n$ करने के लिए $0$ (दोनों शामिल) और एक truthy मूल्य एक कॉल रिटर्न जैसे ही बंद हो जाता है।

S = (n, c) =>               // n = integer, c = callback function
  n >= 0 ?                  // if n is greater than or equal to 0:
    c(n) ||                 //   invoke c with n; stop if it's truthy
    S(n - 1, c)             //   or go on with n - 1 if it's falsy
  :                         // else:
    0                       //   stop recursion and return 0

मुख्य कार्य

हम $A=1$ शुरू करते हैं ।

$(w,h)$ $w\times h = A$ $1\times1$ $n\times n$

$(X,Y)$ $W$ $l[\text{ }]$

$A$ $A+1$

f = ( n,                    // n = input
      A ) =>                // A = candidate area (initially undefined)
S(A, w =>                   // for w = A to w = 0:
  A % w ?                   //   if w is not a divisor of A:
    0                       //     do nothing
  : (                       //   else:
    F = (l, n) =>           //     F = recursive function taking a list l[] and a size n
      n ?                   //       if n is not equal to 0:
        S(w - n, x =>       //         for x = w - n to x = 0
          S(A / w - n, y => //           for y = A / w - n to y = 0:
            l.some(         //             for each square in l[]
            ([X, Y, W]) =>  //             located at (X, Y) and of width W:
              X < x + n &   //               test whether this square is overlapping
              X + W > x &   //               with the new square of width n that we're
              Y < y + n &   //               trying to insert at (x, y)
              Y + W > y     //
            ) ?             //             if some existing square does overlap:
              0             //               abort
            :               //             else:
              F([ ...l,     //               recursive call to F:
                  [x, y, n] //                 append the new square to l[]
                ],          //
                n - 1       //                 and decrement n
              )             //               end of recursive call
          )                 //           end of iteration over y
        )                   //         end of iteration over x
      :                     //       else (n = 0):
        1                   //         success: stop recursion and return 1
    )([], n)                //     initial call to F with an empty list of squares
) ?                         // end of iteration over w; if it was successful:
  A                         //   return A
:                           // else:
  f(n, -~A)                 //   try again with A + 1

— Arnauld
स्रोत

2

पुनरावृत्ति TIO की पूंछ के hलिए परीक्षण को परिभाषित और स्थानांतरित नहीं करके 6 * सहेजें । बेशक यह बहुत धीमा है। (* कम से कम - मैं कोई जावास्क्रिप्ट विशेषज्ञ नहीं हूँ!)a%w<1

— जोनाथन एलन

@JonathanAllan धन्यवाद :) वास्तव में, मुझे आश्चर्य है कि अगर a%w<1बस के साथ प्रतिस्थापित किया जा सकता है 1। मुझे बाद में दोबारा जांच करनी होगी।

— Arnauld

0

पायथन 2 (PyPy) , 250 236 बाइट्स

-14 बाइट्स msh210 के सुझावों के लिए धन्यवाद ।

अनुक्रम के 1-अनुक्रमित nth शब्द को आउटपुट करता है।

n=input()
r=range
k=n*-~n*(n-~n)/6
m=k*k
for Q in r(m):
 P={0}
 for X in r(n,0,-1):P|=([x for x in[{(x+a,y+b)for a in r(X)for b in r(X)}for x in r(Q%k-X+1)for y in r(Q/k-X+1)]if not x&P]+[{0}])[0]
 if len(P)>k:m=min(Q%k*(Q/k),m)
print m

इसे ऑनलाइन आज़माएं! N> 4 के लिए, इसमें बहुत समय लगता है। मैंने परिणाम को स्थानीय रूप से n = 7 तक सत्यापित किया है।

— OVS
स्रोत

क्या आप इस बात की व्याख्या करना चाहेंगे कि यह कैसे काम करता है? इसके अलावा, मुझे लगता है कि आप सात (बजाय दूसरे इंडेंटेशन) के बजाय एक समय में एक स्थान को इंडेंट करके बाइट्स दाढ़ी कर सकते हैं। (वास्तव में, मुझे लगता है कि शायद दो forलाइनें एक लाइन पर हो सकती हैं, और आपको केवल एक बार इंडेंट करने की आवश्यकता है।)

— msh210

1

@ msh210 "7 स्पेस" वास्तव में एक टैब है, जैसा कि पायथन 2 में आप एक स्पेस के साथ पहले इंडेंट कर सकते हैं, फिर एक टैब के साथ। एक पंक्ति में दो छोरों के लिए डाल देना दुर्भाग्य से सिंटैक्स अमान्य होगा।

— ArBo

1

@ msh210 मैंने छोरों के लिए संयोजन करने का एक अलग तरीका पाया। उन 7 स्थानों जहां केवल लाइन पर, पकड़ने के लिए धन्यवाद। मैं एक स्पष्टीकरण कल लिखने की कोशिश करेंगे

— OVS

N तक के आकार के वर्गों को सम्‍मिलित करने के लिए सबसे छोटी आयत का क्षेत्रफल ज्ञात कीजिए