Sie unterrichten eine Klasse von Schülern mit interessanten Präferenzen für die Anordnung ihrer Stühle. Es gibt 3 sehr spezifische Anforderungen an die Anordnung der Stühle:

1. Sie werden meist in einem Rechteck angeordnet, auch wenn dadurch einige Stühle leer werden.

2. Es müssen so wenig Stühle wie möglich frei sein.

3. Sie müssen so quadratisch wie möglich sein. Die Rechteckigkeit wird durch den Abstand zwischen der Breite und der Höhe des Rechtecks ​​bestimmt, niedriger ist besser. Beispiel: Ein Rechteck 4x7hat eine Quadratzahl von 3.

Genauer gesagt ist die "Punktzahl" einer Anordnung der Abstand zwischen der Breite und der Höhe plus der Anzahl der Stühle, die leer gehen würden.

Nehmen wir ein Beispiel. Angenommen, Sie haben 13 Schüler. Sie können die Stühle folgendermaßen anordnen:

1x13
2x7
3x5
4x4

1x13ist nicht sehr quadratisch. Tatsächlich sind 1 und 13 12 voneinander entfernt, daher geben wir dieser Anordnung 12 Punkte. Es hat auch 0 leere Stühle, also addieren wir 0 Punkte, was diesem Arrangement eine Punktzahl von 12 gibt. Nicht so toll.

2x7ist sicherlich besser. 2 und 7 sind nur 5 voneinander entfernt, daher geben wir dieser Anordnung 5 Punkte. Wenn Sie jedoch zwei Reihen mit sieben Stühlen arrangieren würden, würde dies 14 Stühle einnehmen, was bedeutet, dass ein Stuhl leer wäre. Also addieren wir einen Punkt und geben diesem Arrangement eine Punktzahl von 6.

Wir könnten es auch tun 3x5. 3 und 5 sind 2 auseinander, also +2 Punkte. Es werden 15 Stühle benötigt, was bedeutet, dass wir zwei zusätzliche Stühle haben, also weitere +2 Punkte für eine Punktzahl von 4.

Letzte Option 4x4. 4 und 4 sind 0 auseinander, also geben wir diese +0 Punkte. 4x4 nimmt 16 Stühle ein, sodass 3 Stühle leer sind, was eine Gesamtpunktzahl von 3 ergibt. Dies ist die optimale Lösung.

Im Falle eines Unentschieden ist die optimale Lösung die mit weniger leeren Stühlen.

Die Herausforderung

Sie müssen ein Programm oder eine Funktion schreiben, die eine Ganzzahl annimmt und die optimale Anordnung der Lehrstühle für diese Anzahl von Schülern ausgibt. IO kann in jedem vernünftigen Format vorliegen. Hier ist eine Beispielausgabe für eine beliebige Anzahl von Schülern von 1 bis 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)

Wie üblich ist dies Codegolf, daher gelten Standardlücken, und der Gewinner ist die kürzeste Antwort in Bytes.

Jelly , 16 15 14 Bytes

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

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

÷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.

Python 2, 68 Bytes

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

Gleichbedeutend mit dem Offensichtlicheren:

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

Haskell, 65 Bytes

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

Anwendungsbeispiel: map f [1..5]-> [(1,1),(1,2),(2,2),(2,2),(2,3)].

Durchläuft eine äußere Schleife avon 1bis x(x -> Anzahl der Schüler) und eine innere Schleife bvon 1bis a. Bewahrt alle Positionen (b,a)auf a*b>=xund bildet Paare, ((arrangement points,seats left), (b,a))die der lexikografischen Reihenfolge folgen, in der wir das Minimum finden müssen. Hinweis: aist immer größer als b, daher brauchen wir keine absQuadratmeter. Es ist nicht erforderlich, xvon der Punktzahl "Plätze übrig" abzuziehen , da nur die relative Reihenfolge von Bedeutung ist. Zum Schluss entfernen wir das Score-Paar mit snd.

