도전 설명

단조는 시퀀스 번호의 서열이다 [a1, a2, ..., an]되도록

a1 <= a2 <= ... <= an또는 a1 >= a2 >= ... >= an. [1, 3, 3, 7, 9, 13, 13, 100]는 단조로운 (비 감소) 서브 시퀀스이며 [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가장 작은 수의 서브리스트에서 가장 큰 수까지 선택 지점을 생성 하므로 가장 작은 것을 반환합니다 .

펄, 65 바이트

62 바이트의 코드 + -n플래그의 경우 3 바이트

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

@Gabriel Benamy 덕분에 -5 바이트.

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비어 있지 않은 숫자 목록 (정수 또는 실수)을 취하는 명명 된 함수 . 앞뒤로 작동하여 첫 번째 요소를 반복적으로 삭제하고 얼마나 많은 하위 시퀀스가 ​​필요한지 추적합니다. 더 장황한 :

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

(이것이 바이트 수를 최소화하는 가장 적합한 방법이라고 확신하지는 않습니다)

펄, 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

'우주선 연산자' <=>는 LHS <RHS 인 경우 -1을, LHS = RHS 인 경우 0을, LHS> RHS 인 경우 +1을 반환합니다. 세 개의 연속적인 요소를 비교할 때 $a,$b,$c있는 거 단조가 있는지 확인하려면, 그것은 정확히 하나가된다는 사실을 그렇지 않다 것으로 판단하기 만의 $a<=>$b, $b<=>$c1이고, 다른 하나는 -1 - 그들의 제품이있는 경우에만 발생한다 -1. 어느 경우 $a==$b나 $b==$c, 그 서열은 단조, 생성물은 0 인 경우 $a < $b < $c-1에서 다음 두 결과, -1 -1 * = 1 인 경우 $a > $b > $c1, 그들은 모두 결과, 1 * 1 = 1이다. 두 경우 모두 시퀀스는 단조롭고 계속 진행하고자합니다.

제품이 0보다 작 으면 시퀀스가 ​​단조롭지 않다는 $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;

설명이 담겨 있지 않은

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

자바 스크립트 (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

입력을 여러 매개 변수로 사용합니다. 처음 세 요소를 재귀 적으로 비교하여 단조로운 지 여부를 확인합니다. 그렇지 않으면 중간 요소가 쓸모 없으므로 제거하고 처음 두 요소를 제거하고 새로운 시퀀스를 시작합니다.

클로저, 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은 결과에서 두 번째 요소를 가져옵니다 (카운터 i임).