Considere um pedaço de corda (como em "corda", não como em "um monte de caracteres"), que é dobrado para frente e para trás na linha real. Podemos descrever o formato da string com uma lista de pontos pelos quais ela passa (em ordem). Para simplificar, assumiremos que todos esses pontos são inteiros.

Tome como exemplo [-1, 3, 1, -2, 5, 2, 3, 4](observe que nem cada entrada implica em uma dobra):

^{A corda que se estende ao longo da direção vertical é apenas para fins de visualização. Imagine a corda toda achatada na linha real.}

Agora, aqui está a pergunta: qual é o maior número de peças em que essa corda pode ser cortada com um único corte (que teria que ser vertical na figura acima). Nesse caso, a resposta é 6 com um corte em qualquer lugar entre 2e 3:

Para evitar ambiguidades, o corte deve ser realizado em uma posição não inteira.

O desafio

Dada uma lista de posições inteiras pelas quais uma string é dobrada, você deve determinar o maior número de partes em que a string pode ser cortada com um único corte em uma posição não inteira.

Você pode escrever um programa completo ou uma função. Você pode receber entradas via STDIN, argumento de linha de comando, prompt ou parâmetro de função. Você pode gravar a saída em STDOUT, exibi-la em uma caixa de diálogo ou retorná-la da função.

Você pode supor que a lista esteja em qualquer formato conveniente de lista ou string.

A lista conterá pelo menos 2 e não mais de 100 entradas. As entradas serão inteiras, cada uma no intervalo -2 ³¹ ≤ p _i <2 ³¹ . Você pode assumir que não há duas entradas consecutivas iguais.

Seu código deve processar qualquer entrada (incluindo os casos de teste abaixo) em menos de 10 segundos em um PC de mesa razoável.

Casos de teste

Todos os casos de teste são simplesmente de entrada, seguidos de saída.

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

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

Obrigado a @ngn por salvar 2 bytes.

Na ⎕verdade, é um caractere de caixa, não um erro de fonte ausente. Você pode experimentar o programa em tryapl.org , mas como ⎕não é totalmente suportado por lá, substitua-o pelo valor de entrada:

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

Explicação

O programa é melhor explicado com o exemplo de entrada s = ¯1 3 1 ¯2 5 2 3 4, retirado do STDIN por ⎕. Primeiro, calculamos o ≤produto -outer susando ele mesmo ∘.≤⍨. Isso resulta em uma matriz booleana cuja ilinha th indica quais elementos ssão menores ou iguais 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

As ocorrências de 0 1e 1 0na linha imarcam os locais onde a sequência passa sobre o ponto s[i] + 0.5. Combinamos isso em todas as linhas usando 2≠/"reduzir 2 sublistas em ≠":

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

O que resta é pegar as somas das linhas com +/

2 5 3 0 2 3 5 3

e um mais o máximo destes com 1+⌈/:

6

O resultado é impresso automaticamente em STDOUT na maioria das implementações de APL.

Python, 88 75 73 bytes

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

Apenas uma lambda direta

Apenas para mostrar outra abordagem:

Pitão, 28 27 bytes

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

Este é aproximadamente 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

aplicado à lista de entrada do STDIN. Experimente no intérprete online .

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

heSmsm&<hSkdgeSkdC,tQQQ

Experimente aqui: Pyth Compiler / Executor

Ele espera uma lista de números inteiros como entrada [-1, 3, 1, -2, 5, 2, 3, 4]

É uma tradução direta do meu programa Python:

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

Solução antiga: Pyth 28 char

Apenas por razões de arquivamento.

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

Um código Python correspondente seria:

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 bytes

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

Eu acredito que existe um algoritmo melhor por aí na natureza. Ainda assim, isso funciona abaixo do limite exigido para todos os casos de teste (mesmo no compilador online)

Entrada é como

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

A saída (para o caso acima) é

2

Como funciona

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

Agora, suponha que a matriz de entrada seja [-1 3 1 -2 5 2 3 4], as etapas de zipagem se parecem com:

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

A segunda matriz na última linha são as dobras da string.

Agora, iteramos [-1 3 1 -2 5 2 3 4]e calculamos o número de conjuntos em que cada um deles se encontra. Tire o máximo proveito desse número, aumente e tenha nossa resposta.

Experimente online aqui

Matlab (123) (97) (85)

Finalmente, um uso para o XNOR =) Tenho certeza de que ele pode ser jogado muito mais.

Mas, honestamente, estou um pouco envergonhado por o MatLab estar se tornando o idioma que eu conheço melhor = /

O tempo de execução aproximado é 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: Nova versão mais golfe (incluindo dicas de @DennisJaheruddin, obrigado!)

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)

Versão antiga:

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: Gosto muito dos seus pequenos e agradáveis ​​desafios antes de ir para a cama!

Mathematica 134 133 104

Divertido de resolver, apesar do tamanho do código. Ainda mais golfe pode ser alcançado, substituindo a idéia de IntervalMemberQ[Interval[a,b],n]com 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

Explicação

list1é que a lista de pontos fornecida list2é uma lista abreviada que remove números que não estavam nas dobras; eles são irrelevantes. Não é necessário fazer isso, mas leva a uma solução mais clara e eficiente.

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}

Os intervalos list1e list2são mostrados nos gráficos abaixo:

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

