... Nhưng này, không cần phải nghiêm khắc.

Đưa ra một mảng không trống của các số nguyên dương, xác định xem nó có phải là:

1. Đơn điệu giảm nghiêm ngặt . Điều này có nghĩa là mỗi mục hoàn toàn ít hơn mục trước.
2. Đơn điệu không tăng, nhưng không giảm nghiêm ngặt . Điều này có nghĩa là mỗi mục nhập nhỏ hơn hoặc bằng với mục trước và mảng không thuộc danh mục trên.
3. Không có cái nào ở trên .

Lưu ý các trường hợp góc sau:

• Một mảng với một số duy nhất là đơn điệu giảm nghiêm ngặt (bỏ trống như vậy).
• Một mảng có cùng số được lặp lại là không tăng đơn điệu, nhưng không giảm nghiêm ngặt.

Quy tắc

Bạn có thể cung cấp một chương trình hoặc một chức năng

Đầu vào có thể được lấy ở bất kỳ định dạng hợp lý nào: mảng, danh sách, chuỗi với các số được phân tách bằng dấu cách, ...

Bạn có thể chọn bất kỳ ba đầu ra nhất quán cho ba loại tương ứng. Ví dụ, kết quả đầu ra có thể là các số 0, 1, 2; hoặc chuỗi 1 1,, 1 0chuỗi rỗng.

Mã ngắn nhất tính bằng byte

Các trường hợp thử nghiệm

Monotone giảm nghiêm ngặt:

7 5 4 3 1
42 41
5

Đơn điệu không tăng, nhưng không giảm nghiêm ngặt:

27 19 19 10 3
6 4 2 2 2
9 9 9 9

Không có điều nào ở trên:

1 2 3 2
10 9 8 7 12
4 6 4 4 2

Thạch , 10 9 5 byte

-Method được tìm thấy bởi DrMcMoylex, hãy cho một số tín dụng!

;0IṠṀ

Dùng thử trực tuyến! hoặc chạy tất cả các bài kiểm tra

Trả về: -1= đơn điệu giảm nghiêm ngặt; 0= đơn điệu không tăng; 1= khác.

Làm sao?

;0IṠṀ - Main link: list
;0    - concatenate with a zero
  I   - incremental differences
   Ṡ  - sign
    Ṁ - maximum

Perl 6 , 17 byte

{[>](@_)+[>=] @_}

• Monotone giảm nghiêm ngặt: 2
• Đơn điệu không tăng: 1
• Khác: 0

Mở rộng:

{            # bare block lambda with implicit parameter list ｢@_｣
  [>]( @_ )  # reduce using ｢&infix:« > »｣
  +
  [>=] @_    # reduce using ｢&infix:« >= »｣
}

MATL , 10 , 7 byte

0hdX>ZS

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm!

Đã lưu 3 byte, nhờ @LuisMendo!

Đầu ra là

• Giảm nghiêm ngặt: -1

• Không tăng: 0

• Khác: 1

Giải trình:

0           % Push a '0'
 h          % Join the 0 to the end of the input array.
  d         % Get consecutive differences
   X>       % Get the largest difference
     ZS     % Get its sign
            % Implicitly print it

Toán học, 22 byte

Sign@*Max@*Differences

Hàm không tên lấy danh sách các số làm đầu vào. Trả về -1nếu danh sách đang giảm nghiêm ngặt, 0nếu nó không tăng nhưng không giảm nghiêm ngặt, và 1nếu không.

Thuật toán khá đơn giản: lấy sự khác biệt của các cặp liên tiếp, lấy cái lớn nhất và lấy dấu của cái lớn nhất đó.

(Tôi cảm thấy như phải tồn tại một số ngôn ngữ trong đó thuật toán này là 3 byte ....)

Về một mảng với một mục duy nhất: Differencesmang lại một danh sách trống; Maxcủa một danh sách trống cho -∞(!); và Sign[-∞]đánh giá -1(!!). Vì vậy, nó thực sự hoạt động trên trường hợp góc này. Đôi khi phải yêu Mathicala. (Thật vậy, hàm cũng chính xác gắn nhãn một danh sách trống là giảm nghiêm ngặt.)

Haskell, 40 38 37 byte

foldl min GT.(zipWith compare<*>tail)

Trả về

• GT cho Monotone giảm nghiêm ngặt
• EQ cho Monotone không tăng
• LT khác

