Gerçek çizgi üzerinde ileri geri katlanmış bir ip (düşünülen ipte olduğu gibi "bir demet karakter" deki gibi) düşünün. Dize şeklini, içinden geçtiği noktaların bir listesini (sırayla) açıklayabiliriz. Basit olması için, tüm bu noktaların tamsayı olduğunu varsayacağız.

Örnek olarak alın [-1, 3, 1, -2, 5, 2, 3, 4](her girişin bir katlama yapmadığına dikkat edin):

^{Dikey yön boyunca uzanan tel sadece görselleştirme amaçlıdır. Tüm gerçek çizgiye düzleştirilmiş dize düşünün.}

Şimdi soru şu: bu dizginin tek bir kesimle kesilebilecek en fazla parça sayısı nedir (yukarıdaki resimde dikey olması gerekir). Bu durumda, cevap 6 arasında 2ve arasında herhangi bir yerde bir kesiklidir 3:

Önlemek belirsizlikler için, kesme sahip bir tam sayı olmayan konumunda gerçekleştirilmelidir.

Meydan okuma

Bir tamsayı konumlarının bir listesi göz önüne alındığında, bir dize, tamsayı olmayan bir konumda tek bir kesimle kesilebilecek en fazla parça sayısını belirlersiniz.

Tam bir program veya bir fonksiyon yazabilirsiniz. STDIN, komut satırı argümanı, prompt veya function parametresi ile giriş yapabilirsiniz. Çıktıları STDOUT'a yazabilir, bir iletişim kutusunda görüntüleyebilir veya işlevden geri döndürebilirsiniz.

Listenin herhangi bir uygun liste veya dize biçiminde olduğunu varsayabilirsiniz.

Listede en az 2 ve en fazla 100 giriş bulunacaktır . Girişler, her biri -2 ³¹ ≤ p _i <2 ³¹ aralığında tamsayılar olacaktır . İki ardışık girişin aynı olmadığını varsayabilirsiniz.

Kodunuz makul bir masaüstü PC'de böyle bir girişi (aşağıdaki test durumları dahil) 10 saniyeden kısa sürede işlemelidir.

Test Kılıfları

Tüm test durumları basitçe girdi ve ardından çıktı olarak girilir.

[0, 1]
2

[2147483647, -2147483648]
2

[0, 1, -1]
3

[1, 0, -1]
2

[-1, 3, 1, -2, 5, 2, 3, 4]
6

[-1122432493, -1297520062, 1893305528, 1165360246, -1888929223, 385040723, -80352673, 1372936505, 2115121074, -1856246962, 1501350808, -183583125, 2134014610, 720827868,  -1915801069, -829434432, 444418495, -207928085, -764106377, -180766255, 429579526,  -1887092002, -1139248992, -1967220622, -541417291, -1617463896, 517511661, -1781260846,  -804604982, 834431625, 1800360467, 603678316, 557395424, -763031007, -1336769888,  -1871888929, 1594598244, 1789292665, 962604079, -1185224024, 199953143, -1078097556, 1286821852, -1441858782, -1050367058, 956106641, -1792710927, -417329507, 1298074488,  -2081642949, -1142130252, 2069006433, -889029611, 2083629927, 1621142867, -1340561463,  676558478, 78265900, -1317128172, 1763225513, 1783160195, 483383997, -1548533202,  2122113423, -1197641704, 319428736, -116274800, -888049925, -798148170, 1768740405,  473572890, -1931167061, -298056529, 1602950715, -412370479, -2044658831, -1165885212,  -865307089, -969908936, 203868919, 278855174, -729662598, -1950547957, 679003141,  1423171080, 1870799802, 1978532600, 107162612, -1482878754, -1512232885, 1595639326,  1848766908, -321446009, -1491438272, 1619109855, 351277170, 1034981600, 421097157,  1072577364, -538901064]
53

