...しかし、ちょっと、厳密である必要はありません。

厳密に正の整数の空でない配列が与えられた場合、それが以下であるかどうかを判断します。

1. 単調に厳密に減少します。これは、各エントリが前のエントリよりも厳密に少ないことを意味します。
2. 単調な増加はしませんが、厳密には減少しません。これは、各エントリが前のエントリ以下であり、配列が上記のカテゴリに該当しないことを意味します。
3. 上記のどれでもない。

次のコーナーケースに注意してください。

• 単一の数値を持つ配列は、単調に厳密に減少します（無意味に減少します）。
• 同じ数が繰り返された配列は、単調な非増加ですが、厳密には減少していません。

ルール

プログラムまたは機能を提供できます

入力は、配列、リスト、スペースで区切られた数字の文字列など、任意の合理的な形式で取得できます。

3つのカテゴリに対してそれぞれ3つの一貫した出力を選択できます。例えば、出力は数値とすることができます0、1、2。または文字列1 1、1 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

ゼリー、10 9 5 バイト

-DrMcMoylexが見つけたメソッド、名誉を与えてください！

;0IṠṀ

TryItOnline！またはすべてのテストを実行する

戻り値：-1=単調に厳密に減少。0=単調増加しない; 1=その他。

どうやって？

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

Perl 6、17バイト

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

• 単調に厳密に減少： 2
• 単調な非増加： 1
• その他： 0

拡張：

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

MATL、10、7つのバイト

0hdX>ZS

オンラインでお試しください！またはすべてのテストケースを検証してください！

@LuisMendoのおかげで3バイトが節約されました！

出力は

• 厳密に減少：-1

• 増加しない：0

• その他：1

説明：

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バイト

Sign@*Max@*Differences

入力として数値のリストを取る名前のない関数。-1リストが厳密に減少している0場合、増加していないが厳密に減少していない1場合、およびどちらでもない場合に返します。

非常に単純なアルゴリズム：連続するペアの差を取り、最大のものを取り、その最大のものの符号を取ります。

（このアルゴリズムが3バイトである言語が存在する必要があると思います。...）

単一のエントリを持つ配列に関して：Differences空のリストを生成します。Max空のリストの場合は-∞（！）; （!!）とSign[-∞]評価され-1ます。したがって、実際にはこのコーナーケースで機能します。時々Mathematicaが大好きです。（実際、関数は空のリストを厳密に減少するものとして正しくラベル付けします。）

Haskell、40 38 37バイト

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

返品

• GT モノトーンが厳密に減少する場合
• EQ モノトーン非増加用
• LT 他に

compare2つの数値を比較し、最初の数値が2番目の数値よりも大きい（等しい、より小さい）場合、GT（EQ、LT）を返します。zipWith compare<*>tail隣接要素を比較します。foldl min GTGTで始まるMIN関数との比較結果のリスト減少（注：LT< EQ< GT）。

編集：@xnorは2 3バイトを見つけました。ありがとう！

Common Lisp、43 40バイト

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

これは入力をLispリストとして受け取り、3つのカテゴリを区別するため(T T)に(NIL T)と(NIL NIL)を返します。ここでは、提供されているテストケースで実行されています。

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バイト

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

-1厳密に減少する場合0、弱く減少する場合、減少+1しない場合

を使用cmpして連続した要素を比較し、最大値を取ります。これは、リストの1つのコピーの最初の要素を削除してから、マッピングすることによって行われcmpます。たとえば、l=[2,2,1]与える

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

これは持ってmax平等が存在するため、0を。

短いリストはで自動的に拡張されますがNone、これはすべての数字よりも少ないため無害です。また、このファントム要素minは、入力の長さが1の場合に空のリストを取得しないようにします。

Brachylog、7バイト

>,1|>=,

オンラインでお試しください！

これは1、厳密に減少する場合、0増加しfalse.ない場合、その他の場合に出力されます。

説明

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

その他の7バイトソリューション

>=!>,;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バイト

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

stdinから入力を読み取り、入力に応じて以下を出力します。

出力：

[1] FALSE TRUE：単調増加しない

[1] TRUE FALSE：単調に厳密に減少

[1] FALSE FALSE： 上記のどれでもない

JavaScript（ES6）、51バイト

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

厳密な減少の場合は0、増加しない場合は1、それ以外の場合は2を返します。

05AB1E、5 8バイト

エミグナが修正したバグ、ありがとう！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

オンラインでお試しください！

出力は次のとおりです。

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

ルビー、37バイト

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

出力：[true,true]、[true,false]または[false,false]

Mathematica、15 11バイト

##>0|##>=0&

これは可変引数関数であり、すべての入力整数を個別の引数として受け取ります。

• 厳密に減少： True | True
• 増加しない： False | True
• どちらでもない： False | False

注意|ではありませんOrが、Alternativesこれらの式はに評価されません理由を説明するパターンマッチング構文の一部であり、True、True、Falseそれぞれ。

コード自体は、主にこのヒントのアプリケーションです。例えば##>0ですGreater[##, 0]が、その後##、私たちのようなものを得るように、すべての入力値に展開Greater[5, 3, 2, 0]自体が意味します5>3>2>0。

ラケット、44バイト

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

呼び出された：

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

結果：

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

C ++ 14、85バイト

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

厳密な減少の場合は3（0b11）、増加しない場合は1（0b01）、それ以外の場合は0を返します。

ゴルフをしていない：

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

これはC ++ 17の折りたたみ式にとって完璧な問題だと思いました。

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

残念ながら、関係演算子は連鎖しませんが、連鎖します

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

望んでいませんでした。

パイソン2、61 74バイト

単一の数値入力の場合は+13バイト

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

