의자 배치 방법에 대한 흥미로운 선호도를 가진 학생들에게 수업을 진행합니다. 의자 배치 방법에 대한 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 개가되어 의자 하나가 비어있게됩니다. 그래서 우리는 한 점을 더해서이 배열에 6 점을줍니다.

우리는 또한 할 수있었습니다 3x5. 3과 5는 2 개 떨어져 있으므로 +2 점입니다. 15 개의 의자가 필요합니다. 즉, 2 개의 추가 의자가 있으므로 다른 점수는 2 점으로 4 점을 얻습니다.

마지막 옵션 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.

파이썬 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)

하스켈, 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)). 참고 : a는 항상보다 큽니다 b. 따라서 우리는 구 형성을 필요 abs로 하지 않습니다 . x상대적 순서 만 중요하기 때문에 "좌측 자리수"점수에서 빼지 않아도됩니다 . 마지막으로으로 점수 쌍을 제거합니다 snd.

루비, 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

자바 스크립트, 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였고 비어 있는지 확인 했으므로 첫 번째 라운드에서 특별한 경우였습니다. 그러나 변수를 Infinity로 초기화하는 edc65의 답변에서 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 상수에는 전체 점수에 그들을 추가 할 필요가 없습니다.
• 함수는 표준 독립형 프로그램보다 몇 바이트 적습니다.
• 나는 너무 많은 바이트를 절약하는 오름차순 정렬 기술을 사용했습니다.

편집 3 : 성능 테스트.

파이썬 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]

온라인으로 사용해보십시오!

작동 원리

이 코드는 다음과 같은 ungolfed 버전과 동일합니다 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 ≤ N ≤ I 및 J = ⌈n / i⌉ .

이러한 배치에 대한 점수는 | j-i | + (ij-n) . 여기서 두 번째 소환은 비어있는 의자의 수입니다. 실제 점수 대신 ij + | j-i | 와 같은 상수로 증가 된 점수를 비교할 수 있습니다. + 1 .

이것은 쌍을 고려하기에 충분하다 [I, J] 난 ≤ J 약정 보낸 [I, J] 및 [J, I]는 똑같이 유효하다. 대신 j = max (⌈n / i⌉, i) 를 설정하여 내림차순으로 엄격하게 내림차순을 처리합니다. 그러면 j ≥ i 이고 / n / i⌉ <i 인 경우 차선의 점수를 얻습니다 .

이후 - J i가 0 ≥ , 우리가 J - 내가 | IJ는 +를 | + 1 = ij + j-i + 1 = (i + 1) × (j-1) , 더 적은 바이트의 코드로 계산할 수 있습니다.

마지막 indmin/ indmax인덱스 제공 m (따라서, 및의 값 내가 되는 최적 배열의) m 의해 ⌈n / m⌉를 . 동점은 첫 번째 발생으로 나뉩니다. 이는 i 의 가장 낮은 값 , 따라서 j-i 의 가장 높은 값, 따라서 ij-n 의 가장 낮은 값 (빈 의자)에 해당합니다.

자바 스크립트 (ES6) 74 78

Thiht의 답변에서 빌린 2 개의 var 대신 배열로 임시 결과를 유지하는 편집

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 바이트를 사용 합니다 (한 줄에 넣으면)과 멀리 표제 보급 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점수 공식에서 제거함으로써 우리는 -$n아무것도 잃지 않고 또 다른 3 바이트 (PHP 코드는 )를 절약합니다 .
• 마지막 두 문장이 주어지면 점수 공식은 height - width + width * height( $j-$i+$i*$j)이됩니다.
• 동점 (현재 배치의 점수는 이전 최고 점수와 동일)에서 규칙은 자유 좌석이 적은 배치를 사용하도록 규정합니다. 너비는 항상 증가하고 높이는 항상 감소하기 때문에height - width 하므로 점수 일부는 각 단계에서 감소합니다.
• 현재 점수가 이전 최고 점수와 동일한 경우, 이전 진술은 현재 배치의 자유 좌석 수가 이전 최고 배치보다 더 많다는 것을 알려줍니다. 이것은 이전의 최선의 배치가 동점임을 의미합니다.
• 동점은 항상 이전 최고 합의에 의해 이뤄지기 때문에, 새로운 합의는 그 최고점이 이전 최고보다 더 작은 경우에만 새로운 최고 합의가됩니다. 유무를 확인하는 코드는 쓸모가 없으며 제거 할 수 있습니다 (||$c==$s&&$i*$j<$w*$h -많은 바이트).
• -$n스코어의 공식으로부터 의 제거로 인해 , 제 1 배열 ( 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.php0 이라고 말함 ) 인수로 0보다 큰 정수로 실행하십시오. 계산 된 배열의 너비와 높이를 쉼표로 구분하여 표시합니다.

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