Ruby, 64 Bytes

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

Eine Lambada, die die Anzahl der Personen als Argument verwendet und ein Array mit der Breite und Höhe der optimalen Lösung zurückgibt.

MATL , 18 Bytes

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

Probieren Sie es online!

Erläuterung

:      % 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

Javascript, 98 Bytes

Mein erster Code Golf, also poste ich trotzdem!

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}

Anfänglich war mein oObjekt leer und ich habe geprüft, ob o.aes leer war, also war es ein Sonderfall in der ersten Runde. Aber ich habe den 1/0-Trick in edc65's Antwort gefunden, um die Variable auf Unendlich zu initialisieren.

Pyth, 24 22 21 Bytes

Bearbeiten : Im Sortierschlüssel stelle ich fest, dass die Anzahl der leeren Stühle nicht ermittelt werden muss. Dies entspricht der Gesamtzahl der Stühle. Das hat mir 2 Bytes gespart.

h.m_+B*FbaFbm,d.EcQdS

Probieren Sie es online!

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)

• trick 1: ich habe den betrag 1-1/length*widthals unentschieden addiert

• trick 2: ich habe die number_students/lengthdecke für die breite des rechteckes berechnet , die obere grenze ist das quadrat, aber auch die decke

• Ich bin sicher, es kann weiter golfen werden ...

Versuch es

Bearbeiten: auf die Ausführungen von @StewieGriffin verwiesen.

Bearbeiten 2:

• 1und nsind Konstanten, die nicht zur Gesamtpunktzahl addiert werden müssen.
• Eine Funktion ist einige Bytes kleiner als das Standard-Standalone-Programm.
• Ich habe eine aufsteigende Sortiertechnik verwendet, die allerdings zu viele Bytes spart.

Edit 3: Leistungstest.

Python 2, 64 Bytes

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

Dies ist eine Zusammenführung von @Lynns Python-Antwort (von wo ich den max(...)[1:]Trick genommen habe) und dem Algorithmus aus meiner Julia-Antwort (die eine etwas kürzere Implementierung ermöglicht).

Teste es auf Ideone .

Julia, 61 59 55 53 52 Bytes

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

Probieren Sie es online!

Wie es funktioniert

Der Code entspricht der folgenden ungolfierten Version, bei der cldes sich um eine Deckeneinteilung handelt.

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

Um die optimale Anordnung zu finden, ist es eindeutig ausreichend, die Paare [i, j] zu untersuchen , wobei 1 ≤ i ≤ n und j = ⌈n / i⌉ .

Die Punktzahl für eine solche Anordnung ist | j - i | + (ij - n) , wobei der zweite Summand die Anzahl der leeren Stühle ist. Anstelle der tatsächlichen Ergebnisse können wir Ergebnisse vergleichen, die durch eine Konstante wie ij + | j - i | + 1 .

Es ist ausreichend, Paare [i, j] zu betrachten, bei denen i ≤ j ist, da die Anordnungen [i, j] und [j, i] gleichermaßen gültig sind. Wir beschäftigen uns mit streng absteigenden Paaren, indem wir stattdessen j = max (⌈n / i⌉, i) setzen , was sicherstellt, dass j ≥ i ist und eine suboptimale Punktzahl ergibt, wenn ⌈n / i⌉ <i ist .

Da j - i ≥ 0 ist , haben wir ij + | j - i | + 1 = ij + j - i + 1 = (i + 1) × (j - 1) , was in weniger Codebytes berechnet werden kann.

Schließlich gibt indmin/ indmaxden Index m (und damit den Wert von i ) der optimalen Anordnung an, der m mal ⌈n / m⌉ ist . Gleichstände werden beim ersten Auftreten gebrochen, was dem niedrigsten Wert von i entspricht , also dem höchsten Wert von j - i und damit dem niedrigsten Wert von ij - n (leere Stühle).

JavaScript (ES6) 74 78

