आपको अपनी कुर्सियों की व्यवस्था कैसे करनी चाहिए?

Question

आप छात्रों के एक वर्ग को उनकी प्राथमिकताओं के बारे में दिलचस्प प्राथमिकताओं के साथ पढ़ाते हैं कि उनकी कुर्सियों की व्यवस्था कैसे की जाती है। कुर्सियों की व्यवस्था कैसे की जाती है, इसके लिए 3 बहुत विशिष्ट आवश्यकताएं हैं:

1. वे ज्यादातर एक आयत में व्यवस्थित होते हैं, भले ही इसका मतलब है कि कुछ कुर्सियां ​​खाली जाती हैं।

2. संभव के रूप में कुछ खाली कुर्सियां ​​होनी चाहिए।

3. उन्हें यथासंभव "चौकोर" होना चाहिए। चौकोर-नेस आयत की चौड़ाई और ऊंचाई के बीच की दूरी से निर्धारित होता है, कम बेहतर होता है। उदाहरण के लिए, एक आयत जिसमें 4x73 का एक वर्ग-नेस है।

अधिक विशिष्ट होने के लिए, एक व्यवस्था का "स्कोर" चौड़ाई और ऊंचाई के बीच की दूरी है और साथ ही कुर्सियों की संख्या जो खाली जाएगी।

एक उदाहरण लेते हैं। मान लीजिए कि आपके पास 13 छात्र हैं। आप इनमें से किसी भी तरीके से कुर्सियों की व्यवस्था कर सकते हैं:

1x13
2x7
3x5
4x4

1x13बहुत चौकोर नहीं है। वास्तव में, 1 और 13 12 अलग हैं, इसलिए हम इस व्यवस्था को 12 अंक देते हैं। इसमें 0 खाली कुर्सियां ​​भी हैं, इसलिए हम 0 अंक जोड़ते हैं, इस व्यवस्था को 12 का स्कोर दिया गया है।

2x7निश्चित रूप से बेहतर है। 2 और 7 केवल 5 अलग हैं, इसलिए हम इस व्यवस्था को 5 अंक देते हैं। हालाँकि, अगर आपने वास्तव में सात कुर्सियों की 2 पंक्तियों को व्यवस्थित किया है, तो 14 कुर्सियाँ लगेंगी, जिसका अर्थ है कि एक कुर्सी खाली होगी। तो हम एक बिंदु जोड़ते हैं, इस व्यवस्था को 6 का स्कोर देते हैं।

हम भी कर सकते थे 3x5। 3 और 5 2 अलग हैं, इसलिए +2 अंक। यह 15 कुर्सियाँ लेता है, जिसका अर्थ है कि हमारे पास दो अतिरिक्त कुर्सियाँ हैं, इसलिए 4 के स्कोर के लिए एक और +2 अंक।

अंतिम विकल्प, 4x4। 4 और 4 0 अलग हैं, इसलिए हम इसे +0 अंक देते हैं। 4x4 में 16 कुर्सियां ​​हैं, इसलिए 3 कुर्सियां ​​खाली हैं, कुल स्कोर 3 के लिए। यह इष्टतम समाधान है।

एक टाई के मामले में, इष्टतम समाधान कम खाली कुर्सियों के साथ एक है।

चुनौती

आपको एक प्रोग्राम या फ़ंक्शन लिखना होगा जो एक पूर्णांक लेता है और उस छात्रों की संख्या के लिए कुर्सियों की इष्टतम व्यवस्था को आउटपुट करता है। IO किसी भी उचित प्रारूप में हो सकता है। यहां 1 से 100 तक के किसी भी छात्र के लिए नमूना आउटपुट है:

1:  (1, 1)
2:  (1, 2)
3:  (2, 2)
4:  (2, 2)
5:  (2, 3)
6:  (2, 3)
7:  (3, 3)
8:  (3, 3)
9:  (3, 3)
10: (2, 5)
11: (3, 4)
12: (3, 4)
13: (4, 4)
14: (4, 4)
15: (4, 4)
16: (4, 4)
17: (3, 6)
18: (3, 6)
19: (4, 5)
20: (4, 5)
21: (3, 7)
22: (5, 5)
23: (5, 5)
24: (5, 5)
25: (5, 5)
26: (4, 7)
27: (4, 7)
28: (4, 7)
29: (5, 6)
30: (5, 6)
31: (4, 8)
32: (4, 8)
33: (6, 6)
34: (6, 6)
35: (6, 6)
36: (6, 6)
37: (5, 8)
38: (5, 8)
39: (5, 8)
40: (5, 8)
41: (6, 7)
42: (6, 7)
43: (5, 9)
44: (5, 9)
45: (5, 9)
46: (7, 7)
47: (7, 7)
48: (7, 7)
49: (7, 7)
50: (5, 10)
51: (6, 9)
52: (6, 9)
53: (6, 9)
54: (6, 9)
55: (7, 8)
56: (7, 8)
57: (6, 10)
58: (6, 10)
59: (6, 10)
60: (6, 10)
61: (8, 8)
62: (8, 8)
63: (8, 8)
64: (8, 8)
65: (6, 11)
66: (6, 11)
67: (7, 10)
68: (7, 10)
69: (7, 10)
70: (7, 10)
71: (8, 9)
72: (8, 9)
73: (7, 11)
74: (7, 11)
75: (7, 11)
76: (7, 11)
77: (7, 11)
78: (9, 9)
79: (9, 9)
80: (9, 9)
81: (9, 9)
82: (7, 12)
83: (7, 12)
84: (7, 12)
85: (8, 11)
86: (8, 11)
87: (8, 11)
88: (8, 11)
89: (9, 10)
90: (9, 10)
91: (7, 13)
92: (8, 12)
93: (8, 12)
94: (8, 12)
95: (8, 12)
96: (8, 12)
97: (10, 10)
98: (10, 10)
99: (10, 10)
100: (10, 10)

