... tapi hei, tidak perlu ketat.

Diberikan array kosong yang benar-benar kosong, tentukan apakah itu:

1. Monoton menurun secara drastis . Ini berarti bahwa setiap entri sangat kurang dari yang sebelumnya.
2. Monoton tidak meningkat, tetapi tidak menurun secara ketat . Ini berarti bahwa setiap entri kurang dari atau sama dengan sebelumnya, dan array tidak termasuk dalam kategori di atas.
3. Tidak satu pun di atas .

Perhatikan kasus sudut berikut:

• Array dengan nomor tunggal adalah monoton yang sangat menurun (sangat kosong).
• Array dengan nomor yang sama diulang adalah tidak monoton meningkat, tetapi tidak sepenuhnya menurun.

Aturan

Anda dapat menyediakan program atau fungsi

Input dapat diambil dalam format apa pun yang wajar: array, daftar, string dengan angka yang dipisahkan oleh spasi, ...

Anda dapat memilih tiga output yang konsisten untuk masing-masing kategori. Sebagai contoh, output dapat nomor 0, 1, 2; atau string 1 1,, 1 0string kosong.

Kode terpendek dalam byte menang

Uji kasus

Monoton menurun secara drastis:

7 5 4 3 1
42 41
5

Monoton tidak bertambah, tetapi tidak menurun secara ketat:

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

Bukan dari salah satu di atas:

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

Jelly , 10 9 5 byte

-Metode ditemukan oleh DrMcMoylex, berikan kredit!

;0IṠṀ

TryItOnline! atau jalankan semua tes

Pengembalian: -1= monoton menurun secara ketat; 0= monoton tidak meningkat; 1= lainnya.

Bagaimana?

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

Perl 6 , 17 byte

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

• Monoton menurun secara drastis: 2
• Monoton tidak meningkat: 1
• Lain: 0

Diperluas:

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

MATL , 10 , 7 byte

0hdX>ZS

Cobalah online! atau verifikasi semua kasus uji!

3 byte disimpan, terima kasih kepada @LuisMendo!

Outputnya adalah

• Mengurangi secara ketat: -1

• Non-meningkat: 0

• Lainnya: 1

Penjelasan:

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 byte

Sign@*Max@*Differences

Fungsi yang tidak disebutkan namanya mengambil daftar angka sebagai input. Mengembalikan -1jika daftar benar-benar menurun, 0jika tidak meningkat tetapi tidak sepenuhnya menurun, dan 1jika tidak.

Algoritma yang cukup sederhana: ambil perbedaan pasangan berturut-turut, ambil yang terbesar, dan ambil tanda yang terbesar.

(Saya merasa seperti harus ada beberapa bahasa di mana algoritma ini adalah 3 byte ....)

Mengenai array dengan satu entri: Differencesmenghasilkan daftar kosong; Maxdaftar kosong memberi -∞(!); dan Sign[-∞]mengevaluasi ke -1(!!). Jadi itu benar-benar berfungsi pada kasus sudut ini. Kadang-kadang harus mencintai Mathematica. (Memang, fungsi ini juga memberi label yang benar pada daftar kosong sebagai benar-benar menurun.)

Haskell, 40 38 37 byte

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

Kembali

• GT untuk Monoton menurun secara ketat
• EQ untuk Monoton tidak meningkat
• LT lain

comparemembandingkan dua angka dan mengembalikan GT( EQ, LT) jika angka pertama lebih besar dari (sama dengan, kurang dari) angka kedua. zipWith compare<*>tailmembandingkan elemen tetangga. foldl min GTmengurangi daftar hasil perbandingan dengan fungsi min yang dimulai dengan GT (catatan:LT < EQ< GT).

Sunting: @xnor ditemukan 2 3 byte. Terima kasih!

Common Lisp, 43 40 byte

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

Ini mengambil input sebagai daftar Lisp, dan kembali (T T) , (NIL T)dan (NIL NIL)untuk membedakan 3 kategori. Ini sedang dijalankan pada test case yang disediakan:

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

-1untuk penurunan ketat, 0untuk penurunan lemah, +1untuk tidak menurun

Menggunakan cmpuntuk membandingkan elemen berurutan, dan mengambil maksimum. Ini dilakukan dengan menghapus elemen pertama dari satu salinan daftar, lalu memetakan cmp. Misalnya, l=[2,2,1]memberi

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

yang memiliki max0 karena kesetaraan ada.

Daftar yang lebih pendek secara otomatis diperpanjang None, yang kurang dari semua angka dan tidak berbahaya. Elemen hantu ini juga mengisolasi terhadap pengambilan mindaftar kosong ketika input memiliki panjang 1.