のようなブラケットリスト形式での入力が必要[3,2,1]です。厳密な減少の場合は2、増加しない場合は1、それ以外の場合は0を返します。

古いソリューション：

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

Pythonの3、81 52バイト（おかげFryAmTheEggMan）

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

オンラインでお試しください！

Befunge、50バイト

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

オンラインでお試しください！

スペースで区切られたintのシーケンスとして入力を受け入れ、厳密に減少する場合は0、厳密に減少しない場合は1、そうでない場合は2を返します。

言語を知らない場合、befungeの読み取りは一種不可能なので、これは擬似コードのアルゴリズムです。

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

* befungeメモリ内のスタックは、無限の0で始まります。pop（）、push（x）、input（）、output（x）は自明であり、私が使用した他の疑似関数は次のように機能します。

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

ファンジ！

以前のバージョン、41バイトだけですが、入力シーケンスを終了するために0を必要とするため無効です（または、このようなインタープリターを使用）

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

オンラインでお試しください！

J、14バイト

右側のリストを受け取り1、厳密に減少するか、0弱く減少するか、_1そうでない場合に戻るモナド動詞。

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

リストの*最小<./連続差の符号を取ります2-/\。Jは、差を取るときに差の順序を入れ替えないので、たとえば、これらがすべて正の場合、シーケンスは厳密に減少します。特に、<./ゼロ要素リストでは正の無限大を返します。

REPLで使用中：

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

C、68 67バイト

fintの配列（l）の前にその長さ（n、またint）が渡される関数。単調に厳密に減少する場合は3、単調に増加しない場合は1、厳密に減少しない場合は1、それ以外の場合は0を返します。

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

読みやすさのためにゴルフを少ししていない：

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

ロジックを表示するために再配置およびコメント化されました：

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

テストケース（礼儀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

網膜、41バイト

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

オンラインでお試しください！（最初の行は、改行で区切られたテストスイートを有効にします。）

• 厳密に減少： 2
• 増加しない： 3
• どちらでもない： 1

説明

\d+
$*

入力単項を変換します。

A`\b(1+) 1\1

ここでの正規表現は、連続する数字の増加するペアと一致します。この場合、入力は明らかに増加しないことはできません。A入力ラインが正規表現と一致する場合、空の文字列で廃棄して交換されることを意味する「抗grepの」段階として表すこと。

S`\b$

これは、入力が破棄されなかった場合にのみ入力に改行を追加するために使用される分割ステージです。したがって、これまでに2つの可能な結果がありました。増加しない入力は最後に改行を取得し、他はまだ空です。

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

最後に、この正規表現の一致数をカウントします。正規表現は、同一の番号（およびのような入力でこの種の複数の一致を回避するために文字列の最後まですべて1 1 1 1）または「入力の終わり」に一致します。3種類の入力を見ていきましょう。

• 厳密に減少：すべての値は一意ですが、$一致するため、正規表現の最初の部分は一致しません。今$ではありません正確に「文字列の終わり」。また、後続の改行の前で一致させることもできます。したがって、実際には2つの一致を取得します。1つは入力の最後に、もう1つは挿入した改行の後にあります。
• 非増加：正規表現の最初の部分も一致を提供するようになり、3つの一致になります。
• どちらでもない：入力を空の文字列に変換するように注意したため、$1回だけ一致することに注意してください。

公理、114バイト

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)

非ゴルフ

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

結果

(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バイト

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

注：1つの要素配列をa←1⍴3他の例として入力してください：a←4 3 2 1

出力の解釈：

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

アイデア：元の配列と並べ替えられた配列を比較して単調性をテストし、重複が削除された配列と比較して増加しないことを確認します。

（そして、改善できると思います...）

Haskell、36バイト

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

(+x)haskell (-x)はセクションではなく値として誤って解釈するためです。表現全体が有益に無意味にできるのではないかと思います。

LabVIEW、12ノード、18ワイヤ==>慣例により48バイト

他の場合のフレームには隠された機能はなく、たった1本のワイヤーで接続されています。

セイロン、86バイト

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

関数は、パラメータとして入力を受け取り、そして0または1ブール値のタプルを返す- [false]するためのモノトーンは厳密に減少、[true]のためにモノトーンの非増加が、厳密に減少していない、と[]のために上記のなし。

次のように使用できます。

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

出力：

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

無償のコメント付きバージョン：

// 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バイト

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

非常に簡単1で、厳密に減少する場合、2増加しnilない場合、その他の場合に戻ります。

またapply、マクロを使用して回避しようとしました~@が、それは43文字で長くなっています（これはになります[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)]

ピップ、8バイト

O$>g$>=g

完全なプログラム。入力リストをコマンドライン引数として受け取ります。11厳密に減少する場合、出力しない01場合、増加00しない場合、どちらにもなりません。

オンラインでお試しください！

説明

このアプローチは、PythonのようなPipの比較演算子がC ：のよう4>3>2に(4>3)>2（false）であるのではなくtrueであるため機能します。また、比較演算子が$foldメタ演算子で変更された場合も同じ動作になります。

          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バイト

-1「厳密に減少する単調」、0「増加しない単調」などの出力1。

än rw g

それを試してみてください

Oliverに感謝します。

R、34バイト

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

オンラインでお試しください！

Ports DJのMATL回答。

R、43バイト

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

オンラインでお試しください！

2厳密に減少する場合、1増加し0ない場合、その他の場合に戻ります。

all(x==cummin(x))is TRUE（1算術で使用する場合に変換）fは、厳密な場合を含めて、増加しない場合に限ります。

all(diff(x)<0)であるTRUE場合にのみ、f厳密に減少しています。