हमेशा की तरह, यह कोड-गोल्फ है, इसलिए मानक कमियां लागू होती हैं, और विजेता बाइट्स में सबसे छोटा उत्तर होता है।

Comments

सम्बंधित।

— मार्टिन एंडर

Answer 1

जेली , 16 15 14 बाइट्स

÷RĊ,Rµạ/+PỤḢịZ

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

÷RĊ,Rµạ/+PỤḢịZ  Main link. Argument: n

 R              Range; yield [1, ..., n].
÷               Divide n by each k in [1, ..., n].
  Ċ             Ceil; round the quotients up to the nearest integer.
    R           Range; yield [1, ..., n].
   ,            Pair; yield A := [[ ⌈n ÷ 1⌉, ..., ⌈n ÷ n⌉ ], [ 1, ..., n ]].
     µ          Begin a new, monadic chain. Argument: A
      ạ/        Reduce A by absolute difference.
                This yields [ |⌈n ÷ 1⌉ - 1|, ..., |⌈n ÷ n⌉ - n| ].
         P      Product; reduce A by multiplication.
                This yields [ ⌈n ÷ 1⌉ × 1, ..., ⌈n ÷ n⌉ × n].
       +        Add the results to left and right, element by element. This yields
                [ |⌈n ÷ 1⌉ - 1| + ⌈n ÷ 1⌉ × 1, ..., |⌈n ÷ n⌉ - n| + ⌈n ÷ n⌉ × n ].
          Ụ     Grade up; sort the indices of the list of sums by their values.
           Ḣ    Head; extract the first value, which corresponds to the smallest
                sum. Grading up is stable, so this selects the first index of all
                with the smallest sum in case of a tie. In this event, the first
                index will have the highest absolute difference of all indices
                with the smallest sum, meaning that it has the lowest product and,
                therefore, the lowest number of empty chairs.
             Z  Zip; transpose A's rows and columns.
                This yields [[ ⌈n ÷ 1⌉, 1 ], ..., [ ⌈n ÷ n⌉, n ]].
            ị   Retrieve the pair at that index.

Answer 2

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

lambda n:min((abs(~i-n/~i)+n/~i*~i,i+1,0-n/~i)for i in range(n))[1:]

अधिक "स्पष्ट" के बराबर:

lambda n:min([(i+1,0-n/~i)for i in range(n)],key=lambda(p,q):abs(p-q)+p*q)

Comments

आप तीन बाइट्स को इससे अधिक पुनरावृति करके बचा सकते हैं range(-n,0), जैसे मैं अपने उत्तर में करता हूं । परीक्षण सूट।

— डेनिस

Answer 3

हास्केल, 65 बाइट्स

f x=snd$minimum[((a*b+a-b,a*b),(b,a))|a<-[1..x],b<-[1..a],a*b>=x]

प्रयोग उदाहरण: map f [1..5]-> [(1,1),(1,2),(2,2),(2,2),(2,3)]।

एक बाहरी लूप के माध्यम से चला जाता है aसे 1करने के लिए x(-> छात्रों की संख्या x) और एक आंतरिक पाश bसे 1करने के लिए a। सभी रखता है (b,a)जहां a*b>=xऔर जोड़े की बनाता है ((arrangement points,seats left), (b,a))जो lexicographical क्रम का पालन करें हम कम से कम खोजने की जरूरत है। नोट: aहमेशा से अधिक है b, इसलिए हमें absचौकोरपन की आवश्यकता नहीं है । x"सीट्स लेफ्ट" स्कोर से घटाए जाने की आवश्यकता नहीं है , क्योंकि केवल सापेक्ष क्रम मायने रखता है। अंत में हम स्कोर जोड़ी को हटा देते हैं snd।

