Considere un trozo de cuerda (como en "cuerda", no como en "un montón de caracteres"), que se pliega de un lado a otro en la línea real. Podemos describir la forma de la cadena con una lista de puntos por los que pasa (en orden). Por simplicidad, asumiremos que todos esos puntos son enteros.

Tomemos como ejemplo [-1, 3, 1, -2, 5, 2, 3, 4](tenga en cuenta que no cada entrada implica un pliegue):

^{La cadena que se extiende a lo largo de la dirección vertical es solo para fines de visualización. Imagina que la cuerda se aplana en la línea real.}

Ahora aquí está la pregunta: ¿cuál es el mayor número de piezas en las que se puede cortar esta cadena con un solo corte (que tendría que ser vertical en la imagen de arriba)? En este caso, la respuesta es 6 con un corte entre 2y 3:

Para ambigüedades EVITAR, el corte tiene que ser realizado en una posición no entero.

El reto

Dada una lista de posiciones enteras por las que se pliega una cadena, debe determinar el mayor número de piezas en las que se puede cortar la cadena con un solo corte en una posición no entera.

Puede escribir un programa completo o una función. Puede recibir información a través de STDIN, argumento de línea de comando, indicador o parámetro de función. Puede escribir la salida en STDOUT, mostrarla en un cuadro de diálogo o devolverla desde la función.

Puede suponer que la lista está en cualquier lista conveniente o formato de cadena.

La lista contendrá al menos 2 y no más de 100 entradas. Las entradas serán números enteros, cada uno en el rango -2 ³¹ ≤ p _i <2 ³¹ . Puede suponer que no hay dos entradas consecutivas idénticas.

Su código debe procesar dicha entrada (incluidos los casos de prueba a continuación) en menos de 10 segundos en una PC de escritorio razonable.

Casos de prueba

Todos los casos de prueba son simplemente de entrada seguidos de salida.

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

Gracias a @ngn por guardar 2 bytes.

El ⎕es en realidad un carácter de cuadro, no un error de fuente faltante. Puede probar el programa en tryapl.org , pero como ⎕no es totalmente compatible allí, debe reemplazarlo por el valor de entrada:

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

Explicación

El programa se explica mejor con la entrada de ejemplo s = ¯1 3 1 ¯2 5 2 3 4, que es tomada de STDIN por ⎕. Primero, calculamos el ≤producto externo de ssí mismo usando ∘.≤⍨. Esto da como resultado una matriz booleana cuya ifila th indica qué elementos sson menores o iguales que 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

Las ocurrencias de 0 1y 1 0en la fila imarcan los lugares donde la cadena pasa sobre el punto s[i] + 0.5. Coincidimos con estos en cada fila usando 2≠/"reducir 2 sublistas por ≠":

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

Lo que queda es tomar las sumas de las filas con +/

2 5 3 0 2 3 5 3

y uno más el máximo de estos con 1+⌈/:

6

El resultado se imprime automáticamente en STDOUT en la mayoría de las implementaciones 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

Solo una simple lambda

Solo para mostrar otro enfoque:

Pyth, 28 27 bytes

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

Este es 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 a la lista de entrada de STDIN. Pruébelo en el intérprete en línea .

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

heSmsm&<hSkdgeSkdC,tQQQ

Pruébalo aquí: Pyth Compiler / Executor

Espera una lista de enteros como entrada [-1, 3, 1, -2, 5, 2, 3, 4]

Es una traducción directa de mi programa Python:

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

Antigua solución: Pyth 28 char

Solo por razones de archivo.

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

Un código de Python correspondiente sería:

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

Creo que hay un mejor algoritmo en la naturaleza. Aún así, esto funciona por debajo del límite requerido para todos los casos de prueba (incluso en el compilador en línea)

La entrada es 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]

La salida (para el caso anterior) es

2

Cómo 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";

Ahora suponga que la matriz de entrada es [-1 3 1 -2 5 2 3 4], los pasos de compresión se ven así:

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

La segunda matriz en la última línea son los pliegues de la cadena.

Ahora iteramos [-1 3 1 -2 5 2 3 4]y calculamos el número de conjuntos en los que se encuentra cada uno de ellos. Obtenga el máximo de ese número, increméntelo y tenemos nuestra respuesta.

Pruébalo en línea aquí

Matlab (123) (97) (85)

Sí, finalmente un uso para XNOR =) Estoy seguro de que se puede jugar mucho más.

Pero, sinceramente, estoy un poco avergonzado de que MatLab se esté convirtiendo en el idioma que mejor conozco = /

El tiempo de ejecución aproximado es 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)

EDITAR: Nueva versión más golfizada (incluyendo pistas de @DennisJaheruddin, ¡gracias!)

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ón antigua:

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: ¡Realmente disfruto de tus pequeños y agradables desafíos justo antes de irme a la cama!

Mathematica 134 133 104

Divertido de resolver, a pesar del tamaño del código. Se puede seguir jugando al golf reemplazando la idea de 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 6

Explicación

list1la lista de puntos dada list2es una lista abreviada que elimina los números que no estaban en pliegues; Son irrelevantes. No es necesario hacer esto, pero conduce a una solución más clara y más 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}

Los intervalos en list1y list2se muestran en las parcelas a continuación:

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

