... aber hey, keine Notwendigkeit, streng zu sein.

Bestimmen Sie bei einem nicht leeren Array von streng positiven Ganzzahlen, ob es sich um Folgendes handelt:

1. Monoton streng abnehmend . Dies bedeutet, dass jeder Eintrag kleiner ist als der vorherige.
2. Monoton nicht steigend, aber nicht streng fallend . Dies bedeutet, dass jeder Eintrag kleiner oder gleich dem vorhergehenden ist und das Array nicht in die obige Kategorie fällt.
3. Nichts von alledem .

Beachten Sie die folgenden Eckfälle:

• Ein Array mit einer einzelnen Zahl ist monoton und nimmt streng ab (vakuus).
• Ein Array mit der gleichen Anzahl von Wiederholungen ist monoton, nicht ansteigend, aber nicht streng absteigend.

Regeln

Sie können ein Programm oder eine Funktion bereitstellen

Die Eingabe kann in jedem vernünftigen Format erfolgen: Array, Liste, Zeichenfolge mit durch Leerzeichen getrennten Zahlen, ...

Sie können jeweils drei konsistente Ausgaben für die drei Kategorien auswählen. Zum Beispiel können die Ausgänge Zahlen sein 0, 1, 2; oder Strings 1 1, 1 0, leeren String.

Kürzester Code in Bytes gewinnt

Testfälle

Monoton streng abnehmend:

7 5 4 3 1
42 41
5

Monoton nicht steigend, aber nicht streng fallend:

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

Nichts des oben Genannten:

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

Jelly , 10 9 5 Bytes

-Methode von DrMcMoylex gefunden, geben Sie etwas Anerkennung!

;0IṠṀ

TryItOnline! oder führen Sie alle Tests durch

Rückgabe: -1= monoton streng abnehmend; 0= monoton nicht ansteigend; 1= andere.

Wie?

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

Perl 6 , 17 Bytes

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

• Monoton streng abnehmend: 2
• Monoton, nicht ansteigend: 1
• Andere: 0

Erweitert:

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

MATL , 10 , 7 Bytes

0hdX>ZS

Probieren Sie es online! oder überprüfe alle Testfälle!

3 Bytes gespart, dank @LuisMendo!

Die Ausgänge sind

• Streng abnehmend: -1

• Nicht steigend: 0

• Sonstiges: 1

Erläuterung:

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

Mathematica, 22 Bytes

Sign@*Max@*Differences

Unbenannte Funktion, die eine Liste von Zahlen als Eingabe verwendet. Gibt zurück, -1wenn die Liste stark abnimmt, 0nicht zunimmt, aber nicht stark abnimmt und 1keine.

Ziemlich einfacher Algorithmus: Nimm die Differenzen von aufeinanderfolgenden Paaren, nimm das größte und nimm das Vorzeichen des größten.

(Ich glaube, es muss eine Sprache geben, in der dieser Algorithmus 3 Bytes lang ist ....)

In Bezug auf ein Array mit einem einzelnen Eintrag: Differencesergibt eine leere Liste; Maxvon einer leeren Liste gibt -∞(!); und Sign[-∞]wertet aus -1(!!). Also funktioniert es tatsächlich bei diesem Eckfall. Muss Mathematica manchmal lieben. (Tatsächlich kennzeichnet die Funktion eine leere Liste auch korrekt als streng absteigend.)

Haskell, 40 38 37 Bytes

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

Kehrt zurück

• GT für Monotone streng abnehmend
• EQ für monoton nicht ansteigend
• LT sonst

comparevergleicht zwei Zahlen und gibt GT( EQ, LT) zurück , wenn die erste Zahl größer als (gleich, kleiner als) die zweite Zahl ist. zipWith compare<*>tailvergleicht Nachbarelemente. foldl min GTreduziert die Liste der Vergleichsergebnisse mit der min - Funktion mit GT starten (Anmerkung: LT< EQ< GT).

Edit: @xnor 2 3 Bytes gefunden. Vielen Dank!

Common Lisp, 43 40 Bytes

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

Dies nimmt die Eingabe als Lisp - Liste und kehrt (T T), (NIL T)und (NIL NIL)die drei Kategorien zu unterscheiden. Hier läuft es auf den mitgelieferten Testfällen:

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 Bytes

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

-1für streng abnehmend, 0für schwach abnehmend, +1für nicht abnehmend

Verwenden Sie cmp, um aufeinanderfolgende Elemente zu vergleichen, und nimmt das Maximum an. Dies erfolgt durch Entfernen des ersten Elements einer Kopie der Liste und anschließendes Zuordnen cmp. Zum Beispiel l=[2,2,1]gibt

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

die max0 hat, weil eine Gleichheit besteht.

Die kürzere Liste wird automatisch mit erweitert None, was weniger ist als alle Nummern und somit harmlos. Dieses Phantomelement schützt auch vor dem Aufnehmen mineiner leeren Liste, wenn der Eingang die Länge 1 hat.

Brachylog , 7 Bytes

>,1|>=,

Probieren Sie es online!

Dies druckt 1zum strikten Verringern, 0zum Nichterhöhen und auf false.andere Weise.