Comments

सिर्फ ( ए + ए, (बी, ए)) क्यों नहीं ? यदि आप स्कोर को कम करते हैं, तो निश्चित रूप से आप कम से कम भी तरह से बी को , या मैं कुछ याद कर रहा हूं?

— justinpc

@jpcooper: a*b(फ्री सीट की संख्या) टाई ब्रेकर है अगर मुख्य स्कोर बराबर है। जैसे n=43: ए) a=7, b=7, स्कोर: (49,49)बी) a=9, b=5, स्कोर (49,45):। मुख्य स्कोर बराबर है, टाई ब्रेकर तय करता है, बी) जीतता है।

— nimi

आप सही हे। मुझे विवरण को बेहतर ढंग से पढ़ना चाहिए था।

— justinpc

@jpcooper: एक मिनट प्रतीक्षा करें ... यदि मैं टाई ब्रेकर को हटाता हूं a*b, तो संख्याओं को (b,a)जो मुझे वैसे भी ले जाना है, टाई ब्रेकर के रूप में कार्य करते हैं और कम से कम उसी परिणाम देते हैं n=1..300। एक उत्पाद छोटा है अगर कारकों में से एक (यहाँ b) छोटा है। लेकिन जब तक मेरे पास कोई औपचारिक प्रमाण नहीं है, मैं इस तथ्य का उपयोग नहीं करना चाहता। आइए देखें कि क्या मुझे पता है।

— nimi

अच्छी बात। यह सही लगता है, और एक प्रमाण के साथ आने के लिए बहुत कठिन नहीं होना चाहिए। मुझे आश्चर्य है कि क्या इस समस्या का एक रैखिक समाधान हो सकता है।

— justinpc

Answer 4

रूबी, 64 बाइट्स

->n{(1..n).map{|w|h=(n+w-1)/w;[(h-w).abs+h*w,w*h,w,h]}.min[2,3]}

एक लंबादा जो एक तर्क के रूप में लोगों की संख्या लेता है और इष्टतम समाधान की चौड़ाई और ऊंचाई के साथ एक सरणी देता है।

Comments

आपको w*hअपने ऐरे में दूसरे तत्व की आवश्यकता क्यों है ? मुझे नहीं लगता कि जब आप कॉल करते हैं तो यह विशेष रूप से कुछ भी बदलता है minक्योंकि आप पहले तत्व उर्फ ​​अंक पर कम से कम होते हैं।

— मूल्य इंक

@ केविनलाउ-केनेकी सवाल से:In case of a tie, the optimal solution is the one with less empty chairs

— मेगाटॉम

Answer 5

MATL , 18 बाइट्स

:Gy/Xkvtd|yp+&X<Z)

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

व्याख्या

:      % Implicit input number N. Range [1 2 ... N]
G      % Push N again
y      % Duplicate second-from-top: push [1 2 ... N] again
/Xk    % Divide and round up
v      % Vertically concatenate. Gives 2×N array of rectangle sizes
td|    % Duplicate. Absolute difference of each column
y      % Duplicate second-from-top: push 2×N array again
p      % Product of each column
+      % Sum absolute differences and products
&X<    % Arg min
Z)     % Use as column index into the 2×N array. Implicitly display

Answer 6

जावास्क्रिप्ट, 98 बाइट्स

मेरा पहला कोड गोल्फ है, इसलिए मैं वैसे भी पोस्ट करता हूं!

f=n=>{for(o=1/0,i=1;i<=n;i++)for(j=n;i*j>=n;j--)t=i*j-n+Math.abs(i-j),o>t&&(o=t,a=[i,j]);return a}

शुरू में मेरी oएक खाली वस्तु थी और मैंने जाँच की कि o.aक्या खाली है, इसलिए यह पहले दौर में एक विशेष मामला था। लेकिन मुझे इनफिनिटी के लिए वैरिएबल को इनिशियलाइज़ करने के लिए edc65 के जवाब में 1/0 ट्रिक मिली।

Comments

और मैं अस्थायी परिणाम

— edc65

Answer 7

पायथ, 24 22 21 बाइट्स

संपादित करें : छँटाई कुंजी में, मुझे पता है कि खाली कुर्सियों की संख्या खोजने की कोई आवश्यकता नहीं है। यह कुर्सियों की कुल संख्या के बराबर है। इसने मुझे 2 बाइट्स से बचाया।

h.m_+B*FbaFbm,d.EcQdS

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

Answer 8

Matlab(174) (146)121

  function g(n),f=@(n,i)ceil(n/i);x=[];for i=1:n,x=[sortrows(x); f(n,i)*i-1/(f(n,i)*i)+abs(f(n,i)-i) i f(n,i)];end,x(1,2:3)

