Sandalyelerinin nasıl düzenlendiği konusunda ilginç tercihlere sahip bir sınıf öğrencisine öğretiyorsunuz. Sandalyelerin nasıl düzenlendiğine ilişkin 3 çok özel gereksinim vardır:

1. Bazı sandalyeler boş olsa bile, çoğu dikdörtgen şeklinde düzenlenmiştir.

2. Mümkün olduğunca az boş sandalye bulunmalıdır.

3. Mümkün olduğunca "kare" olmalıdırlar. Kareliklik, dikdörtgenin genişliği ve yüksekliği arasındaki mesafe ile belirlenir, daha düşüktür. Örneğin, kare kare 4x73'tür.

Daha açık olmak gerekirse, bir düzenlemenin "puanı", genişlik ve yükseklik artı boş olacak sandalye sayısı arasındaki mesafedir.

Bir örnek verelim. Diyelim ki 13 öğrenciniz var. Sandalyeleri şu yollardan herhangi biriyle düzenleyebilirsiniz:

1x13
2x7
3x5
4x4

1x13çok kare değil. Aslında, 1 ve 13 birbirinden 12'dir; Ayrıca 0 boş sandalye var, bu yüzden bu düzenlemeye 12 puan vererek 0 puan ekliyoruz.

2x7kesinlikle daha iyi. 2 ve 7 aralarında sadece 5 tane var, bu yüzden bu düzenlemeye 5 puan veriyoruz. Bununla birlikte, aslında yedi sandalyeden oluşan 2 sıra ayarladıysanız, bu 14 sandalye alacaktır, yani bir sandalye boş olacaktır. Bu nedenle, bu düzenlemeye 6 puan vererek bir puan ekliyoruz.

Biz de yapabiliriz 3x5. 3 ve 5 ayrı 2, yani +2 puan. 15 sandalye gerekiyor, yani iki ekstra sandalyemiz olacak, yani 4 puan için başka bir +2 puan.

Son seçenek 4x4,. 4 ve 4 birbirinden ayrı, bu yüzden +0 puan veriyoruz. 4x4 16 sandalye alır, bu nedenle 3 sandalye toplam 3 puan için boşalır. Bu en uygun çözümdür.

Beraberlik durumunda, en uygun çözüm daha az boş sandalyeye sahip çözümdür.

Meydan okuma

Bir tamsayı alan ve bu sayıda öğrenci için en uygun koltuk düzenini sağlayan bir program veya işlev yazmalısınız. ES herhangi bir makul biçimde olabilir. 1'den 100'e kadar herhangi bir sayıda öğrenci için örnek çıktı:

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)

Her zamanki gibi, bu kod golf, bu yüzden standart boşluklar geçerlidir ve kazanan bayt cinsinden en kısa cevaptır.

Jöle , 16 15 14 bayt

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

Çevrimiçi deneyin! veya tüm test senaryolarını doğrulayın .

Nasıl çalışır

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

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

Daha “açık” olana eşdeğer:

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

Haskell, 65 bayt

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

Kullanım örneği: map f [1..5]-> [(1,1),(1,2),(2,2),(2,2),(2,3)].

Bir dış döngü vasıtasıyla gider agelen 1için x(-> öğrenci sayısı x) ve bir iç döngü bgelen 1için a. Her (b,a)yeri tutar a*b>=xve çiftleri ((arrangement points,seats left), (b,a))minimum bulmak için gereken sözcük sırasına göre oluşturur . Not: aher zamankinden daha büyüktür b, bu yüzden abskare biçimine ihtiyacımız yoktur. xSadece göreceli sipariş önemli olduğundan, "koltuk sol" puanı çıkarmaya gerek yok . Son olarak skor çiftini ile kaldırıyoruz snd.

Ruby, 64 bayt

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

Kişi sayısını argüman olarak alan ve en uygun çözümün genişliği ve yüksekliği olan bir dizi döndüren bir lambada.

MATL , 18 bayt

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

Çevrimiçi deneyin!

açıklama

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

İlk kod golf, bu yüzden yine de sonrası!

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}

Başlangıçta benim oboş bir nesneydi ve boş olup olmadığını kontrol ettim o.a, bu yüzden ilk turda özel bir durumdu. Ama edc65'in Infinity değişkenini başlatmak için verdiği cevapta 1/0 numara buldum.

Pyth, 24 22 21 bayt

Düzenleme : sıralama anahtarında, boş sandalye sayısını bulmak gerek olmadığını biliyoruz. Toplam sandalye sayısını puanlamaya eşittir. Bu beni 2 bayt kurtardı.

