Hãy xem xét một đoạn dây (như trong "sợi dây", chứ không phải trong "một bó các ký tự"), được gấp lại qua lại trên dòng thực. Chúng ta có thể mô tả hình dạng của chuỗi bằng một danh sách các điểm nó đi qua (theo thứ tự). Để đơn giản, chúng tôi sẽ giả sử tất cả các điểm đó là số nguyên.

Lấy một ví dụ [-1, 3, 1, -2, 5, 2, 3, 4](lưu ý rằng không phải mỗi mục đều ngụ ý một nếp gấp):

^{Chuỗi kéo dài theo hướng dọc chỉ dành cho mục đích trực quan hóa. Hãy tưởng tượng tất cả các chuỗi được làm phẳng trên dòng thực.}

Bây giờ đây là câu hỏi: số mảnh lớn nhất mà chuỗi này có thể được cắt bằng một vết cắt duy nhất (sẽ phải thẳng đứng trong hình trên). Trong trường hợp này, câu trả lời là 6 với một vết cắt ở giữa 2và 3:

Để mập mờ tránh, việc cắt giảm có được thực hiện ở một vị trí không nguyên.

Các thách thức

Đưa ra một danh sách các vị trí số nguyên mà một chuỗi được gấp lại, bạn sẽ xác định số lượng mảnh lớn nhất mà chuỗi có thể được cắt bằng một lần cắt tại một vị trí không nguyên.

Bạn có thể viết một chương trình đầy đủ hoặc một chức năng. Bạn có thể nhận đầu vào thông qua STDIN, đối số dòng lệnh, dấu nhắc hoặc tham số hàm. Bạn có thể ghi đầu ra vào STDOUT, hiển thị nó trong hộp thoại hoặc trả lại từ hàm.

Bạn có thể cho rằng danh sách này ở bất kỳ định dạng chuỗi hoặc danh sách thuận tiện.

Danh sách sẽ chứa ít nhất 2 và không quá 100 mục. Các mục nhập sẽ là số nguyên, mỗi số trong phạm vi -2 ³¹ ≤ p _i <2 ³¹ . Bạn có thể cho rằng không có hai mục liên tiếp giống hệt nhau.

Mã của bạn phải xử lý bất kỳ đầu vào nào như vậy (bao gồm các trường hợp thử nghiệm bên dưới) trong chưa đầy 10 giây trên máy tính để bàn hợp lý.

Các trường hợp thử nghiệm

Tất cả các trường hợp thử nghiệm chỉ đơn giản là đầu vào theo sau là đầu ra.

[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 byte

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

Cảm ơn @ngn vì đã lưu 2 byte.

Đây ⎕thực sự là một ký tự hộp, không phải là lỗi thiếu phông chữ. Bạn có thể thử chương trình tại tryapl.org , nhưng vì ⎕không được hỗ trợ đầy đủ ở đó, bạn phải thay thế nó bằng giá trị đầu vào:

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

Giải trình

Chương trình được giải thích tốt nhất với đầu vào ví dụ s = ¯1 3 1 ¯2 5 2 3 4, được lấy từ STDIN bởi ⎕. Đầu tiên, chúng tôi tính toán ≤sản phẩm -outer của schính nó bằng cách sử dụng ∘.≤⍨. Điều này dẫn đến một ma trận Boolean có ihàng thứ cho biết phần tử snào nhỏ hơn hoặc bằng 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

Sự xuất hiện của 0 1và 1 0trên hàng iđánh dấu nơi các chuỗi đi qua điểm s[i] + 0.5. Chúng tôi khớp với những thứ này trên mỗi hàng bằng cách sử dụng 2≠/, "giảm 2 danh sách con theo ≠":

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

Những gì còn lại là lấy tổng của các hàng với +/

2 5 3 0 2 3 5 3

và một cộng với tối đa của những điều này với 1+⌈/:

6

Kết quả được tự động in thành STDOUT trong hầu hết các triển khai APL.

Python, 88 75 73 byte

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

Chỉ là một lambda đơn giản

Chỉ để hiển thị một cách tiếp cận khác:

Bình thường, 28 27 byte

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

Cái này gần tương đương với

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

áp dụng cho danh sách đầu vào từ STDIN. Hãy thử nó trên trình thông dịch trực tuyến .

Pyth : 31 30 29 28 24 23 ký tự (Python 68 ký tự)

heSmsm&<hSkdgeSkdC,tQQQ

Dùng thử tại đây: Trình biên dịch / thực thi Pyth

Nó mong đợi một danh sách các số nguyên làm đầu vào [-1, 3, 1, -2, 5, 2, 3, 4]

Đây là bản dịch đơn giản của chương trình Python của tôi:

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

Giải pháp cũ: Pyth 28 char

Chỉ vì lý do lưu trữ.

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

Mã Python tương ứng sẽ là:

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 byte

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

Tôi tin rằng có một thuật toán tốt hơn ngoài tự nhiên. Tuy nhiên, điều này hoạt động dưới giới hạn cần thiết cho tất cả các trường hợp thử nghiệm (ngay cả trên trình biên dịch trực tuyến)

Đầu vào giống như

[-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]

Đầu ra (đối với trường hợp trên) là

2

Làm thế nào nó hoạt động

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

Bây giờ giả sử mảng đầu vào là [-1 3 1 -2 5 2 3 4], các bước nén giống như:

[-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]]]