Só precisamos testar uma única linha em cada intervalo determinado pelos pontos de dobra. As linhas de teste são as linhas verticais tracejadas no gráfico.

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

flocaliza o número de cortes ou cruzamentos de cada linha de teste. A linha em x = 2,5 faz 5 cruzamentos. Isso deixa 5 + 1 pedaços de barbante.

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

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

Pitão, 21 bytes

heSmsmq1xS+dSkdC,tQQQ

Experimente aqui.

Dê entrada como lista no estilo Python, por exemplo [-1, 3, 1, -2, 5, 2, 3, 4]

Basicamente baseado no programa do @ jakube, mas com um algoritmo central aprimorado. Em vez de fazer uma >verificação e uma >=verificação, eu faço uma .index()nos três números combinados e certifico-me de que o índice seja 1, o que significa que é maior que o mínimo e menor ou igual ao máximo.

R, 86 83

Estava trabalhando nisso e percebi que eu tinha essencialmente encontrado a mesma solução que o Optimizer e outras que eu suspeito.

Enfim, aqui é como uma função que leva um vetor

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

GolfScript (43 bytes)

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

Em termos de eficiência, é O (n ^ 2) assumindo que as comparações levam tempo O (1). Ele divide a entrada em segmentos de linha e, para cada ponto inicial, conta os segmentos de linha semi-abertos que a atravessam.

Demonstração online

Python - 161

Provavelmente isso pode ser jogado mais. gnibbler ajudou muito a jogar golfe.

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

Semelhante às soluções Python em conceito.

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

Adicione 2 caracteres antes do código, por exemplo, f=se você deseja uma função nomeada. Thx para MarkReed .

C #, 73 65 bytes

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

Lendo as regras, pensei que um lambda C # deveria se sair muito bem.

Edit: recém encontrado Counttem uma sobrecarga útil para filtrar!

Você pode testar isso definindo o delegatetipo apropriado :

delegate int solver(int[] l);

E depois

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)

A entrada é fornecida como um vetor de linha passado para a função f. Então, por exemplo, f([-1, 3, 1, -2, 5, 2, 3, 4])retorna 6.

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

Versão mais curta:

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

Oitava (31)

No Octave bsxfunpode ser removido graças à transmissão automática:

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

JavaScript (ES6) 80 82

Ver comentários - a contagem de bytes não inclui a atribuição a F (ainda é necessário testar)

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

Teste no console do 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])
]

Resultado

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

Gelatina , 10 bytes

>þ`^ƝS$€Ṁ‘

Experimente online!

Como funciona

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

ε@Ôg}à

Experimente online!

Explicação:

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

JavaScript (Node.js) , 71 bytes

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

Experimente online!

Adicionar ++ , 27 bytes

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

Experimente online!

_{Abordagem graças a Zgarb por sua resposta APL}

A parte principal desse desafio é implementar um comando externo do produto. Infelizmente, o Add ++ não possui um built-in para isso, não possui nenhuma maneira de definir funções que usam outras funções como argumentos. No entanto, ainda podemos fazer com que um produto externo generalizado funcione. Como a única maneira de acessar uma função dentro de outra função é através da referência a uma função existente, definida pelo usuário ou embutida, precisamos criar um 'embutido' que faça referência a essa função.

Uma função "tabela" generalizada ficaria assim:

D,func,@@,+

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

Experimente online!

onde funcé uma função diádica que contém nosso operando. Você pode ver pequenas semelhanças dessa estrutura na submissão original, no início da função w , mas aqui queremos, principalmente, uma função de produto externo monádico - uma função de produto externo que adota o mesmo argumento dos dois lados.

A função geral da tabela tira proveito de como o €ach quick aborda as funções diádicas. Se a pilha parecer

 [a b c d e]

quando €{func}é encontrado, o €pop aparece e, vincula esse argumento à esquerda à díade e mapeia essa função parcial a, b, c, d. No entanto, os €mapas rápidos sobre toda a pilha, em vez de sobre as listas. Portanto, precisamos achatar as matrizes passadas como argumentos primeiro.

A função de tabela funciona de maneira geral assim

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

No entanto, podemos reduzi-lo bastante devido ao fato de que precisamos que nossa tabela externa seja monádica e que apenas seja aplicável ao argumento passado. O Acomando envia cada argumento para a pilha individualmente, portanto, não precisamos mexer com nenhuma manipulação de pilha. Em resumo, se nosso argumento é a matriz [a b c d], precisamos transformar a pilha em

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

O valor superior é, obviamente, o argumento. Você pode ter notado no exemplo geral que bUé o comando unpack, ou seja, ele divide a matriz superior na pilha. Então, para fazer a configuração acima, podemos usar o código

L,bUA

Experimente online!

No entanto, isso pode ser reduzido por um byte. Como um alias para L,bU, podemos usar a ~flag, para dividir os argumentos na pilha de antemão, transformando nosso exemplo de configuração em

L~,A

Experimente online!

que é o início da segunda linha do programa. Agora que implementamos o produto externo monádico, precisamos apenas implementar o restante do algoritmo. Depois de recuperar o resultado da tabela com <(menor que) e conte o número de [0 1]e [1 0]pares em cada linha. Finalmente, pegamos o máximo dessas contagens e incrementamos.

O passo completo para o passo a passo é

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]