... แต่เดี๋ยวก่อนไม่จำเป็นต้องเข้มงวด

รับอาร์เรย์ที่ไม่ว่างเปล่าของจำนวนเต็มบวกอย่างเคร่งครัดตรวจสอบว่าเป็น:

1. Monotone อย่างเคร่งครัดลดลง ซึ่งหมายความว่าแต่ละรายการจะน้อยกว่ารายการก่อนหน้าอย่างเคร่งครัด
2. Monotone ที่ไม่เพิ่มขึ้น แต่ไม่ได้ลดลงอย่างเคร่งครัด ซึ่งหมายความว่าแต่ละรายการมีค่าน้อยกว่าหรือเท่ากับก่อนหน้านี้และอาร์เรย์ไม่ได้อยู่ในหมวดหมู่ข้างต้น
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

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด!

บันทึก 3 ไบต์ด้วย @LuisMendo!

ผลที่ได้คือ

• ลดลงอย่างเคร่งครัด: -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 สำหรับ Monotone ลดลงอย่างเคร่งครัด
• EQ สำหรับ Monotone ที่ไม่เพิ่มขึ้น
• LT อื่น

compareเปรียบเทียบตัวเลขสองตัวและส่งคืนGT( EQ, LT) ถ้าตัวเลขตัวแรกมากกว่า (เท่ากับหรือน้อยกว่า) จำนวนที่สอง zipWith compare<*>tailเปรียบเทียบองค์ประกอบเพื่อนบ้าน foldl min GTลดรายการผลการเปรียบเทียบกับฟังก์ชั่นเริ่มต้นที่นาทีกับ GT (หมายเหตุ: LT< EQ< GT)

แก้ไข: @xnor พบ2 3 ไบต์ ขอบคุณ!

เสียงกระเพื่อมสามัญ43 40 ไบต์

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

นี้จะเข้าเป็นรายการที่ชัดและผลตอบแทน(T T), (NIL T)และ(NIL NIL)แยกเป็น 3 ประเภท ที่นี่มันทำงานในกรณีทดสอบที่ให้ไว้:

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เพื่อเปรียบเทียบองค์ประกอบที่ต่อเนื่องกันและใช้เวลาสูงสุด cmpนี้จะกระทำโดยการเอาองค์ประกอบแรกของหนึ่งสำเนาของรายการทำแผนที่แล้ว ตัวอย่างเช่นl=[2,2,1]ให้

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

ซึ่งมีmax0 เพราะมีความเสมอภาคอยู่

รายการสั้นจะถูกขยายโดยอัตโนมัติด้วย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 ไบต์

แก้ไขข้อผิดพลาดโดย Emigna ขอบคุณ! โดยจะใช้วิธีการเดียวกับ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

ลองออนไลน์!

ผลลัพธ์คือ:

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

Ruby, 37 ไบต์

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

ขาออก[true,true], [true,false]หรือ[false,false]

Mathematica, 15 11 ไบต์

##>0|##>=0&

นี่เป็นฟังก์ชั่น Variadic โดยรับค่าจำนวนเต็มอินพุตทั้งหมดเป็นอาร์กิวเมนต์แยกต่างหาก

• ลดลงอย่างเคร่งครัด: 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 เป็นอย่างอื่น

Ungolfed:

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

ซึ่งไม่เป็นที่ต้องการ

Python 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 นั้นเป็นไปไม่ได้ถ้าคุณไม่รู้ภาษานี่เป็นอัลกอริธึมใน 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())

* ในหน่วยความจำ befunge คือสแต็กซึ่งเริ่มต้นด้วยจำนวน 0 ที่ไม่สิ้นสุด pop (), push (x), input () และ output (x) เป็นแบบอธิบายตนเอง, pseudofunctions อื่น ๆ ที่ฉันใช้ทำงานเช่นนี้:

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!

รุ่นก่อนหน้าเพียง 41 ไบต์ แต่ไม่ถูกต้องเนื่องจากต้องใช้ 0 เพื่อยกเลิกลำดับการป้อนข้อมูล (หรือใช้ล่ามเช่นนี้ )

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

ลองออนไลน์!

J, 14 ไบต์

คำกริยา Monadic รับรายการทางด้านขวาส่งคืน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 ไบต์

ฟังก์ชั่นfซึ่งจะถูกส่งผ่านอาร์เรย์ของ ints ( l) นำหน้าด้วยความยาวของมัน ( nยังเป็น int) ส่งคืน 3 ถ้า monotone ลดลงอย่างเคร่งครัด 1 ถ้า monotone ไม่เพิ่มขึ้น แต่ไม่ลดลงอย่างเคร่งครัด 0 มิฉะนั้น

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

Un-golfed เล็กน้อยเพื่อความสะดวกในการอ่าน:

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

regex ตรงกับตัวเลขที่เพิ่มขึ้นต่อเนื่อง หากเป็นกรณีนี้อินพุตไม่สามารถเพิ่มได้อย่างชัดเจน Aหมายถึงว่ามันเป็น "ป้องกัน grep" เวทีซึ่งหมายความว่าสายการป้อนข้อมูลจะถูกยกเลิกและแทนที่ด้วยสตริงที่ว่างเปล่าถ้าตรงกับ regex

