Mari kita mengurangi monotonnya

33

... 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
Luis Mendo
sumber
Apakah menulis fungsi variadik (di mana nilai input tidak dibungkus dengan jenis data apa pun, tetapi semuanya diteruskan langsung ke fungsi sebagai argumen) termasuk dalam "format apa pun yang masuk akal"?
Martin Ender
@ Martin Ya, benar!
Luis Mendo

Jawaban:

9

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
Jonathan Allan
sumber
Apakah diacrtic Mmerupakan bagian dari peta karakter 8bit? Anda tidak dapat mengatakan bahwa itu adalah 5 byte karena tidak. CP1252 tidak memilikinya misalnya.
Euri Pinhollow
2
@EuriPinhollow Jelly menggunakan halaman kode khusus ini untuk menghitung byte, yang ditautkan dalam kata bytedi header posting ini.
Fatalkan
@Fatalize: thx, mengerti.
Euri Pinhollow
22

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:« >= »」
}
Brad Gilbert b2gills
sumber
4
Perl ajaib
Gugatan Dana Monica
Ini dapat diperpanjang untuk bekerja dengan jenis apa pun jika >diaktifkan dengan afterdan >=dengan !before. say {[after](@_)+[!before] @_}(<d c b a>) #=> 2
Brad Gilbert b2gills
13

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
DJMcMayhem
sumber
1
Tidak bisakah Anda menambahkan 0alih - alih menambahkan terakhir 1? Sesuatu seperti0hdX>ZS
Luis Mendo
2
@LuisMendo Ah, itu jenius! Terima kasih!
DJMcMayhem
Tidak membantu, tetapi untuk kebingungan Anda juga dapat menggunakan: 0hdX>0/- Pertanyaan untuk Anda dan @LuisMendo: Apakah mungkin untuk memanfaatkan fakta bahwa pengurutan hanya 1 char (berlawanan dengan X>), dengan entah bagaimana secara implisit menggunakan nilai terakhir?
Dennis Jaheruddin
@DennisJaheruddin Saya juga berpikir untuk menggunakan S, tapi saya belum menemukan cara untuk membuatnya lebih pendek ...
Luis Mendo
9

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

Greg Martin
sumber
Saya melihat DrMcMoylex mengalahkan saya dalam 7 menit! :)
Greg Martin
2
"Saya merasa seperti harus ada beberapa bahasa di mana algoritma ini adalah 3 byte" chat.stackexchange.com/transcript/message/33720906#33720906 :(
Martin Ender
7

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!

