Рассмотрим кусок строки (как в «веревке», а не в «группе символов»), который сложен взад-вперед на реальной линии. Мы можем описать форму строки с помощью списка точек, через которые она проходит (по порядку). Для простоты мы будем предполагать, что все эти точки являются целыми числами.

Возьмите в качестве примера [-1, 3, 1, -2, 5, 2, 3, 4](обратите внимание, что не каждая запись подразумевает фолд):

^{Строка, идущая вдоль вертикального направления, предназначена только для визуализации. Представьте, что все нити сплющены на реальной линии.}

Теперь возникает вопрос: какое наибольшее количество кусочков может быть разрезано на эту строку за один разрез (который должен быть вертикальным на рисунке выше). В этом случае ответ 6 с разрезом где-нибудь между 2и 3:

Чтобы избежать неясностей, разрез должен быть выполнен в нецелочисленном положении.

Соревнование

Учитывая список целочисленных позиций, через которые складывается строка, вы должны определить наибольшее количество фрагментов, в которые строка может быть разрезана с одним разрезом в нецелочисленной позиции.

Вы можете написать полную программу или функцию. Вы можете получить ввод через STDIN, аргумент командной строки, приглашение или параметр функции. Вы можете записать вывод в STDOUT, отобразить его в диалоговом окне или вернуть из функции.

Вы можете предположить, что список находится в любом удобном формате списка или строки.

Список будет содержать не менее 2 и не более 100 записей. Записи будут целыми числами, каждое в диапазоне -2 ³¹ ≤ p _i <2 ³¹ . Вы можете предположить, что никакие две последовательные записи не являются идентичными.

Ваш код должен обработать любой такой ввод (включая тестовые примеры ниже) менее чем за 10 секунд на приемлемом настольном ПК.

Тестовые случаи

Все контрольные примеры просто вводятся, а затем выводятся.

[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 байтов

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

Спасибо @ngn за сохранение 2 байта.

На ⎕самом деле это символ коробки, а не ошибка отсутствующего шрифта. Вы можете попробовать программу на сайте tryapl.org , но, поскольку ⎕он там не поддерживается полностью, вы должны заменить его на входное значение:

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

объяснение

Программу лучше всего объяснить на примере ввода s = ¯1 3 1 ¯2 5 2 3 4, который взят из STDIN ⎕. Во-первых, мы вычисляем произведение ≤-утер sс помощью самого себя ∘.≤⍨. Это приводит к булевой матрице, чья iстрока указывает, какие элементы sменьше или равны 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

Вхождения 0 1и 1 0в строке iотмечают места, где строка проходит над точкой s[i] + 0.5. Мы сопоставляем их в каждой строке, используя 2≠/«уменьшить 2-подсписки ≠»:

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

Осталось взять суммы строк с +/

2 5 3 0 2 3 5 3

и один плюс максимум из них с 1+⌈/:

6

Результат автоматически выводится на STDOUT в большинстве реализаций APL.

Python, 88 75 73 байта

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

Просто прямая лямбда

Просто чтобы показать другой подход:

Pyth, 28 27 байтов

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

Это примерно эквивалентно

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

применяется к списку ввода из STDIN. Попробуйте это на онлайн-переводчике .

Pyth : 31 30 29 28 24 23 символа (Python 68 символов)

heSmsm&<hSkdgeSkdC,tQQQ

Попробуйте это здесь: Pyth Compiler / Executor

Ожидается список целых чисел в качестве входных данных [-1, 3, 1, -2, 5, 2, 3, 4]

Это простой перевод моей программы на Python:

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

Старое решение: Pyth 28 char

Просто по причинам архивации.

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

Соответствующий код Python будет:

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 байт

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

Я считаю, что в природе существует лучший алгоритм. Тем не менее, это работает в рамках ограничения, необходимого для всех тестовых случаев (даже на онлайн-компиляторе)

Ввод как

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

Как это работает

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

Теперь предположим, что входной массив имеет следующие [-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] [[-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]]]

Второй массив в последней строке - это сгибы строки.

Теперь мы перебираем [-1 3 1 -2 5 2 3 4]и вычисляем количество наборов, в которых лежит каждый из них. Получите максимальное из этого числа, увеличьте его, и мы получим наш ответ.

Попробуйте онлайн здесь

Матлаб (123) (97) (85)

Yay, наконец, использование для XNOR =) Я уверен, что это может быть гораздо лучше.

Но, честно говоря, я немного смущен тем, что MatLab становится языком, который я знаю лучше всего = /

Приблизительное время выполнения есть 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)

РЕДАКТИРОВАТЬ: Новая версия для гольфа (включая подсказки от @DennisJaheruddin, спасибо!)

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)

Старая версия:

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: Мне действительно нравятся твои милые маленькие проблемы перед сном!

Mathematica 134 133 104

Весело решать, несмотря на размер кода. Далее игра в гольф все еще может быть достигнуто путем замены идеи IntervalMemberQ[Interval[a,b],n]с 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

объяснение

list1является ли данный список точек list2сокращенным списком, который удаляет числа, которые не были в сгибах; они не имеют значения. В этом нет необходимости, но это приводит к более четкому и эффективному решению.

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}

Интервалы в list1и list2показаны на графиках ниже:

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

Нам нужно проверить только одну линию в каждом интервале, определяемом точками сгиба. Тестовые линии - это пунктирные вертикальные линии на графике.

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

