Pertimbangkan seutas tali (seperti dalam "tali", bukan seperti dalam "sekelompok karakter"), yang dilipat bolak-balik pada garis nyata. Kita dapat menggambarkan bentuk string dengan daftar poin yang dilewatinya (secara berurutan). Untuk mempermudah, kami akan menganggap semua titik tersebut adalah bilangan bulat.

Ambil sebagai contoh [-1, 3, 1, -2, 5, 2, 3, 4](perhatikan bahwa tidak setiap entri menyiratkan lipatan):

^{Tali memanjang sepanjang arah vertikal hanya untuk keperluan visualisasi. Bayangkan string semua diratakan ke garis nyata.}

Sekarang inilah pertanyaannya: berapakah jumlah string terbesar yang dapat dipotong menjadi satu dengan potongan tunggal (yang harus vertikal pada gambar di atas). Dalam hal ini, jawabannya adalah 6 dengan potongan di antara 2dan 3:

Untuk ambiguitas menghindari, dipotong memiliki harus dilakukan pada posisi non-integer.

Tantangan

Diberikan daftar posisi integer yang dilipat oleh string, Anda harus menentukan jumlah terbesar dari string yang dapat dipotong menjadi dengan potongan tunggal pada posisi non-integer.

Anda dapat menulis program atau fungsi lengkap. Anda dapat mengambil input melalui STDIN, argumen baris perintah, parameter prompt atau fungsi. Anda dapat menulis output ke STDOUT, menampilkannya di kotak dialog atau mengembalikannya dari fungsi.

Anda dapat mengasumsikan bahwa daftar tersebut ada dalam format daftar atau string yang mudah.

Daftar ini akan berisi setidaknya 2 dan tidak lebih dari 100 entri. Entri akan menjadi bilangan bulat, masing-masing dalam kisaran -2 ³¹ ≤ p _i <2 ³¹ . Anda dapat berasumsi bahwa tidak ada dua entri berturut-turut yang identik.

Kode Anda harus memproses input semacam itu (termasuk kasus uji di bawah) dalam waktu kurang dari 10 detik pada PC desktop yang wajar.

Uji Kasus

Semua test case hanya input diikuti oleh output.

[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≠/∘.≤⍨⎕

Terima kasih kepada @ngn untuk menghemat 2 byte.

The ⎕sebenarnya karakter kotak, bukan kesalahan hilang-font. Anda dapat mencoba program di tryapl.org , tetapi karena ⎕tidak sepenuhnya didukung di sana, Anda harus menggantinya dengan nilai input:

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

Penjelasan

Program paling baik dijelaskan dengan contoh input s = ¯1 3 1 ¯2 5 2 3 4, yang diambil dari STDIN oleh ⎕. Pertama, kita menghitung ≤produk -outer sdengan menggunakan dirinya sendiri ∘.≤⍨. Ini menghasilkan matriks Boolean yang ibarisnya memberitahu elemen mana syang kurang atau sama dengan 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

Kemunculan 0 1dan 1 0pada itanda baris menempatkan tempat string melewati titik s[i] + 0.5. Kami mencocokkan ini di setiap baris menggunakan 2≠/, "kurangi 2-sublist oleh ≠":

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

Yang tersisa adalah mengambil jumlah baris +/

2 5 3 0 2 3 5 3

dan satu ditambah maksimum dari ini dengan 1+⌈/:

6

Hasilnya secara otomatis dicetak ke STDOUT di sebagian besar implementasi 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

Hanya lambda yang terus terang

Hanya untuk menunjukkan pendekatan lain:

Pyth, 28 27 byte

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

Yang ini kira-kira setara dengan

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

diterapkan ke daftar input dari STDIN. Cobalah menggunakan penerjemah online .

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

heSmsm&<hSkdgeSkdC,tQQQ

Coba di sini: Pyth Compiler / Executor

Ia mengharapkan daftar bilangan bulat sebagai input [-1, 3, 1, -2, 5, 2, 3, 4]

Ini adalah terjemahan langsung dari program Python saya:

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

Solusi lama: Pyth 28 char

Hanya untuk alasan pengarsipan.

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

Kode Python yang sesuai adalah:

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

Saya percaya bahwa ada algoritma yang lebih baik di luar sana di alam liar. Namun, ini berfungsi di bawah batas yang diperlukan untuk semua kasus uji (bahkan pada kompiler online)

Inputnya seperti

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

Output (untuk kasus di atas) adalah

2

Bagaimana itu bekerja

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

Sekarang anggap array inputnya adalah [-1 3 1 -2 5 2 3 4], langkah-langkah zip terlihat seperti:

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

Array kedua pada baris terakhir adalah lipatan string.

Sekarang kita beralih [-1 3 1 -2 5 2 3 4] dan menghitung jumlah set masing-masing terletak. Dapatkan maksimal dari jumlah itu, tambahkan dan kita punya jawaban kita.

Cobalah online di sini

Matlab (123) (97) (85)

Yay, akhirnya digunakan untuk XNOR =) Saya yakin itu bisa di-golf turun lebih jauh.

