พิจารณาชิ้นส่วนของสตริง (เช่นเดียวกับใน "เชือก" ไม่ใช่ใน "กลุ่มของอักขระ") ซึ่งถูกพับไปมาบนบรรทัดจริง เราสามารถอธิบายรูปร่างของสตริงด้วยรายการของจุดที่มันผ่าน (ตามลำดับ) เพื่อความง่ายเราจะสมมติว่าจุดเหล่านั้นทั้งหมดเป็นจำนวนเต็ม

ใช้เป็นตัวอย่าง[-1, 3, 1, -2, 5, 2, 3, 4](โปรดทราบว่าไม่ใช่แต่ละรายการที่แสดงถึงการพับ):

^{สตริงที่ขยายไปตามทิศทางแนวตั้งนั้นใช้เพื่อจุดประสงค์ในการสร้างภาพเท่านั้น ลองนึกภาพสายทั้งหมดแบนไปยังเส้นจริง}

ทีนี้นี่คือคำถาม: อะไรคือจำนวนชิ้นที่ยิ่งใหญ่ที่สุดที่สายนี้สามารถตัดด้วยการตัดครั้งเดียว (ซึ่งจะต้องเป็นแนวตั้งในภาพด้านบน) ในกรณีนี้คำตอบคือ6โดยตัดระหว่าง2และ3:

เพื่อหลีกเลี่ยงความงงงวย, ตัดมีที่จะดำเนินการในตำแหน่งที่ไม่ใช่จำนวนเต็ม

ความท้าทาย

เนื่องจากรายการของจำนวนเต็มตำแหน่งที่สตริงถูกพับผ่านคุณต้องพิจารณาจำนวนชิ้นที่มากที่สุดที่สตริงสามารถถูกตัดด้วยการตัดครั้งเดียวที่ตำแหน่งที่ไม่ใช่จำนวนเต็ม

คุณสามารถเขียนโปรแกรมหรือฟังก์ชั่นเต็มรูปแบบ คุณสามารถรับอินพุตผ่าน STDIN, อาร์กิวเมนต์บรรทัดคำสั่ง, พรอมต์หรือพารามิเตอร์ฟังก์ชัน คุณสามารถเขียนผลลัพธ์ไปยัง STDOUT แสดงในกล่องโต้ตอบหรือส่งคืนจากฟังก์ชัน

คุณอาจคิดว่ารายการอยู่ในรายการหรือรูปแบบสตริงที่สะดวก

รายการจะมีอย่างน้อย2และไม่เกิน100รายการ รายการจะเป็นจำนวนเต็มในแต่ละช่วง-2 ³¹ ≤ P _ฉัน <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

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 ⎕โดย ครั้งแรกที่เราคำนวณ≤สินค้า -outer ของด้วยตัวเองโดยใช้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-sublists by ≠":

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 ถ่าน

เพียงเพื่อเหตุผลในการเก็บถาวร

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

รหัสหลามที่สอดคล้องกันจะเป็น:

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]และคำนวณจำนวนชุดที่แต่ละชุดอยู่รับจำนวนสูงสุดจากนั้นเพิ่มขึ้นและเรามีคำตอบ

ลองออนไลน์ได้ที่นี่

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

แก้ไข:รุ่นใหม่มากขึ้น golfed (รวมถึงคำแนะนำจาก @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ค้นหาจำนวนการตัดหรือการข้ามของแต่ละบรรทัดการทดสอบ เส้นที่ x = 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 อย่างใกล้ชิด แต่ด้วยอัลกอริทึมกลางที่ได้รับการปรับปรุง แทนที่จะทำการ>ตรวจสอบและ>=ตรวจสอบฉันทำ.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) มันแบ่งอินพุตเป็นเซ็กเมนต์บรรทัดและสำหรับแต่ละจุดเริ่มต้นนับจำนวนเซกเมนต์บรรทัดครึ่งเปิดที่ข้าม

การสาธิตออนไลน์

Python - 161