Bearbeiten Sie, indem Sie das temporäre Ergebnis als Array anstelle von zwei Variablen speichern, die aus Thihts Antwort stammen

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

Weniger golfen

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
}

Prüfung

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>

PHP, 129 Bytes

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

PHP, 104 Bytes

Der Algorithmus, der dieses Problem löst, ist einfach und wird wahrscheinlich von anderen Antworten in PHP-ähnlichen Sprachen (JavaScript, z. B.) verwendet:

• Beginnen Sie mit einem großen Wert für die anfängliche Punktzahl. nist groß genug (wo nist der Eingabewert); die Punktzahl der Anordnung, die bei der ersten Iteration ( 1, n) berechnet wurde, ist (n-1)+0;
• iterieren Sie für alle Werte der Breite zwischen 1und n; Berechnen Sie die Mindesthöhe wie ceil(n/width)folgt: Berechnen Sie die Anordnungspunktzahl mithilfe der in der Frage angegebenen Formel (dh abs(width - height) + (width * height - n)). Wenn die Punktzahl besser ist als die vorherige beste Punktzahl, merken Sie sich die Breite, die Höhe und die neue beste Punktzahl. Verwenden Sie bei Verbindungen den Wert von width * height - nfür die aktuelle Anordnung und die vorherige beste Anordnung, um die neue beste Anordnung zu ermitteln.
• das ist alles.

Nach dem Golfen erzeugt dieser Algorithmus so etwas (zur besseren Lesbarkeit hier eingeschlossen):

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";

Es verwendet 137 Bytes (wenn es in eine einzelne Zeile gesetzt wird) und ist weit von den 104 Bytes entfernt, die im Titel angegeben sind. Der Code kann wahrscheinlich um weitere 2-3 Bytes gekürzt werden, aber die Hauptverbesserungsquelle liegt an einer anderen Stelle: in den Details des Algorithmus.

Der überarbeitete Algorithmus:

Es gibt mehrere Stellen, an denen der Algorithmus verbessert werden kann, indem nutzloser Code entfernt wird.

• Es ist nicht erforderlich, die Breite von 1bis zu iterieren $n. für die Geschwindigkeit, die Breite ( $imüssen) durchlaufen zwischen 1und floor(sqrt($n))dies macht aber den Code noch länger , anstatt sie zu verkürzen; Wenn die Breite jedoch nicht überschritten wird sqrt($n), ist die minimale Höhe ( $j) immer größer als sqrt($n)(ihr Produkt muss mindestens sein $n).
• Die vorherige Anweisung ermöglicht die Verwendung von $i <= $j(width <= height) als Abbruchbedingung für die Schleife. Auf diese Weise wird die Breite von 1bis iteriert , floor(sqrt($n))und die Höhe erhält Werte, die mit beginnen $nund bis ceil(sqrt($n))(nicht unbedingt alle) abfallen .
• Wenn wir wissen, dass die Breite immer kleiner oder gleich der Höhe ist, können wir wissen, dass dies abs(width - height)immer height - width( $j-$i) ist. 5 Bytes auf diese Weise gespeichert;
• Der Eingabewert $nwird für die Berechnung der Punktzahl verwendet (die Anzahl der nicht besetzten Plätze ist width * height - n), wird jedoch nicht benötigt. die Partitur muss nicht angezeigt werden, sie wird nur zum Vergleich der Arrangements berechnet; Durch Entfernen - naus der Bewertungsformel sparen wir weitere 3 Bytes (der PHP-Code ist -$n), ohne etwas zu verlieren.
• Bei den letzten beiden Anweisungen lautet die Bewertungsformel height - width + width * height( $j-$i+$i*$j).
• Bei Gleichstand (die Punktzahl des aktuellen Arrangements entspricht der vorherigen Bestpunktzahl) wird nach den Regeln das Arrangement mit weniger freien Plätzen verwendet. Da die Breite immer zunimmt und die Höhe immer abnimmt, nimmt der height - widthTeil der Partitur mit jedem Schritt ab.
• Wenn die aktuelle Punktzahl mit der vorherigen besten Punktzahl übereinstimmt, besagen die vorherigen Aussagen, dass die Anzahl der freien Plätze der aktuellen Vereinbarung größer ist als die der vorherigen besten Vereinbarung. Dies bedeutet, dass das bisher beste Arrangement das Unentschieden gewinnt.
• Da die Bande immer von der vorherigen besten Anordnung gewonnen werden, wird eine neue Anordnung nur dann zur neuen besten Anordnung, wenn ihre Punktzahl kleiner als die vorherige beste ist. Der Code, der nach Bindungen sucht, ist nutzlos und kann entfernt werden ( ||$c==$s&&$i*$j<$w*$h- viele Bytes).
• wegen der Entfernung von -$naus der Partiturformel ist die Partitur für die erste Anordnung ( 1x$n) $n-1+1*$n(dh 2*$n-1); Der Anfangswert der besten Bewertung ( $s) kann ein beliebiger Wert größer oder gleich sein 2*$n. Die erste Iteration hat eine bessere Punktzahl und ist die beste Anordnung, mit der der Algorithmus ohne Initialisierungsprobleme ausgeführt werden kann.