이것은 @Neil 의 답변 (JavaScript / ES6, 85 바이트) 의 PHP 버전입니다 .

각 언어의 기능으로 인해 눈에 띄는 차이점이 있습니다.

• JS 응답은 n(정의되지 않은) 값 의 배열을 생성 한 다음 해당 키를 사용하여 반복 0합니다 n-1. 그것은 증가 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의 비교는, I (대체 자신의 연산자를 부정 <으로 >=); 이것은 또한 JS 버전보다 더 큰 코드를 생성합니다.
• PHP의 변수 이름 앞에 접두사를 붙여야하기 때문에 다른 23 바이트를 추가해야합니다. $ .

모든 솔루션과 테스트 스위트의 ungolfed 버전은 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)에 대한 최소 비용을 계산하고 두 값의 시퀀스 (폭, 높이)를 반환하는 Lamba

해당 람다에 이름을 추가하려면 다른 두 문자가 필요합니다 (예 : {..} 대신 f : {..}).

테스트

{..}'1+!100

여기서 {..}는 람다입니다. "1 + 처음 100 정수의 각 값에 람다를 적용합니다"(즉, 각 값 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)} 는 x 의자에 대한 모든 후보 (widht, height) 쌍을 두 개의 시퀀스 (w1 w2 w3 ..; h1 h2 h3 ..) (폭 및 높이)로 생성합니다. 왼쪽에서 오른쪽으로 읽지 만 오른쪽에서 왼쪽으로 평가

a:1+!x 값 1..x를 생성하고 해당 시퀀스를

-_- 부정적 플로어 부정적이며 ceil을 구현합니다 (ceil은 언어의 기본이 아닙니다)

b:-_-x%ax의 각 값을 임의의 항목 im a로 나눈 ceil을 적용하고 결과 시퀀스를 b에 할당합니다. 즉, b는 각각의 x를 각각 1..x로 나눈다.

+(b;a) seq a와 seq b로 구성된 secuence를 반환하고 a를 뒤집습니다 (결과는 i-pair가 a의 요소 i와 b의 i 요소를 포함하는 쌍의 시퀀스입니다)

b<a b와 a의 항목을 기준으로 항목을 비교하고 논리 값의 보안 성을 생성합니다 (b [i]

s?xx의 첫 번째 위치를 순서대로 반환합니다. 함께 (b<a)?1b우리는 비교 B와의 결과 순서 1B (참값)에 대한보고, 첫 번째 위치 어디에 B를 얻을 수

n#sseq에서 n 개의 처음 n 개 항목을 가져옵니다. 중복 쌍을 버리고 싶기 때문에 쌍의 첫 번째 항목 <두 번째 항목 (예 : 13,1은 고려하지만 1,13은 고려하지 않음) 일 때 중지합니다.

부작용으로, 결과 시퀀스의 각 쌍은 a와 b 사이의 거리가 감소합니다 (예 : (13 1; 7 2; 5 3; 4 4)

중첩 된 람다에 의해 생성 된 후보 쌍은 c에 할당됩니다. 그런 다음 c를 뒤집고 (b를 다시 얻음) 인수에 */곱하기와 -/빼기의 두 함수를 적용 합니다. 결과는 (-/;*/)@\:+c각 쌍의 차이와 곱입니다. +/합계이며, 최종 계산 비용입니다. 각 patir의 비용은 d에 할당

& /는 최소 이상이므로 &/d는 최소 비용입니다. 함께 d?&/d우리 D, 그리고 C와 최소의 비용의 첫번째 발생을 찾을 @ .. 우리는 그 위치에 쌍을 검색한다. 각 쌍의 a와 n 사이의 거리가 줄어들 기 때문에 발견 된 첫 번째 최소값은 다른 최소 쌍 사이의 최대 거리를 가지므로 넥타이 규칙을 올바르게 적용합니다.