h.m_+B*FbaFbm,d.EcQdS

Çevrimiçi deneyin!

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)

• hile 1: miktarı 1-1/length*widthkravat puanlaması olarak ekledim

• hüner 2:number_students/length Dikdörtgenin genişliği için tavan hesapladı , üst sınır kare ama tavan da

• Eminim daha fazla golf oynayabilir ...

dene

Düzenleme: @StewieGriffin'in sözlerine atıfta bulunur.

Düzenleme 2:

• 1ve nsabitleri genel skora eklemenize gerek yok.
• Bir işlev, standart bağımsız programdan daha az bayt daha azdır.
• Ben çok fazla bayt tasarruf olsa artan sıralama tekniği kullandım.

Düzenleme 3: performans testi.

Python 2, 64 bayt

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

Bu, @ Lynn'in Python cevabının ( max(...)[1:]hile aldığım yerden ) ve Julia cevabımın algoritmasından (biraz daha kısa bir uygulamaya izin verir ) bir birleşimidir .

Ideone üzerinde test edin .

Julia, 61 59 55 53 52 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

Kod, cldtavan bölümü olan aşağıdaki, çözülmemiş versiyona eşdeğerdir .

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

Optimal düzenlemeyi bulmak için , 1 ≤ i ≤ n ve j = ⌈n / i⌉ çiftlerini [i, j] incelemek açıkça yeterlidir .

Böyle bir düzenleme için puan | j - i | + (ij - n) , burada ikinci özet boş sandalye sayısıdır. Gerçek puanlar yerine, bir sabit tarafından artırılan puanları karşılaştırabiliriz, örneğin ij + | j - i | + 1 .

Çiftleri değerlendirmek yeterlidir; [ij] i ≤ j düzenlemeleri yana [i, j] ve [j, i] de geçerlidir. Biz ayarlayarak kesinlikle azalan çiftleri başa = max (⌈n / i⌉, ı) j emin kılan yerine ≥ i j ve optimal olmayan bir skor eğer verecektir ⌈n / i⌉ <i .

Yana - j i 0 ≥ , elimizdeki j - i | ij + | + 1 = ij + j - i + 1 = (i + 1) × (j - 1) , daha az bayt kodda hesaplanabilir.

Son olarak indmin/ indmaxgöstergesi vermektedir m (ve böylece değeri i optimal düzenlemesinin, bir) m ile ⌈n / m⌉ . Bağlar ilk önce i'nin en düşük değerine , dolayısıyla en yüksek j - i değerine ve dolayısıyla en düşük ij - n değerine (boş sandalyeler) karşılık gelir.

JavaScript (ES6) 74 78

Thiht'ın cevabından ödünç alınan geçici sonucu 2 varyasyon yerine dizi olarak tutarak düzenleme

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

Daha az golf

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
}

Ölçek

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 bayt

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 bayt

Bu sorunu çözen algoritma basittir ve muhtemelen PHP (JavaScript, fe) gibi dillerdeki diğer cevaplar tarafından kullanılır:

• başlangıç ​​puanı için büyük bir değerle başlayın; nyeterince büyük ( ngiriş değeri nerede ); ilk yinelemede ( 1, n) hesaplanan düzenlemenin puanı(n-1)+0 ;
• 1ve arasındaki tüm genişlik değerleri için yineleme n; asgari yüksekliği ceil(n/width), soruda verilen formülü (yani abs(width - height) + (width * height - n)) kullanarak düzenleme puanını hesaplayın ; skor bir önceki en iyi skordan daha iyiyse genişliği, yüksekliği ve yeni en iyi skoru hatırlayın; bağlarda width * height - nmevcut düzenlemenin değerini ve yeni en iyi düzenlemeyi tespit etmek için önceki en iyi düzenlemeyi kullanın;
• bu kadar.

Golften sonra, bu algoritma böyle bir şey üretir (okunabilirlik için buraya sarılmıştır):

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 bayt kullanır (tek bir satıra konduğunda) ve başlıkta bildirilen 104 bayttan çok uzaktır. Kod muhtemelen 2-3 bayt daha kısaltılabilir, ancak büyük iyileştirme kaynağı başka bir yerde: algoritmanın ayrıntılarında.

Gözden geçirilmiş algoritma:

Yararsız kod kaldırılarak algoritmanın geliştirilebileceği birkaç yer vardır.