[-2142140080, -2066313811, -2015945568, -2013211927, -1988504811, -1884073403, -1860777718,  -1852780618, -1829202121, -1754543670, -1589422902, -1557970039, -1507704627, -1410033893,  -1313864752, -1191655050, -1183729403, -1155076106, -1150685547, -1148162179, -1143013543,  -1012615847, -914543424, -898063429, -831941836, -808337369, -807593292, -775755312, -682786953, -679343381, -657346098, -616936747, -545017823, -522339238, -501194053,  -473081322, -376141541, -350526016, -344380659, -341195356, -303406389, -285611307, -282860017, -156809093, -127312384, -24161190, -420036, 50190256, 74000721, 84358785,  102958758, 124538981, 131053395, 280688418, 281444103, 303002802, 309255004, 360083648,  400920491, 429956579, 478710051, 500159683, 518335017, 559645553, 560041153, 638459051,  640161676, 643850364, 671996492, 733068514, 743285502, 1027514169, 1142193844, 1145750868,  1187862077, 1219366484, 1347996225, 1357239296, 1384342636, 1387532909, 1408330157,  1490584236, 1496234950, 1515355210, 1567464831, 1790076258, 1829519996, 1889752281,  1903484827, 1904323014, 1912488777, 1939200260, 2061174784, 2074677533, 2080731335, 2111876929, 2115658011, 2118089950, 2127342676, 2145430585]
2

APL, 16 14 bayt

1+⌈/+/2≠/∘.≤⍨⎕

2 byte tasarruf için @ngn teşekkürler.

Bu ⎕aslında bir kutu karakteridir, eksik yazı tipi hatası değildir. Programı tryapl.org adresinde deneyebilirsiniz , ancak ⎕orada tam olarak desteklenmediğinden, giriş değeriyle değiştirmeniz gerekir:

    1+⌈/+/2≠/∘.≤⍨ ¯1 3 1 ¯2 5 2 3 4
6

açıklama

Program en iyi şekilde s = ¯1 3 1 ¯2 5 2 3 4STDIN tarafından alınan örnek girişle açıklanmaktadır ⎕. İlk önce ≤-outer ürününü skullanarak kendisiyle hesaplıyoruz ∘.≤⍨. Bu i, hangi satırında hangi unsurların sdaha küçük veya ona eşit olduğunu söyleyen bir Boolean matrisiyle sonuçlanır s[i]:

1 1 1 0 1 1 1 1
0 1 0 0 1 0 1 1
0 1 1 0 1 1 1 1
1 1 1 1 1 1 1 1
0 0 0 0 1 0 0 0
0 1 0 0 1 1 1 1
0 1 0 0 1 0 1 1
0 0 0 0 1 0 0 1

Satır işaretinin üzerinde 0 1ve 1 0üstünde oluşması i, dizenin noktadan geçtiği yerleri gösterir s[i] + 0.5. Bunları her satırda eşleştiriyoruz 2≠/, "2 listeyi azaltarak ≠":

0 0 1 1 0 0 0
1 1 0 1 1 1 0
1 0 1 1 0 0 0
0 0 0 0 0 0 0
0 0 0 1 1 0 0
1 1 0 1 0 0 0
1 1 0 1 1 1 0
0 0 0 1 1 0 1

Geriye kalan, satırların toplamını almaktır. +/

2 5 3 0 2 3 5 3

ve bunlardan biri artı bir artı 1+⌈/:

6

Çoğu APL uygulamasında sonuç otomatik olarak STDOUT'a yazdırılır.

Python, 88 75 73 bayt

lambda x:max(sum((a+.5-m)*(a+.5-n)<0for m,n in zip(x,x[1:]))for a in x)+1

Sadece basit bir lambda

Sadece başka bir yaklaşım göstermek için:

Pyth, 28 27 bayt

heSmsmq@S+k(d)1dC,QtQm+b.5Q

Bu kabaca eşdeğerdir

lambda x:max(sum(a+.5==sorted(n+(a+.5,))[1]for n in zip(x,x[1:]))for a in x)+1

STDIN'den giriş listesine uygulanır. Çevrimiçi tercüman üzerinde deneyin .

Pyth : 31 30 29 28 24 23 karakter (Python 68 karakter)

heSmsm&<hSkdgeSkdC,tQQQ

Burada deneyin: Pyth Derleyici / Yürütücü

Girdi olarak bir tamsayı listesi bekliyor [-1, 3, 1, -2, 5, 2, 3, 4]

Python programımın basit bir çevirisi:

lambda s:1+max(sum(min(a)<i<=max(a)for a in zip(s,s[1:]))for i in s)

Eski çözüm: Pyth 28 karakter

Sadece arşivleme sebeplerinden dolayı.

