Vamos diminuir a monotonia

33

... 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
Luis Mendo
fonte
Escrever uma função variável (em que os valores de entrada não são agrupados em nenhum tipo de dado, mas todos são passados ​​diretamente para a função como argumentos) se enquadra em "qualquer formato razoável"?
Martin Ender
@ Martin Sim, faz!
Luis Mendo

Respostas:

9

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
Jonathan Allan
fonte
Diacrtic é Mparte de qualquer mapa de caracteres de 8 bits? Você não pode dizer que são 5 bytes porque não são. O CP1252 não possui, por exemplo.
Euri Pinhollow
2
O @EuriPinhollow Jelly usa essa página de código personalizada para contar bytes, que estão vinculados à palavra byteno cabeçalho desta postagem.
Fatalize 25/11/16
@Fatalize: thx, entendi.
Euri Pinhollow
22

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:« >= »」
}
Brad Gilbert b2gills
fonte
4
Perl é mágico
Fund Monica's Lawsuit
Isso pode ser estendido para trabalhar com qualquer tipo, se >foi alternado com aftere >=com !before. say {[after](@_)+[!before] @_}(<d c b a>) #=> 2
Brad Gilbert b2gills
13

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
DJMcMayhem
fonte
1
Você não pode anexar um em 0vez de anexar a última vantagem 1? Algo como0hdX>ZS
Luis Mendo
2
@LuisMendo Ah, isso é genial! Obrigado!
DJMcMayhem
Não ajuda, mas, para ofuscação, você também pode usar: 0hdX>0/- Pergunta para você e @LuisMendo: É possível aproveitar o fato de que a classificação é de apenas 1 caractere (ao contrário de X>), de alguma forma usando implicitamente o último valor?
Dennis Jaheruddin 25/11/16
@DennisJaheruddin Eu também pensei sobre o uso S, mas eu não encontrei uma maneira de torná-lo mais curto ...
Luis Mendo
9

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

Greg Martin
fonte
Vejo o DrMcMoylex me vencer por 7 minutos! :)
Greg Martin
2
"Eu sinto que deve existir alguma linguagem na qual esse algoritmo tenha 3 bytes" chat.stackexchange.com/transcript/message/33720906#33720906 :(
Martin Ender
7

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!

