... ama hey, katı olmaya gerek yok.

Boş olmayan bir kesinlikle pozitif tamsayı dizisi verildiğinde, bunun olup olmadığını belirleyin:

1. Monoton kesinlikle azalıyor . Bu, her girişin bir öncekinden kesinlikle daha az olduğu anlamına gelir.
2. Monoton artmaz, ancak kesinlikle azalmaz . Bu, her girişin öncekinden küçük veya ona eşit olduğu anlamına gelir ve dizi yukarıdaki kategoriye girmez.
3. Yukarıdakilerin hiçbiri .

Aşağıdaki köşe durumlarına dikkat edin:

• Tek bir numaraya sahip bir dizi monoton kesinlikle azalır (bu şekilde boş).
• Aynı sayıda tekrarlanan dizi, monoton artmaz, ancak kesinlikle azalmaz.

kurallar

Bir program veya işlev sunabilirsiniz

Girdi, herhangi bir makul biçimde alınabilir: dizi, liste, boşluklarla ayrılmış sayılarla dize, ...

Üç kategori için sırasıyla herhangi bir üç tutarlı çıkışı seçebilirsiniz. Örneğin, çıkış sayılar olabilir 0, 1, 2; veya dizeleri 1 1, 1 0boş dize.

Bayt cinsinden en kısa kod kazanır

Test durumları

Monoton kesinlikle azalan:

7 5 4 3 1
42 41
5

Monoton artmaz, fakat kesinlikle azalmaz:

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

Yukarıdakilerin hiçbiri:

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

Jöle , 10 9 5 bayt

- DrMcMoylex tarafından bulunan Metod, git biraz kredi ver!

;0IṠṀ

TryItOnline! veya tüm testleri çalıştırın

Döndürür: -1= monoton kesinlikle düşüyor; 0= monoton artmayan; 1= Diğer.

Nasıl?

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

Perl 6 , 17 bayt

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

• Monoton kesinlikle azalan: 2
• Monoton artmayan: 1
• Diğer: 0

Expanded:

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

MATL , 10 , 7 bayt

0hdX>ZS

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın!

@LuisMendo sayesinde 3 bayt kaydedildi!

Çıkışlar

• Kesinlikle azalan: -1

• Artan olmayan: 0

• Diğer: 1

Açıklama:

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 bayt

Sign@*Max@*Differences

Adsız işlev, giriş olarak bir sayılar listesini alarak İade -1listesi kesinlikle azalıyorsa 0o artmayacak ama kesinlikle azalan değilse ve 1ikisi de değil eğer.

Oldukça basit bir algoritma: ardışık çiftlerin farklarını alın, en büyüğünü alın ve en büyüğünün işaretini alın.

(Bu algoritmanın 3 bayt olduğu bir dil olmalı ...)

Tek girişli bir dizi ile ilgili olarak: Differencesboş bir liste verir; Maxboş bir listenin verir -∞(!); ve (!!) olarak Sign[-∞]değerlendirir -1. Bu yüzden aslında bu köşe davasında çalışıyor. Bazen Mathematica'yı sevmeliyim. (Gerçekten de, işlev boş bir listeyi kesinlikle azalan şekilde doğru şekilde etiketler.)

Haskell, 40 38 37 bayt

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

İade

• GT Monoton için kesinlikle azalan
• EQ artan Monoton için
• LT Başka

compareİki numaraları ve döner karşılaştırır GT( EQ, LT) birinci sayı, ikinci sayı (daha az, eşit) daha büyük ise. zipWith compare<*>tailKomşu elemanları karşılaştırır. foldl min GTGT başlayarak dakika fonksiyonu ile mukayese sonuçlarının listesinde azaltır (not: LT< EQ< GT).

Düzenleme: @xnor 2 3 bayt buldu . Teşekkürler!

Ortak Lisp, 43 40 bayt

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

Bu Lisp liste olarak girdi alır ve döner (T T), (NIL T)ve (NIL NIL)3 kategoriye ayırmak için. İşte sağlanan test durumlarında çalışıyor:

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 bayt

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

-1kesinlikle azaltmak için, 0zayıflamak +1için , azaltmak için değil

cmpArdışık elemanları karşılaştırmak için kullanmak , ve azami alır. Bu, listenin bir kopyasının ilk öğesini kaldırarak ve sonra eşleştirerek yapılır cmp. Örneğin, l=[2,2,1]verir

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

ki bu max0 çünkü bir eşitlik var.

Kısa liste Nonetüm numaralardan daha az ve çok zararsız olan otomatik olarak genişletilir . Bu hayali eleman min, girişin uzunluğu 1 olduğunda boş bir listenin alınmasına karşı yalıtır .

Brachylog , 7 bayt