• ट्रिक 1: मैंने 1-1/length*widthटाई-स्कोरिंग के रूप में राशि जोड़ी

• ट्रिक 2:number_students/length आयत की चौड़ाई के लिए सीमांकित गणना , ऊपरी बाउंड वर्गाकार है, लेकिन सीमलेस भी है

• मुझे यकीन है कि इसे आगे बढ़ाया जा सकता है ...

कोशिश करो

---

संपादित करें: @StewieGriffin की टिप्पणी का संदर्भ दिया गया।

2 संपादित करें:

• 1और nस्थिरांक को समग्र स्कोर में उन्हें जोड़ने की कोई आवश्यकता नहीं है।
• एक फ़ंक्शन स्टैड स्टैंडअलोन प्रोग्राम की तुलना में कुछ बाइट्स कम है।
• मैंने आरोही सॉर्टिंग तकनीक का उपयोग किया, हालांकि यह बहुत अधिक बाइट्स बचाता है।

3 संपादित करें: peformance test।

Comments

@StewieGriffin जो बड़ा मुद्दा नहीं है, इसे इस्तेमाल करके हल किया जा सकता हैunique

— Abr001am

मुझे लगता है कि इस समस्या के लिए कुछ अच्छे गणितीय अनुवाद करने के लिए आधे रास्ते पर हैं, लेकिन अभी भी यह अनुमान के रूप में बना हुआ है

— अब्राहम

इस बारे में भी सोचा। जूलिया का उदाहरण देखें।

— एमएसचौयर

Answer 9

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

lambda n:max((~-i*~min(i,n/i),0-n/i,-i)for i in range(-n,0))[1:]

