生徒の椅子にどのように椅子を配置するかについての興味深い好みを教えます。椅子の配置方法には3つの非常に具体的な要件があります。

1. 一部の椅子が空になることを意味する場合でも、ほとんどの場合、長方形に配置されます。

2. 空の椅子はできるだけ少なくする必要があります。

3. それらは可能な限り「正方形」でなければなりません。角型性は、長方形の幅と高さの間の距離によって決まり、低いほど良いです。たとえば4x7、3の角型性を持つ長方形。

より具体的には、配置の「スコア」は、幅と高さの間の距離に、空になる椅子の数を加えたものです。

例を見てみましょう。13人の生徒がいるとしましょう。次のいずれかの方法で椅子を配置できます。

1x13
2x7
3x5
4x4

1x13非常に角張っていません。実際、1と13は12離れているので、この配置に12ポイントを与えます。また、空の椅子は0なので、0ポイントを追加して、このアレンジメントに12のスコアを与えます。

2x7確かに優れています。2と7は5つしか離れていないので、この配置に5ポイントを与えます。ただし、実際に7列の椅子を2列配置した場合、14列の椅子が必要になり、1列の椅子は空になります。そのため、このアレンジメントにスコア6を与えて、1ポイントを追加します。

することもできます3x5。3と5は2つ離れているため、+ 2ポイントです。15脚の椅子が必要です。つまり、2脚の椅子が必要なので、スコアが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)

いつものように、これはコードゴルフなので、標準的な抜け穴が適用され、勝者はバイト単位の最短回答です。

ゼリー、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.

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

Haskell、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)]。

to aから外側のループ（x->学生数）とto から内側のループを通過します。最小値を見つけるために必要な辞書式順序に従う場所とビルドのペアをすべて保持します。注：は常により大きいため、直角度は必要ありません。相対的な順序のみが重要であるため、「左の座席」スコアから減算する必要はありません。最後に、でスコアペアを削除します。1xb1a(b,a)a*b>=x((arrangement points,seats left), (b,a))ababsxsnd

ルビー、64バイト

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

引数として人の数を取り、最適なソリューションの幅と高さの配列を返すラムダ。

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

Javascript、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の回答で変数をInfinityに初期化する1/0トリックを見つけました。

Pyth、24 22 21バイト

編集：並べ替えキーで、空の椅子の数を見つける必要がないことがわかります。これは、椅子の総数を点数化するのと同じです。これで2バイト節約できました。

h.m_+B*FbaFbm,d.EcQdS

オンラインでお試しください！

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定数には、全体的なスコアに」日を追加する必要はありません。
• 関数は、stdinスタンドアロンプ​​ログラムより数バイト少ないです。
• しかし、あまりにも多くのバイトを節約するために、アセンダントソート手法を使用しました。

編集3：パフォーマンステスト。

Python 2、64バイト

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

これは、@ LynnのPythonの回答（私がmax(...)[1:]トリックをとった場所）とJuliaの回答（わずかに短い実装を可能にする）のアルゴリズムの融合です。

Ideoneでテストします。

ジュリア、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 =⌈n/i⌉。

このような配置のスコアは| j-i |です +（ij-n）、2番目の被加数は空の椅子の数です。実際のスコアの代わりに、ij + | j-i |などの定数で補強されたスコアを比較できます。+ 1。

これは、ペアを検討するのに十分である[I、J] 私は≤jの手配から[I、J]と[J、I]は、同様に有効です。次のように設定することで、厳密に下降するペアを処理します MAX（⌈n/i⌉、I）= jで代わりに、そのことを確認しますjは≥私とあれば、次善のスコアを得られます⌈n/i⌉私は<。

以来 J - I≥0 、我々は持っている+ IJを| J - I | + 1 = ij + j-i + 1 =（i + 1）×（j-1）。これは、より少ないバイトのコードで計算できます。

最後にindmin/ indmaxインデックス付与M（したがって、値Iであり、最適な配置の）Mによって⌈n/m⌉を。タイは、iの最低値、つまりj-iの最高値、したがってij-nの最低値に対応する最初のオカレンスによって分割されます。（空の椅子）にます。

JavaScript（ES6）74 78

編集Thihtの答えから借用した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>

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

ゴルフをしていない：

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バイト

この問題を解決するアルゴリズムは単純であり、おそらくPHP（JavaScript、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バイトを（1行に配置する場合）、タイトルでアドバタイズされる104バイトとはかけ離れています。コードはおそらく2〜3バイト短くなる可能性がありますが、大きな改善の源はどこかにあります。アルゴリズムの詳細です。

改訂されたアルゴリズム：

無駄なコードを削除することでアルゴリズムを改善できる場所がいくつかあります。

