คำอธิบายการท้าทาย

subsequence เนื่องเป็นลำดับของตัวเลข[a1, a2, ..., an]ดังกล่าวว่า

a1 <= a2 <= ... <= ana1 >= a2 >= ... >= anหรือ [1, 3, 3, 7, 9, 13, 13, 100]เป็นลำดับ (ไม่ลด) monotonic เช่นเดียวกับ[9, 4, 4, 3, 0, -10, -12](อันนี้ไม่เพิ่มขึ้น) แต่[1, 3, 6, 9, 8]ไม่ รับรายการจำนวนเต็ม (ในรูปแบบที่เหมาะสม) ส่งออกจำนวนที่น้อยที่สุดNซึ่งลำดับของจำนวนเต็มเหล่านี้สามารถแบ่งออกเป็นNลำดับแบบโมโนโทนิก

ตัวอย่าง

[1, 3, 7, 5, 4, 2] -> [[1, 3, 7], [5, 4, 2]] -> 2
[1, 2, 3, 4, 5, 6] -> [1, 2, 3, 4, 5, 6]     -> 1
[3, 1, 5, 5, 6]    -> [[3, 1], [5, 5, 6]]    -> 2
[4, 6, 8, 9, 1, 6] -> [[4, 6, 8, 9], [1, 6]] -> 2
[3, 3, 3, 3]       -> [[3, 3, 3, 3]]         -> 1
[7]                -> [[7]]                  -> 1
[]                 -> []                     -> anything (you don't actually have to handle an empty list case)
[1, 3, 2, -1, 6, 9, 10, 2, 1, -12] -> [[1, 3], [2, -1], [6, 9, 10], [2, 1, -12]] -> 4

Brachylogขนาด 12 ไบต์

~c:{<=|>=}al

ลองออนไลน์!

ผลตอบแทนนี้สำหรับรายการที่ว่างเปล่าfalse.[]

คำอธิบาย

(?)~c                 Take a list of sublists which when concatenated result in the Input
     :{<=|>=}a        Each sublist must be either increasing or decreasing
              l(.)    Output is the length of that list

สิ่งนี้จะส่งคืนค่าที่เล็กที่สุดเพราะ~cจะสร้างคะแนนทางเลือกจากจำนวนรายการย่อยที่น้อยที่สุดไปหามากที่สุด

Perl, 65 ไบต์

รหัส 62 ไบต์ + 3 ไบต์สำหรับการ-nตั้งค่าสถานะ

monot_seq.pl:

#!perl -n
s/\S+ /($_<=>$&)*($&<=>$')-$g>=0?$g=1:$.++;$g--;$_=$&/ge,$_=$.

ให้อินพุตโดยไม่ขึ้นบรรทัดใหม่ด้วยตัวเลขคั่นด้วยช่องว่าง:

$ echo -n "1 3 2 -1 6 9 10 2 1 -12" | perl -M5.010 monot_seq.pl
4

-5 ไบต์ขอบคุณ @Gabriel Benamy

Mathematica, 111 ไบต์

d=#[[2]]-#[[1]]&;r=Rest;f@{n_}:=1;f@k__:=If[d@k==0,f@r@k,g[k Sign@d@k]];g@{n_}:=1;g@k__:=If[d@k>0,g@r@k,1+f@r@k]

ฟังก์ชั่นที่fมีชื่อการรายการที่ไม่ว่างของตัวเลข (จำนวนเต็มหรือแม้กระทั่ง reals) ทำงานจากด้านหน้าไปด้านหลังโดยละทิ้งองค์ประกอบแรกซ้ำ ๆ และติดตามว่าจำเป็นต้องมีส่วนประกอบกี่ส่วน verbose เพิ่มเติม:

d = #[[2]] - #[[1]] &;         function: difference of the first two elements
r = Rest;                      function: a list with its first element dropped
f@{n_} := 1;                   f of a length-1 list equals 1
f@k__ := If[d@k == 0, f@r@k,   if the first two elements are equal, drop one
                                 element and call f again ...
            g[k Sign@d@k]];  ... otherwise call the helper function g on the
                                 list, multiplying by -1 if necessary to ensure
                                 that the list starts with an increase
g@{n_} := 1;                   g of a length-1 list equals 1
g@k__ := If[d@k > 0, g@r@k,    if the list starts with an increase, drop one
                                 element and call g again ...
            1 + f@r@k];        ... otherwise drop one element, call f on the
                                 resulting list, and add 1

เยลลี่ขนาด 19 ไบต์

IṠḟ0E
ŒṖÇ€€0e$Ðḟḅ1Ṃ

TryItOnline! หรือเรียกใช้การทดสอบทั้งหมด (ผลลัพธ์รายการว่างเปล่า1)

อย่างไร?

IṠḟ0E - Link 1, test for monotonicity: a sublist
I     - incremental differences
 Ṡ    - sign {fall:-1; same:0; rise:1}
  ḟ0  - filter out the zeros
    E - all equal?

ŒṖÇ€€0e$Ðḟḅ1Ṃ - Main link
ŒṖ            - all partitions of the input list
  Ç€€         - call last link (1) as a monad for €ach for €ach
        Ðḟ    - filter out results:
       $      -    last two links as a monad
     0e       -        contains zero?
          ḅ1  - convert from unary (vectorises)
            Ṃ - minimum

(ฉันไม่มั่นใจว่านี่เป็นวิธีที่เหมาะสมที่สุดในการลดจำนวนไบต์)

Perl, 98 97 96 79 ไบต์

($a,$b)=($a<=>$b)*($b<=>$c)<0?($c,shift,$d++):($b,$c)while$c=shift;say$d+1 if$a

ป้อนข้อมูลให้เป็นรายการของตัวเลขคั่นด้วยช่องว่างให้ที่รันไทม์เช่น

perl -M5.010 monotonic.pl 1 3 2 -1 6 9 10 2 1 -12
4

(4 คือเอาท์พุท)

อ่านได้:

($a,$b)=($a<=>$b)*($b<=>$c)<0
    ?($c,shift,$d++)
    :($b,$c)
  while$c=shift;
say$d+1
  if$a

'โอเปอเรเตอร์ยานอวกาศ' <=>ส่งคืน -1 ถ้า LHS <RHS, 0 ถ้า LHS = RHS, และ +1 ถ้า LHS> RHS เมื่อเปรียบเทียบองค์ประกอบตามลำดับสามรายการ$a,$b,$cเพื่อตรวจสอบว่าเป็นแบบโมโนโทนิกมีความจำเป็นเพียงเพื่อพิจารณาว่าไม่ใช่กรณีที่หนึ่งใน$a<=>$bนั้น$b<=>$cคือ 1 และอีกหนึ่งเป็น -1 ซึ่งเกิดขึ้นเมื่อผลิตภัณฑ์ของพวกเขาเป็น -1 เท่านั้น ถ้าอย่างใดอย่างหนึ่ง$a==$bหรือ$b==$cลำดับแล้วเป็นแบบโมโนโทนิคและผลิตภัณฑ์คือ 0 ถ้าหาก$a < $b < $cทั้งคู่ส่งผลให้ -1, และ -1 * -1 = 1 ถ้าหาก$a > $b > $cผลลัพธ์ทั้งคู่เป็น 1 และ 1 * 1 = 1 ไม่ว่าในกรณีใดลำดับนั้นเป็นแบบโมโนโทนและเราต้องการดำเนินการต่อ

หากผลิตภัณฑ์มีค่าน้อยกว่า 0 เรารู้ว่าลำดับนั้นไม่ได้เป็นแบบ monotonic และเราละทิ้งคุณค่าที่$a,$bเราถืออยู่ในปัจจุบันและเพิ่มตัวนับการเรียงลำดับของเรา มิฉะนั้นเราจะเลื่อนไปข้างหน้าหนึ่งหมายเลข

ไม่ส่งคืนสิ่งใดถ้าอินพุตว่างมิฉะนั้นจะส่งคืนค่าลำดับเลขคอร์ดที่ต่อเนื่องกันน้อยที่สุด

C # 6, 297 209 ไบต์

using System.Linq;int G(int[] a)=>a.Any()?a.SkipWhile((x,i)=>i<1||x>=a[i-1]).Count()<a.SkipWhile((x,i)=>i<1||x<=a[i-1]).Count()?G(a.Select(x=>-x).ToArray()):G(a.SkipWhile((x,i)=>i<1||x<=a[i-1]).ToArray())+1:0;

Ungolfed ด้วยคำอธิบาย

int G(int[] a)=>
    a.Any()
        ?a.SkipWhile((x,i)=>i<1||x>=a[i-1]).Count()<a.SkipWhile((x,i)=>i<1||x<=a[i-1]).Count()   // If a begins by decreasing (including whole a decreasing)...
            ?G(a.Select(x=>-x).ToArray())   // ... Then flip sign to make a begins by increasing
            :G(a.SkipWhile((x,i)=>i<1||x<=a[i-1]).ToArray())+1   // ... Else skip the increasing part, recursively find the remaining part number, then add 1
        :0;   // Return 0 if a is empty

JavaScript (ES6), 69 ไบต์

f=(d,c,b,...a)=>1/b?(d>c)*(b>c)+(d<c)*(b<c)?1+f(b,...a):f(d,b,...a):1

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

Clojure, 97 ไบต์

#((reduce(fn[[C i]s](let[S(conj C s)](if(or(apply <= S)(apply >= S))[S i][[s](inc i)])))[[]1]%)1)

reduceติดตามการเรียงลำดับปัจจุบันและคำนวณจำนวนครั้ง<=และ>=เงื่อนไขล้มเหลว สุดท้าย1ใช้องค์ประกอบที่ 2 จากผลลัพธ์ (เป็นตัวนับi)