Mảng thứ hai trên dòng cuối cùng là các nếp gấp của chuỗi.

Bây giờ chúng tôi lặp đi lặp lại [-1 3 1 -2 5 2 3 4]và tính toán số lượng bộ mà mỗi bộ nằm trong đó. Lấy tối đa số đó, tăng nó và chúng tôi có câu trả lời của chúng tôi.

Dùng thử trực tuyến tại đây

Matlab (123) (97) (85)

Yay, cuối cùng là sử dụng cho XNOR =) Tôi chắc chắn rằng nó có thể được đánh golf xuống nhiều hơn.

Nhưng thành thật mà nói, tôi hơi bối rối rằng MatLab đang trở thành ngôn ngữ tôi biết rõ nhất = /

Thời gian chạy gần đúng là 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: Phiên bản mới được chơi nhiều hơn (bao gồm các gợi ý từ @DennisJaheruddin, cảm ơn!)

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)

Phiên bản cũ:

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: Tôi thực sự rất thích những thử thách nhỏ bé trước khi tôi đi ngủ!

Toán học 134 133 104

Vui để giải quyết, mặc dù kích thước của mã. Chơi gôn hơn nữa vẫn có thể đạt được bằng cách thay thế ý tưởng IntervalMemberQ[Interval[a,b],n]bằng 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

Giải trình

list1là danh sách các điểm đã cho list2là một danh sách rút gọn loại bỏ các số không nằm trong các nếp gấp; chúng không liên quan. Không cần thiết phải làm điều này, nhưng nó dẫn đến một giải pháp rõ ràng và hiệu quả hơn.

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}

Các khoảng trong list1và list2được hiển thị trong các ô bên dưới:

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

Chúng ta chỉ cần kiểm tra một dòng duy nhất trong mỗi khoảng thời gian được xác định bởi các điểm gấp. Các dòng thử nghiệm là các đường thẳng đứng đứt nét trong cốt truyện.

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

ftìm thấy số lần cắt hoặc cắt của mỗi dòng thử nghiệm. Đường thẳng tại x = 2,5 tạo ra 5 điểm giao nhau. Điều đó để lại 5 + 1 mảnh chuỗi.

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

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

Bình thường, 21 byte

heSmsmq1xS+dSkdC,tQQQ

Hãy thử nó ở đây.

Cung cấp đầu vào dưới dạng danh sách kiểu Python, vd [-1, 3, 1, -2, 5, 2, 3, 4]

Dựa hoàn toàn vào chương trình của @ jakube, nhưng với một thuật toán trung tâm được cải tiến. Thay vì thực hiện >kiểm tra và >=kiểm tra, tôi thực hiện một .index()trong ba số kết hợp và đảm bảo chỉ số là 1, có nghĩa là nó lớn hơn tối thiểu và nhỏ hơn hoặc bằng tối đa.

R, 86 83

Đã làm việc thông qua điều này và sau đó nhận ra rằng về cơ bản tôi đã đưa ra giải pháp tương tự như Trình tối ưu hóa và những người khác mà tôi nghi ngờ.

Dù sao ở đây nó là một hàm lấy một vectơ

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

GolfScript (43 byte)

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

Về hiệu quả, đây là O (n ^ 2) giả sử rằng các phép so sánh mất thời gian O (1). Nó chia đầu vào thành các phân đoạn dòng và với mỗi điểm bắt đầu, nó sẽ tính các phân đoạn nửa mở ngang qua nó.

Bản demo trực tuyến

Con trăn - 161

Điều này có thể có thể được chơi golf nhiều hơn. gnibbler đã giúp chơi golf này rất nhiều.

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

Tương tự như các giải pháp Python trong khái niệm.

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

Thêm 2 ký tự trước mã, ví dụ f=nếu bạn muốn một hàm được đặt tên. Thx đến MarkReed .

C #, 73 65 byte

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

Đọc các quy tắc tôi nghĩ rằng một lambda C # nên làm khá tốt.

Chỉnh sửa: vừa tìm thấy Count có một quá tải hữu ích để lọc!

Bạn có thể kiểm tra điều này bằng cách xác định delegateloại thích hợp :

