... але ей, не потрібно бути суворим.

Давши не порожній масив суворопозитивних цілих чисел, визначте, чи це:

1. Монотона суворо зменшується . Це означає, що кожен запис суворо менше попереднього.
2. Монотонне не збільшується, але не суворо зменшується . Це означає, що кожен запис є меншим або рівним попередньому, а масив не потрапляє у вищевказану категорію.
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ṠṀ

СпробуйтеItOnline! або запустити всі тести

Повертає: -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

Математика, 22 байти

Sign@*Max@*Differences

Безіменна функція, що приймає список чисел як вхід. Повертається, -1якщо список суттєво зменшується, 0якщо він не збільшується, але не суворо зменшується, і 1якщо він не є жодним.

Досить простий алгоритм: візьміть відмінності послідовних пар, візьміть найбільшу і візьміть знак цієї найбільшої.

(Я відчуваю, що повинна існувати мова, якою цей алгоритм є 3 байти ....)

Щодо масиву з одним записом: Differencesвидає порожній список; Maxпорожнього списку дає -∞(!); і Sign[-∞]оцінює -1(!!). Так це насправді працює на цьому кутовому випадку. Іноді треба любити Математику. (Дійсно, функція також правильно позначає порожній список як суворо зменшений.)

Haskell, 40 38 37 байт

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

Повертається

• GT для Монотону суворо зменшується
• EQ для монотону, що не збільшується
• 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)))

Це сприймає дані як список Lisp, і повертає (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.

Брахілог , 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]

Математика, 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)...

чого не шукали.

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 є неможливим, якщо ви не знаєте мови, це алгоритм у псевдокоді:

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 memory - це стек, який починається з нескінченної кількості 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 байт

Функція f, якій передається масив ints ( l), що передує її довжині ( n, також int). Повертає 3, якщо монотонна суворо зменшується, 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позначає його як «анти-ГРЕП» стадія , що означає , що вхідна лінія викидається і замінюється на порожній рядку , якщо регулярний вираз відповідає.

S`\b$

Це розділена стадія, яка використовується для додавання стрічки передачі до входу, лише якщо вхід не був відкинутий. Таким чином, у нас є два можливі результати поки що: що збільшуються вхідні дані отримують зворотну передачу в кінці, а інші все ще порожні.

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

Нарешті, ми підраховуємо кількість збігів цього регулярного виразу. Регекс відповідає або однаковим числам (а потім все до кінця рядка, щоб уникнути декількох відповідностей такого типу для входів типу 1 1 1 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

Примітка: введіть один масив елементів, наприклад, 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 байт за домовленістю

Ніяких функцій, прихованих в інших корпусах, лише один провід поперек.

Цейлон, 86 байт

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

Функція приймає вхідні дані як свої параметри і повертає кортеж нульового або одного булевих значень - [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, з’єднуються між собою: 4>3>2вірно, а не (4>3)>2(помилково), як у C. І така ж поведінка дотримується, коли оператори порівняння модифікуються зі $складеним метаоператором.

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

Спробуйте в Інтернеті!

Порт DJ відповідь 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суворо зменшується.