Descrição do Desafio

Uma subsequência monotônica é uma sequência de números [a1, a2, ..., an]tal que

a1 <= a2 <= ... <= anou a1 >= a2 >= ... >= an. [1, 3, 3, 7, 9, 13, 13, 100]é uma subsequência monotônica (não decrescente), bem como [9, 4, 4, 3, 0, -10, -12](esta não é crescente), mas [1, 3, 6, 9, 8]não é. Dada uma lista de números inteiros (em qualquer formato razoável), imprima o menor número, de Nmodo que a sequência desses números inteiros possa ser dividida em Nsequências monotônicas.

Exemplos

[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

Braquilog , 12 bytes

~c:{<=|>=}al

Experimente online!

Isso retorna false.para a lista vazia [].

Explicação

(?)~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

Isso retornará o menor porque ~cgerará pontos de escolha do menor número de sublistas para o maior.

Perl, 65 bytes

62 bytes de código + 3 bytes para -nsinalizador.

monot_seq.pl:

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

Forneça a entrada sem nova linha final, com os números separados por espaços:

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

-5 bytes graças a @Gabriel Benamy.

Mathematica, 111 bytes

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]

Função nomeada fque obtém uma lista não vazia de números (números inteiros ou mesmo reais). Funciona de frente para trás, descartando o primeiro elemento repetidamente e acompanhando quantas subseqüências são necessárias. Mais detalhado:

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

Geléia , 19 bytes

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

TryItOnline! ou executar todos os testes (a lista vazia resulta em1)

Quão?

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

No entanto, não estou convencido de que este seja o método mais adequado para minimizar a contagem de bytes.

Perl, 98 97 96 79 bytes

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

A entrada é fornecida como uma lista de números, separados por espaços, fornecidos em tempo de execução, por exemplo

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

(o 4 é a saída)

Legível:

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

O 'operador de nave espacial' <=>retorna -1 se LHS <RHS, 0 se LHS = RHS e +1 se LHS> RHS. Ao comparar três elementos sequenciais $a,$b,$cpara determinar se são monotônicos, é necessário apenas determinar que esse não é exatamente um de $a<=>$b, $b<=>$cé 1 e o outro é -1 - o que só acontece quando o produto é -1. Se um $a==$bou $b==$c, então, a sequência é monotônica e o produto é 0. Se $a < $b < $c, então ambos resultam em -1 e -1 * -1 = 1. Se $a > $b > $c, então ambos resultam em 1 e 1 * 1 = 1. Nos dois casos, a sequência é monotônica e queremos continuar.

Se o produto for menor que 0, sabemos que a sequência não é monotônica, descartamos os valores $a,$bque estamos mantendo no momento e aumentamos nosso contador de subsequências. Caso contrário, avançamos um número.

Não retorna nada se a entrada estiver vazia; caso contrário, retorna o menor número de subsequências monotônicas contíguas

C # 6, 297 209 bytes

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 com explicações

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 bytes

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

Recebe entrada como vários parâmetros. Funciona comparando recursivamente os três primeiros elementos para verificar se são monotônicos; nesse caso, remove o elemento do meio, pois é inútil; caso contrário, remove os dois primeiros elementos e inicia uma nova sequência.

Clojure, 97 bytes

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

reducecontrola a subsequência atual e calcula quantas vezes <=e as >=condições falham. Last 1pega o segundo elemento do resultado (sendo o contador i).