Der neue Code ( 104 Byte ) nach Anwendung der oben beschriebenen Verbesserungen lautet:

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";

Es wird hier zur besseren Lesbarkeit umbrochen. Stellen Sie dem obigen Code den PHP-Marker voran <?php(technisch gesehen ist er nicht Teil des Codes), fügen Sie ihn in eine Datei ein (sagen wir mal arrange-your-chairs.php) und führen Sie ihn mit einer Ganzzahl größer als Null als Argument aus. Hier werden Breite und Höhe der berechneten Anordnung durch Komma getrennt angezeigt:

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

Eine andere Lösung (116 Bytes)

Eine andere Lösung, die einen anderen Algorithmus verwendet:

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

Alle Kombinationen von mindestens $nSitzen werden in eine assoziative Liste aufgenommen. der Schlüssel ist die Textdarstellung des Arrangements, der Wert ist die Punktzahl des Arrangements. Anschließend wird die Liste sortiert (aufsteigend nach Wert) und der Schlüssel des ersten Eintrags abgerufen.

Ein weiteres (115 Bytes)

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";

Dies ist die PHP-Version von @ Neils Antwort (JavaScript / ES6, 85 Byte).

Es gibt einige bemerkenswerte Unterschiede aufgrund der Merkmale der einzelnen Sprachen:

• Die JS-Antwort generiert ein Array von n(undefinierten) Werten und verwendet dann ihre Schlüssel, um von 0bis zu iterieren n-1. es inkrementiert i( d=(n+i++)/i|0), um es von 1zu iterieren n; Die PHP-Lösung muss nicht erhöht werden. Es wird verwendet range(), um ein Array zu generieren. Anschließend werden die generierten Werte ( 1to n) zum Iterieren verwendet.
• Die Antwort von JS (n+i)/iusing konvertiert dann den Wert in eine Ganzzahl, wobei verwendet wird |0, um die kleinste Ganzzahl größer als zu erhalten n/i. Die PHP-Antwort löst dieses Problem auf einfache Weise mit der PHP-Funktion ceil(). JavaScript bietet auch Math.ceil(), verwendet jedoch 5 Byte mehr als die von Neil gefundene Lösung.
• PHP bietet eine array_map()ähnliche Funktion wie JS Array.map(), hilft aber hier nicht weiter. seine Syntax ist wortreich, a foreacherzeugt kürzeren Code; es ist jedoch größer als der JS-Code;
• Das Zusammenführen der Zuweisungen mit in die Bedingungen ||ist in PHP nicht möglich, da der Komma-Operator fehlt. Ich übersetzte a||b||cin if(!a&&!b)cdann, weil aund bVergleiche sind, negierte ich ihre Operatoren (ersetzt <durch >=); Dies erzeugt auch größeren Code als die JS-Version.
• Weitere 23 Bytes müssen hinzugefügt werden, nur weil den Namen der Variablen in PHP das Präfix vorangestellt werden muss $.