Tapi jujur ​​saya sedikit malu bahwa MatLab menjadi bahasa yang saya tahu terbaik = /

Perkiraan waktu proses adalah 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: Versi golf baru lainnya (termasuk petunjuk dari @DennisJaheruddin, terima kasih!)

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)

Versi lama:

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: Saya sangat menikmati tantangan kecil Anda sebelum-saya-pergi-tidur!

Mathematica 134 133 104

Menyenangkan untuk dipecahkan, terlepas dari ukuran kodenya. Golf lebih lanjut masih bisa dicapai dengan mengganti ide IntervalMemberQ[Interval[a,b],n]dengan 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

Penjelasan

list1adalah daftar poin yang diberikan list2adalah daftar singkat yang menghilangkan angka yang tidak terlipat; mereka tidak relevan. Tidak perlu melakukan ini, tetapi mengarah ke solusi yang lebih jelas dan lebih efisien.

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}

Interval dalam list1dan list2ditunjukkan dalam plot di bawah ini:

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

Kita hanya perlu menguji satu garis di setiap interval yang ditentukan oleh titik lipat. Garis uji adalah garis vertikal putus-putus dalam plot.

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

fmenemukan jumlah potongan atau persilangan dari setiap garis uji. Garis pada x = 2,5 membuat 5 persimpangan. Itu menyisakan 5 + 1 lembar tali.

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

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

Pyth, 21 byte

heSmsmq1xS+dSkdC,tQQQ

Coba di sini.

Berikan input sebagai daftar gaya-Python, mis [-1, 3, 1, -2, 5, 2, 3, 4]

Berbasis dekat dari program @ jakube, tetapi dengan algoritma pusat yang ditingkatkan. Alih-alih melakukan >cek dan >=cek, saya melakukan .index()gabungan tiga angka dan memastikan indeksnya 1, artinya lebih besar dari minimum dan kurang dari atau sama dengan maksimum.

R, 86 83

Sedang mengerjakan ini dan kemudian menyadari bahwa pada dasarnya saya telah menemukan solusi yang sama dengan Pengoptimal dan lainnya yang saya duga.

Pokoknya di sini itu sebagai fungsi yang mengambil vektor

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

Dalam hal efisiensi, ini adalah O (n ^ 2) dengan asumsi bahwa perbandingan membutuhkan waktu O (1). Memecah input menjadi segmen garis dan untuk setiap titik awal menghitung segmen garis setengah terbuka yang melewatinya.

Demo online

Python - 161

Ini mungkin bisa lebih banyak golf. gnibbler banyak membantu golf ini.

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

Mirip dengan solusi Python dalam konsep.

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

Tambahkan 2 karakter sebelum kode misalnya f=jika Anda ingin fungsi bernama. Terima kasih untuk 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))

Membaca aturan saya pikir C # lambda harusnya cukup baik.

Edit: baru ditemukan Count memiliki kelebihan yang berguna untuk pemfilteran!

Anda dapat menguji ini dengan mendefinisikan delegatejenis yang sesuai :

