... mas ei, não precisa ser rigoroso.

Dada uma matriz não vazia de números inteiros estritamente positivos, determine se é:

1. Monótono estritamente decrescente . Isso significa que cada entrada é estritamente menor que a anterior.
2. Monótono não aumenta, mas não diminui estritamente . Isso significa que cada entrada é menor ou igual à anterior e a matriz não se enquadra na categoria acima.
3. Nenhuma das opções acima .

Observe os seguintes casos de canto:

• Uma matriz com um único número é monótona diminuindo estritamente (de maneira vacuosa).
• Uma matriz com o mesmo número repetido é monotônica, não aumentando, mas não diminuindo estritamente.

Regras

Você pode fornecer um programa ou uma função

As entradas podem ser obtidas em qualquer formato razoável: array, lista, string com números separados por espaços, ...

Você pode escolher quaisquer três saídas consistentes para as três categorias, respectivamente. Por exemplo, as saídas podem ser números 0, 1, 2; ou strings 1 1, 1 0string vazia.

O menor código em bytes ganha

Casos de teste

Monotônico estritamente decrescente:

7 5 4 3 1
42 41
5

Monótono não crescente, mas não estritamente decrescente:

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

Nenhuma das acima:

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

Geléia , 10 9 5 bytes

Método encontrado por DrMcMoylex, dê algum crédito!

;0IṠṀ

TryItOnline! ou execute todos os testes

Retorna: -1= monótono estritamente decrescente; 0= monótono não crescente; 1= outro.

Quão?

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

Perl 6 , 17 bytes

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

• Monotônico estritamente decrescente: 2
• Monótono sem aumento: 1
• De outros: 0

Expandido:

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

MATL , 10 , 7 bytes

0hdX>ZS

Experimente online! ou verifique todos os casos de teste!

3 bytes salvos, graças a @LuisMendo!

As saídas são

• Estritamente decrescente: -1

• Sem aumento: 0

• Outro: 1

Explicação:

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

Função sem nome, levando uma lista de números como entrada. Retorna -1se a lista está estritamente diminuindo, 0se não está aumentando, mas não está estritamente diminuindo, e 1se não está.

Algoritmo bastante simples: pegue as diferenças de pares consecutivos, pegue o maior e faça o sinal desse maior.

(Eu sinto que deve existir alguma linguagem na qual esse algoritmo tenha 3 bytes ....)

Em relação a uma matriz com uma única entrada: Differencesgera uma lista vazia; Maxde uma lista vazia dá -∞(!); e Sign[-∞]avalia como -1(!!). Então, ele realmente funciona nesta caixa de canto. Às vezes tenho que amar o Mathematica. (De fato, a função também rotula corretamente uma lista vazia como estritamente decrescente.)

Haskell, 40 38 37 bytes

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

Devoluções

• GT para Monotone diminuindo estritamente
• EQ para monótonos sem aumento
• LT outro

comparecompara dois números e retorna GT( EQ, LT) se o primeiro número for maior que (igual a, menor que) o segundo número. zipWith compare<*>tailcompara elementos vizinhos. foldl min GTreduz a lista dos resultados da comparação com a função min começando com GT (nota: LT< EQ< GT).

Edit: @xnor encontrado 2 3 bytes. Obrigado!

Lisp comum, 43 40 bytes

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

Isso leva de entrada como uma lista Lisp, e retorna (T T), (NIL T)e (NIL NIL)para distinguir as 3 categorias. Aqui, ele está sendo executado nos casos de teste fornecidos:

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 diminuir estritamente, 0para diminuir fracamente, +1para não diminuir

Usando cmppara comparar elementos consecutivos e leva o máximo. Isso é feito removendo o primeiro elemento de uma cópia da lista e, em seguida, mapeando cmp. Por exemplo, l=[2,2,1]dá

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

que tem max0 porque existe uma igualdade.

A lista mais curta é automaticamente estendida com None, que é menor que todos os números e é inofensiva. Esse elemento fantasma também se isola de aceitar minuma lista vazia quando a entrada tiver comprimento 1.