นี่อาจเป็นเรื่องของกอล์ฟมากกว่า gnibbler ช่วยกอล์ฟได้มาก

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

Matlab ( 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 ++ ไม่มี builtin ให้ทำเช่นนั้นไม่มีวิธีกำหนดฟังก์ชันที่ใช้ฟังก์ชันอื่นเป็นอาร์กิวเมนต์ อย่างไรก็ตามเรายังสามารถสร้างฟังก์ชั่นผลิตภัณฑ์ด้านนอกทั่วไปได้อย่างไรก็ตาม เป็นวิธีเดียวที่ฟังก์ชั่นที่จะเข้าถึงภายในฟังก์ชั่นอื่นคือการอ้างอิงฟังก์ชั่นที่มีอยู่ผู้ใช้กำหนดหรือ builtin เราต้องสร้าง 'builtin' ที่อ้างอิงฟังก์ชั่นดังกล่าว

ฟังก์ชัน "ตาราง" ทั่วไปจะมีลักษณะดังนี้:

D,func,@@,+

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

ลองออนไลน์!

ที่funcเป็นฟังก์ชัน dyadic ที่มีตัวถูกดำเนินการของเรา คุณสามารถเห็นความคล้ายคลึงกันเล็กน้อยของโครงสร้างนี้ในการส่งต้นฉบับที่จุดเริ่มต้นของฟังก์ชั่นwแต่ที่นี่เราต้องการส่วนใหญ่ฟังก์ชั่นผลิตภัณฑ์ด้านนอกmonadic - ฟังก์ชั่นผลิตภัณฑ์ด้านนอกที่ใช้อาร์กิวเมนต์เดียวกันทั้งสองด้าน

ฟังก์ชั่นตารางทั่วไปใช้ประโยชน์จากวิธีการที่€รวดเร็วในการเข้าถึงฟังก์ชั่น dyadic หากดูจากสแต็ค

 [a b c d e]

เมื่อ€{func}พบการ€ปรากฏผูกที่เป็นอาร์กิวเมนต์ซ้ายเพื่อคู่และแผนที่ที่ฟังก์ชั่นบางส่วนมากกว่า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

อย่างไรก็ตามเราสามารถย่อให้สั้นลงได้มากเนื่องจากความจริงที่ว่าเราต้องการโต๊ะด้านนอกของเราเป็นแบบ monadicและต้องการเพียงแค่ใช้กับการโต้แย้งที่ผ่าน Aคำสั่งผลักดันอาร์กิวเมนต์สแต็คแต่ละคนดังนั้นเราจึงไม่จำเป็นต้องยุ่ง ๆ กับการจัดการสแต็ค กล่าวโดยย่อถ้าอาร์กิวเมนต์ของเราคืออาร์เรย์[a b c d]เราต้องทำให้สแต็กเป็น

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

แน่นอนค่าสูงสุดคืออาร์กิวเมนต์คุณอาจสังเกตเห็นจากตัวอย่างทั่วไปที่bUเป็นคำสั่งunpackนั่นคือมันจะแบ่งอาร์เรย์บนสุดกับสแต็ก ดังนั้นเพื่อให้การกำหนดค่าข้างต้นเราสามารถใช้รหัส

L,bUA

ลองออนไลน์!

อย่างไรก็ตามสามารถย่อให้สั้นลงด้วยไบต์ ในฐานะนามแฝงL,bUเราสามารถใช้~แฟล็กเพื่อแยกอาร์กิวเมนต์ไปยังสแต็กล่วงหน้าทำให้ตัวอย่างการกำหนดค่าของเราเป็น

L~,A

ลองออนไลน์!

ซึ่งเป็นจุดเริ่มต้นของบรรทัดที่สองในโปรแกรม ตอนนี้เราได้ใช้ผลิตภัณฑ์ชั้นนอกแบบ monadic เราแค่ต้องใช้อัลกอริธึมที่เหลือ เมื่อดึงผลลัพธ์ของตารางด้วย<(น้อยกว่า) และนับจำนวน[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]