На сколько кусков вы можете разрезать эту струну?


45

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

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

введите описание изображения здесь

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

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

введите описание изображения здесь

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

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

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

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

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

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

Ваш код должен обработать любой такой ввод (включая тестовые примеры ниже) менее чем за 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

Можем ли мы предположить, что вы хотите, чтобы разрез находился в месте, которое гарантирует максимальное количество кусков?
DavidC

2
Я бы сказал: «определите наибольшее количество фигур» вместо «определите, сколько элементов».
DavidC

1
Разве это не a reasonable desktop PCдовольно двусмысленно?
Глупый

3
@globby Это довольно распространенная фраза, которую мы используем, когда время выполнения не является частью критерия выигрыша (но используется только для того, чтобы гарантировать, что решения не используют грубую силу). Это в основном означает, что предел не является на 100% строгим. Если на вашей машине это займет 15 секунд (а вы не используете суперкомпьютер), скорее всего, у кого-то здесь есть настольный ПК, который завершает работу за 10 секунд. Но если это займет минуту на вашей машине, это менее вероятно, поэтому вам придется подумать о другом подходе. Кроме того, предел выбирается таким образом, чтобы эффективный алгоритм легко выполнялся менее чем за 10 секунд.
Мартин Эндер

2
@ZainR Нет .
Мартин Эндер

Ответы:


16

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.


@ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ Мой плохой - ожидаемый результат - количество штук, а не место, где его можно создать.
J ...

Технически это 16 символов, 28 байтов. Юникод сделает это за вас = P
KChaloux

1
@KChaloux, только если вы учитываете в utf8 байтов, чего не было бы для APL Существует однобайтовая кодовая страница, которая содержит весь набор символов, используемый APL, поэтому справедливо использовать его для подсчета.
Мартин Эндер

@ MartinBüttner Надежная ссылка на источник была бы отличной. В противном случае кто-то может создать собственную веб-страницу, используя только набор символов, используемый для любого языка, чтобы уменьшить количество байтов.
agweber

1
@GuillaumeLethuillier APL на самом деле очень легко выучить, по крайней мере, до такой степени, что вы можете написать простые ответы о гольфе, как это. Есть несколько десятков функций с легко запоминающимися именами, такими как ×умножение, и очень простыми правилами синтаксиса. Google "освоение Dyalog APL" для хорошего руководства.
Згарб

16

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. Попробуйте это на онлайн-переводчике .


Вы даже можете хранить функцию в том же количестве символов:def f(x):max(sum((a+.5-m)*(a+.5-n)<0for m,n in zip(x,x[1:]))for a in x)+1
Кристиан Сонн

4
@ChristianSonne Ваша функция ничего не возвращает.
Якуб

Стреляй, ты прав @Jakube
Кристиан

Я не совсем уверен, как это работает, но я думаю, что вы можете удалить +.5s, чтобы сохранить некоторые символы. Я понял, что они бессмысленны в моем.
KSFT

@KSFT Разбивает строку на интервалы, перебирает каждый a = point + .5и подсчитывает количество строго содержащих интервалов a. Без этого у .5вас будут проблемы с [1, 0, -1]примерами.
Sp3000

16

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

Уверен, что вы могли бы использовать ,QtQвместо[QtQ)
FryAmTheEggman

iне линия пересечения, i - 0.5это. И поэтому 1 (на самом деле 1 - 0.5 = 0.5) находится внутри (-1, 1). min(a)<i<=max(a)эквивалентно min(a) < i - 0.5 < max(a), которая решается в Pyth с min(a) < i < max(a)+1(обратите внимание на hв heSk).
Якуб

Я думаю, что ты прямо здесь. Или, по крайней мере, я не могу найти ни одного случая, когда эта логика не работает ...
Оптимизатор

Вы можете сохранить символ, используя g, что >=, если заменить <dheSkс geSkd.
Исаак

2
Спасибо @isaacg. Но почему вы всегда приходите и разрушаете мое решение, когда я действительно счастлив и уверен в этом? ;-)
Якуб

10

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]и вычисляем количество наборов, в которых лежит каждый из них. Получите максимальное из этого числа, увеличьте его, и мы получим наш ответ.

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


10

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


10
Моя жена не может терпеть XNORing
gnibbler

9
Время @xnor делать заметки =)
flawr

Я думаю, что вы можете сэкономить на поиске точек разреза, так как сгибы всегда целочисленные: c=sort(a)-.5Конечно, первая точка выходит за пределы диапазона, но, конечно, с этим легче справиться. В худшем случае вы можете сделать c(1)=[];. - Также вы можете удалить команду disp, просто подсчитав что-то, запишете это в стандартный вывод .-- Наконец, в этом случае numelего можно заменить наnnz
Деннис Джаэруддин

Но я так гордился своим convподходом ... = D. Я всегда забываю о nnz, большое спасибо!
flawr

Я мог бы найти немало способов сделать его еще короче! Я использую, dispтак как кто-то однажды раскритиковал, что с помощью предложенного вами метода вы также получите другие символы (имя ans
переменной

9

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


8

Pyth, 21 байт

heSmsmq1xS+dSkdC,tQQQ

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

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

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


7

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

ОК, поэтому я пристрастен и просто как R. FWIW вы могли бы сохранить 3 символа, используя Tдля «ИСТИНА»
Карл Виттофт

@CarlWitthoft Спасибо за совет
MickyT

4

GolfScript (43 байта)

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

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

Онлайн демо


4

Питон - 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

1
@ MartinBüttner / Якуб, я исправил это. Теперь он работает для всех тестовых случаев менее чем за десять секунд.
KSFT

Почему по этому поводу есть два отрицательных ответа?
KSFT

3

Руби, 63

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

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

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


Чистый процесс представляется приемлемым ответом без присвоения его переменной. Спасает двух персонажей.
Марк Рид

3

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

3

Матлаб ( 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

2

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]


2
Основываясь на lambdaрешениях Python , вам не нужно присваивать значение функции фактической переменной, поэтому вы можете выбить два символа.
Марк Рид

1
Ага. Если в задании не указано иное, безымянные функции вполне подходят.
Мартин Эндер

1

Желе , 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



0

Добавить ++ , 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]
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.