fнаходит количество порезов или пересечений каждой тестовой линии. Линия при х = 2,5 составляет 5 пересечений. Это оставляет 5 + 1 кусочков нити.

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

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

Pyth, 21 байт

heSmsmq1xS+dSkdC,tQQQ

Попробуй это здесь.

Предоставить ввод в виде списка в стиле Python, например [-1, 3, 1, -2, 5, 2, 3, 4]

Близко основано на программе @ jakube, но с улучшенным центральным алгоритмом. Вместо того, чтобы делать >проверку и >=проверку, я делаю a .index()на трех числах вместе и проверяю, что индекс равен 1, что означает, что он больше минимального и меньше или равен максимальному.

R 86 83

Работал над этим, а потом понял, что по сути я придумал то же решение, что и Оптимизатор и другие, которые я подозреваю.

Во всяком случае здесь это как функция, которая принимает вектор

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

GolfScript (43 байта)

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

С точки зрения эффективности это O (n ^ 2), если предположить, что сравнение занимает O (1) время. Он разбивает входные данные на отрезки и для каждой начальной точки подсчитывает полуоткрытые отрезки, которые пересекают его.

Онлайн демо

Питон - 161

Это, вероятно, может быть в гольф больше. Гнибблер очень помог гольфу.

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

Руби, 63

Аналогично решениям Python по концепции.

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

Добавьте 2 символа перед кодом, например, f=если вы хотите именованную функцию. Thx в MarkReed .

C #, 73 65 байт

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

Читая правила, я подумал, что C # лямбда должна работать довольно хорошо.

Изменить: только что найденный Countимеет полезную перегрузку для фильтрации!

Вы можете проверить это, определив соответствующий delegateтип:

delegate int solver(int[] l);

А потом

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

Матлаб ( 63 43)

Входные данные даны как вектор строки, переданный функции f. Так например f([-1, 3, 1, -2, 5, 2, 3, 4])возвращается 6.

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

Более короткая версия:

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

Октава (31)

В Octave bsxfunможно удалить благодаря автоматической трансляции:

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

JavaScript (ES6) 80 82

См. Комментарии - в число байтов не входит присвоение F (это все еще необходимо для проверки)

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

Тест в консоли 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])
]

Выход

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

Желе , 10 байт

>þ`^ƝS$€Ṁ‘

Попробуйте онлайн!

Как это работает

>þ`^Ɲ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 байтов

ε@Ôg}à

Попробуйте онлайн!

Объяснение:

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

JavaScript (Node.js) , 71 байт

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

Попробуйте онлайн!

Добавить ++ , 27 байт

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

Попробуйте онлайн!

_{Подход, спасибо Zgarb за ответ APL}

Ключевой частью этой задачи является реализация команды внешнего продукта. К сожалению, Add ++ не имеет встроенной функции для этого, и не имеет никакого способа определения функций, которые принимают другие функции в качестве аргументов. Тем не менее, мы все равно можем сделать обобщенную функцию внешнего произведения. Поскольку единственный доступ к функции внутри другой функции заключается в обращении к существующей функции, определенной пользователем или встроенной, мы должны создать «встроенную», которая ссылается на такую ​​функцию.

Обобщенная табличная функция будет выглядеть примерно так:

D,func,@@,+

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

Попробуйте онлайн!

где funcдиадическая функция, которая содержит наш операнд. Вы можете увидеть слабые сходства этой структуры в исходном представлении, в начале функции w , но здесь мы хотим, прежде всего, монадическую внешнюю функцию продукта - внешнюю функцию продукта, которая принимает одинаковый аргумент с обеих сторон.

Общая табличная функция использует преимущества €быстрого достижения диадических функций. Если стек выглядит

 [a b c d e]

когда €{func}встречается, €pops eсвязывает это как левый аргумент с диадой и отображает эту частичную функцию поверх a, b, c, d. Тем не менее, €быстрые карты по всему стеку, а не по спискам. Поэтому сначала нам нужно сгладить массивы, переданные в качестве аргументов.

Таблица функция работает в целом , как это

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

Тем не менее, мы можем значительно сократить это из-за того, что наша внешняя таблица должна быть монадической , и нам нужно применять ее только к переданному аргументу. Команда Aпомещает каждый аргумент в стек по отдельности, поэтому нам не нужно возиться с какими-либо манипуляциями со стеком. Короче говоря, если нашим аргументом является массив [a b c d], нам нужно превратить стек в

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

Верхнее значение, конечно же, является аргументом. Вы, возможно, заметили из общего примера, что bUэто команда unpack, т.е. она разбивает верхний массив на стек. Таким образом, чтобы сделать вышеуказанную конфигурацию, мы можем использовать код

L,bUA

Попробуйте онлайн!

Однако это может быть сокращено байтом. В качестве псевдонима L,bUмы можем использовать ~флаг, чтобы заранее разбить аргументы на стек, превратив наш пример конфигурации в

L~,A

Попробуйте онлайн!

который является началом второй строки в программе. Теперь мы реализовали монадический внешний продукт, нам просто нужно реализовать остальную часть алгоритма. После получения результата таблицы с <(меньше чем) и подсчитать количество [0 1]и [1 0]пар в каждой строке. Наконец, мы берем максимум этих отсчетов и увеличиваем его.

Полный шаг для пошаговой прогулки -

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]