... pero bueno, no es necesario ser estricto.

Dada una matriz no vacía de enteros estrictamente positivos, determine si es:

1. Monótono estrictamente decreciente . Esto significa que cada entrada es estrictamente menor que la anterior.
2. Monótono no creciente, pero no estrictamente decreciente . Esto significa que cada entrada es menor o igual que la anterior, y la matriz no cae en la categoría anterior.
3. Ninguna de las anteriores .

Tenga en cuenta los siguientes casos de esquina:

• Una matriz con un solo número es monótono estrictamente decreciente (de manera muy vaga).
• Una matriz con el mismo número repetido es monótona, no aumenta, pero no disminuye estrictamente.

Reglas

Puede proporcionar un programa o una función

La entrada se puede tomar en cualquier formato razonable: matriz, lista, cadena con números separados por espacios, ...

Puede elegir tres salidas consistentes para las tres categorías respectivamente. Por ejemplo, las salidas pueden ser números 0, 1, 2; o cadenas 1 1, 1 0cadena vacía.

El código más corto en bytes gana

Casos de prueba

Monótono estrictamente decreciente:

7 5 4 3 1
42 41
5

Monótono que no aumenta, pero no disminuye estrictamente:

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

Ninguna de las anteriores:

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

Jalea , 10 9 5 bytes

-Método encontrado por DrMcMoylex, ¡ve a dar crédito!

;0IṠṀ

TryItOnline! o ejecutar todas las pruebas

Devuelve: -1= monótono estrictamente decreciente; 0= monótono no creciente; 1= otro.

¿Cómo?

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

Perl 6 , 17 bytes

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

• Monótono estrictamente decreciente: 2
• Monótono no creciente: 1
• Otro: 0

Expandido:

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

MATL , 10 , 7 bytes

0hdX>ZS

Pruébalo en línea! o verificar todos los casos de prueba!

¡3 bytes guardados, gracias a @LuisMendo!

Las salidas son

• Estrictamente decreciente: -1

• No creciente: 0

• Otro: 1

Explicación:

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 bytes

Sign@*Max@*Differences

Función sin nombre que toma una lista de números como entrada. Devuelve -1si la lista está disminuyendo estrictamente, 0si no aumenta pero no disminuye estrictamente, y 1si no lo es.

Algoritmo bastante simple: tome las diferencias de pares consecutivos, tome el más grande y tome el signo de ese par más grande.

(Siento que debe existir algún lenguaje en el que este algoritmo sea de 3 bytes ...)

Con respecto a una matriz con una sola entrada: Differencesproduce una lista vacía; Maxde una lista vacía da -∞(!); y Sign[-∞]evalúa a -1(!!). Entonces, en realidad funciona en este caso de esquina. Tengo que amar a Mathematica a veces. (De hecho, la función también etiqueta correctamente una lista vacía como estrictamente decreciente).

Haskell, 40 38 37 bytes

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

Devoluciones

• GT para Monotono estrictamente decreciente
• EQ para monótono no creciente
• LT más

comparecompara dos números y devuelve GT( EQ, LT) si el primer número es mayor que (igual que, menor que) el segundo número. zipWith compare<*>tailcompara elementos vecinos. foldl min GTreduce la lista de los resultados de la comparación con la función min comenzando con GT (nota: LT< EQ< GT).

Editar: @xnor encontró 2 3 bytes. ¡Gracias!

Lisp común, 43 40 bytes

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

Esto toma la entrada como una lista de Lisp, y devuelve (T T), (NIL T)y (NIL NIL)para distinguir las 3 categorías. Aquí se ejecuta en los casos de prueba proporcionados:

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 bytes

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

-1para disminuir estrictamente, 0para disminuir débilmente, +1para no disminuir

Utilizando cmppara comparar elementos consecutivos, y toma el máximo. Esto se hace eliminando el primer elemento de una copia de la lista y luego asignando cmp. Por ejemplo, l=[2,2,1]da

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

que tiene max0 porque existe una igualdad.

La lista más corta se amplía automáticamente con None, que es menor que todos los números y es inofensiva. Este elemento fantasma también aísla contra la toma minde una lista vacía cuando la entrada tiene longitud 1.

Brachylog , 7 bytes