compareso sánh hai số và trả về GT( EQ, LT) nếu số thứ nhất lớn hơn (bằng, nhỏ hơn) số thứ hai. zipWith compare<*>tailso sánh các yếu tố hàng xóm. foldl min GTlàm giảm danh sách các kết quả so sánh với chức năng tối thiểu bắt đầu với GT (lưu ý: LT< EQ< GT).

Chỉnh sửa: @xnor tìm thấy 2 3 byte. Cảm ơn!

Lisp thường gặp, 43 40 byte

(defun f(x)`(,(apply'> x),(apply'>= x)))

Cái này lấy đầu vào là một danh sách Lisp, và trả về (T T), (NIL T)và (NIL NIL)để phân biệt 3 loại. Ở đây nó đang chạy trên các trường hợp thử nghiệm được cung cấp:

CL-USER> (mapcar #'f '((7 5 4 3 1)
                       (42 41)
                       (5)
                       (27 19 19 10 3)
                       (6 4 2 2 2)
                       (9 9 9 9)
                       (1 2 3 2)
                       (10 9 8 7 12)
                       (4 6 4 4 2)))
((T T) (T T) (T T) (NIL T) (NIL T) (NIL T) (NIL NIL) (NIL NIL) (NIL NIL))

Python 2, 30 byte

lambda l:max(map(cmp,l[1:],l))

-1giảm nghiêm ngặt, giảm 0yếu, +1không giảm

Sử dụng cmpđể so sánh các yếu tố liên tiếp, và lấy tối đa. Điều này được thực hiện bằng cách loại bỏ phần tử đầu tiên của một bản sao của danh sách, sau đó ánh xạ cmp. Ví dụ, l=[2,2,1]cho

l[1:]  2   1   None
l      2   2   1
cmp    0  -1   -1

trong đó có max0 vì một đẳng thức tồn tại.

Danh sách ngắn hơn được tự động mở rộng với None, ít hơn tất cả các số và vì vậy vô hại. Phần tử ảo này cũng cách ly với việc lấy mindanh sách trống khi đầu vào có độ dài 1.

Brachylog , 7 byte

>,1|>=,

Hãy thử trực tuyến!

Bản in này 1giảm nghiêm ngặt, 0không tăng và mặt false.khác.

Giải trình

  (?)>              Input is a strictly decreasing list
      ,1(.)         Output = 1
|                 Or
  (?)>=             Input is a non-increasing list
       ,(.)         Output is a free variable; gets automatically labeled as an integer at
                      the end of execution. Since its domain is [-inf, +inf], the first
                      value it takes is 0
                  Or
                    No other possibility, thus this main predicate is false.

Các giải pháp 7 byte khác

>=!>,;1           Returns 0 for strictly decreasing, false. for non-increasing, 1 otherwise.

>=!>,1|           Returns 1 for strictly decreasing, false. for non-increasing, 0 otherwise.

R, 44 byte

d=diff(scan());c(any(!d)&all(d<=0),all(d<0))

Đọc đầu vào từ stdin và in các mục sau tùy thuộc vào đầu vào:

Đầu ra:

[1] FALSE TRUE: Đơn điệu không tăng

[1] TRUE FALSE: Monotone giảm nghiêm ngặt

[1] FALSE FALSE: Không có cái nào ở trên

JavaScript (ES6), 51 byte

a=>a.some((e,i)=>e>a[i-1])+a.some((e,i)=>e>=a[i-1])

Trả về 0 khi giảm nghiêm ngặt, 1 cho không tăng, 2 nếu không.

05AB1E ,5 8 byte

Sửa lỗi bởi Emigna, cảm ơn! Nó sử dụng phương pháp tương tự như của DrMcMoylex .

®¸ì¥Z0.S

®¸ì   Implicitly take input and appends -1 to it
¥     Yield deltas
 Z    Take the largest delta
  0.S Take its sign and implicitly display it

Hãy thử trực tuyến!

Đầu ra là:

-1 if strictly decreasing sequence
 0 if non-strictly decreasing sequence
 1 otherwise

Ruby, 37 byte

->l{[d=l==l.sort.reverse,d&&l|[]==l]}

Output: [true,true], [true,false]hoặc[false,false]

Toán học, 15 11 byte

##>0|##>=0&

Đây là một hàm matrixdic, lấy tất cả các số nguyên đầu vào làm các đối số riêng biệt.

• Giảm nghiêm ngặt: True | True
• Không tăng: False | True
• Cũng không: False | False

Lưu ý rằng |không phải là Ornhưng Alternatives, đó là một phần của cú pháp mô hình phù hợp, điều này giải thích tại sao những biểu hiện không được đánh giá để True, True, False, tương ứng.

Bản thân mã này chủ yếu là một ứng dụng của mẹo này . Ví dụ ##>0là Greater[##, 0]nhưng sau đó ##mở rộng ra tất cả các giá trị đầu vào để chúng ta có được một cái gì đó giống như Greater[5, 3, 2, 0], chính nó có nghĩa 5>3>2>0.

Vợt , 44 byte

(λ(x)(map(λ(p)(apply p`(,@x 0)))`(,>,>=)))

Yêu cầu:

(map (λ(x)(map(λ(p)(apply p`(,@x 0)))`(,>,>=)))
 '((7 5 4 3 1)
   (42 41)
   (5)
   (27 19 19 10 3)
   (6 4 2 2 2)
   (9 9 9 9)
   (1 2 3 2)
   (10 9 8 7 12)
   (4 6 4 4 2)))

Kết quả:

'((#t #t)
 (#t #t)
 (#t #t)
 (#f #t)
 (#f #t)
 (#f #t)
 (#f #f)
 (#f #f)
 (#f #f))

C ++ 14, 85 byte

int f(int x){return 3;}int f(int x,int y,auto...p){return((x>=y)+2*(x>y))&f(y,p...);}

Trả về 3 (0b11) khi giảm nghiêm ngặt, 1 (0b01) khi không tăng và 0 nếu không.

Ung dung:

int f(int x) {return 3;}
int f(int x,int y,auto...p){
  return ((x>=y)+2*(x>y)) & f(y,p...);
}

Tôi nghĩ rằng đây là một vấn đề hoàn hảo cho các biểu thức gấp của C ++ 17:

int g(auto...x){return(x>...)+(x>=...);}

Thật không may, nó không chuỗi các toán tử quan hệ nhưng không

((x1>x2)>x3)>x4)...

mà không phải là muốn

Python 2, 61 74 byte

+13 byte cho đầu vào số đơn

x=map(str,input())
print[2,eval(">".join(x))+eval(">=".join(x))][len(x)>1]

Yêu cầu đầu vào trong danh sách khung như thế nào [3,2,1]. Trả về 2 khi giảm nghiêm ngặt, 1 cho không tăng và 0 nếu không.

Giải pháp cũ:

print eval(">".join(x))+eval(">=".join(x))

Python 3, 81 52 byte (Nhờ FryAmTheEggMan )

e=sorted
lambda a:(a==e(a)[::-1])+(e({*a})[::-1]==a)

Hãy thử trực tuyến!

Befunge, 50 byte

&: >~1+#^_v>:0`|
1\:^  @.$$<-@.2_
-: ^    >& ^   >