Erläuterung

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

Andere 7-Byte-Lösungen

>=!>,;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 Bytes

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

Liest die Eingabe von stdin und gibt abhängig von der Eingabe Folgendes aus:

Ausgabe:

[1] FALSE TRUE: Monoton, nicht ansteigend

[1] TRUE FALSE: Monoton streng abnehmend

[1] FALSE FALSE: Nichts des oben Genannten

JavaScript (ES6), 51 Byte

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

Liefert 0 für striktes Verringern, 1 für nicht steigendes, 2 andernfalls.

05AB1E ,5 8 Bytes

Fehler behoben von Emigna, danke! Es verwendet die gleiche Methode wie 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

Probieren Sie es online!

Ausgabe ist:

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

Ruby, 37 Bytes

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

Ausgang: [true,true], [true,false]oder[false,false]

Mathematica, 15 11 Bytes

##>0|##>=0&

Dies ist eine variable Funktion, bei der alle Eingabe-Ganzzahlen als separate Argumente verwendet werden.

• Streng abnehmend: True | True
• Nicht steigend: False | True
• Weder: False | False

Beachten Sie, dass dies |nicht Orbut Alternativesist. Dies ist Teil der Pattern-Matching-Syntax. Dies erklärt, warum diese Ausdrücke nicht ausgewertet Truewerden True.False , respectively.

Der Code selbst ist meist eine Anwendung dieses Tipps . Zum Beispiel ##>0wird Greater[##, 0]dann aber ##auf alle Eingabewerte erweitert, so dass wir so etwas wie bekommen Greater[5, 3, 2, 0], was selbst bedeutet 5>3>2>0.

Schläger , 44 Bytes

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

Aufgerufen:

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

Ergebnis:

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

C ++ 14, 85 Bytes

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

Gibt 3 (0b11) für das strikte Verringern, 1 (0b01) für das Nichterhöhen und 0 ansonsten zurück.

Ungolfed:

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

Ich dachte, dies sei ein perfektes Problem für die Folding-Ausdrücke von C ++ 17:

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

Leider verkettet es die Vergleichsoperatoren nicht, tut es aber

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

was nicht gewollt war.

Python 2, 61 74 Bytes

+13 Bytes für die Eingabe einer einzelnen Zahl

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

Benötigt Eingabe in Klammerlistenform wie [3,2,1]. Gibt 2 für das strikte Verringern, 1 für das Nichterhöhen und 0 ansonsten zurück.

Alte Lösung:

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

Python 3, 81 52 Bytes (Dank an FryAmTheEggMan )

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

Probieren Sie es online!

Befunge, 50 Bytes

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

Probieren Sie es online!

Akzeptiert Eingaben als eine durch Leerzeichen getrennte Folge von int und gibt 0 zurück, wenn sie streng abnehmen, 1, wenn sie nicht streng abnehmen, 2, sonst.

Da das Lesen von Befunge unmöglich ist, wenn Sie die Sprache nicht kennen, ist dies der Algorithmus im Pseudocode:

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

* im befunge Speicher ist ein Stapel, der mit einer unendlichen Menge von 0 beginnt. pop (), push (x), input () und output (x) sind selbsterklärend, die anderen verwendeten Pseudofunktionen funktionieren so:

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!

Vorherige Version, nur 41 Byte, aber ungültig, da zum Beenden der Eingabesequenz eine 0 erforderlich ist (oder ein Interpreter wie dieser verwendet wird )

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

Probieren Sie es online!

J, 14 Bytes

Monadisches Verb, das die Liste auf der rechten Seite aufnimmt und zurückkehrt, 1um streng zu verringern, 0schwach zu verringern und auf _1andere Weise.

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

Nimmt das Vorzeichen *des Minimums <./aufeinanderfolgender Unterschiede 2-/\der Liste. J vertauscht die Reihenfolge der Differenzen nicht, wenn sie genommen werden, so dass z. B. die Reihenfolge streng abnimmt, wenn diese alle positiv sind. Gibt insbesondere bei <./Listen mit Nullelementen eine positive Unendlichkeit zurück.

Im Einsatz bei der REPL:

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

C 68 67 Bytes

Eine Funktion f, der ein Array von ints ( l) übergeben wird, dem die Länge ( nauch ein int) vorausgeht . Gibt 3 zurück, wenn die Monotonie stark abnimmt, 1, wenn die Monotonie nicht zunimmt, aber nicht stark abnimmt, andernfalls 0.

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

Aus Gründen der Lesbarkeit leicht ungespielt:

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);
}

Neu angeordnet und kommentiert, um die Logik zu zeigen:

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