nimi
fonte
Você pode acrescentar um LT ao invés de 0?
Xnor
@xnor: Sim, obrigado, mas ele deve ser um GT, porque precisamos do mínimo da lista (eu tinha no máximo, o que estava errado e uma relíquia de uma versão inicial em que eu usei =<<em vez de <*>).
N
1
Entendo. Na verdade, que tal foldl min GT?
Xnor
6

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))
Omar
fonte
1
O mesmo número exato de bytes que (defun f(x)(mapcar'apply'(> >=)`(,x,x))). Observe que você pode apenas escrever (lambda(x)...)para ser mais curto.
Coredump #
6

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]

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.

xnor
fonte
Mesmo com a pouca Python Eu sei que eu posso apreciar o quão grande essa resposta é
Luis Mendo
5

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.
Fatalizar
fonte
4

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

Billywob
fonte
d=diff(scan());ifelse(all(d<=0),!prod(d),2)é 1 byte mais curto. Ele retorna 0 se monótono estritamente, 1 se monótono não aumenta e 2 se nenhum dos itens acima. Não tenho certeza se é permitido retornar nada se nenhuma das opções acima, mas você pode simplificar ainda mais d=diff(scan());if(all(d<=0))!prod(d).
JAD
Na verdade, d=diff(scan());if(all(d<=0))any(!d)é um byte melhor.
JAD
3

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.

Neil
fonte
3

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
Osable
fonte
1
®¸ì¥Z0.Scorrigiria o problema de elemento único.
Emigna
Bom obrigado! Eu acho que 0 no começo também funcionaria, já que todos os números são positivos (estritamente por padrão, eu acho).
Osable
Sim 0 iria funcionar tão bem, mas é bom que ele funciona para a entrada contendo 0 (mesmo que, por definição, não vai) :)
Emigna
Curiosidade: em francês "positivo" significa positivo ou zero e você deve especificar "estritamente positivo" para alcançar o mesmo significado que "positivo" em inglês.
Osable
3

Ruby, 37 bytes

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

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

GB
fonte
2

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.

Martin Ender
fonte
2

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))
Matthew Butterick
fonte
É uma pena que Racket não defina o caso da aridade >como verdadeiro. O Lisp comum acerta isso, mas falha ao definir o caso arity 0 (que também deve ser verdadeiro).
Omar
2

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.

Karl Napf
fonte
2

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))
Karl Napf
fonte
2

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

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

Experimente online!

Sygmei
fonte
sorted(s)[::-1]é mais curto para reverter uma lista classificada. No Python 3, você pode fazer {*a}para obter um conjunto dos elementos de a. sortedretorna uma lista para que você também não precise converter o conjunto em uma lista. Também adicionar booleanos é perfeitamente kosher! Finalmente, você pode enviar uma lambda anônima, para não precisar f=. Eu recebo 52 bytes no final. repl.it/E7eG/2
FryAmTheEggman
2

Befunge, 50 bytes

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

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@.$_<[email protected]_
- >:v  >^   >

Experimente online!

Leo
fonte
Receio que um final 0não conte como um formato de entrada válido. Eu acho que se enquadra na categoria "entrada pré-processada". De fato, algumas respostas acrescentam a 0no código (incluindo isso na contagem de bytes). Eu seria aceitável se você pudesse. Você pode substituir o 0por algum caractere não numérico? Isso seria aceitável
Luis Mendo
@LuisMendo Na verdade, com esse intérprete (que eu usei para desenvolver o código) o EOF retorna 0, então não há necessidade de adicionar nada à entrada. Não consegui descobrir qual deveria ser o comportamento pretendido, então não sei se essa suposição é padrão ou não. Uma coisa que eu posso ter interpretado mal, porém, é: os zeros podem fazer parte da sequência de entrada? Nesse caso, precisaria modificar o código de qualquer maneira.
Leo
Não, zeros não podem fazer parte da sequência (considerando uma matriz não vazia de números inteiros positivos - eu quis dizer números inteiros estritamente positivos). Mas algumas respostas usam um 0inserido pelo código para lidar com o caso em que a entrada possui apenas uma entrada. Essa é uma das razões pelas quais considero que incluir isso 0na entrada não é válido. De qualquer forma, se houver um intérprete que não seja necessário, você poderá usá-lo para provar que sua resposta é válida sem o 0. Se o intérprete do Try-it-online precisar disso 0, você poderá incluí-lo para fins de demonstração, com uma nota explicativa apropriada
Luis Mendo
@JamesHolderness enquanto estiver no tryonline ~ funciona como deveria e tem um comportamento estranho no EOF, aparentemente repetindo a última entrada para sempre. Veja aqui um exemplo
Leo
1
Eu editei a resposta usando a abordagem de James, agora a entrada é terminada por EOF
Leo
2

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
algoritmshark
fonte
2

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
hmmwhatsthisdo
fonte
2

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.
Martin Ender
fonte
1

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] 
RosLuP
fonte
1
Última atualização: 1 de maio de 2014
Luis Mendo
1

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

Roman Susi
fonte
Alterado para um número. Bytes aumentados em 2 ...
Roman Susi 25/11
1

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.

xnor
fonte
1

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

insira a descrição da imagem aqui

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

SRM
fonte
1

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];
Paŭlo Ebermann
fonte
1

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)]
NikoNyrh
fonte
1

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)
DLosc
fonte
1

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 .

Shaggy
fonte
@ Oliver, sim; caso contrário, o padrão será ... Espere, o que? Por que isso funciona ?! än mg rwretorna os resultados errados sem o, Jmas esse não é o caso än rw g. Esquisito.
Shaggy
1

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.

Giuseppe
fonte