• gelen genişlik yineleme için bir ihtiyaç vardır 1için $n; hız için, width ( $i) yinelemelidir 1ve floor(sqrt($n))bu kodu kısaltmak yerine daha da uzun hale getirir; ancak genişlik aşılmazsa sqrt($n), minimum yükseklik ( $j) her zamankinden daha büyük olacaktır sqrt($n)(ürünleri en az olmalıdır $n);
• önceki ifade, $i <= $jdöngü için sonlandırma koşulu olarak (width <= height) kullanılmasına izin verir ; bu şekilde, genişlik ile arasında yineleme 1yapılır floor(sqrt($n))ve yükseklik, ile başlayan $nveceil(sqrt($n)) (değil mutlaka hepsiyle);
• genişliğin her zaman yüksekliğe eşit veya daha küçük olduğunu bilmek bize abs(width - height)her zaman height - width( $j-$i); 5 bayt bu şekilde kaydedildi;
• giriş değeri $n puanın hesaplanmasında kullanılır (boş koltuk sayısı width * height - n) ama gerekli değildir; puanın gösterilmesine gerek yoktur, sadece düzenlemelerin karşılaştırılması için hesaplanır; - npuan formülünden kaldırarak başka bir 3 bayt (PHP kodu -$n) bir şey kaybetmeden kaydeder;
• son iki cümle verildiğinde skor formülü height - width + width * height( $j-$i+$i*$j) olur ;
• bağlarda (mevcut düzenlemenin puanı bir önceki en iyi puanla aynıdır), kurallar düzenlemeyi daha az boş koltukla kullandığını söyler; çünkü genişlik her zaman artar ve yükseklik her zaman azalır, height - widthher adımda skorun bir kısmı azalır;
• mevcut puan önceki en iyi puanla eşitse, önceki ifadeler bize mevcut düzenlemenin serbest sandalye sayısının önceki en iyi düzenlemeden daha fazla olduğunu söyler; bu, önceki en iyi düzenlemenin berabere kazandığı anlamına gelir;
• bağlar her zaman bir önceki en iyi düzenleme ile kazanıldığından, yeni bir düzenleme ancak puanı bir önceki en iyi düzenlemeden daha küçük olduğunda yeni en iyi düzenleme haline gelir; ilişkileri kontrol eden kod işe yaramaz ve kaldırılabilir (||$c==$s&&$i*$j<$w*$h - çok bayt);
• -$nskorun formülünden çıkarılmasından dolayı , birinci düzenleme ( 1x$n) için skor $n-1+1*$n(yani 2*$n-1); en iyi puanın ( $s) başlangıç ​​değeri, daha büyük veya ona eşit herhangi bir değer olabilir 2*$n; ilk yinelemenin daha iyi bir puanı vardır ve algoritmanın başlatma sorunları olmadan çalışmasına izin veren en iyi düzenleme haline gelir.

Yukarıda açıklanan iyileştirmeleri uyguladıktan sonra yeni kod ( 104 bayt ):

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

Okunabilirlik için buraya sarılmıştır. PHP koduyla yukarıdaki kodu <?php(teknik olarak, kodun bir parçası değildir) ekleyin, bir dosyaya koyun (diyelim arrange-your-chairs.php) ve argüman olarak sıfırdan büyük bir tamsayı ile çalıştırın. Hesaplanan düzenlemenin genişliğini ve yüksekliğini virgülle ayırarak görüntüler:

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

Başka bir çözüm (116 bayt)

Farklı bir algoritma kullanan başka bir çözüm:

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

En azından $nkoltukların tüm kombinasyonlarını ilişkilendirilebilir bir listeye koyar ; anahtar düzenlemenin metin temsilidir, değer düzenlemenin puanıdır. Daha sonra listeyi sıralar (değere göre artan) ve ilk girişin anahtarını alır.

Bir tane daha (115 bayt)

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

Bu, Neil'in cevabının PHP versiyonudur (JavaScript / ES6, 85 bayt).

Her dilin özellikleri nedeniyle göze çarpan bazı farklılıklar vardır:

• JS yanıt bir dizi oluşturur no andan itibaren gezinmek için anahtarlarını kullanarak değerlerinin (tanımlanmamış) 0için n-1; Bu artırır i( d=(n+i++)/i|0) ile olan iterate yapmak 1için n; PHP çözümünün artırılması gerekmez; kullandığı range()bu (üretilen değerleri kullanan daha sonra bir dizi oluşturmak için 1için nyineleme için);
• JS yanıtı kullanır (n+i)/isonra değeri |0en küçük tamsayıyı daha büyük elde etmek için kullanarak tamsayıya dönüştürür n/i; PHP cevabı PHP fonksiyonuyla bu sorunu kolayca çözer ceil(); JavaScript de sağlar Math.ceil()ancak Neil tarafından bulunan çözümden 5 bayt daha fazla kullanır;
• PHP, array_map()JS ile bir şekilde benzer olan işlevi sağlar, Array.map()ancak burada yardımcı olmaz; sözdizimi ayrıntılı, birforeach daha kısa bir kod üretir; JS kodundan daha büyük olsa da;
• ||virgül operatörüne sahip olmadığından ödevleri kullanarak koşullara birleştirmek mümkün değildir; Ben tercüme a||b||ciçine if(!a&&!b)cçünkü o zaman ave bkarşılaştırmalar, ben (değiştirildi onların operatörleri etkisiz <ile >=); bu da JS sürümünden daha büyük kod üretir;
• PHP'deki değişkenlerin isimlerinin önüne ön ek verilmesi gerektiğinden başka bir 23 bayt eklenmelidir $.

Tüm çözümler ve test paketinin ungolfed versiyonları bulunabilir Github .

JavaSCript (ES6), 83 bayt

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

Bu sorun için sihirli bir işlev bulma yönünde bir adım olduğunu düşünüyorum :

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

Sadece çiftlere bakar (i, j=(i+n)/(i+1))veya(i, j+1)

Oracle SQL 11.2, 173 bayt

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;

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

Q 58 Bayt

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

Belirli bir değer (x) için minimum maliyeti hesaplayan ve iki değer (genişlik, yükseklik) dizisi döndüren Lamba

Bu lambda'ya ad eklemek için başka iki karakter daha gerekir ({..} yerine f: {..})

Ölçek

{..}'1+!100

burada {..} lambda. "Her 1 + ilk 100 int değerine lambda uygular" (diğer bir deyişle her değere 1..100) olarak okuyun.

üretir

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

açıklama

İç içe lamdba {((b<a)?1b)#+(b:-_-x%a;a:1+!x)}, x sandalyeler için tüm adayları (genişlik, yükseklik) çiftlerini iki sekans (w1 w2 w3 ..; h1 h2 h3 ..) (genişlik ve yükseklik) olarak üretir. Soldan sağa okur, ancak sağdan sola değerlendirir

a:1+!x 1..x değerlerini üretir ve bu diziyi bir

-_- zemini olumsuzlamak ve tavanı uygulamaktır (tavan dilin bir ilkeli değildir)

b:-_-x%ax'in her bir değerine im a öğesinin bölünmesiyle tavan uygular ve sonuçta oluşan diziyi b'ye atar. Başka bir deyişle, b, her bir x bölünmüş tavandır, her biri 1..x

+(b;a) seq a ve seq b'den oluşan bir güvenlik döndürür, sonra döndürür (sonuç, i-çiftinin a elemanını i ve b elemanını i içerdiği bir çift dizisidir)

b<a maddeyi b ve a öğelerine göre karşılaştırır ve mantıksal değerlerin güvenliğini üretir (b = i] 'nin her dizinde true = 1b

s?xx öğesinin s sırasındaki ilk konumunu döndürür. İle (b<a)?1bb ve a'yı karşılaştırarak sırayla 1b (gerçek değer) ararız ve b

n#sseq s'den ilk n öğeyi alır. Yinelenen çiftleri atmak istiyoruz, bu nedenle bir çift <ikinci öğenin ilk öğesi (ör. 13,1'i dikkate alın, ancak 1,13'ü dikkate almayın) dururuz.

Bir yan etki olarak, elde edilen sekansın her bir çifti a ve b arasındaki mesafeyi azaltır (ör. (13 1; 7 2; 5 3; 4 4)

Yuvalanmış lambda tarafından üretilen aday çifti c'ye atanır. Daha sonra c'yi çeviririz (b, a'yı tekrar alır) ve bu argümana iki işlev uygularız: */çarpar ve çıkar -/. Sonuç, (-/;*/)@\:+cher bir çiftin farkı ve ürünüdür.+/toplamı ve nihai maliyeti hesaplar. Her patirin maliyeti d

& / en düşük, bu nedenle &/d en düşük maliyettir. İle d?&/dbiz d ve c ile düşük maliyetle ilk geçtiği bulmak @ .. o pozisyonda çifti almak. Her çift a ve n arasındaki mesafeyi azalttığından, bulunan ilk minimum diğer minimum çiftler arasındaki maksimum mesafeye sahiptir, bu nedenle bağlama kuralını doğru şekilde uygularız