Testfälle (mit freundlicher Genehmigung von 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

Retina , 41 Bytes

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

Probieren Sie es online! (Die erste Zeile aktiviert eine durch Zeilenvorschub getrennte Testsuite.)

• Streng abnehmend: 2
• Nicht steigend: 3
• Weder: 1

Erläuterung

\d+
$*

Konvertiert die Eingabe unär.

A`\b(1+) 1\1

Der reguläre Ausdruck entspricht hier einem zunehmenden Paar aufeinanderfolgender Zahlen. Wenn dies der Fall ist, kann der Eingang eindeutig nicht nicht ansteigend sein. Die Abezeichnet er als ein „anti-grep“ -Stufe was bedeutet , dass die Eingangsleitung verworfen wird und mit dem leeren String , wenn die Regex Einstimmungen ersetzt.

S`\b$

Dies ist eine geteilte Stufe, mit der ein Zeilenvorschub nur dann an den Eingang angehängt wird, wenn der Eingang nicht verworfen wurde. Wir haben also zwei mögliche Ergebnisse: Nicht ansteigende Eingaben erhalten am Ende einen Zeilenvorschub und andere sind noch leer.

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

Schließlich zählen wir die Anzahl der Übereinstimmungen dieses regulären Ausdrucks. Der reguläre Ausdruck stimmt entweder mit identischen Zahlen überein (und dann alles bis zum Ende der Zeichenfolge, um mehrfache Übereinstimmungen dieser Art für Eingaben wie zu vermeiden 1 1 1 1) oder mit dem "Ende der Eingabe". Lassen Sie uns die drei Arten von Eingaben durchgehen:

• Streng abnehmend: Der erste Teil des regulären Ausdrucks kann nicht übereinstimmen, da alle Werte eindeutig sind $ Übereinstimmungen. Jetzt $ist nicht genau "das Ende der Zeichenfolge". Es kann auch vor einem nachfolgenden Zeilenvorschub passen. Wir erhalten also tatsächlich zwei Übereinstimmungen, eine am Ende der Eingabe und eine nach dem Zeilenvorschub, den wir eingefügt haben.
• Nicht steigend: Jetzt liefert der erste Teil des regulären Ausdrucks auch ein Match, und wir haben am Ende drei Matches.
• Weder noch: Denken Sie daran, dass wir darauf geachtet haben, die Eingabe in eine leere Zeichenfolge umzuwandeln, sodass sie jetzt $nur einmal übereinstimmt.

Axiom, 114 Bytes

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)

Ungolfed

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

Ergebnisse

(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 Bytes

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

Hinweis: Geben Sie ein Elementarray wie z a←1⍴3 ansonsten:a←4 3 2 1

Ausgabe interpretieren:

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

Idee: Testen Sie die Monotonie, indem Sie das Original mit dem sortierten Array vergleichen, und prüfen Sie, ob keine Erhöhung vorliegt, indem Sie das Array mit entfernten Duplikaten vergleichen.

(Und ich denke, es kann verbessert werden ...)

Haskell, 36 Bytes

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

(+x)Das liegt daran, dass haskell nicht (-x)als Abschnitt, sondern als Wert falsch interpretiert . Ich frage mich, ob der ganze Ausdruck gewinnbringend sinnlos gemacht werden kann.

LabVIEW, 12 Knoten, 18 Drähte ==> 48 Bytes gemäß Konvention

Keine Funktionen in den anderen Gehäuserahmen verborgen, nur ein einziger Draht über.

Ceylon, 86 Bytes

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

Die Funktion nimmt die Eingabe als Parameter und gibt ein Tupel mit null oder einem Booleschen Wert zurück - [false]für Monotone, das streng abnimmt , [true]für Monotone, das nicht zunimmt, aber nicht streng abnimmt , und []für keines der oben genannten .

Es kann so verwendet werden:

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));
}

Ausgabe:

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

Eine ungolfed und kommentierte Version:

// 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 Bytes

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

Sehr einfach, kehrt zurück, 1wenn sie streng abnimmt, 2wenn sie nicht zunimmt und nilansonsten.

Auch versucht, applymit Makros zu vermeiden , ~@aber es ist nur länger bei 43 Zeichen (dies führt zu [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 Bytes

O$>g$>=g

Volles Programm. Nimmt die Eingabeliste als Befehlszeilenargumente. Outputs 11für streng abnehmende, 01für nicht ansteigende, 00für keine.

Probieren Sie es online!

Erläuterung

Dieser Ansatz funktioniert, weil die Vergleichsoperatoren von Pip, wie die von Python, miteinander verkettet sind: 4>3>2ist wahr und nicht (4>3)>2(falsch) wie in C. Und dasselbe Verhalten gilt, wenn die Vergleichsoperatoren mit dem $Fold-Metaoperator geändert werden.

          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 Bytes

Ausgänge -1für "monoton streng abnehmend", 0für "monoton nicht inkrementierend" und 1sonst.

än rw g

Versuch es

1 Byte gespeichert, danke an Oliver .

R , 34 Bytes

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

Probieren Sie es online!

Ports DJs MATL Antwort .

R , 43 Bytes

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

Probieren Sie es online!

Rückgabe 2für streng abnehmend, 1für nicht steigend und 0sonst.

all(x==cummin(x))is TRUE(konvertiert in, 1wenn es in der Arithmetik verwendet wird) nur dann, wenn fes nicht ansteigt, einschließlich der Groß- und Kleinschreibung.

all(diff(x)<0) ist TRUE nur, wenn fes streng abnimmt.