Brachylog , 7 byte

>,1|>=,

Cobalah online!

Ini mencetak 1untuk mengurangi ketat, 0untuk tidak menambah dan false.sebaliknya.

Penjelasan

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

Solusi 7 byte lainnya

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

Membaca input dari stdin dan mencetak yang berikut tergantung pada input:

Keluaran:

[1] FALSE TRUE: Monoton tidak meningkat

[1] TRUE FALSE: Monoton menurun secara drastis

[1] FALSE FALSE: Bukan dari salah satu di atas

JavaScript (ES6), 51 byte

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

Mengembalikan 0 untuk pengurangan ketat, 1 untuk tidak meningkatkan, 2 sebaliknya.

05AB1E ,5 8 byte

Bug diperbaiki oleh Emigna, terima kasih! Ini menggunakan metode yang sama seperti DrMcMoylex 's.

®¸ì¥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

Cobalah online!

Output adalah:

-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]atau[false,false]

Mathematica, 15 11 byte

##>0|##>=0&

Ini adalah fungsi variadic, mengambil semua integer input sebagai argumen terpisah.

• Mengurangi secara ketat: True | True
• Tidak meningkat: False | True
• Tidak ada: False | False

Perhatikan bahwa |ini bukan Ortapi Alternatives, yang merupakan bagian dari sintaks pencocokan pola, yang menjelaskan mengapa ekspresi ini tidak dievaluasiTrue , True, False, masing-masing.

Kode itu sendiri sebagian besar merupakan aplikasi tip ini . Sebagai contoh ##>0adalah Greater[##, 0]tetapi kemudian ##diperluas ke semua nilai input sehingga kami mendapatkan sesuatu seperti Greater[5, 3, 2, 0], yang artinya sendiri 5>3>2>0.

Racket , 44 byte

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

Dipanggil:

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

Hasil:

'((#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...);}

Mengembalikan 3 (0b11) untuk penurunan ketat, 1 (0b01) untuk non-meningkat dan 0 sebaliknya.

Tidak Disatukan:

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

Saya pikir ini adalah masalah yang sempurna untuk ekspresi lipat C ++ 17:

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

Sayangnya itu tidak rantai operator relasional tetapi

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

yang tidak diinginkan.

Python 2, 61 74 byte

+13 byte untuk input nomor tunggal

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

Membutuhkan input dalam bentuk daftar braket seperti [3,2,1] . Mengembalikan 2 untuk pengurangan ketat, 1 untuk tidak meningkat dan 0 sebaliknya.

Solusi lama:

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

Python 3, 81 52 byte (Terima kasih kepada FryAmTheEggMan )

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

Cobalah online!

Befunge, 50 byte

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

Cobalah online!

Menerima input sebagai urutan int yang dipisahkan oleh spasi, dan mengembalikan 0 jika benar-benar menurun, 1 jika tidak benar-benar menurun, 2 sebaliknya.

Karena membaca befunge agak mustahil jika Anda tidak tahu bahasa, ini adalah algoritma dalam 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())

* Dalam memori befunge adalah tumpukan yang dimulai dengan jumlah 0 tak terbatas di atasnya. pop (), push (x), input () dan output (x) cukup jelas, fungsi lain yang saya gunakan berfungsi seperti ini:

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!

Versi sebelumnya, hanya 41 byte tetapi tidak valid karena memerlukan 0 untuk mengakhiri urutan input (atau menggunakan juru bahasa seperti ini )

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

Cobalah online!

J, 14 byte

Kata kerja monadik mengambil daftar di sebelah kanan, kembali 1untuk penurunan yang ketat, 0untuk penurunan yang lemah, dan _1sebaliknya.

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

Mengambil tanda *minimum<./ berturut-turut 2-/\dalam daftar. J tidak menukar urutan perbedaan ketika mengambilnya jadi mis. Urutannya sangat menurun jika semuanya positif. Terutama,<./ mengembalikan infinity positif pada daftar elemen nol.

Digunakan di REPL:

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

C, 68 67 Bytes

Suatu fungsi f, yang dilewatkan array ints ( l) didahului oleh panjangnya ( n, juga sebuah int). Mengembalikan 3 jika monoton menurun secara ketat, 1 jika monoton tidak meningkat, tetapi tidak menurun secara ketat, 0 sebaliknya.

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

Hapus sedikit golf agar mudah dibaca:

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

Mengatur ulang dan berkomentar untuk menunjukkan logika:

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