Hãy thử trực tuyến!

Chấp nhận đầu vào là một chuỗi int được phân tách bằng dấu cách và trả về 0 nếu giảm nghiêm ngặt, 1 nếu giảm không nghiêm ngặt, 2 nếu không.

Vì việc đọc befunge là không thể nếu bạn không biết ngôn ngữ, đây là thuật toán trong mã giả:

push(input())

while( getchar()!=EOF ){
  push(input())
  subtract()
  duplicate()
  if(pop()>0){
    subtract() //we are doing a-(a-b), so b is now on top
    duplicate()
  }
  else{
    if(pop()==0){
      push(1) //the sequence is not strictly decreasing
      swap()
      duplicate()
    }
    else{
      push(2) //the sequence has just increased
      output(pop)
      return
    }
  }
}
pop()
pop()
output(pop())

* trong bộ nhớ befunge là một ngăn xếp bắt đầu với số lượng 0 vô hạn trên nó. pop (), push (x), input () và output (x) là tự giải thích, các giả hành khác tôi đã sử dụng làm việc như thế này:

function duplicate(){
  a=pop()
  push(a)
  push(a)
}

function subtract(){
  a=pop()
  b=pop()
  push(b-a)
}

function swap(){
  a=pop()
  b=pop()
  push(a)
  push(b)
}

Funge!