Braquilog , 7 bytes

>,1|>=,

Experimente online!

Isso imprime 1para diminuir estritamente, 0para não aumentar e de false.outra forma.

Explicação

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

Outras soluções 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))

Lê a entrada do stdin e imprime o seguinte, dependendo da entrada:

Saída:

[1] FALSE TRUE: Monótono sem aumento

[1] TRUE FALSE: Monótono diminuindo estritamente

[1] FALSE FALSE: Nenhuma das acima

JavaScript (ES6), 51 bytes

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

Retorna 0 para decrescente estrito, 1 para não aumentar, 2 caso contrário.

05AB1E ,5 8 bytes

Bug corrigido por Emigna, obrigado! Ele usa o mesmo método que o 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

Experimente online!

A saída é:

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

Saída: [true,true], [true,false]ou[false,false]

Mathematica, 15 11 bytes

##>0|##>=0&

Essa é uma função variável, considerando todos os números inteiros de entrada como argumentos separados.

• Diminuindo estritamente: True | True
• Não crescente: False | True
• Nem: False | False

Note que |não é Or, mas Alternatives, que faz parte da sintaxe padrão de correspondência, o que explica por que essas expressões não se avaliou a True, True, False, respectivamente.

O código em si é principalmente uma aplicação desta dica . Por exemplo ##>0é Greater[##, 0]mas depois ##se expande para todos os valores da entrada para que obter algo parecido Greater[5, 3, 2, 0], o que em si significa 5>3>2>0.

Raquete , 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...);}

Retorna 3 (0b11) para redução estrita, 1 (0b01) para não aumento e 0 em caso contrário.

Ungolfed:

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

Eu pensei que este era um problema perfeito para as expressões dobráveis ​​do C ++ 17:

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

Infelizmente, ele não encadeia os operadores relacionais, mas

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

o que não é era desejado.

Python 2, 61 74 bytes

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

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

Requer entrada em forma de lista de colchetes, como [3,2,1]. Retorna 2 para decrescente estrito, 1 para não aumentar e 0 caso contrário.

Solução antiga:

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

Python 3, 81 52 bytes (Graças a FryAmTheEggMan )

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

Experimente online!

Befunge, 50 bytes

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

Experimente online!

Aceita entrada como uma sequência de int separada por espaços e retorna 0 se estritamente decrescente, 1 se não estritamente decrescente, 2 caso contrário.

Como ler befunge é meio impossível se você não conhece a linguagem, este é o algoritmo no 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())

* in befunge memory é uma pilha que começa com uma quantidade infinita de 0 nela. pop (), push (x), input () e output (x) são auto-explicativos, as outras pseudo-funções que eu usei funcionam assim:

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!

Versão anterior, apenas 41 bytes, mas inválida, pois requer um 0 para finalizar a sequência de entrada (ou usando um intérprete como este )

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

Experimente online!

J, 14 bytes

Verbo monádico, tomando a lista à direita, retornando 1para diminuir estritamente, 0para diminuir levemente e de _1outra forma.

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

Toma o sinal *do mínimo <./de diferenças consecutivas 2-/\da lista. J não troca a ordem das diferenças ao tomá-las, por exemplo, a sequência diminui estritamente se todas forem positivas. Notavelmente, <./retorna infinito positivo nas listas de elemento zero.

Em uso no REPL:

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

C, 68 67 bytes

Uma função fque recebe uma matriz de ints ( l) precedida por seu comprimento ( n, também um int). Retorna 3 se monótono estritamente diminuindo, 1 se monótono não aumentando, mas não estritamente diminuindo, 0 caso contrário.

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 ligeiramente para facilitar a leitura:

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