Uji kasus ( seizin 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 byte

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

Cobalah online! (Baris pertama memungkinkan suite tes yang dipisahkan dengan linefeed.)

• Mengurangi secara ketat: 2
• Tidak meningkat: 3
• Tidak ada: 1

Penjelasan

\d+
$*

Mengonversi input yang unary.

A`\b(1+) 1\1

Regex di sini cocok dengan pasangan angka yang terus meningkat. Jika ini masalahnya, input jelas tidak bisa tidak meningkat. Yang Amenyatakan itu sebagai tahap "anti-grep" yang berarti bahwa garis input dibuang dan diganti dengan string kosong jika regex cocok.

S`\b$

Ini adalah tahap split yang digunakan untuk menambahkan linefeed ke input saja jika input tidak dibuang. Jadi kami memiliki dua hasil yang mungkin sejauh ini: input yang tidak bertambah mendapat linefeed pada akhirnya dan yang lainnya masih kosong.

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

Akhirnya, kami menghitung jumlah kecocokan dari regex ini. Regex cocok dengan angka yang sama (dan kemudian semuanya sampai akhir string untuk menghindari beberapa kecocokan dari jenis ini untuk input seperti1 1 1 1 ), atau "akhir input". Mari kita lihat tiga jenis input:

• Mengurangi dengan ketat: bagian pertama dari regex tidak dapat cocok karena semua nilai unik, tetapi $cocok. Sekarang $bukan persis "akhir dari string". Itu juga bisa cocok di depan linefeed tambahan. Jadi kita akan benar-benar mendapatkan dua kecocokan darinya, satu di akhir input, dan satu setelah linefeed yang kita masukkan.
• Non-meningkat: sekarang bagian pertama dari regex juga menyediakan pertandingan, dan kami berakhir dengan tiga pertandingan.
• Tidak satu pun: ingat bahwa kami berhati-hati untuk mengubah input menjadi string kosong, jadi sekarang $hanya cocok sekali.

Aksioma, 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)

Tidak disatukan

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

Hasil

(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

Catatan: masukkan satu array elemen, misalnya a←1⍴3sebaliknya:a←4 3 2 1

Menafsirkan output:

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

Ide: uji untuk monotonitas dengan membandingkan array asli ke array, periksa non-meningkat dengan membandingkan array dengan duplikasi yang dihapus.

(Dan saya pikir itu bisa diperbaiki ...)

Haskell, 36 byte

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

(+x)karena haskell salah mengartikan (-x)sebagai nilai, bukan bagian. Saya bertanya-tanya apakah seluruh ekspresi dapat secara menguntungkan dijadikan pointfree.

LabVIEW, 12 node, 18 kabel ==> 48 byte oleh konvensi

Tidak ada fungsi yang disembunyikan di bingkai case lainnya, hanya satu kabel saja.

Ceylon, 86 byte

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

Fungsi ini mengambil input sebagai parameternya, dan mengembalikan tupel nol atau satu boolean - [false]untuk Monotone menurun secara ketat , [true]untuk Monotone tidak meningkat, tetapi tidak secara ketat menurun , dan []untuk None di atas .

Dapat digunakan seperti ini:

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

Keluaran:

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

Versi tanpa tanda dan komentar:

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

Sangat mudah, pengembalian 1untuk jika benar-benar menurun, 2jika tidak bertambah dan nilsebaliknya.

Juga mencoba menghindari applydengan makro ~@tetapi hanya lebih lama di 43 karakter (ini menghasilkan [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

Program lengkap. Mengambil daftar input sebagai argumen baris perintah. Output 11untuk penurunan ketat, 01untuk non-meningkat, 00untuk keduanya.

Cobalah online!

Penjelasan

Pendekatan ini bekerja karena operator perbandingan Pip, seperti Python, rantai bersama: 4>3>2benar, daripada menjadi (4>3)>2(salah) seperti dalam C. Dan perilaku yang sama berlaku ketika operator perbandingan dimodifikasi dengan $meta-operator lipat.

          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

Output -1untuk "monoton dikurangi secara ketat", 0untuk "monoton tanpa-kenaikan" dan 1sebaliknya.

än rw g

Cobalah

1 byte disimpan berkat Oliver .

R , 34 byte

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

Cobalah online!

Ports jawaban MATL DJ .

R , 43 byte

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

Cobalah online!

Pengembalian 2untuk pengurangan ketat, 1untuk tidak meningkat, dan 0sebaliknya.

all(x==cummin(x))is TRUE(dikonversi ke 1saat digunakan dalam aritmatika) jika dan hanya jikaf tidak meningkat, termasuk kasus ketat.

all(diff(x)<0)adalah TRUEhanya ketika fsecara ketat menurun.