Phiên bản trước, chỉ có 41 byte nhưng không hợp lệ vì nó yêu cầu 0 để chấm dứt chuỗi đầu vào (hoặc sử dụng trình thông dịch như thế này )

&:  >&:|>:0`|
1\v@.$_<-@.2_
- >:v  >^   >

Hãy thử trực tuyến!

J, 14 byte

Động từ monadic lấy danh sách bên phải, trở lại 1để giảm nghiêm ngặt, 0cho giảm yếu, và _1nếu không.

*@([:<./2-/\])

Có dấu hiệu *của sự <./khác biệt tối thiểu liên tiếp 2-/\của danh sách. J không hoán đổi thứ tự của sự khác biệt khi lấy chúng, ví dụ như chuỗi đang giảm nghiêm ngặt nếu tất cả đều dương. Đáng chú ý là<./ trả về vô cực dương trên danh sách phần tử không.

Đang sử dụng tại REPL:

   *@([:<./2-/\]) 3
1
   *@([:<./2-/\]) 3 2
1
   *@([:<./2-/\]) 3 2 2
0
   *@([:<./2-/\]) 3 2 2 3
_1

C, 68 67 byte

Một hàm f, được truyền vào một mảng ints ( l) đứng trước độ dài của nó ( n, cũng là một int). Trả về 3 nếu đơn điệu giảm nghiêm ngặt, 1 nếu đơn điệu không tăng, nhưng không giảm nghiêm ngặt, 0 nếu không.

f(int n,int*l){return n<2?3:((l[0]>l[1])*2|l[0]>=l[1])&f(n-1,l+1);}

Un-golfed hơi cho dễ đọc:

int f_semiungolfed(int n, int* l) {
    return (n < 2) ? 3 : ((l[0] > l[1]) * 2 | l[0] >= l[1]) & f(n - 1, l + 1);
}

Sắp xếp lại và nhận xét để hiển thị logic:

int f_ungolfed(int n, int* l) {
    int case1 = 0, case2 = 0, recursion = 0;
    if (n < 2) { // Analogous to the ternary conditional I used - n < 2 means we have a single-element/empty list
        return 3; // Handles the vacuous-truth scenario for single lists
    } else {
        case1 = l[0] > l[1]; // The first case - are the two numbers in the list strictly decreasing? (case1 is 1 if so)
        case2 = l[0] >= l[1]; // The second case - are the two numbers strictly non-increasing (case2 is 1 if so)
        recursion = f_ungolfed(n - 1, l + 1); // Recursively call ourselves on the "rest" of the list (that is, everything other than the first element). Consider that comparison is transitive, and that we already have a vacuous-truth scenario covered.
        case1 *= 2; // Shift case1's value over to the left by one bit by multiplying by 2. If case1 was 1 (0b01), it's now 2 (0b10) - otherwise it's still 0 (0b00)
        return (case1 | case2) & recursion; 
        // The bitwise OR operator (|) will combine any 1-bits from case1's value (either 0b10 or 0b00) or case2's value (either 0b01 or 0b00) into either 3, 2, 1, or 0 (0b11, 0b10, 0b01, or 0b00 respectively).
        // The bitwise AND operator (&) will combine only matching 1-bits from (case1|case2) and the return value of the recursive call - if recursion = 0b11 and case1|case2 = 0b01, then the return value will be 0b01.
    }
}

Các trường hợp thử nghiệm (lịch sự IDEOne ):

{7, 5, 4, 3, 1}: 3
{42, 41}: 3
{5}: 3
{27, 19, 19, 10, 3}: 1
{6, 4, 2, 2, 2}: 1
{9, 9, 9, 9}: 1
{1, 2, 3, 2}: 0
{10, 9, 8, 7, 12}: 0
{4, 6, 4, 4, 2}: 0

Võng mạc , 41 byte

\d+
$*
A`\b(1+) 1\1
S`\b$
\b(1+) \1\b.*|$

Hãy thử trực tuyến! (Dòng đầu tiên cho phép bộ kiểm tra được phân tách bằng nguồn cấp.)

• Giảm nghiêm ngặt: 2
• Không tăng: 3
• Cũng không: 1

Giải trình

\d+
$*

Chuyển đổi đầu vào unary.

A`\b(1+) 1\1