Reorganizados e comentados 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 teste (cortesia 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.*|$

Experimente online! (A primeira linha ativa um conjunto de testes separado por avanço de linha.)

• Diminuindo estritamente: 2
• Não crescente: 3
• Nem: 1

Explicação

\d+
$*

Converte a entrada unária.

A`\b(1+) 1\1

A regex aqui corresponde a um par crescente de números consecutivos. Se for esse o caso, a entrada claramente não pode aumentar. O Adenota como um estágio "anti-grep", o que significa que a linha de entrada é descartada e substituída pela sequência vazia, se o regex corresponder.

S`\b$

Este é um estágio dividido que é usado para anexar um avanço de linha à entrada apenas se a entrada não tiver sido descartada. Portanto, temos dois resultados possíveis até agora: entradas não crescentes obtêm um avanço de linha no final e outras ainda estão vazias.

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

Finalmente, contamos o número de correspondências desse regex. A regex corresponde a números idênticos (e depois tudo ao final da string para evitar várias correspondências desse tipo para entradas como 1 1 1 1) ou o "final da entrada". Vamos analisar os três tipos de entradas:

• Diminuindo estritamente: a primeira parte da regex não pode corresponder porque todos os valores são únicos, mas as $correspondências. Agora $não é exatamente "o fim da string". Também pode corresponder à frente de um avanço de linha à direita. Então, na verdade, obteremos duas correspondências, uma no final da entrada e outra após o avanço de linha que inserimos.
• Sem aumento: agora a primeira parte da regex também fornece uma correspondência e terminamos com três correspondências.
• Nenhum: lembre-se de que tomamos o cuidado de transformar a entrada em uma sequência vazia, portanto agora $corresponde apenas uma 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)

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

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: insira uma matriz de elementos como por exemplo a←1⍴3:a←4 3 2 1

Interpretando a saída:

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

Idéia: teste a monotonicidade comparando a matriz original com a classificada, verifique se não há aumento comparando a matriz com as duplicações removidas.

(E acho que pode ser melhorado ...)

Haskell, 36 bytes

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

(+x)é porque haskell interpreta mal (-x)como um valor em vez de uma seção. Eu me pergunto se toda a expressão pode ser lucrativa e sem sentido.

LabVIEW, 12 nós, 18 fios ==> 48 bytes por convenção

Nenhuma função oculta nos outros quadros do gabinete, apenas um único fio.

Ceilão, 86 bytes

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

A função pega a entrada como seus parâmetros e retorna uma tupla de zero ou um booleano - [false]para Monotone estritamente decrescente , [true]para Monotone não crescente, mas não estritamente decrescente , e []para Nenhuma das opções acima .

Pode ser usado assim:

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

Saída:

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

Uma versão não-gasta e 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))

Muito simples, retorna 1para se estiver estritamente diminuindo, 2se não estiver aumentando e de niloutra forma.

Também tentei evitar applycom macro, ~@mas é apenas mais longo em 43 caracteres (isso resulta em [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. Leva a lista de entrada como argumentos da linha de comando. Saídas 11para diminuir estritamente, 01para não aumentar, 00para nenhuma.

Experimente online!

Explicação

Essa abordagem funciona porque os operadores de comparação do Pip, como o do Python, se encadearam: 4>3>2são verdadeiros, em vez de serem (4>3)>2(falsos), como em C. E o mesmo comportamento ocorre quando os operadores de comparação são modificados com o $meta-operador fold.

          g is list of command-line args (implicit)
 $>g      Fold g on >
O         Output without newline
    $>=g  Fold g on >=
          Print (implicit)

Japonês , 9 8 7 bytes

Saídas -1para "monotonia estritamente decrescente", 0para "monotonia não incrementada" e 1outras.

än rw g

Tente

1 byte salvo graças a Oliver .

R , 34 bytes

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

Experimente online!

Portos resposta do MATL do DJ .

R , 43 bytes

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

Experimente online!

Retorna 2para diminuir estritamente, 1para não aumentar e de 0outra forma.

all(x==cummin(x))is TRUE(converte para 1quando usado em aritmética) se e somente se fnão aumentar, incluindo o caso estrito.

all(diff(x)<0)é TRUEsomente quando festá estritamente diminuindo.