delegate int solver(int[] l);

Và sau đó

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)

Đầu vào được đưa ra dưới dạng một vectơ hàng được truyền cho hàm f. Vì vậy, ví dụ f([-1, 3, 1, -2, 5, 2, 3, 4])trả về 6.

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

Phiên bản ngắn hơn:

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

Octave (31)

Trong Octave bsxfuncó thể được gỡ bỏ nhờ phát sóng tự động:

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

JavaScript (ES6) 80 82

Xem bình luận - số byte không bao gồm gán cho F (vẫn cần kiểm tra)

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

Kiểm tra trong bảng điều khiển FireFox / FireBug

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

Đầu ra

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

Thạch , 10 byte

>þ`^ƝS$€Ṁ‘

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

>þ`^Ɲ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 byte

ε@Ôg}à

Hãy thử trực tuyến!

Giải trình:

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

JavaScript (Node.js) , 71 byte

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

Hãy thử trực tuyến!

Thêm ++ , 27 byte

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

Hãy thử trực tuyến!

_{Tiếp cận cảm ơn Zgarb vì câu trả lời APL của họ}

Phần quan trọng của thách thức này là thực hiện một lệnh sản phẩm bên ngoài. Thật không may, Add ++ không có tích hợp sẵn để làm như vậy, nó không có cách nào để xác định các hàm lấy các hàm khác làm đối số. Tuy nhiên, chúng ta vẫn có thể tạo ra một chức năng sản phẩm bên ngoài tổng quát. Vì cách duy nhất để một hàm được truy cập bên trong một hàm khác là thông qua tham chiếu một hàm hiện có, do người dùng xác định hoặc dựng sẵn, chúng ta phải tạo một 'dựng sẵn' tham chiếu đến một hàm như vậy.

Hàm "bảng" tổng quát sẽ trông giống như thế này:

D,func,@@,+

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

Hãy thử trực tuyến!

trong đó funcmột hàm dyadic chứa toán hạng của chúng ta. Bạn có thể thấy sự tương đồng mờ nhạt của cấu trúc này trong lần gửi ban đầu, khi bắt đầu chức năng w , nhưng ở đây chúng tôi muốn, chủ yếu, một chức năng sản phẩm bên ngoài đơn nguyên - một chức năng sản phẩm bên ngoài có cùng đối số ở cả hai bên.

Hàm bảng chung tận dụng lợi thế của cách €tiếp cận nhanh chóng với các hàm dyadic. Nếu ngăn xếp trông như

 [a b c d e]

khi €{func}gặp phải, các €cửa sổ bật lên e, liên kết đó là đối số bên trái với dyad và ánh xạ chức năng một phần đó a, b, c, d. Tuy nhiên, €bản đồ nhanh trên toàn bộ ngăn xếp, thay vì trên danh sách. Vì vậy, chúng ta cần làm phẳng các mảng được truyền dưới dạng đối số trước tiên.

Hàm bảng hoạt động tổng thể như thế này

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

Tuy nhiên, chúng ta có thể rút ngắn điều này khá nhiều do thực tế là chúng ta cần bảng ngoài của chúng ta là đơn điệu và chỉ cần áp dụng cho đối số được thông qua. Các Alệnh đẩy mỗi đối số vào stack riêng lẻ, vì vậy chúng tôi không cần phải mess xung quanh với bất kỳ ngăn xếp thao tác. Nói tóm lại, nếu đối số của chúng ta là mảng [a b c d], chúng ta cần tạo ngăn xếp thành

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

Tất nhiên, giá trị trên cùng là đối số. Bạn có thể nhận thấy từ ví dụ chung đó bUlà lệnh giải nén tức là nó sẽ tách mảng trên cùng thành ngăn xếp. Vì vậy, để thực hiện cấu hình trên, chúng ta có thể sử dụng mã

L,bUA

Hãy thử trực tuyến!

Tuy nhiên, điều này có thể được rút ngắn bằng một byte. Là một bí danh cho L,bU, chúng ta có thể sử dụng ~cờ, để phân tách các đối số vào ngăn xếp trước đó, làm cho ví dụ cấu hình của chúng ta thành

L~,A

Hãy thử trực tuyến!

đó là sự khởi đầu của dòng thứ hai trong chương trình. Bây giờ chúng tôi đã triển khai sản phẩm bên ngoài đơn nguyên, chúng tôi chỉ cần thực hiện phần còn lại của thuật toán. Sau khi lấy kết quả của bảng với <(nhỏ hơn) và đếm số lượng [0 1]và [1 0]cặp trong mỗi hàng. Cuối cùng, chúng tôi lấy tối đa các số đếm này và tăng nó.

Bước hoàn chỉnh cho bước đi qua là

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]