Regex ở đây khớp với một cặp số liên tiếp tăng dần. Nếu đây là trường hợp, đầu vào rõ ràng không thể không tăng. Các Abiểu thị nó như là một "anti-grep" giai đoạn có nghĩa là dòng đầu vào bị loại bỏ và thay thế bằng chuỗi rỗng nếu các trận đấu regex.

S`\b$

Đây là giai đoạn phân tách được sử dụng để nối thêm nguồn cấp dữ liệu vào đầu vào chỉ khi đầu vào không bị loại bỏ. Vì vậy, cho đến nay chúng tôi đã có hai kết quả có thể xảy ra: đầu vào không tăng sẽ nhận được một nguồn cấp dữ liệu ở cuối và các kết quả khác vẫn trống.

\b(1+) \1\b.*|$

Cuối cùng, chúng tôi đếm số lượng trận đấu của regex này. Regex khớp với các số giống hệt nhau (và sau đó mọi thứ ở cuối chuỗi để tránh nhiều kết quả khớp loại này cho các đầu vào như 1 1 1 1) hoặc "kết thúc đầu vào". Chúng ta hãy đi qua ba loại đầu vào:

• Giảm nghiêm ngặt: phần đầu tiên của regex không thể khớp vì tất cả các giá trị là duy nhất, nhưng $khớp. Bây giờ $không chính xác "kết thúc của chuỗi". Nó cũng có thể khớp trước một nguồn cấp dữ liệu. Vì vậy, chúng tôi thực sự sẽ nhận được hai trận đấu từ nó, một trận đấu ở cuối đầu vào và một trận đấu sau đường dẫn chúng tôi đã chèn.
• Không tăng: bây giờ phần đầu tiên của regex cũng cung cấp một trận đấu và chúng tôi kết thúc với ba trận đấu.
• Không phải: hãy nhớ rằng chúng tôi đã cẩn thận biến đầu vào thành một chuỗi trống, vì vậy bây giờ $chỉ khớp một lần.

Tiên đề, 114 byte

m(c:List(INT)):INT==(i:=r:=1;repeat(~index?(i+1,c)=>break;c.i<c.(i+1)=>return 0;if c.i=c.(i+1)then r:=2;i:=i+1);r)

Bị đánh cắp

-- if [a,b,..n] decrescente ritorna 1
--          non crescente   ritorna 2
--          altrimenti      ritorna 0  
m(c:List(INT)):INT==
   i:=r:=1
   repeat
      ~index?(i+1,c)=>break 
      c.i<c.(i+1)   =>return 0
      if c.i=c.(i+1) then r:=2
      i:=i+1
   r

Các kết quả

(x) -> m([3,1])=1, m([1,1])=2, m([])=1, m([1])=1, m([1,3])=0
   (x)  [1= 1,2= 2,1= 1,1= 1,0= 0] 

APL, 16 byte

(a≡a[⍒a])×1+a≡∪a

Lưu ý: nhập một mảng phần tử, ví dụ a←1⍴3:a←4 3 2 1

Phiên dịch đầu ra:

2 Monotone strictly decreasing
1 Monotone non-increasing, but not strictly decreasing
0 None of the above

Ý tưởng: kiểm tra tính đơn điệu bằng cách so sánh mảng gốc với mảng đã sắp xếp, kiểm tra không tăng bằng cách so sánh với mảng với các bản sao bị loại bỏ.

(Và tôi nghĩ nó có thể được cải thiện ...)

Haskell, 36 byte

f l=[scanl1(min.(+x))l==l|x<-[0,-1]]

(+x)là bởi vì haskell diễn giải sai (-x)như một giá trị thay vì một phần. Tôi tự hỏi nếu toàn bộ biểu thức có thể được tạo ra lợi nhuận miễn phí.

LabVIEW, 12 nút, 18 dây ==> 48 byte theo quy ước

Không có chức năng ẩn trong các khung trường hợp khác, chỉ có một dây đơn.

Ceylon, 86 byte

Object m(Integer+l)=>let(c=l.paired.map(([x,y])=>x<=>y))[if(!smaller in c)equal in c];

Hàm lấy đầu vào làm tham số của nó và trả về một tuple bằng 0 hoặc một booleans - [false]đối với Monotone giảm nghiêm ngặt , [true]đối với Monotone không tăng, nhưng không giảm nghiêm ngặt và []đối với Không có điều nào ở trên .

Nó có thể được sử dụng như thế này:

shared void run() {
    print("Monotone strictly decreasing:");
    print(m(7, 5, 4, 3, 1));
    print(m(42, 41));
    print(m(5));

    print("Monotone non-increasing, but not strictly decreasing:");
    print(m(27, 19, 19, 10, 3));
    print(m(6, 4, 2, 2, 2));
    print(m(9, 9, 9, 9));

    print("None of the above:");
    print(m(1, 2, 3, 2));
    print(m(10, 9, 8, 7, 12));
    print(m(4, 6, 4, 4, 2));
}

Đầu ra:

Monotone strictly decreasing:
[false]
[false]
[false]
Monotone non-increasing, but not strictly decreasing:
[true]
[true]
[true]
None of the above:
[]
[]
[]

Một phiên bản chưa được chỉnh sửa và nhận xét:

// Let's decrease the monotony! 
//
// Question:  http://codegolf.stackexchange.com/q/101036/2338
// My Answer: http://codegolf.stackexchange.com/a/101309/2338


// Define a function which takes a non-empty list `l` of Integers)
// (which arrive as a tuple) and returns an Object (actually
// a `[Boolean*]`, but that is longer.) 
Object m(Integer+ l) =>
        // the let-clause declares a variable c, which is created by taking
        // pairs of consecutive elements in the input, and then comparing
        // them. This results in lists like those (for the example inputs):
        // { larger, larger, larger, larger }
        // { larger }
        // {}
        // { larger, equal, larger, larger }
        // { larger, larger, equal, equal }
        // { equal, equal, equal }
        // { smaller, smaller, larger }
        // { larger, larger, larger, smaller }
        // { smaller, larger, equal, larger }  
        let (c = l.paired.map( ([x,y]) => x<=>y) )
            // now we analyze c ...
            // If it contains `smaller`, we have an non-decreasing sequence.
            // We return `[]` in this case (an empty tuple).
            // Otherwise we check whether `equal` is in the list, returning
            // `[true]` (a non-strictly decreasing sequence) if so,
            // and `[false]` (a strictly decreasing sequence) otherwise.
            [if(!smaller in c) equal in c];

Clojure, 34 byte

#(if(apply > %)1(if(apply >= %)2))

Rất thẳng, trả lại 1 nếu giảm nghiêm ngặt, 2nếu không tăng vànil ngược lại.

Cũng đã cố gắng tránh applyvới macro ~@nhưng nó chỉ dài hơn ở 43 ký tự (kết quả này là [1 2 nil]):

(defmacro f[& i]`(if(> ~@i)1(if(>= ~@i)2)))

