Considera un pezzo di corda (come in "corda", non come in "un mucchio di personaggi"), che è piegato avanti e indietro sulla linea reale. Possiamo descrivere la forma della stringa con un elenco di punti che attraversa (in ordine). Per semplicità, supponiamo che tutti questi punti siano numeri interi.

Prendi come esempio [-1, 3, 1, -2, 5, 2, 3, 4](nota che non ogni voce implica una piega):

^{La stringa che si estende lungo la direzione verticale è solo a scopo di visualizzazione. Immagina la corda tutta appiattita sulla linea reale.}

Ora ecco la domanda: qual è il maggior numero di pezzi in cui questa corda può essere tagliata con un singolo taglio (che dovrebbe essere verticale nella figura sopra). In questo caso, la risposta è 6 con un taglio ovunque tra 2e 3:

Per evitare ambiguità, il taglio deve essere eseguito in una posizione non intera.

La sfida

Dato un elenco di posizioni di numero intero in cui viene piegata una stringa, devi determinare il maggior numero di pezzi in cui la stringa può essere tagliata con un singolo taglio in una posizione non intera.

È possibile scrivere un programma completo o una funzione. È possibile accettare input tramite STDIN, argomento della riga di comando, prompt o parametro di funzione. È possibile scrivere l'output su STDOUT, visualizzarlo in una finestra di dialogo o restituirlo dalla funzione.

Si può presumere che l'elenco sia in qualsiasi elenco o formato stringa conveniente.

L'elenco conterrà almeno 2 e non più di 100 voci. Le voci saranno numeri interi, ciascuno compreso nell'intervallo -2 ³¹ ≤ p _i <2 ³¹ . Si può presumere che non vi siano due voci consecutive identiche.

Il tuo codice deve elaborare tali input (compresi i casi di test di seguito) in meno di 10 secondi su un PC desktop ragionevole.

Casi test

Tutti i casi di test sono semplicemente input seguiti da 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≠/∘.≤⍨⎕

Grazie a @ngn per aver salvato 2 byte.

In ⎕realtà è un carattere box, non un errore di font mancante. Puoi provare il programma su tryapl.org , ma poiché ⎕non è completamente supportato lì, devi sostituirlo con il valore di input:

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

Spiegazione

Il programma è meglio spiegato con l'input di esempio s = ¯1 3 1 ¯2 5 2 3 4, che è preso da STDIN da ⎕. In primo luogo, calcoliamo il ≤prodotto esterno scon se stesso utilizzando ∘.≤⍨. Ciò si traduce in una matrice booleana la cui iriga indica quali elementi ssono inferiori o uguali a 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

Le occorrenze di 0 1e 1 0sulla riga iindicano i punti in cui la stringa passa sopra il punto s[i] + 0.5. Corrispondiamo su questi su ogni riga usando 2≠/"riduci 2 elenchi secondari di ≠":

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

Ciò che resta è prendere le somme delle righe con +/

2 5 3 0 2 3 5 3

e uno più il massimo di questi con 1+⌈/:

6

Il risultato viene automaticamente stampato su STDOUT nella maggior parte delle implementazioni 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

Solo una semplice lambda

Solo per mostrare un altro approccio:

Pyth, 28 27 byte

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

Questo è approssimativamente equivalente a

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

applicato all'elenco di input da STDIN. Provalo sull'interprete online .

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

heSmsm&<hSkdgeSkdC,tQQQ

Provalo qui: Pyth Compiler / Executor

Si aspetta un elenco di numeri interi come input [-1, 3, 1, -2, 5, 2, 3, 4]

È una traduzione semplice del mio programma Python:

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

Vecchia soluzione: Pyth 28 char

Solo per motivi di archiviazione.

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

Un codice Python corrispondente sarebbe:

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

Credo che esista un algoritmo migliore in circolazione. Tuttavia, questo funziona sotto il limite richiesto per tutti i casi di test (anche sul compilatore online)

L'input è come

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

L'output (per il caso precedente) è

2

Come funziona

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

Ora supponiamo che l'array di input sia [-1 3 1 -2 5 2 3 4], i passaggi zippati sembrano:

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

Il secondo array sull'ultima riga sono le pieghe della stringa.

Ora ripetiamo [-1 3 1 -2 5 2 3 4]e calcoliamo il numero di set in ognuno dei quali si trovano. Ottieni il massimo da quel numero, incrementalo e abbiamo la nostra risposta.

Provalo online qui

Matlab (123) (97) (85)

Sì, finalmente un uso per XNOR =) Sono sicuro che può essere giocato molto di più.

Ma onestamente sono un po 'imbarazzato che MatLab stia diventando la lingua che conosco meglio = /

Il tempo di esecuzione approssimativo è 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: nuova versione più giocata a golf (compresi i suggerimenti di @DennisJaheruddin, grazie!)

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)

Vecchia versione:

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: mi piacciono molto le tue simpatiche sfide appena prima di andare a letto!

Mathematica 134 133 104

Divertente da risolvere, nonostante le dimensioni del codice. Si può ancora ottenere ulteriore golf sostituendo l'idea di IntervalMemberQ[Interval[a,b],n]con 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

Spiegazione

list1è il dato elenco di punti list2è un elenco abbreviato che rimuove i numeri che non erano in piega; sono irrilevanti. Non è necessario farlo, ma porta a una soluzione più chiara ed efficiente.

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}

Gli intervalli in list1e list2sono mostrati nei grafici seguenti:

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

