Meydan açıklaması

Bir monotonik alt dizi numaralarının dizisidir [a1, a2, ..., an]şekilde

a1 <= a2 <= ... <= anveya a1 >= a2 >= ... >= an. [1, 3, 3, 7, 9, 13, 13, 100]monotonik (azalmayan) [9, 4, 4, 3, 0, -10, -12]bir art arda olduğu gibi (bu artmakta değildir), fakat [1, 3, 6, 9, 8]değildir. Bir tamsayı listesi verildiğinde (herhangi bir makul formatta), bu en küçük sayıların çıktısını alın, Nöyle ki bu tamsayıların Ndizisi monoton dizilere bölünebilir .

Örnekler

[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 bayt

~c:{<=|>=}al

Çevrimiçi deneyin!

Bu false.boş liste için döner [].

açıklama

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

Bu en küçüğü döndürür, çünkü ~cen az sayıda alt listeden en büyüğe seçim noktaları oluşturur.

Perl, 65 bayt

-nBayrak için 62 bayt kod + 3 bayt .

monot_seq.pl:

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

Girdiyi son satır olmadan, sayıları boşluklarla ayırarak verin:

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

-Gabriel Benamy sayesinde -5 bayt.

Mathematica, 111 bayt

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]

fBoş bir sayı listesi alarak adlandırılmış fonksiyon Önden arkaya doğru çalışır, ilk öğeyi tekrar tekrar atar ve kaç ekin gerekli olduğunu takip eder. Daha ayrıntılı

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

Jöle , 19 bayt

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

TryItOnline! veya tüm testleri çalıştırın (boş liste sonuçlanır.1 )

Nasıl?

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

(Bunun bayt sayısını en aza indirmek için en uygun yöntem olduğuna ikna olmadım)

Perl, 98 97 96 79 bayt

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

Giriş, çalışma zamanında sağlanan, boşluklarla ayrılmış, örneğin

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

(4, çıktıdır)

Okunabilir:

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

'Uzay gemisi operatörü' <=>LHS <RHS ise -1, LHS = RHS ise 0 ve LHS> RHS ise +1 döndürür. Üç sıralı unsurları karşılaştırılırken $a,$b,$ckonum monoton onlar olmadığını belirlemek için, bu tam olarak bir o durumda olmadığını belirlemek için yalnızca gerekli $a<=>$b, $b<=>$c1 ve diğeri ise -1 - onların ürünüdür yalnızca olur hangi -1. Ya $a==$bda $b==$c, öyleyse, sıra monoton ve ürün 0'dır. Öyleyse $a < $b < $c, her ikisi de -1 ve -1 * -1 = 1 olur.$a > $b > $c sonuçlanır. , ikisi de 1 ve 1 * 1 = 1 ile sonuçlanır. Her iki durumda da, sıra monotoniktir ve devam etmek istiyoruz.

Ürün 0'dan küçükse, dizinin monotonik olmadığını biliyoruz ve $a,$bşu anda tuttuğumuz değerleri atarız ve alt sayaç sayacımızı artırırız. Aksi takdirde, bir sayı ileri gideriz.

Girdi boşsa hiçbir şey döndürmez, aksi takdirde en küçük bitişik monotonik alt diziyi döndürür

C # 6, 297 209 bayt

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;

Açıklamaları ile 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 bayt

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

Girdiyi çoklu parametre olarak alır. Monoton olup olmadıklarını görmek için ilk üç öğeyi tekrar tekrar karşılaştırarak çalışır, öyleyse orta öğeyi işe yaramaz olduğu için kaldırır, eğer değilse ilk iki öğeyi kaldırır ve yeni bir dizi başlatır.

Clojure, 97 bayt

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

reduceMevcut sırayı takip eder ve kaç kez <=ve >=koşulun başarısız olduğunu hesaplar . Son 1sonuçtan 2. eleman alır (sayaç i).