>,1|>=,

Pruébalo en línea!

Esto se imprime 1para disminuir estrictamente, 0para no aumentar y de false.otra manera.

Explicación

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

Otras soluciones de 7 bytes

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

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

Lee la entrada de stdin e imprime lo siguiente según la entrada:

Salida:

[1] FALSE TRUE: Monótono no creciente

[1] TRUE FALSE: Monótono estrictamente decreciente

[1] FALSE FALSE: Ninguna de las anteriores

JavaScript (ES6), 51 bytes

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

Devuelve 0 para disminución estricta, 1 para no aumento, 2 de lo contrario.

05AB1E ,5 5 8 bytes

Error solucionado por Emigna, gracias! Utiliza el mismo método que el de 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

Pruébalo en línea!

Salida es:

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

Ruby, 37 bytes

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

Salida: [true,true], [true,false]o[false,false]

Mathematica, 15 11 bytes

##>0|##>=0&

Esta es una función variada, que toma todos los enteros de entrada como argumentos separados.

• Estrictamente decreciente: True | True
• No creciente: False | True
• Ninguno: False | False

Tenga en cuenta que |no es Orsino Alternatives, lo que es parte de la sintaxis de coincidencia de patrones, lo que explica por qué estas expresiones no se evalúan a True, True, False, respectivamente.

El código en sí es principalmente una aplicación de este consejo . Por ejemplo ##>0es Greater[##, 0]pero luego ##se expande a todos los valores de la entrada, así que conseguir algo así Greater[5, 3, 2, 0], que a su vez significa 5>3>2>0.

Raqueta , 44 bytes

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

Invocado:

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

Resultado:

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

C ++ 14, 85 bytes

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

Devuelve 3 (0b11) para disminuir estrictamente, 1 (0b01) para no aumentar y 0 en caso contrario.

Sin golf:

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

Pensé que este era un problema perfecto para las expresiones plegables de C ++ 17:

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

Desafortunadamente, no encadena a los operadores relacionales pero sí

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

lo que no se quería.

Python 2, 61 74 bytes

+13 bytes para la entrada de número único

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

Requiere entrada en forma de lista de paréntesis como [3,2,1]. Devuelve 2 para disminución estricta, 1 para no aumento y 0 en caso contrario.

Vieja solución:

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

Python 3, 81 52 bytes (Gracias a FryAmTheEggMan )

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

Pruébalo en línea!

Befunge, 50 bytes

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

Pruébalo en línea!

Acepta la entrada como una secuencia de int separada por espacios, y devuelve 0 si disminuye estrictamente, 1 si disminuye no estrictamente, 2 de lo contrario.

Dado que leer befunge es imposible si no conoce el idioma, este es el algoritmo en pseudocódigo:

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

* en la memoria befunge hay una pila que comienza con una cantidad infinita de 0. pop (), push (x), input () y output (x) se explican por sí mismos, las otras pseudofunciones que utilicé funcionan así:

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ón anterior, solo 41 bytes pero no válida ya que requiere un 0 para terminar la secuencia de entrada (o usar un intérprete como este )

&:  >&:|>:0`|
1\v@.$_<[email protected]_
- >:v  >^   >

Pruébalo en línea!

J, 14 bytes

El verbo monádico toma la lista de la derecha, regresa 1para disminuir estrictamente, 0para disminuir débilmente y de _1otra manera.

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

Toma el signo *del mínimo <./de diferencias consecutivas 2-/\de la lista. J no cambia el orden de las diferencias al tomarlas, por lo que la secuencia está disminuyendo estrictamente si todas son positivas. En particular, <./devuelve infinito positivo en las listas de elementos cero.

En uso en REPL:

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

C, 68 67 bytes

Una función f, a la que se le pasa una matriz de ints ( l) precedida por su longitud ( n, también un int). Devuelve 3 si el tono monótono disminuye estrictamente, 1 si el tono monótono no aumenta, pero no disminuye estrictamente, 0 en caso contrario.

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

Sin golf ligeramente para facilitar la lectura:

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

Reorganizado y comentado para mostrar lógica:

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

Casos de prueba (cortesía de 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

Retina , 41 bytes

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

Pruébalo en línea! (La primera línea habilita un conjunto de pruebas separado por salto de línea).

• Estrictamente decreciente: 2
• No creciente: 3
• Ninguno: 1

Explicación

\d+
$*

Convierte la entrada unaria.

A`\b(1+) 1\1