delegate int solver(int[] l);

Lalu

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)

Input diberikan sebagai vektor baris yang diteruskan ke fungsi f. Jadi misalnya f([-1, 3, 1, -2, 5, 2, 3, 4])mengembalikan 6.

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

Versi lebih pendek:

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

Oktaf (31)

Di Oktaf bsxfundapat dihapus berkat penyiaran otomatis:

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

JavaScript (ES6) 80 82

Lihat komentar - jumlah byte tidak termasuk penetapan ke F (yang masih perlu diuji)

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

Uji di konsol 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])
]

Keluaran

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

Jelly , 10 byte

>þ`^ƝS$€Ṁ‘

Cobalah online!

Bagaimana itu bekerja

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

Cobalah online!

Penjelasan:

ε   }    # 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))

Cobalah online!

Tambahkan ++ , 27 byte

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

Cobalah online!

_{Pendekatan terima kasih kepada Zgarb untuk jawaban APL mereka}

Bagian penting dari tantangan ini adalah menerapkan perintah produk luar. Sayangnya, Add ++ tidak memiliki builtin untuk melakukannya, juga tidak memiliki cara mendefinisikan fungsi yang menggunakan fungsi lain sebagai argumen. Namun, kita masih bisa membuat fungsi produk luar yang digeneralisasi. Karena satu-satunya cara agar suatu fungsi dapat diakses di dalam fungsi lain adalah dengan mereferensikan fungsi yang ada, yang ditentukan pengguna atau builtin, kita harus membuat 'builtin' yang merujuk fungsi tersebut.

Fungsi "tabel" umum akan terlihat seperti ini:

D,func,@@,+

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

Cobalah online!

di mana funcadalah fungsi diad yang berisi operan kami. Anda dapat melihat sedikit kesamaan struktur ini dalam pengiriman asli, pada awal fungsi w , tetapi di sini kami ingin, terutama, fungsi produk luar monadik - fungsi produk luar yang mengambil argumen yang sama di kedua sisi.

Fungsi tabel umum mengambil keuntungan dari bagaimana €ach cepat mendekati fungsi diad. Jika tumpukan terlihat seperti

 [a b c d e]

ketika €{func}ditemui, €muncul e, mengikat itu sebagai argumen kiri ke angka dua, dan peta yang fungsi parsial berakhir a, b, c, d. Namun, €peta cepat di seluruh tumpukan, bukan dari daftar. Jadi kita perlu meratakan array yang dilewatkan sebagai argumen terlebih dahulu.

Fungsi tabel bekerja secara keseluruhan seperti ini

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

Namun, kita dapat mempersingkat ini cukup banyak karena fakta bahwa kita perlu meja luar kita menjadi monadik , dan hanya perlu berlaku untuk argumen yang disahkan. The Aperintah mendorong setiap argumen ke stack secara individual, jadi kita tidak perlu dipusingkan dengan manipulasi stack. Singkatnya, jika argumen kita adalah array [a b c d], kita perlu membuat stack menjadi

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

Nilai atas adalah, tentu saja, argument.You mungkin telah memperhatikan dari contoh umum yang bUadalah membongkar perintah yakni lingkar atas array untuk stack. Jadi untuk membuat konfigurasi di atas, kita bisa menggunakan kodenya

L,bUA

Cobalah online!

Namun, ini dapat dipersingkat dengan satu byte. Sebagai alias untuk L,bU, kita dapat menggunakan ~flag, untuk memerciki argumen ke stack sebelumnya, menjadikan contoh konfigurasi kita menjadi

L~,A

Cobalah online!

yang merupakan awal dari baris kedua dalam program ini. Sekarang kita sudah menerapkan produk luar monadik, kita hanya perlu mengimplementasikan sisa dari algoritma. Setelah mengambil hasil tabel dengan <(kurang dari), dan hitung jumlah [0 1]dan [1 0]pasangan di setiap baris. Akhirnya, kami mengambil jumlah maksimum ini, dan menambahkannya.

Langkah lengkap untuk langkah berjalan adalah

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]