• から1まで幅を繰り返す必要はありません$n。速度のために、幅（$i）はその間1を繰り返す必要がありますfloor(sqrt($n))が、これによりコードは短くなる代わりにさらに長くなります。ただし、幅がを超えない場合sqrt($n)、最小高さ（$j）は常にsqrt($n)（製品は少なくともでなければなりません$n）より大きくなります。
• 前のステートメントでは$i <= $j、ループの終了条件として（width <= height）を使用できます。この方法は、幅がから反復されます1とfloor(sqrt($n))、高さの値が始まるでしょう$nとまで行きますceil(sqrt($n))（必ずしもそれらのすべて）。
• 幅が常に高さ以下であることを知っているabs(width - height)と、それが常にheight - width（$j-$i）であるます。この方法で5バイト節約されました。
• 入力値$nはスコアの計算に使用されます（空席数はですwidth * height - n）が、必要ありません。スコアを表示する必要はありません。アレンジの比較のためにのみ計算されます。- nスコア式から削除することにより、-$n何も失わずにさらに3バイト（PHPコードは）節約します。
• 最後の2つのステートメントが与えられると、スコア式はheight - width + width * height（$j-$i+$i*$j）になります。
• 同点の場合（現在のアレンジメントのスコアは前のベストスコアと同じです）、ルールは、より少ない自由席でアレンジメントを使用することを言います。幅は常に増加し、高さは常に減少するため、height - widthスコア一部は各ステップで減少します。
• 現在のスコアが前のベストスコアと等しい場合、前のステートメントは、現在のアレンジメントの自由席の数が前のベストアレンジメントの自由席の数より多いことを示しています。これは、以前の最良の配置がネクタイに勝つことを意味します。
• ネクタイは常に以前のベストアレンジメントで勝つため、スコアが以前のベストアレンジよりも小さい場合にのみ、新しいアレンジメントが新しいベストアレンジメントになります。関係をチェックするコードは役に立たず、削除できます（||$c==$s&&$i*$j<$w*$h-大量のバイト）;
• -$nスコアの式からの削除のため、最初の配置（1x$n）のスコアは$n-1+1*$n（ie 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座席のすべての組み合わせを連想リストに入れます。キーはアレンジメントのテキスト表現で、値はアレンジメントのスコアです。次に、リストをソートし（値で昇順）、最初のエントリのキーを取得します。

もう1つ（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";

これは@Neil の回答のPHPバージョンです（JavaScript / ES6、85バイト）。

各言語の機能により、いくつかの顕著な違いがあります。

• JS回答はn（未定義の）値の配列を生成し、そのキーを使用してtoから反復0しn-1ます。toを反復させるためにi（d=(n+i++)/i|0）をインクリメント1しnます。PHPソリューションを増やす必要はありません。それが使用するrange()アレイを生成するために、それは（生成された値を使用1しますn反復します）。
• JSの回答は(n+i)/i、を使用して値を整数に変換し、を|0超える最小の整数を取得しn/iます。PHPの回答は、PHP関数を使用してこの問題を簡単に解決しますceil()。JavaScriptも提供しますMath.ceil()が、Neilが見つけたソリューションよりも5バイト多く使用します。
• PHPは、array_map()JSと多少似た機能を提供しますが、Array.map()ここでは役に立ちません。その構文は冗長であり、foreachはより短いコードを生成します。ただし、JSコードよりも大きくなります。
• ||PHPでは、カンマ演算子がないため、割り当てを使用して条件にマージすることはできません。私は翻訳a||b||cの中にif(!a&&!b)cあるため、その後、aとb比較され、私は（置き換え、その演算子を否定<して>=）。これにより、JSバージョンよりも大きなコードが生成されます。
• PHPの変数名の前にを付ける必要があるため、さらに23バイトを追加する必要があります$。

すべてのソリューションの未使用バージョンとテストスイートは、Githubにあります。

JavaSCript（ES6）、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

ジュリア、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)

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;

ゴルフをしていない

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バイト

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

特定の値（x）の最小コストを計算し、2つの値（幅、高さ）のシーケンスを返すLamba

そのラムダに名前を追加するには、他の2文字が必要です（例：{..}の代わりにf：{..}）

テスト

{..}'1+!100

{..}はラムダです。「1+最初の100 intの各値にラムダを適用する」（言い換えると、各値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
..

説明

ネストされたlamdba {((b<a)?1b)#+(b:-_-x%a;a:1+!x)}は、xの椅子のすべての候補（widht、height）ペアを2つのシーケンス（w1 w2 w3 ..; h1 h2 h3 ..）（幅と高さ）として生成します。左から右に読むが、右から左に評価する

a:1+!x 値1..xを生成し、そのシーケンスを

-_- ネゲートフロアネゲートであり、ceilを実装します（ceilは言語のプリミティブではありません）

b:-_-x%a任意の項目im aで除算されたxの各値にceilを適用し、結果のシーケンスをbに割り当てます。言い換えると、bはceil各x分割された各1..x

+(b;a) seq aとseq bで構成されるsecuenceを返し、それを反転します（結果はiペアがaの要素iとbの要素iを含むペアのシーケンスです）

b<a bとaのアイテムごとにアイテムを比較し、論理値のシーケンスを生成します（b [i]の各インデックスに対してtrue = 1b

s?xシーケンスsのアイテムxの最初の位置を返します。(b<a)?1b私たちは、コンペアBとの結果のシーケンスで1B（真値）を探し、そしてここで、b最初の位置を取得します

n#sseq sから最初のn個のアイテムを取得します。重複するペアを破棄するため、ペアの最初のアイテム<2番目のアイテム（13.1ではなく、13ではなく13を考慮）で停止します。

副作用として、結果のシーケンスの各ペアは、aとbの間の距離が減少します（ex（13 1; 7 2; 5 3; 4 4）

ネストされたラムダによって生成された候補ペアはcに割り当てられます。次に、cを反転し（再びb、aを取得）、2つの関数をその引数に適用します。*/乗算と-/減算です。の結果(-/;*/)@\:+cは、各ペアの差と積です。+/合計で、calcularesの最終コストです。各パティルのコストはdに割り当てられます

＆/は最小オーバーであるため、&/dは最小コストです。ではd?&/d、私たちDで、そしてCとの最小コストの最初の発生を見つける@ ..我々はその位置でペアを取得します。各ペアはaとnの間で距離が減少しているため、最初に見つかった最小値は他の最小ペアよりも最大距離にあるため、タイルールを正しく適用します。