Abbiamo solo bisogno di testare una singola linea in ogni intervallo determinato dai punti di piega. Le linee di prova sono le linee verticali tratteggiate nella trama.

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

ftrova il numero di tagli o incroci di ciascuna linea di prova. La linea in x = 2.5 fa 5 incroci. Ciò lascia 5 + 1 pezzi di spago.

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

Provalo qui.

Fornisci input come elenco in stile Python, ad es [-1, 3, 1, -2, 5, 2, 3, 4]

Basato strettamente sul programma di @ jakube, ma con un algoritmo centrale migliorato. Invece di fare un >controllo e un >=controllo, faccio uno .index()sui tre numeri combinati e mi assicuro che l'indice sia 1, il che significa che è maggiore del minimo e minore o uguale al massimo.

R, 86 83

Stavo lavorando su questo e poi mi sono reso conto che avevo essenzialmente escogitato la stessa soluzione di Optimizer e di altri che sospetto.

Comunque qui è come una funzione che accetta un vettore

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

In termini di efficienza, questo è O (n ^ 2) supponendo che i confronti richiedano tempo O (1). Rompe l'input in segmenti di linea e per ogni punto iniziale conta i segmenti di linea semiaperti che lo attraversano.

Demo online

Python - 161

Questo probabilmente può essere giocato a golf di più. gnibbler mi ha aiutato molto a giocare a golf.

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 anni

Simile alle soluzioni Python nel concetto.

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

Aggiungi 2 caratteri prima del codice, ad esempio f=se desideri una funzione con nome. Grazie a 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))

Leggendo le regole, ho pensato che una lambda C # avrebbe dovuto fare abbastanza bene.

Modifica: appena trovato Countha un utile sovraccarico per il filtraggio!

Puoi verificarlo definendo il delegatetipo appropriato :

delegate int solver(int[] l);

E poi

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)

L'input viene dato come un vettore di riga passato alla funzione f. Quindi ad esempio f([-1, 3, 1, -2, 5, 2, 3, 4])ritorna 6.

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

Versione più corta:

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

Ottava (31)

In Octave bsxfunpuò essere rimosso grazie alla trasmissione automatica:

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

JavaScript (ES6) 80 82

Vedi commenti - il conteggio dei byte non include l'assegnazione a F (che è ancora necessario per il test)

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

Test nella console 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])
]

Produzione

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

Gelatina , 10 byte

>þ`^ƝS$€Ṁ‘

Provalo online!

Come funziona

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

Provalo online!

Spiegazione:

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

Provalo online!

Aggiungi ++ , 27 byte

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

Provalo online!

_{Approccio grazie a Zgarb per la risposta APL}

La parte fondamentale di questa sfida è l'implementazione di un comando di prodotto esterno. Sfortunatamente, Add ++ non ha un builtin per farlo, non ha alcun modo di definire funzioni che accettano altre funzioni come argomenti. Tuttavia, possiamo comunque far funzionare un prodotto esterno generalizzato. Poiché l'unico modo per accedere a una funzione all'interno di un'altra funzione è tramite il riferimento a una funzione esistente, definita dall'utente o incorporata, dobbiamo creare un "builtin" che faccia riferimento a tale funzione.

Una funzione "tabella" generalizzata sarebbe simile a questa:

D,func,@@,+

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

Provalo online!

dove funcè una funzione diadica che contiene il nostro operando. Puoi vedere deboli somiglianze di questa struttura nella presentazione originale, all'inizio della funzione w , ma qui vogliamo, in primo luogo, una funzione monadica del prodotto esterno - una funzione del prodotto esterno che accetta lo stesso argomento su entrambi i lati.

La funzione di tabella generale sfrutta il modo in cui il €rapido si avvicina alle funzioni diadiche. Se lo stack sembra

 [a b c d e]

quando €{func}viene rilevato, il €pop e, lo lega come argomento sinistro alla diade e mappa quella funzione parziale a, b, c, d. Tuttavia, le €mappe rapide sull'intero stack, piuttosto che sugli elenchi. Quindi è necessario appiattire prima le matrici passate come argomenti.

La funzione tabella funziona in questo modo

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

Tuttavia, possiamo accorciare di molto il fatto che abbiamo bisogno che la nostra tabella esterna sia monadica e debba solo applicarsi all'argomento passato. Il Acomando invia individualmente ogni argomento allo stack, quindi non abbiamo bisogno di manipolare lo stack. In breve, se il nostro argomento è l'array [a b c d], dobbiamo creare lo stack

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

Il valore più alto è, naturalmente, l'argomento. Potresti aver notato dall'esempio generale che bUè il comando unpack, ovvero divide l'array superiore nello stack. Quindi per effettuare la configurazione sopra, possiamo usare il codice

L,bUA

Provalo online!

Tuttavia, questo può essere ridotto di un byte. Come alias per L,bU, possiamo usare il ~flag, per suddividere in anticipo gli argomenti nello stack, trasformando il nostro esempio di configurazione in

L~,A

Provalo online!

che è l'inizio della seconda riga nel programma. Ora abbiamo implementato il prodotto esterno monadico, dobbiamo solo implementare il resto dell'algoritmo. Dopo aver recuperato il risultato della tabella con <(minore di), conta il numero di [0 1]e le [1 0]coppie in ogni riga. Infine, prendiamo il massimo di questi conteggi e lo incrementiamo.

Il passaggio completo per il passaggio è

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]