Solo necesitamos probar una sola línea en cada intervalo determinado por los puntos de plegado. Las líneas de prueba son las líneas verticales discontinuas en el gráfico.

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

fencuentra el número de cortes o cruces de cada línea de prueba. La línea en x = 2.5 hace 5 cruces. Eso deja 5 + 1 piezas de cuerda.

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

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

Pyth, 21 bytes

heSmsmq1xS+dSkdC,tQQQ

Pruébalo aquí

Dar entrada como lista de estilo Python, por ejemplo [-1, 3, 1, -2, 5, 2, 3, 4]

Estrechamente basado en el programa de @jakube, pero con un algoritmo central mejorado. En lugar de hacer una >verificación y una >=verificación, hago un a .index()en los tres números combinados y me aseguro de que el índice sea 1, lo que significa que es mayor que el mínimo y menor o igual que el máximo.

R, 86 83

Estaba trabajando en esto y luego me di cuenta de que esencialmente había encontrado la misma solución que Optimizer y otras que sospecho.

De todos modos aquí es como una función que toma un vector

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

En términos de eficiencia, esto es O (n ^ 2) suponiendo que las comparaciones toman O (1) tiempo. Rompe la entrada en segmentos de línea y para cada punto de inicio cuenta los segmentos de línea medio abiertos que la cruzan.

Demostración en línea

Python - 161

Esto probablemente se puede jugar más al golf. gnibbler ayudó mucho al 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

Rubí, 63

Similar a las soluciones de Python en concepto.

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

Agregue 2 caracteres antes del código, por ejemplo, f=si desea una función con nombre. Gracias a 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))

Leyendo las reglas, pensé que una lambda C # debería funcionar bastante bien.

Editar: ¡recién encontrado Counttiene una sobrecarga útil para filtrar!

Puede probar esto definiendo el delegatetipo apropiado :

delegate int solver(int[] l);

Y entonces

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)

La entrada se da como un vector de fila pasado a la función f. Entonces, por ejemplo, f([-1, 3, 1, -2, 5, 2, 3, 4])vuelve 6.

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

Versión más corta:

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

Octava (31)

En Octave bsxfunse puede eliminar gracias a la transmisión automática:

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

JavaScript (ES6) 80 82

Ver comentarios: el recuento de bytes no incluye la asignación a F (que todavía se necesita para probar)

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

Prueba en la consola 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])
]

Salida

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

Jalea , 10 bytes

>þ`^ƝS$€Ṁ‘

Pruébalo en línea!

Cómo 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}à

Pruébalo en línea!

Explicación:

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

Pruébalo en línea!

Agregar ++ , 27 bytes

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

Pruébalo en línea!

_{Enfoque gracias a Zgarb por su respuesta APL}

La parte clave de este desafío es implementar un comando externo del producto. Desafortunadamente, Add ++ no tiene una función integrada para hacerlo, tampoco tiene ninguna forma de definir funciones que tomen otras funciones como argumentos. Sin embargo, aún podemos hacer que un producto externo general funcione de todos modos. Como la única forma de acceder a una función dentro de otra función es haciendo referencia a una función existente, definida por el usuario o incorporada, tenemos que crear un 'incorporado' que haga referencia a dicha función.

Una función de "tabla" generalizada se vería así:

D,func,@@,+

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

Pruébalo en línea!

donde funces una función diádica que contiene nuestro operando. Puede ver ligeras similitudes de esta estructura en la presentación original, al comienzo de la función w , pero aquí queremos, principalmente, una función de producto externo monádico , una función de producto externo que tome el mismo argumento en ambos lados.

La función de tabla general aprovecha la forma en que €ach quick se acerca a las funciones diádicas. Si la pila se ve así

 [a b c d e]

cuando €{func}se encuentra, los €estallidos e, lo vinculan como argumento izquierdo a la díada, y mapean esa función parcial a, b, c, d. Sin embargo, los €mapas rápidos sobre toda la pila, en lugar de sobre listas. Por lo tanto, primero debemos aplanar las matrices pasadas como argumentos.

La función de tabla funciona en general de esta manera

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

Sin embargo, podemos acortar esto bastante debido al hecho de que necesitamos que nuestra tabla externa sea monádica , y solo necesitamos aplicarla al argumento pasado. El Acomando empuja cada argumento a la pila de forma individual, por lo que no necesitamos perder el tiempo con ninguna manipulación de la pila. En resumen, si nuestro argumento es la matriz [a b c d], necesitamos convertir la pila en

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

El valor superior es, por supuesto, el argumento. Puede haber notado en el ejemplo general que bUes el comando desempaquetar, es decir, salpica la matriz superior a la pila. Entonces, para hacer la configuración anterior, podemos usar el código

L,bUA

Pruébalo en línea!

Sin embargo, esto puede acortarse en un byte. Como un alias para L,bU, podemos usar la ~bandera, para salpicar los argumentos a la pila de antemano, convirtiendo nuestro ejemplo de configuración en

L~,A

Pruébalo en línea!

que es el comienzo de la segunda línea en el programa. Ahora que hemos implementado un producto externo monádico, solo necesitamos implementar el resto del algoritmo. Una vez recuperar el resultado de mesa con <(menor que), y contar el número de [0 1]y [1 0]pares en cada fila. Finalmente, tomamos el máximo de estos recuentos y lo incrementamos.

El paso completo para caminar paso a paso es

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]