La expresión regular aquí coincide con un par creciente de números consecutivos. Si este es el caso, la entrada claramente no puede ser no creciente. La Adenota como una etapa "anti-grep", lo que significa que la línea de entrada se descarta y se reemplaza con la cadena vacía si la expresión regular coincide.

S`\b$

Esta es una etapa dividida que se utiliza para agregar un salto de línea a la entrada solo si la entrada no se descartó. Así que tenemos dos resultados posibles hasta ahora: las entradas que no aumentan obtienen un salto de línea al final y otras aún están vacías.

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

Finalmente, contamos el número de coincidencias de esta expresión regular. La expresión regular coincide con números idénticos (y luego todo hasta el final de la cadena para evitar múltiples coincidencias de este tipo para entradas como 1 1 1 1), o el "final de la entrada". Veamos los tres tipos de entradas:

• Estrictamente decreciente: la primera parte de la expresión regular no puede coincidir porque todos los valores son únicos, pero las $coincidencias. Ahora $no es exactamente "el final de la cadena". También puede coincidir frente a un salto de línea final. Así que en realidad obtendremos dos coincidencias, una al final de la entrada y otra después del salto de línea que insertamos.
• No aumenta: ahora la primera parte de la expresión regular también proporciona una coincidencia, y terminamos con tres coincidencias.
• Tampoco: recuerde que nos encargamos de convertir la entrada en una cadena vacía, por lo que ahora $solo coincide una vez.

Axioma, 114 bytes

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)

Sin golf

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

Resultados

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

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

Nota: ingrese una matriz de elementos como por ejemplo a←1⍴3:a←4 3 2 1

Interpretación de salida:

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

Idea: pruebe la monotonicidad comparando la matriz original con la ordenada, verifique que no aumente comparando la matriz con las duplicaciones eliminadas.

(Y creo que se puede mejorar ...)

Haskell, 36 bytes

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

(+x)es porque haskell interpreta mal (-x)como un valor en lugar de una sección. Me pregunto si toda la expresión se puede hacer rentable sin puntos.

LabVIEW, 12 nodos, 18 cables ==> 48 bytes por convención

No hay funciones ocultas en los otros marcos de casos, solo un cable de ancho.

Ceilán, 86 bytes

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

La función toma la entrada como sus parámetros y devuelve una tupla de cero o uno booleanos: [false]para Monotono estrictamente decreciente , [true]para Monotono no creciente, pero no estrictamente decreciente , y []para Ninguno de los anteriores .

Se puede usar así:

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

Salida:

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

Una versión no comentada y comentada:

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

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

Muy sencillo, devuelve 1si está disminuyendo estrictamente, 2si no aumenta y de nilotra manera.

También intenté evitar applycon macros, ~@pero solo es más largo con 43 caracteres (esto da como resultado [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 bytes

O$>g$>=g

Programa completo Toma la lista de entrada como argumentos de línea de comandos. Salidas 11para disminuir estrictamente, 01para no aumentar, 00para ninguno.

Pruébalo en línea!

Explicación

Este enfoque funciona porque los operadores de comparación de Pip, como Python, encadenan juntos: 4>3>2es verdadero, en lugar de ser (4>3)>2(falso) como en C. Y el mismo comportamiento se cumple cuando los operadores de comparación se modifican con el $metaoperador de plegado.

          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 bytes

Salidas -1para "monótono estrictamente decreciente", 0para "monótono no creciente" y de 1otro modo.

än rw g

Intentalo

1 byte guardado gracias a Oliver .

R , 34 bytes

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

Pruébalo en línea!

Puertos DJ's MATL respuesta .

R , 43 bytes

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

Pruébalo en línea!

Devoluciones 2por estrictamente decreciente, 1por no aumentar, y de 0otra manera.

all(x==cummin(x))es TRUE(se convierte a 1cuando se usa en aritmética) si y solo si fno aumenta, incluido el caso estricto.

all(diff(x)<0)es TRUEsolo cuando festá disminuyendo estrictamente.