Die ungolfed Versionen aller Lösungen und der Testsuite sind auf Github zu finden .

JavaSCript (ES6), 83 Byte

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

Julia, 87

Ich denke, dies ist ein Schritt in Richtung einer magischen Funktion für das Problem:

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

Es sieht nur bei Paaren (i, j=(i+n)/(i+1))oder(i, j+1)

Oracle SQL 11.2, 173 Byte

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;

Nicht golfen

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

Q 58 Bytes

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

Lamba, der minimale Kosten für einen bestimmten Wert berechnet (x) und eine Folge von zwei Werten (Breite, Höhe) zurückgibt

Das Hinzufügen des Namens zu diesem Lambda erfordert zwei weitere Zeichen (z. B. {..} anstelle von {..}).

Prüfung

{..}'1+!100

wo {..} ist das Lambda. Lesen Sie als "Wendet Lambda auf jeden Wert von 1 + den ersten 100 Zoll an" (mit anderen Worten auf jeden Wert von 1..100)

Erzeugt

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

Erläuterung

Die verschachtelte Lamdba {((b<a)?1b)#+(b:-_-x%a;a:1+!x)}generiert alle Kandidatenpaare (Breite, Höhe) für x Stühle als zwei Sequenzen (w1, w2, w3 ..; h1, h2, h3 ..) (Breiten und Höhen). Von links nach rechts lesen, aber von rechts nach links auswerten

a:1+!x generiert Werte 1..x und ordnet diese Sequenz einem zu

-_- ist negate floor negate und implementiert ceil (ceil ist kein Primitiv der Sprache)

b:-_-x%aWendet ceil auf jeden Wert von x dividiert durch ein beliebiges Element im a an und weist die resultierende Sequenz b zu. Mit anderen Worten, b ist ceil jedes x geteilt durch jedes 1..x.

+(b;a) Geben Sie eine aus seq a und seq b zusammengesetzte Folge zurück, und drehen Sie sie dann um (das Ergebnis ist eine Folge von Paaren, wobei i-pair das Element i von a und das Element i von b enthält).

b<a vergleicht Element für Element von b und a und generiert eine Folge von logischen Werten (true = 1b für jeden Index, wobei b [i]

s?xLiefert die erste Position von Item x in der Reihenfolge s. Mit (b<a)?1bWir suchen nach 1b (wahrer Wert) in der Folge, die sich aus dem Vergleich von b und a ergibt, und erhalten die erste Position, an der b steht

n#sNimmt n erste n Elemente aus der Folge s. Wir wollen doppelte Paare verwerfen, also stoppen wir, wenn der erste Gegenstand eines Paares <der zweite Gegenstand ist (zB 13,1, aber nicht 1,13).

Als Nebeneffekt hat jedes Paar der resultierenden Sequenz einen abnehmenden Abstand zwischen a und b (ex (13 1; 7 2; 5 3; 4 4)

Das durch verschachteltes Lambda erzeugte Kandidatenpaar wird c zugewiesen. Wir kehren dann c um (erhalten b, a erneut) und wenden zwei Funktionen auf dieses Argument an: */multiplizieren und -/subtrahieren. Das Ergebnis von (-/;*/)@\:+cist die Differenz und das Produkt jedes Paares. +/ist die Summe und berechnet die Endkosten. Die Kosten für jeden Patir werden d zugewiesen

& / ist das Minimum, also sind &/d die minimalen Kosten. Mit d?&/dfinden wir das erste Auftreten von minimalen Kosten in d, und mit c @ .. erhalten wir das Paar an dieser Position. Da jedes Paar eine abnehmende Distanz zwischen a und n hat, hat das erste gefundene Minimum die maximale Distanz zwischen anderen minimalen Paaren, so dass wir die Bindungsregel korrekt anwenden