heSmsm<*-dhk-dek0C,tQQm+b.5Q

Karşılık gelen bir Python kodu şöyle olacaktır:

f=lambda x:1+max(sum((i-a)*(i-b)<0for a,b in zip(x,x[1:]))for i in [j+.5 for j in x])

CJam, 36 34 33 30 bayt

q~[__(+]zW<f{f{1$+$#1=}1b}$W=)

Vahşi doğada daha iyi bir algoritma olduğuna inanıyorum. Yine de bu, tüm test senaryoları için gereken sınırın altında çalışır (çevrimiçi derleyicide bile)

Giriş gibidir

[-2142140080 -2066313811 -2015945568 -2013211927 -1988504811 -1884073403 -1860777718  -1852780618 -1829202121 -1754543670 -1589422902 -1557970039 -1507704627 -1410033893  -1313864752 -1191655050 -1183729403 -1155076106 -1150685547 -1148162179 -1143013543  -1012615847 -914543424 -898063429 -831941836 -808337369 -807593292 -775755312 -682786953 -679343381 -657346098 -616936747 -545017823 -522339238 -501194053  -473081322 -376141541 -350526016 -344380659 -341195356 -303406389 -285611307 -282860017 -156809093 -127312384 -24161190 -420036 50190256 74000721 84358785  102958758 124538981 131053395 280688418 281444103 303002802 309255004 360083648  400920491 429956579 478710051 500159683 518335017 559645553 560041153 638459051  640161676 643850364 671996492 733068514 743285502 1027514169 1142193844 1145750868  1187862077 1219366484 1347996225 1357239296 1384342636 1387532909 1408330157  1490584236 1496234950 1515355210 1567464831 1790076258 1829519996 1889752281  1903484827 1904323014 1912488777 1939200260 2061174784 2074677533 2080731335 2111876929 2115658011 2118089950 2127342676 2145430585]

Çıktı (yukarıdaki durum için)

2

Nasıl çalışır

q~[__(+]zW<f{f{1$+$#1=}1b}$W=)
q~                                "Evaluate input string as array";
  [__                             "Put two copies of it in an array";
     (+]                          "Shift first element of second copy to its end";
        z                         "Zip together the two arrays. This creates";
                                  "pair of adjacent elements of the input.";
         W<                       "Remove the last pair";
           f{            }        "For each element of input array, take the zipped";
                                  "array and run the code block";
             f{       }           "For each element of the zipped array along with";
                                  "the current element from input array, run this block";
               1$+                "Copy the current number and add it to the pair";
                  $#              "Sort the pair and find index of current number";;
                    1=            "check if index == 1 for a < I <= b check";
                       1b         "Get how many pairs have this number inside of them";
                          $W=)    "Get the maximum parts the rope can be cut into";

Şimdi giriş dizisinin, [-1 3 1 -2 5 2 3 4]sıkıştırma adımlarının şöyle olduğunu varsayalım :

[-1 3 1 -2 5 2 3 4] [[-1 3 1 -2 5 2 3 4] [-1 3 1 -2 5 2 3 4]
[-1 3 1 -2 5 2 3 4] [[-1 3 1 -2 5 2 3 4] [3 1 -2 5 2 3 4 -1]
[-1 3 1 -2 5 2 3 4] [[-1 3] [3 1] [1 -2] [-2 5] [5 2] [2 3] [3 4]]]

Son satırdaki ikinci dizi, dizenin kıvrımlarıdır.

Şimdi yineliyoruz [-1 3 1 -2 5 2 3 4]ve her birinin içinde bulunduğu kümelerin sayısını hesaplıyoruz. Bu sayıdan maksimum verimi alın, arttırın ve cevabımızı aldık.

Burada çevrimiçi deneyin

Matlab (123) (97) (85)

Yay, nihayet XNOR için bir kullanım =) Ben daha çok aşağı golf olabilir eminim.

Ama dürüst olmak gerekirse, MatLab'ın en iyi bildiğim dil haline gelmesinden biraz korktum.

Yaklaşık çalışma zamanı O(n^2).

EDIT2:

a=input();v=2:nnz(a);disp(max(arrayfun(@(e)sum(~xor(a(v-1)<e,e<a(v))),sort(a)-.5))+1)

EDIT: Yeni golf oyunu (@DennisJaheruddin'den gelen ipuçları da dahil, teşekkürler!)

a=input();c=sort(a)-.5;n=0;v=2:nnz(c);for e=c;n=[n,sum(~xor(a(v-1)<e,e<a(v)))];end;disp(max(n)+1)

Eski versiyon:

a=input();
c=conv(sort(a),[.5,.5],'valid');' %find all cutting positions by taking the mean of two successive points
k=numel(c);
for e=1:k %iterate over all 'cuts'
    n(e)=sum(~xor(a(1:k)<c(e),c(e)<a(2:k+1)));%find the number of threads the cut cuts
end
disp(max(n)+1) %output the max

@ MartinBüttner: Benim yatmadan önce karşılaştığım zorluklardan çok hoşlanıyorum!

Mathematica 134 133 104

Kodun boyutuna rağmen çözmek için eğlenceli. Daha golf hala fikrini değiştirerek elde edilebilir IntervalMemberQ[Interval[a,b],n]ile a<n<b.

n_~f~i_:=Count[IntervalMemberQ[#,n]&/@i,1>0];
g@l_:=Max[f[#,Interval/@Partition[l,2,1]]&/@(Union@l+.5)]+1

g[{-1, 3, 1, -2, 5, 2, 3, 4}]

6

açıklama

list1verilen noktaların list2listesi, katlanmayan sayıları kaldıran kısaltılmış bir listedir; onlar alakasız. Bunu yapmak gerekli değildir, ancak daha açık ve verimli bir çözüme yol açar.

list1 = {-1, 3, 1, -2, 5, 2, 3, 4};
list2 = {-1, 3, 1, -2, 5,2, 3, 4} //. {beg___, a_, b_, c_, end___} /; (a <= b <= c) 
 \[Or] (a >= b >= c) :> {beg, a, c, end}

Aşağıdaki aralıklarda list1ve aralıklarla list2gösterilmektedir:

NumberLinePlot[Interval /@ Partition[list1, 2, 1]]
NumberLinePlot[intervalsArrangedVertically = Interval /@ Partition[list2, 2, 1]]

Katlama noktaları tarafından belirlenen her aralıkta sadece tek bir hat test etmemiz gerekir. Test çizgileri, arsadaki kesikli dikey çizgilerdir.

delimitersLeftToRight = Union[list2]
testLines = delimitersLeftToRight + .5
NumberLinePlot[
 intervalsArrangedVertically = Interval /@ Partition[list2, 2, 1], 
 GridLines -> {testLines, {}}, 
 GridLinesStyle -> Directive[Gray, Dashed]]

fHer test çizgisinin kesik veya geçiş sayısını bulur. X = 2.5'teki çizgi 5 geçiş yapar. Bu 5 + 1 adet ip bırakır.

f[num_, ints_] := Count[IntervalMemberQ[#, num] & /@ ints, True]
f[#, intervalsArrangedVertically] & /@ testLines
Max[%] + 1

{2, 3, 5, 3, 2, 0}
6

Pyth, 21 bayt

heSmsmq1xS+dSkdC,tQQQ

Burada dene.

Python tarzı liste girişi yapın, örneğin [-1, 3, 1, -2, 5, 2, 3, 4]

@ Jakube'un programına yakından bakıldı, ancak merkezi bir algoritma geliştirildi. Bir >kontrol yapmak ve bir >=kontrol yapmak yerine, .index()birleştirilmiş üç sayı üzerinde bir işlem yapıyorum ve endeksin 1 olduğundan emin olun, bunun anlamı minimumdan daha büyük ve maksimumdan daha küçük veya ona eşit.

R, 86 83

Bunun üzerinde çalışıyordum ve daha sonra, aslında Optimizer ve şüphelendiğim diğerleri ile aynı çözümü bulduğumu fark ettim.

Her neyse, burada bir vektör alan bir fonksiyon var.

f=function(l)max(colSums(mapply(function(n)c(l[-1],NA,l)<=n&c(l,l[-1],NA)>=n,l),T))

GolfScript (43 bayt)

~[.(;]zip);{$}%:x{0=:y;x{{y>}%2,=},,}%$-1=)

Verimlilik açısından, bu karşılaştırmaların O (1) zaman alacağını varsayarsak O (n ^ 2) 'dir. Girişi çizgi parçalarına böler ve her başlangıç ​​noktası için onu geçen yarı açık çizgi parçalarını sayar.

Çevrimiçi demo

Python - 161

Bu muhtemelen daha çok golf oynayabilir. gnibbler bunu golfe çok yardımcı oldu.

l=input()
d={}
for i in zip(l,l[1:]):d[sum(i)/2.]=0
for i,k in zip(l,l[1:]):
 for j in[m for m in d.keys()if min(i,k)<m<max(i,k)]:d[j]+=1
print max(d.values())+1

Ruby, 63

Kavramındaki Python çözümlerine benzer.

->a{a.map{|x|a.each_cons(2).count{|v|v.min<x&&x<=v.max}}.max+1}

Koddan önce 2 karakter ekleyin, örneğin f=isimlendirilmiş bir işlev istiyorsanız. İçin Thx MarkReed .

C #, 73 65 bayt

N=>1+N.Max(i=>N.Zip(N.Skip(1),(f,s)=>f<i+.5==i+.5<s).Count(b=>b))

Kuralları okurken, bir C # lambda'nın oldukça iyi yapması gerektiğini düşündüm.

Düzenleme: sadece bulundu Countfiltreleme için yararlı bir aşırı yük!

Bunu uygun delegatetürü tanımlayarak test edebilirsiniz :

delegate int solver(int[] l);

Ve sonra

var l = new int[] { -1, 3, 1, -2, 5, 2, 3, 4 };
solver s = N=>1+N.Max(i=>N.Zip(N.Skip(1),(f,s)=>f<i+.5==i+.5<s).Count(b=>b));

Console.WriteLine(s(l));

Matlab ( 63 43)

Giriş, işleve iletilen satır vektörü olarak verilir f. Yani örneğin f([-1, 3, 1, -2, 5, 2, 3, 4])döner 6.

f=@(x)max(sum(diff(bsxfun(@le,2*x',x(1:end-1)+x(2:end)))~=0))+1

Daha kısa versiyon:

f=@(x)max(sum(diff(bsxfun(@lt,x',x))~=0))+1

Oktav (31)

bsxfunOtomatik yayın sayesinde Octave'da çıkarılabilir:

f=@(x)max(sum(diff(x'<x)~=0))+1

JavaScript (ES6) 80 82

Yorumları görün - bayt sayısı F'ye atanmayı içermez (test etmek için hala gereklidir)

F=l=>Math.max(...l.map(v=>l.map(t=>(n+=t>u?v<t&v>=u:v>=t&v<u,u=t),n=1,u=l[0])&&n))

FireFox / FireBug konsolunda test edin

;[
 F([0, 1])
,F([2147483647, -2147483648])
,F([0, 1, -1])
,F([1, 0, -1])
,F([-1, 3, 1, -2, 5, 2, 3, 4])  
,F([-1122432493, -1297520062, 1893305528, 1165360246, -1888929223, 385040723, -80352673, 1372936505, 2115121074, -1856246962, 1501350808, -183583125, 2134014610, 720827868, -1915801069, -829434432, 444418495, -207928085, -764106377, -180766255, 429579526, -1887092002, -1139248992, -1967220622, -541417291, -1617463896, 517511661, -1781260846, -804604982, 834431625, 1800360467, 603678316, 557395424, -763031007, -1336769888, -1871888929, 1594598244, 1789292665, 962604079, -1185224024, 199953143, -1078097556, 1286821852, -1441858782, -1050367058, 956106641, -1792710927, -417329507, 1298074488, -2081642949, -1142130252, 2069006433, -889029611, 2083629927, 1621142867, -1340561463, 676558478, 78265900, -1317128172, 1763225513, 1783160195, 483383997, -1548533202, 2122113423, -1197641704, 319428736, -116274800, -888049925, -798148170, 1768740405,  473572890, -1931167061, -298056529, 1602950715, -412370479, -2044658831, -1165885212, -865307089, -969908936, 203868919, 278855174, -729662598, -1950547957, 679003141,  1423171080, 1870799802, 1978532600, 107162612, -1482878754, -1512232885, 1595639326, 1848766908, -321446009, -1491438272, 1619109855, 351277170, 1034981600, 421097157, 1072577364, -538901064])
,F([-2142140080, -2066313811, -2015945568, -2013211927, -1988504811, -1884073403, -1860777718, -1852780618, -1829202121, -1754543670, -1589422902, -1557970039, -1507704627, -1410033893,  -1313864752, -1191655050, -1183729403, -1155076106, -1150685547, -1148162179, -1143013543,  -1012615847, -914543424, -898063429, -831941836, -808337369, -807593292, -775755312, -682786953, -679343381, -657346098, -616936747, -545017823, -522339238, -501194053,  -473081322, -376141541, -350526016, -344380659, -341195356, -303406389, -285611307, -282860017, -156809093, -127312384, -24161190, -420036, 50190256, 74000721, 84358785,  102958758, 124538981, 131053395, 280688418, 281444103, 303002802, 309255004, 360083648,  400920491, 429956579, 478710051, 500159683, 518335017, 559645553, 560041153, 638459051,  640161676, 643850364, 671996492, 733068514, 743285502, 1027514169, 1142193844, 1145750868,  1187862077, 1219366484, 1347996225, 1357239296, 1384342636, 1387532909, 1408330157,  1490584236, 1496234950, 1515355210, 1567464831, 1790076258, 1829519996, 1889752281,  1903484827, 1904323014, 1912488777, 1939200260, 2061174784, 2074677533, 2080731335, 2111876929, 2115658011, 2118089950, 2127342676, 2145430585])
]

Çıktı

[2, 2, 3, 2, 6, 53, 2]

Jöle , 10 bayt

>þ`^ƝS$€Ṁ‘

Çevrimiçi deneyin!

Nasıl çalışır

>þ`^ƝS$€Ṁ‘ - Main link. 1 argument        e.g.   [1, 0, -1]
>þ`        - Greater than outer product          [[0, 0, 0], [1, 0, 0], [1, 1, 0]]
      $€   - Over each sublist:           e.g.   [1, 1, 0]
    Ɲ      -   Over each overlapping pair e.g.   [1, 0]
   ^       -     Perform XOR                     1
     S     -   Take the sums                     [0, 1, 1]
        Ṁ  - Take the maximum                    1
         ‘ - Increment                           2

05AB1E , 6 bayt

ε@Ôg}à

Çevrimiçi deneyin!

Açıklama:

ε   }    # for each element of the input
 @       # is each element >= this one? (returns list of booleans)
  Ô      # connected uniquified
   g     # length
     à   # maximum

JavaScript (Node.js) , 71 bayt

a=>Math.max(...a.map(t=>a.map(u=>s+=(a[i++]-t-.5)*(u-t-.5)<0,s=i=1)|s))

Çevrimiçi deneyin!

++ , 27 bayt ekle

D,w,@@,VbUG€<ÑBxs
L~,A€wM1+

Çevrimiçi deneyin!

_{APL cevabı için Zgarb'a teşekkür yaklaşımı}

Bu zorluğun kilit kısmı, dış ürün komutunu uygulamaktır. Ne yazık ki, Add ++ 'ın bunu yapacak bir yeri yok, diğer işlevleri argüman olarak alan fonksiyonları tanımlamanın bir yolu yok. Bununla birlikte, yine de genelleştirilmiş bir dış ürün işlevi yapabiliriz. Bir işleve başka bir işlevin içinde erişilmesinin tek yolu mevcut bir işleve, kullanıcı tanımlı ya da yerleşik olarak gönderme yapmak olduğundan, böyle bir işleve başvuran bir 'yerleşik' yaratmamız gerekir.

Genelleştirilmiş bir "tablo" işlevi şuna benzer:

D,func,@@,+

D,iter,@@*, VbUG €{func}
D,table,@@, $ bRbU @ €{iter} B]

Çevrimiçi deneyin!

nerede funcbizim işlenen içeren bir diyadik fonksiyonudur. Bu yapının soluk benzerliklerini orijinal gönderimde, w işlevinin başında görebilirsiniz, ancak burada, öncelikle, her iki tarafta da aynı argümanı alan bir dış ürün işlevi olan monadik bir dış ürün işlevi istiyoruz.

Genel tablo işlevi, €ağda hızlı çalışmanın ikili fonksiyonlara nasıl yaklaştığından faydalanır . Yığın benziyorsa

 [a b c d e]

zaman €{func}, karşılaşıldığında €babalar ebu sol ikilisi için bağımsız değişken ve haritalar gibi kısmi işlevi üzerinde, bağlar a, b, c, d. Ancak, €hızlı listelerin tümü yerine tüm yığının üzerinde eşlenir. Bu yüzden önce argüman olarak geçen dizileri düzleştirmemiz gerekiyor.

Masa işlevi aşağıdaki gibi genel işler

D,func,@@,+

D,iter,		; Define our helper function iter
		;   This takes an array as its left argument
		;   And a single integer as its right argument
	@@	; Dyadic arguments - take two arguments and push to the stack
	*,	; After execution, return the entire stack, rather then just the top element
		;
		; Example arguments:	[5 6 7 8] 1
		; 
	VbUG	; Unpack the array;	[5 6 7 8 1]
		;
	€{func}	; Map func over the stack
		; As func is dyadic, this pops the right argument
		;   and binds that to a monadic func
		; This then maps the remaining elements, [5 6 7 8]
		;   over the monadic call of func, yielding [6 7 8 9]
		; Now, as the * flag was defined, we return the entire array
		;   rather than just the last element.
		; We'd achieve the same behaviour by removing the flag and appending B]

D,table,	; Define the main table function
		;   This takes two arrays as arguments
		;   Returns a single 2D array representing their outer product with func
	@@,	; Take the two arrays and push to the stack
		; 
		; Example arguments:	[[1 2 3 4] [5 6 7 8]]
		;
	$	; Swap;		STACK = [[5 6 7 8] [1 2 3 4]]
	bR	; Reverse last;	STACK = [[5 6 7 8] [4 3 2 1]]
	bU	; Unpack;	STACK = [[5 6 7 8] 4 3 2 1]
	@	; Reverse;	STACK = [1 2 3 4 [5 6 7 8]]
		; 
		; This allows us to place the stack so that each element of
		;   the first array is iterated over with the second array
		;
	€{iter}	; Map iter;	STACK = [[6 7 8 9] [7 8 9 10] [8 9 10 11] [9 10 11 12]]
		;
	B]	; Return the whole stack;

$table>?>?
O

Bununla birlikte, dış tablomuzun monadik olması gerektiğinden ve sadece geçen argümana başvurmamız gerektiğinden dolayı bunu oldukça kısaltabiliriz . AHerhangi yığın manipülasyon ile karışıklık civarını gerek kalmaz komut, tek tek yığınına her argüman iter. Kısacası, eğer argümanımız dizi ise [a b c d], yığını oluşturmamız gerekiyor.

[a b c d [a b c d]]

En üstteki değer, elbette, argümandır. Genel paketten unpack komutu bUolan örnekten fark etmiş olabilirsiniz, yani üst diziyi yığına yapıştırır. Bu yüzden yukarıdaki konfigürasyonu yapmak için kodu kullanabiliriz.

L,bUA

Çevrimiçi deneyin!

Ancak, bu bir bayt tarafından kısaltılabilir. Bir takma ad olarak L,bU, ~argümanı önceden yığın haline getirmek için bayrağı kullanabiliriz, yapılandırma örneğimizi

L~,A

Çevrimiçi deneyin!

programda ikinci satırın başlangıcıdır. Şimdi monadik dış ürünü uyguladık, sadece algoritmanın geri kalanını uygulamamız gerekiyor. Sonucunu alma sonra tablo ile <(daha az) ve sayısını [0 1]ve [1 0]her bir üst üste çift. Sonunda, bu sayıların azami miktarını alıyoruz ve arttırıyoruz.

Adım adım ilerlemenin tam adımı

D,w,		; Define a function w
		;   This takes an array and an integer as arguments
		;   First, it produces the outer product with less than
		;   Then reduce overlapping pairs by XOR
		;   Finally, sum the rows
	@@,	; Take two arguments
		;
		; Example arguments:		[[0 1 2 3] 0]
		;
	VbUG€<	; Map < over the array;	STACK = [0 1 1 1]
	ÑBx	; Equals [1 0];		STACK = [1 0 0]
	s	; Sum;			STACK = [1]

L		; Define a lambda function
		;   This takes one argument, an array
	~,	;   Splat the array to the stack before doing anything
		;
		; Example argument:		[0 1 2 3]
		;
	A€w	; Map with w;		STACK = [1 1 1 0]
	M	; Maximum;		STACK = [1]
	1+	; Increment;		STACK = [2]