>,1|>=,

Çevrimiçi deneyin!

Bu 1, kesinlikle azalan, 0artan olmayan ve false.başka şekilde yazdırır .

açıklama

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

Diğer 7 byte çözümler

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

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

Stdin'den girişi okur ve girişe bağlı olarak aşağıdakileri yazdırır:

Çıktı:

[1] FALSE TRUE: Monoton artmayan

[1] TRUE FALSE: Monoton kesinlikle azalıyor

[1] FALSE FALSE: Yukarıdakilerin hiçbiri

JavaScript (ES6), 51 bayt

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

Katı düşme için 0, yükselmeme için 1, aksi takdirde 2 döndürür.

05AB1E ,5 8 bayt

Emigna tarafından düzeltilen hata, teşekkürler! DrMcMoylex ile aynı yöntemi kullanır .

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

Çevrimiçi deneyin!

Çıktı:

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

Ruby, 37 bayt

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

Çıktı: [true,true], [true,false]veya[false,false]

Mathematica, 15 11 bayt

##>0|##>=0&

Bu, tüm giriş tam sayılarını ayrı argümanlar olarak alan değişken bir işlevdir.

• Kesinlikle azalan: True | True
• Sigara artan: False | True
• ne: False | False

Not |değil Orama Alternativesbu ifadeler için değerlendirilen alamadım açıklıyor desen eşleştirme sözdizimi, bir parçası, True, True, False, sırasıyla.

Kodun kendisi çoğunlukla bu ipucunun bir uygulamasıdır . Örneğin ##>0, Greater[##, 0]ancak daha sonra ##tüm girdi değerlerine genişler, bu nedenle Greater[5, 3, 2, 0]kendisi gibi bir şey elde ederiz 5>3>2>0.

Raket , 44 bayt

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

çağrılan:

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

Sonuç:

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

C ++ 14, 85 bayt

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

Sıkı bir düşüş için 3 (0b11), artmaması için 1 (0b01), aksi takdirde 0 döndürür.

Ungolfed:

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

Bunun C ++ 17'nin katlama ifadeleri için mükemmel bir sorun olduğunu düşündüm:

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

Maalesef ilişkisel operatörleri zincirlemiyor, fakat

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

istenmedi ki.

Python 2, 61 74 bayt

Tek sayı girişi için +13 bayt

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

Gibi parantez listesi formunda giriş gerektirir [3,2,1] . Katı düşme için 2, yükselmeme için 1 ve aksi takdirde 0 döndürür.

Eski çözüm:

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

Python 3, 81 52 bayt ( FryAmTheEggMan sayesinde )

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

Çevrimiçi deneyin!

Befunge, 50 bayt

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

Çevrimiçi deneyin!

Girdiyi boşluklarla ayrılmış bir int dizisi olarak kabul eder ve kesinlikle azaldığında 0, aksi takdirde azalmıyorsa 1, aksi takdirde 2 döndürür.

Dilini bilmiyorsanız befunge okumak imkansız olduğundan, sözde koddaki algoritma budur:

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 hafızasında sonsuz miktarda 0 ile başlayan bir yığın var. pop (), push (x), input () ve output (x) kendimi açıklamalıdır, kullandığım diğer takma işlevler şöyle çalışır:

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!

Önceki sürüm, sadece 41 bayt ama hatalı bu giriş sekansı sonlandırmak için 0 gerektirir (ya da bu gibi bir yorumlayıcı kullanarak bu yana bu )

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

Çevrimiçi deneyin!

J, 14 bayt

Listeyi sağa alan, 1kesinlikle azalan, 0zayıf azalan ve _1aksi halde geri dönen Monadik fiil .

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

Listenin ardışık farklılıklarının *minimum işaretini alır . J, bunları alırken farklılıkların sırasını değiştirmez; örneğin, eğer hepsi pozitif ise dizi kesinlikle azalır. Özellikle, sıfır eleman listelerinde pozitif sonsuzluğu döndürür.<./2-/\<./

REPL'de kullanımda:

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

C 68 67 Bayt

fÖncesinde bir ints ( l) dizgesinden geçen bir işlevn , ayrıca bir int). Monoton kesinlikle düşüyorsa 3, monoton artmıyorsa, ancak kesinlikle azalmıyorsa 3, aksi takdirde 0 döndürür.

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

Okunabilirlik için hafifçe golf oynamayın:

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

Mantığı göstermek için yeniden düzenlendi ve yorumlandı:

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

Test durumları ( IDEOne izniyle ):

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

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

Çevrimiçi deneyin! (İlk satır satır besleme ile ayrılmış bir test takımı sağlar.)

• Kesinlikle azalan: 2
• Sigara artan: 3
• ne: 1

açıklama

