Описание задачи

Монотонная подпоследовательность представляет собой последовательность чисел , [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

Брахилог , 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 байтов благодаря @ Габриэлю Бенами.

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

(Я не уверен, что это самый подходящий метод, чтобы минимизировать количество байтов, хотя)

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, мы знаем, что последовательность не является монотонной, и мы отбрасываем значения, которые $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

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