nimi
sumber
Bisakah Anda menambahkan LT bukan menambahkan 0?
xnor
@ xnor: Ya, terima kasih, tapi itu pasti GT, karena kita perlu daftar minimum (saya punya maksimum, yang salah dan relik dari versi awal di mana saya menggunakan =<<bukan<*> ).
nimi
1
Saya melihat. Sebenarnya bagaimana foldl min GT?
xnor
6

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))
Omar
sumber
1
Jumlah byte yang sama persis dengan (defun f(x)(mapcar'apply'(> >=)`(,x,x))). Perhatikan bahwa Anda bisa menulis (lambda(x)...)menjadi lebih pendek.
coredump
6

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.

Tidak
sumber
Bahkan dengan Python yang sangat kecil, saya tahu saya bisa menghargai betapa hebatnya jawaban ini
Luis Mendo
5

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.
Fatalisasi
sumber
4

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

Billywob
sumber
d=diff(scan());ifelse(all(d<=0),!prod(d),2)lebih pendek 1 byte. Ini mengembalikan 0 jika monoton secara ketat, 1 jika monoton tidak meningkat dan 2 jika tidak ada yang di atas. Tidak yakin apakah diizinkan untuk mengembalikan apa pun jika tidak ada yang di atas, tetapi kemudian Anda dapat menyederhanakannya d=diff(scan());if(all(d<=0))!prod(d).
JAD
Sebenarnya, d=diff(scan());if(all(d<=0))any(!d)satu byte lebih baik.
JAD
3

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.

Neil
sumber
3

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
Osable
sumber
1
®¸ì¥Z0.Sakan memperbaiki masalah elemen tunggal.
Emigna
Terima kasih banyak! Saya pikir 0 di awal juga akan bekerja karena semua angka positif (secara ketat saya kira).
Osable
Ya 0 akan bekerja juga, tapi itu bagus karena berfungsi untuk input yang berisi 0 (meskipun menurut definisi itu tidak akan) :)
Emigna
Fakta menyenangkan: dalam bahasa Prancis "positif" berarti positif atau nol dan Anda harus menentukan "benar-benar positif" untuk mencapai arti yang sama dengan "positif" dalam bahasa Inggris.
Osable
3

Ruby, 37 byte

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

Output: [true,true], [true,false]atau[false,false]

GB
sumber
2

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.

Martin Ender
sumber
2

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))
Matthew Butterick
sumber
Sayang Racket tidak mendefinisikan kasus arity 1 >sebagai benar. Lisp umum mendapatkan yang benar, tetapi gagal mendefinisikan arity 0 case (yang juga harus benar).
Omar
2

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.

Karl Napf
sumber
2

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))
Karl Napf
sumber
2

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

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

Cobalah online!

Sygmei
sumber
sorted(s)[::-1]lebih pendek untuk membalik daftar yang diurutkan. Dalam Python 3 Anda bisa lakukan {*a}untuk mendapatkan satu set elemen a. sortedmengembalikan daftar sehingga Anda tidak harus membuang set ke daftar juga. Juga menambahkan boolean sangat halal! Akhirnya Anda bisa mengirimkan lambda anonim, jadi Anda tidak perlu f=. Saya mendapatkan 52 byte pada akhirnya. repl.it/E7eG/2
FryAmTheEggman
2

Befunge, 50 byte

&: >~1+#^_v>:0`|
1\:^  @.$$<[email protected]_
-: ^    >& ^   >

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@.$_<[email protected]_
- >:v  >^   >

Cobalah online!

Leo
sumber
Saya khawatir trailing 0tidak dihitung sebagai format input yang valid. Saya pikir ini termasuk dalam kategori "input yang sudah diproses". Bahkan, beberapa jawaban menambahkan a 0dalam kode (dengan demikian termasuk dalam jumlah byte). Saya akan diterima jika Anda bisa. Bisakah Anda mengganti 0dengan beberapa karakter non-numerik? Itu bisa diterima
Luis Mendo
@LuisMendo Sebenarnya, dengan interpreter ini (yang saya gunakan untuk mengembangkan kode) EOF mengembalikan 0, jadi tidak perlu menambahkan apa pun ke input. Saya tidak dapat menemukan perilaku yang seharusnya, jadi saya tidak tahu apakah asumsi ini standar atau tidak. Satu hal yang saya mungkin salah tafsirkan, adalah: bisakah nol menjadi bagian dari urutan input? Jika demikian, saya perlu memodifikasi kodenya.
Leo
Tidak, nol tidak dapat menjadi bagian dari urutan (Diberikan array non-kosong dari bilangan bulat positif_ Maksudku bilangan bulat positif ketat ). Tetapi beberapa jawaban menggunakan kode yang0 dimasukkan untuk menangani kasus bahwa input hanya memiliki satu entri. Itulah salah satu alasan mengapa saya menganggap bahwa memasukkan yang dalam input tidak valid. Bagaimanapun, jika ada penerjemah yang tidak membutuhkannya, Anda dapat menggunakan penerjemah itu untuk membuktikan bahwa jawaban Anda valid tanpa . Jika penerjemah Try-it-online membutuhkannya , Anda dapat memasukkannya untuk tujuan demonstrasi, dengan catatan penjelasan yang sesuai000
Luis Mendo
@JamesHolderness saat di tryonline ~ berfungsi sebagaimana mestinya, & memiliki perilaku aneh pada EOF, tampaknya mengulangi input terakhir selamanya. Lihat di sini sebagai contoh
Leo
1
Saya mengedit jawaban menggunakan pendekatan James, sekarang input diakhiri oleh EOF
Leo
2

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
algoritme hiu
sumber
2

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
hmmwhatsthisdo
sumber
2

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.
Martin Ender
sumber
1

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] 
RosLuP
sumber
1
Forse dovresti tradurre saya commenti all'inglese :-)
Luis Mendo
1

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

Roman Susi
sumber
Diubah menjadi satu nomor. Bytes meningkat 2 ...
Roman Susi
1

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.

Tidak
sumber
1

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

masukkan deskripsi gambar di sini

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

SRM
sumber
1

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];
Paŭlo Ebermann
sumber
1

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)]
NikoNyrh
sumber
1

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)
DLosc
sumber
1

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 .

Shaggy
sumber
@Liver, ya; jika tidak maka akan default ke ... Tunggu, apa? Mengapa itu berhasil ?! än mg rwmengembalikan hasil yang salah tanpa Jtetapi tidak demikian halnya dengan än rw g. Aneh.
Shaggy
1

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.

Giuseppe
sumber