\d+
$*

Giriş birliğini çevirir.

A`\b(1+) 1\1

Buradaki regex artan bir ardışık sayı çifti ile eşleşir. Bu durumda, giriş açıkça artmaz olamaz. Bunu Abir "grep önleme" aşaması olarak ifade eder; bu, giriş çizgisinin atıldığı ve regex eşleşirse boş dizeyle değiştirildiği anlamına gelir.

S`\b$

Bu, yalnızca giriş atılmadığı takdirde girişe bir satır besleme eklemek için kullanılan bölünmüş bir aşamadır . Böylece şu ana kadar iki olası sonuç elde ettik: yükselen olmayan girdiler sonunda satır başı çekiyor ve diğerleri hala boş.

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

Son olarak, bu regex'in eşleşme sayısını sayarız. Düzenli ifade, aynı sayılarla eşleşir (ve daha sonra bu tür girişler için birden fazla eşleşmeyi önlemek için dizenin sonuna kadar olan her şey 1 1 1 1) veya "girişin sonu". Üç tür girdiden geçelim:

• Kesinlikle azalan: regex'in ilk kısmı eşleşemez, çünkü tüm değerler benzersizdir, fakat $eşleşir. Şimdi $değil tam "dizesi sonu". Ayrıca takip eden bir satır yeminin önünde de eşleşebilir. Bu yüzden aslında ondan iki eşleşme elde edeceğiz, biri girdi sonunda, diğeri de eklediğimiz satır beslemesinden sonra.
• Artan olmayan: şimdi regex'in ilk kısmı aynı zamanda bir eşleşme sağlar ve üç maç yaparız.
• Her ikisi de: girişi boş bir dizgeye çevirmeye özen gösterdiğimizi unutmayın, bu yüzden şimdi $yalnızca bir kez eşleşiyor.

Aksiyom, 114 bayt

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

Sonuçlar

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

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

Not: örneğin gibi bir eleman dizisini girmek a←1⍴3aksi:a←4 3 2 1

Yorumlama çıkışı:

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

Fikir: Orijinali sıralama dizisine göre karşılaştırarak monotoniğe karşı test edin, kaldırılmış kopyaları olan dizilere kıyasla artan olmayanları kontrol edin.

(Ve bence geliştirilebilir ...)

Haskell, 36 bayt

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

(+x)Çünkü haskell (-x), bölüm yerine bir değer olarak yanlış yorumluyor . Acaba tüm ifadenin karlı bir şekilde amaçsız yapılıp yapılamayacağını merak ediyorum.

LabVIEW, 12 düğüm, 18 tel = => sözleşmeye göre 48 bayt

Diğer kasa çerçevelerinde hiçbir fonksiyon gizlenmemiş, sadece bir tel.

Seylan, 86 bayt

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

İşlevi parametresi olarak girdi alır, ve sıfır veya bir Boolean bir demet döner - [false]için monoton katı azaltılması , [true]için monoton artmayan ama kesinlikle azalan olmayan , ve []için yukarıda Yok .

Bu şekilde kullanılabilir:

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

Çıktı:

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

Ungolfed ve yorumladı versiyonu:

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

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

Çok dümdüz, 1kesinlikle azalırsa, 2artmazsa ve nilaksi takdirde döner .

Ayrıca kaçınarak çalıştı applymakro yıllardan ile ~@ancak 43 karakter (bu sonuç en adil uzundur [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 bayt

O$>g$>=g

Tam program Giriş listesini komut satırı argümanları olarak alır. 11Kesin düşüş için çıktıları 01arttırmak için,00 için de .

Çevrimiçi deneyin!

açıklama

Bu yaklaşım işe yarıyor çünkü Pip'in Python'daki gibi karşılaştırma operatörleri birlikte zincir: C'deki (yanlış) 4>3>2olmak yerine doğru (4>3)>2. Ve karşılaştırma operatörleri $fold meta-operatörü ile değiştirildiğinde aynı davranış geçerli .

          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 bayt

-1"Monotonun kesinlikle azalmaması", 0"artmayan monoton " için çıktılar ve 1başkaları.

än rw g

Dene

1 bayt Oliver teşekkür kaydetti .

R , 34 bayt

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

Çevrimiçi deneyin!

Bağlantı Noktaları DJ'in MATL cevabı .

R, , 43 bayt

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

Çevrimiçi deneyin!

2Kesinlikle azaltmak için döndürür ,1 için olmayan artan ve 0aksi.

all(x==cummin(x))olduğu TRUE(dönüştürür1 aritmetik kullanıldığında), ancak ve ancak fkatı durum dahil olmak üzere bir artmayan.

all(diff(x)<0)olduğu TRUEyalnızca fkesinlikle azalıyor.