यह @ लिन के पाइथन उत्तर (जहां से मैंने max(...)[1:]ट्रिक ली थी ) और एल्गोरिथ्म का मेरे जूलिया उत्तर से एक समामेलन है (जो थोड़ा कम कार्यान्वयन की अनुमति देता है ।

Ideone पर इसका परीक्षण करें ।

Answer 10

जूलिया, 61 59 55 53 52 बाइट्स

/ =cld
n->[m=indmax([~i*~-max(i,n/i)for i=1:n]),n/m]

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

यह काम किस प्रकार करता है

कोड निम्न, अनगोल्ड संस्करण के बराबर है, जहां cldछत विभाजन है।

function chairs(n)
    m = indmin([(i + 1) * (max(i, cld(n, i)) - 1) for i in 1:n])
    return [m, cld(n, m)]
end

इष्टतम व्यवस्था खोजने के लिए, जोड़े [i, j] की जाँच करना स्पष्ट रूप से पर्याप्त है , जहाँ 1 ≤ i ⌈ n और j = andn / i, ।

इस तरह की व्यवस्था के लिए स्कोर है | j - i + (ij - n) , जहां दूसरा समंद खाली कुर्सियों की संख्या है। वास्तविक अंकों के बजाय, हम एक स्थिर द्वारा संवर्धित स्कोर की तुलना कर सकते हैं, जैसे कि ij + | j - i | + 1 ।

यह जोड़े [i, j] पर विचार करने के लिए पर्याप्त है , जहां व्यवस्था के बाद से मैं the j [i, j] और [j, i] समान रूप से मान्य है। हम इसके बजाय j = max (/n / i, i) सेट करके कड़ाई से उतरते जोड़े से निपटते हैं , जो यह सुनिश्चित करता है कि j that i और imaln / i⌉ <i ।

चूंकि j - i , 0 , हमारे पास ij + | j - i | + 1 = ij + j - i + 1 = (i + 1) × (j - 1) , जिसकी गणना कम बाइट्स कोड में की जा सकती है।

अंत में indmin/ इष्टतम व्यवस्था indmaxके सूचकांक m (और इस प्रकार i का मान ) देता है, जो कि /n / m⌉ द्वारा m है । पहली घटना से संबंध टूट जाते हैं, जो कि मैं के निम्नतम मूल्य से मेल खाती है , इसलिए j - i का उच्चतम मूल्य और इस प्रकार ij - n (खाली कुर्सियां) का सबसे कम मूल्य है ।

Answer 11

जावास्क्रिप्ट (ईएस 6) 74 78

थिहट के उत्तर से उधार लिए गए 2 चर के बजाय एक परिणाम के रूप में अस्थायी परिणाम रखते हुए संपादित करें

n=>(z=>{for(x=0;y=-~(~-n/++x),x<=y;)(s=y-x+x*y-n)>=z||(z=s,r=[x,y])})()||r

कम गोल्फ वाला

n=>{
  z = 1/0
  for (x=0; y=(n-1)/++x+1|0, x <= y; )
  {
    s = y-x+x*y-n;
    if (s<z)
      z=s, r=[x,y]
  }
  return r
}

परीक्षा

f=n=>(z=>{for(x=0;y=-~(~-n/++x),x<=y;)(s=y-x+x*y-n)>=z||(z=s,r=[x,y])})()||r

out=x=>O.textContent+=x+'\n'

for(i=1;i<=100;i++)out(i+' :( '+f(i)+' )')

<pre id=O></pre>

Answer 12

PHP, 129 बाइट्स

function f($i){$s=INF;for($x=1;$x<$i;$x++){if($s>$t=(abs($x-$e=ceil($i/$x))-$i+($e*$x))){$s=$t;$d[0]=$x;$d[1]=$e;}}var_dump($d);}

Ungolfed:

function f ($i){
    $s=INF;
    for($x=1; $x<$i; $x++){ // for every number less than the input
        if( $s > $t=( abs($x-$e=ceil($i/$x))-$i+($e*$x) ) ){ 
            // determine the other dimension, the score, and compare to the minimum score
            $s=$t;
            $d[0]=$x;
            $d[1]=$e;
        }
    }
    var_dump($d);
}

Answer 13

PHP, 104 बाइट्स

एल्गोरिथ्म जो इस समस्या को हल करता है वह सरल है और संभवतः PHP (जावास्क्रिप्ट, fe) के समान भाषाओं में अन्य उत्तरों द्वारा उपयोग किया जाता है:

• प्रारंभिक स्कोर के लिए एक बड़े मूल्य के साथ शुरू करें; nकाफी बड़ा है (जहां nइनपुट मूल्य है); पहले पुनरावृत्ति ( 1, n) पर गणना की गई व्यवस्था का स्कोर है(n-1)+0 ;
• के बीच चौड़ाई के सभी मूल्यों के लिए पुनरावृति 1और n; न्यूनतम ऊंचाई की ceil(n/width)गणना करें, प्रश्न में दिए गए सूत्र का उपयोग करके व्यवस्था स्कोर की गणना करें (यानी abs(width - height) + (width * height - n)); यदि स्कोर पिछले सर्वश्रेष्ठ स्कोर से बेहतर है, तो चौड़ाई, ऊंचाई और नए सर्वश्रेष्ठ स्कोर को याद रखें; संबंधों पर width * height - nवर्तमान व्यवस्था के लिए मूल्य और नई सर्वोत्तम व्यवस्था का पता लगाने के लिए पिछली सबसे अच्छी व्यवस्था का उपयोग करें;
• बस इतना ही।

गोल्फ के बाद, यह एल्गोरिथ्म कुछ इस तरह पैदा करता है (पठनीयता के लिए यहां लिपटा हुआ):

for($s=$h=$j=$n=$argv[$w=$i=1];$i<=$j;$j=ceil($n/++$i)
{$c=$j-$i+$i*$j-$n;if($c<$s||$c==$s&&$i*$j<$w*$h){$w=$i;$h=$j;$s=$c;}}
echo"$w,$h";

इसमें 137 बाइट्स का इस्तेमाल किया गया है (जब एक लाइन पर रखा जाता है) और यह शीर्षक में विज्ञापित 104 बाइट्स से बहुत दूर है। कोड को संभवतः एक और 2-3 बाइट्स द्वारा छोटा किया जा सकता है लेकिन सुधार का बड़ा स्रोत कहीं और है: एल्गोरिथ्म के विवरण में।

संशोधित एल्गोरिथ्म:

ऐसे कई स्थान हैं जहां बेकार कोड को हटाकर एल्गोरिथ्म में सुधार किया जा सकता है।

• से चौड़ाई को पुनरावृत्त करने की कोई आवश्यकता नहीं 1है $n; गति के लिए, चौड़ाई ( $i) के बीच पुनरावृति चाहिए 1और floor(sqrt($n))लेकिन इसमें अधिक समय भी बजाय कोड बनाता है यह छोटा करने की; लेकिन यदि चौड़ाई अधिक नहीं है sqrt($n), तो न्यूनतम ऊंचाई ( $j) हमेशा से बड़ी होगी sqrt($n)(उनका उत्पाद कम से कम होना चाहिए $n);
• पिछला विवरण $i <= $jलूप के लिए समाप्ति की स्थिति के रूप में (चौड़ाई <= ऊंचाई) का उपयोग करने की अनुमति देता है ; इस तरह से, चौड़ाई से पुनरावृति जाएगा 1करने के लिए floor(sqrt($n))और ऊंचाई के मान के साथ शुरू हो जाएगा $nऔर करने के लिए नीचे जा रहाceil(sqrt($n)) (जरूरी नहीं उन सभी को);
• यह जानते हुए कि चौड़ाई हमेशा ऊंचाई से कम या बराबर होती है, हमें पता है कि abs(width - height)हमेशा है height - width($j-$i ); 5 बाइट्स इस तरह से बचाए;
• इनपुट मान $nका उपयोग स्कोर की गणना में किया जाता है (निर्विरोध सीटों की संख्या width * height - n) लेकिन इसकी आवश्यकता नहीं है; स्कोर को प्रदर्शित करने की आवश्यकता नहीं है, यह केवल व्यवस्था की तुलना के लिए गणना की जाती है; बिना कुछ खोए - nस्कोर फॉर्मूला को हटाकर हम एक और 3 बाइट्स (PHP कोड है -$n) बचाते हैं ;
• अंतिम दो कथन दिए गए, स्कोर फॉर्मूला बन गया height - width + width * height( $j-$i+$i*$j);
• संबंधों पर (वर्तमान व्यवस्था का स्कोर पिछले सर्वश्रेष्ठ स्कोर के समान है), नियम कम मुक्त सीटों के साथ व्यवस्था का उपयोग करने के लिए कहते हैं; क्योंकि चौड़ाई हमेशा बढ़ती है और ऊंचाई हमेशा घटती है, height - widthस्कोर का हिस्सा प्रत्येक चरण पर घटता है;
• यदि वर्तमान स्कोर पिछले सर्वश्रेष्ठ स्कोर के बराबर है, तो पिछले कथन हमें बताते हैं कि वर्तमान व्यवस्था की मुफ्त सीटों की संख्या पिछली सर्वश्रेष्ठ व्यवस्था की तुलना में बड़ी है; इसका मतलब है कि पिछली सबसे अच्छी व्यवस्था टाई जीतेगी;
• क्योंकि संबंध हमेशा पिछली सर्वश्रेष्ठ व्यवस्था से जीते जाते हैं, एक नई व्यवस्था नई सर्वोत्तम व्यवस्था बन जाती है, जब उसका स्कोर पिछले सर्वश्रेष्ठ की तुलना में छोटा होता है; कोड जो संबंधों की जांच करता है वह बेकार है और हटाया जा सकता है ( ||$c==$s&&$i*$j<$w*$h- बहुत सारे बाइट्स);
• -$nस्कोर के फॉर्मूले से हटाने के कारण , पहली व्यवस्था के लिए स्कोर ( 1x$n) है $n-1+1*$n(यानी 2*$n-1); सर्वोत्तम स्कोर का प्रारंभिक मूल्य ( $s) किसी भी मूल्य से अधिक या उसके बराबर हो सकता है 2*$n; पहले पुनरावृत्ति का एक बेहतर स्कोर है और यह एल्गोरिथ्म को आरम्भिक समस्याओं के बिना चलाने के लिए सबसे अच्छी व्यवस्था है।

उपरोक्त वर्णित सुधारों को लागू करने के बाद नया कोड ( 104 बाइट्स ):

for($s=2*$j=$n=$argv[$i=1];$i<=$j;$j=ceil($n/++$i))
if($s>$c=$j-$i+$i*$j){$w=$i;$h=$j;$s=$c;}echo"$w,$h";

पठनीयता के लिए इसे यहाँ लपेटा गया है। PHP मार्कर <?php(तकनीकी रूप से, यह कोड का हिस्सा नहीं है) के साथ ऊपर दिए गए कोड को प्रीपेन्ड करें , इसे एक फाइल में डालें (मान लें arrange-your-chairs.php) और इसे तर्क के रूप में शून्य से अधिक पूर्णांक के साथ चलाएं। यह कॉमा द्वारा अलग की गई गणना की चौड़ाई और ऊंचाई को प्रदर्शित करेगा:

$ php arrange-your-chairs.php 1001
28,36

एक अन्य समाधान (116 बाइट्स)

एक और समाधान जो एक अलग एल्गोरिथ्म का उपयोग करता है:

for($n=$argv[1];++$j<=$n;)for($i=0;++$i<=$j;)
if($n<=$k=$i*$j)$a["$i,$j"]=($j-$i+$k-$n)*$n+$k;asort($a);echo key($a);

यह कम से कम $nसीटों के सभी संयोजनों को एक सहयोगी सूची में रखता है ; कुंजी व्यवस्था का पाठ प्रतिनिधित्व है, मूल्य व्यवस्था का स्कोर है। यह तब सूची को क्रमबद्ध करता है (मान द्वारा आरोही) और पहली प्रविष्टि की कुंजी प्राप्त करता है।

एक और (115 बाइट्स)

foreach(range(1,$m=$n=$argv[1])as$i)
if(($d=ceil($n/$i))<=$i&&$m>=$s=$i*$d-$n+$i-$d){$m=$s;$w=$d;$h=$i;}echo"$w,$h";

यह @ नील के उत्तर ( PHP / ES6, 85 बाइट्स) का PHP संस्करण है ।

प्रत्येक भाषा की विशेषताओं के कारण कुछ ध्यान देने योग्य अंतर हैं:

• JS उत्तर n(अपरिभाषित) मानों की एक सरणी उत्पन्न करता है और फिर से 0इसे पुन: व्यवस्थित करने के लिए अपनी कुंजियों का उपयोग करता है n-1; यह वृद्धि i( d=(n+i++)/i|0) से इसे पुनरावृति 1करने के लिए n; PHP समाधान को वेतन वृद्धि की आवश्यकता नहीं है; यह range()एक सरणी उत्पन्न करने के लिए उपयोग करता है तो यह उत्पन्न मानों का उपयोग करता है ( 1मेंn ) को पुनरावृति करने के ;
• जेएस उत्तर का उपयोग करता है (n+i)/iतो |0सबसे छोटे पूर्णांक से बड़ा प्राप्त करने के लिए पूर्णांक का मान परिवर्तित करता है n/i; PHP उत्तर PHP फ़ंक्शन के साथ इस समस्या को आसानी से हल करता है ceil(); जावास्क्रिप्ट भी प्रदान करता हैMath.ceil() लेकिन यह नील द्वारा पाए गए समाधान से 5 बाइट्स का उपयोग करता है;
• PHP फ़ंक्शन प्रदान करता है जो array_map()किसी भी तरह जेएस के साथ समान है Array.map()लेकिन यह यहां मदद नहीं करता है; इसका सिंटैक्स क्रिया है, aforeach छोटा कोड बनाता है; यह जेएस कोड से बड़ा है, हालांकि;
• उपयोग की शर्तों में असाइनमेंट को मर्ज करना ||PHP में संभव नहीं है क्योंकि इसमें अल्पविराम ऑपरेटर का अभाव है; मैंने तब अनुवाद a||b||cकिया if(!a&&!b)c, क्योंकि aऔर bतुलना कर रहे हैं, मैंने उनके ऑपरेटरों ( <साथ प्रतिस्थापित >=) को नकार दिया ; यह भी जेएस संस्करण की तुलना में बड़ा कोड पैदा करता है;
• एक और 23 बाइट्स को सिर्फ इसलिए जोड़ना होगा क्योंकि PHP में वैरिएबल के नामों को प्रीफिक्स करना पड़ता है $।

सभी समाधान और टेस्ट स्वीट के ungolfed संस्करणों पाया जा सकता है Github पर ।

Comments

यह सबसे गहन कोड-गोल्फ उत्तर है जिसे मैंने कभी देखा है।

— DJMcMayhem

Answer 14

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

n=>[...Array(m=n)].map((_,i)=>(d=(n+i++)/i|0)>i||(s=i*d-n+i-d)>m||(m=s,r=[d,i]))&&r

Comments

हो सकता है कि आप मेरी चाल (2 बाइट्स को बचाने के लिए) लागू कर सकें

— लीक नून

@ केनीलाऊ मुझे नहीं लगता कि इससे मदद मिलती है; मुझे mक्षतिपूर्ति के लिए बढ़ाना होगा।

— नील १

Answer 15

जूलिया, 87

मुझे लगता है कि यह समस्या के लिए एक जादू समारोह खोजने की दिशा में एक कदम है:

f(i)=(i+n)÷(i+1)|>j->(j*i<n)+j
_=indmin([sqrt(n)<=i?i-f(i)*(1-i):2n for i=1:n])
_,f(_)

यह केवल जोड़े को देखता है (i, j=(i+n)/(i+1))या(i, j+1)

Comments

कृपया आगे बताएं कि यह कैसे काम करता है, आपने मुझे अपने कार्य के लिए उत्सुक कर दिया

— Abr001am

मुझे यकीन नहीं है कि यह कैसे काम करने वाला है। आप nकहीं भी परिभाषित नहीं करते हैं , और आप इनपुट नहीं लेते हैं।

— डेनिस

आह, क्षमा करें, मैंने अभी nइनपुट के रूप में लिया है । एक को इसमें लपेटने की आवश्यकता होगी n->...। अच्छा लगा कि आप इसे काम कर सकते हैं।

— mschauer

Answer 16

Oracle SQL 11.2, 173 बाइट्स

SELECT MIN(x||','||y)KEEP(DENSE_RANK FIRST ORDER BY y-x+(y*x-:1))FROM(SELECT CEIL(LEVEL/:1)x,CEIL(MOD(LEVEL+.1,:1))y FROM DUAL CONNECT BY LEVEL<=:1*:1)WHERE x<=y AND:1<=x*y;

संयुक्त राष्ट्र के golfed

SELECT MIN(x||','||y)KEEP(DENSE_RANK FIRST ORDER BY y-x+(y*x-:1))  -- Keeps the minimal score
FROM   (SELECT CEIL(LEVEL/:1)x,CEIL(MOD(LEVEL+.1,:1))y FROM DUAL CONNECT BY LEVEL<=:1*:1) -- Generate x,y combinations 
WHERE  x<=y AND :1<=x*y  -- Filters out wrong combinations

Answer 17

क्यू 58 बाइट्स

{c@d?&/d:+/(-/;*/)@\:+c:{((b<a)?1b)#+(b:-_-x%a;a:1+!x)}x}

लांबा जो किसी दिए गए मूल्य (x) के लिए न्यूनतम लागत की गणना करता है और दो मूल्यों (चौड़ाई, ऊंचाई) का एक क्रम देता है

उस मेमने का नाम जोड़ने के लिए अन्य दो चार (पूर्व f: {..} के बजाय {..}) की आवश्यकता है

परीक्षा

{..}'1+!100

जहाँ {..} मेमना है। "1 + पहले 100 ints के प्रत्येक मूल्य पर लंबो लागू होता है" के रूप में पढ़ें (दूसरे शब्दों में प्रत्येक मूल्य 1..100)

उत्पन्न करता है

1 1
2 1
2 2
2 2
3 2
3 2
3 3
3 3
3 3
5 2
4 3
4 3
4 4
4 4
4 4
4 4
6 3
6 3
5 4
5 4
7 3
5 5
..

व्याख्या

नेस्टेड लाम्बा {((b<a)?1b)#+(b:-_-x%a;a:1+!x)}एक्स चेयर के लिए सभी सीक्वेंस (w1 w w w3 ..; h1 h2 h3 ..) (चौड़ाई और हाइट्स) के रूप में सभी उम्मीदवारों (चौड़ाई, ऊंचाई) जोड़े उत्पन्न करता है। बाएं से दाएं पढ़ें, लेकिन दाएं से बाएं से मूल्यांकन करता है

a:1+!x मान उत्पन्न करता है। 1.x और उस अनुक्रम को असाइन करता है a

-_- मंजिल नकारात्मक है, और औजार छत (भाषा की आदिम नहीं है)

b:-_-x%aकिसी भी आइटम im द्वारा विभाजित x के प्रत्येक मान पर छत लागू होता है, और परिणामी अनुक्रम को b को असाइन करता है। दूसरे शब्दों में, b प्रत्येक x विभाजित है प्रत्येक 1.x पर विभाजित करें। x

+(b;a) seq a और seq b से बना एक धर्मनिरपेक्षता लौटाएं, तो एक इसे फ़्लिप करता है (परिणाम जोड़ी का एक क्रम है जहाँ i-pair में a का तत्व i और b का तत्व i होता है)

b<a b और a के मद से आइटम की तुलना करता है, और प्रत्येक सूचकांक के लिए तार्किक मानों का एक सत्य (सही = 1 बी) उत्पन्न करता है जहां b i>]

s?xअनुक्रम s में आइटम x की पहली स्थिति देता है। साथ में(b<a)?1b हम तुलना ख और एक की जिसके परिणामस्वरूप अनुक्रम में 1b (सही मूल्य) के लिए देखो, और पहले की स्थिति जहां ख मिलता है

n#sseq s से n पहला n आइटम लेता है। हम डुप्लिकेट जोड़े को त्यागना चाहते हैं, इसलिए हम एक जोड़ी के पहले आइटम को रोकते हैं <दूसरी आइटम (उदा। 13,1 पर विचार करें, लेकिन 1,13 नहीं)।

एक साइड इफेक्ट के रूप में, परिणामी अनुक्रम की प्रत्येक जोड़ी एक और बी (पूर्व (13 1; 7; 5; 5 3; 4 4) के बीच की दूरी कम कर रही है;

नेस्टेड लैम्ब्डा द्वारा उत्पन्न उम्मीदवार जोड़ी को सी को सौंपा गया है। हम फिर c को फ्लिप करते हैं (b, फिर से प्राप्त करते हैं) और उस तर्क के लिए दो फ़ंक्शन लागू करते हैं: */अधिक से अधिक गुणा करना, और -/घटाना। परिणाम (-/;*/)@\:+cप्रत्येक जोड़ी का अंतर और उत्पाद है।+/राशि से अधिक है, और अंतिम लागत कैलोरी है। प्रत्येक patir की लागत d को दी गई है

& / पर न्यूनतम है, इसलिए &/d न्यूनतम लागत है। जब d?&/dहम d में न्यूनतम लागत की पहली घटना पाते हैं, और c @ के साथ .. हम उस स्थिति में जोड़े को पुनः प्राप्त करते हैं। जैसा कि प्रत्येक जोड़ी एक और n के बीच डिस्टैंट कम कर रही है, पहले न्यूनतम पाए गए अधिकतम डिस्टेंट में अन्य न्यूनतम जोड़े हैं, इसलिए हम टाई नियम को सही ढंग से लागू करते हैं