S`\b$

นี่คือสเตจแยกที่ใช้เพื่อผนวก linefeed เข้ากับอินพุตเฉพาะในกรณีที่อินพุตไม่ถูกละทิ้ง ดังนั้นเราจึงมีผลลัพธ์ที่เป็นไปได้สองประการจนถึงขณะนี้: อินพุตที่ไม่เพิ่มขึ้นจะได้รับการป้อนบรรทัดสุดท้ายและอื่น ๆ ยังคงว่างเปล่า

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

สุดท้ายเราก็นับจำนวนการแข่งขันของ regex นี้ regex จะจับคู่กับตัวเลขที่เหมือนกัน (จากนั้นทุกอย่างจะอยู่ที่ส่วนท้ายของสตริงเพื่อหลีกเลี่ยงการจับคู่แบบนี้สำหรับอินพุตเช่น1 1 1 1) หรือ "จุดสิ้นสุดของอินพุต" มาดูอินพุตสามประเภทกัน:

• การลดลงอย่างเข้มงวด: ส่วนแรกของ regex ไม่สามารถจับคู่ได้เนื่องจากค่าทั้งหมดไม่ซ้ำกัน แต่เป็นการ$จับคู่ ตอนนี้$ไม่ได้เป็น "จุดสิ้นสุดของสตริง" อย่างแน่นอน นอกจากนี้ยังสามารถจับคู่กับด้านหน้าของตัวป้อนบรรทัดต่อท้าย ดังนั้นเราจะได้รับการจับคู่สองรายการจากนั้นหนึ่งรายการที่ส่วนท้ายของอินพุตและอีกหนึ่งรายการหลังจากที่เราป้อนบรรทัด
• ไม่เพิ่มขึ้น: ตอนนี้ส่วนแรกของ regex ยังมีการแข่งขันและเราจบด้วยการแข่งขันสามครั้ง
• ไม่ใช่: จำไว้ว่าเราใช้ความระมัดระวังในการเปลี่ยนอินพุตให้เป็นสตริงว่างดังนั้นตอนนี้$จับคู่เพียงครั้งเดียว

ความจริง 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)

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

ผล

(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

หมายเหตุ: ป้อนหนึ่งองค์ประกอบอาร์เรย์เช่น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

แนวคิด: ทดสอบ monotonicity โดยการเปรียบเทียบต้นฉบับกับอาร์เรย์ที่เรียงลำดับตรวจสอบว่าไม่เพิ่มขึ้นโดยเปรียบเทียบกับอาร์เรย์ที่มีการทำซ้ำที่ถูกลบออก

(และฉันคิดว่ามันสามารถปรับปรุงได้ ... )

Haskell, 36 ไบต์

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

(+x)เป็นเพราะ haskell ตีความผิดพลาด(-x)เป็นค่าแทนส่วน ฉันสงสัยว่าการแสดงออกทั้งหมดสามารถทำกำไรอย่างไร้จุดหมายได้หรือไม่

LabVIEW, 12 โหนด, 18 สาย ==> 48 bytes ตามแบบแผน

ไม่มีฟังก์ชั่นที่ซ่อนอยู่ในกรอบเคสอื่น ๆ เพียงแค่วางสายเส้นเดียว

Ceylon, 86 ไบต์

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

ฟังก์ชั่นจะเข้าเป็นพารามิเตอร์ของตนและส่งกลับ tuple ของศูนย์หรือหนึ่ง booleans - การ[false]สำหรับMonotone อย่างเคร่งครัดลดลง , [true]สำหรับMonotone ที่ไม่เพิ่มขึ้น แต่ไม่เคร่งครัดลดลงและ[]สำหรับไม่มีการข้างต้น

มันสามารถใช้เช่นนี้:

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 chars (ผลลัพธ์นี้ใน[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 ไบต์

O$>g$>=g

โปรแกรมเต็มรูปแบบ รับรายการอินพุตเป็นอาร์กิวเมนต์บรรทัดรับคำสั่ง เอาท์พุท11สำหรับการลดลงอย่างเคร่งครัด01สำหรับที่ไม่เพิ่มขึ้น00สำหรับทั้ง

ลองออนไลน์!

คำอธิบาย

วิธีการนี้ใช้งานได้เนื่องจากตัวดำเนินการเปรียบเทียบของ Pip เช่น Python, chain กัน: 4>3>2เป็นจริงแทนที่จะเป็น(4>3)>2(false) ดังเช่นใน C และพฤติกรรมเดียวกันนี้จะเก็บเมื่อตัวดำเนินการเปรียบเทียบถูกแก้ไขด้วยตัวดำเนินการ$meta-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

ลองมัน

1 ไบต์บันทึกขอบคุณโอลิเวอร์

R , 34 ไบต์

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

ลองออนไลน์!

พอร์ตคำตอบ MATL ดีเจ

R , 43 ไบต์

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

ลองออนไลน์!

ผลตอบแทน2สำหรับการลดลงอย่างเคร่งครัด1สำหรับการไม่เพิ่มขึ้นและ0อื่น ๆ

all(x==cummin(x))คือTRUE(แปลงเป็น1เมื่อใช้ในการคำนวณ) ถ้าเพียง แต่ถ้าfไม่เพิ่มขึ้นรวมถึงตัวพิมพ์ใหญ่

all(diff(x)<0)เป็นTRUEเฉพาะเมื่อfจะลดลงอย่างเคร่งครัด