[(f 7 5 4 3 1)
 (f 27 19 19 10 3)
 (f 1 2 3 2)]

Pip , 8 byte

O$>g$>=g

Chương trình đầy đủ. Lấy danh sách đầu vào làm đối số dòng lệnh. Đầu ra 11giảm nghiêm ngặt, 01không tăng,00 cho không.

Hãy thử trực tuyến!

Giải trình

Cách tiếp cận này hoạt động vì các toán tử so sánh của Pip, như của Python, kết hợp với nhau: 4>3>2là đúng, thay vì là (4>3)>2(sai) như trong C. Và hành vi tương tự cũng xảy ra khi các toán tử so sánh được sửa đổi với $toán tử meta gấp.

          g is list of command-line args (implicit)
 $>g      Fold g on >
O         Output without newline
    $>=g  Fold g on >=
          Print (implicit)

Japt , 9 8 7 byte

Đầu ra -1cho "đơn điệu giảm nghiêm ngặt", 0cho "không đơn điệu" và 1nếu không.

än rw g

Thử nó

Lưu 1 byte cảm ơn Oliver .

R , 34 byte

function(x)max(sign(diff(c(x,0))))

Hãy thử trực tuyến!

Cổng câu trả lời MATL của DJ .

R , 43 byte

function(x)all(diff(x)<0)+all(x==cummin(x))

Hãy thử trực tuyến!

Trả về 2cho giảm nghiêm ngặt, 1cho không tăng, và 0nếu không.

all(x==cummin(x))là TRUE(chuyển đổi thành 1khi được sử dụng trong số học) khi và chỉ khi fkhông tăng, bao gồm cả trường hợp nghiêm ngặt.

all(diff(x)<0)là TRUEchỉ khi fđang giảm nghiêm ngặt.