... но не надо быть строгим.

Учитывая непустой массив строго положительных целых чисел, определите, является ли это:

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

TryItOnline! или запустите все тесты

Возвращает: -1= монотонно строго убывает; 0= монотонно не увеличивается; 1= другие.

Как?

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

Perl 6 , 17 байт

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

• Монотонность строго уменьшается: 2
• Монотонно не увеличивается: 1
• Другие: 0

Expanded:

{            # 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 за монотонность строго уменьшается
• EQ для монотонных не увеличивается
• LT еще

compareсравнивает два числа и возвращает GT( EQ, LT), если первое число больше (равно, меньше) второго числа. zipWith compare<*>tailсравнивает соседние элементы. foldl min GTуменьшает список результатов сравнения с функцией мин , начиная с GT (примечание: LT< EQ< GT).

Изменить: @xnor найдено 2 3 байта. Благодарность!

Common Lisp, 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

который имеет max 0, потому что равенство существует.

Более короткий список автоматически расширяется с помощью 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 байт

Ошибка, исправленная Emigna, спасибо! Он использует тот же метод, что и 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]

Mathematica, 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 в противном случае.

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 отчасти невозможно, если вы не знаете язык, этот алгоритм в псевдокоде:

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

* в следующей памяти это стек, который начинается с бесконечного количества 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)
}

Funge!

Предыдущая версия, только 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)

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

Идея: проверить монотонность, сравнив исходный массив с отсортированным, проверить, не увеличивается ли он, сравнив массив с удаленными дублированиями.

(И я думаю, что это может быть улучшено ...)

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]для монотонного, не увеличивающегося, но не строго убывающего , и []для None из вышеперечисленного. .

Это можно использовать так:

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's MATL ответ .

R , 43 байта

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

Попробуйте онлайн!

Возвращает 2для строго убывающих, 1для нерастущих и 0других.

all(x==cummin(x))is TRUE(конвертируется в 1когда используется в арифметике) тогда и только тогда, когда fне увеличивается, включая строгий регистр.

all(diff(x)<0)это TRUEтолько тогда , когда fстрого убывает.