... ma hey, non c'è bisogno di essere severi.

Dato un array non vuoto di numeri interi assolutamente positivi, determinare se è:

1. Il monotono è in netto calo . Ciò significa che ogni voce è strettamente inferiore alla precedente.
2. Monotono non crescente, ma non strettamente decrescente . Ciò significa che ogni voce è inferiore o uguale alla precedente e l'array non rientra nella categoria precedente.
3. Nessuna delle precedenti .

Nota i seguenti casi angolari:

• Un array con un singolo numero è monotono in diminuzione rigorosamente (vacuamente).
• Un array con lo stesso numero ripetuto è monotono non crescente, ma non strettamente decrescente.

Regole

È possibile fornire un programma o una funzione

L'input può essere preso in qualsiasi formato ragionevole: array, elenco, stringa con numeri separati da spazi, ...

È possibile scegliere tre output coerenti rispettivamente per le tre categorie. Ad esempio, le uscite possono essere numeri 0, 1, 2; o stringhe 1 1, 1 0stringa vuota.

Vince il codice più breve in byte

Casi test

Monotono rigorosamente in calo:

7 5 4 3 1
42 41
5

Monotono non crescente, ma non strettamente decrescente:

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

Nessuno dei precedenti:

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

Gelatina , 10 9 5 byte

-Metodo trovato da DrMcMoylex, vai a dare credito!

;0IṠṀ

TryItOnline! oppure esegui tutti i test

Ritorni: -1= monotono rigorosamente decrescente; 0= monotono non crescente; 1= altro.

Come?

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

Perl 6 , 17 byte

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

• Monotono rigorosamente in calo: 2
• Monotono non crescente: 1
• Altro: 0

Allargato:

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

MATL , 10 , 7 byte

0hdX>ZS

Provalo online! o verifica tutti i casi di test!

3 byte salvati, grazie a @LuisMendo!

Le uscite sono

• Riduzione rigorosa: -1

• Non crescente: 0

• Altro: 1

Spiegazione:

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 byte

Sign@*Max@*Differences

Funzione senza nome che prende un elenco di numeri come input. Restituisce -1se l'elenco sta diminuendo rigorosamente, 0se non è in aumento ma non in modo rigoroso, e 1se non è nessuno dei due.

Algoritmo abbastanza semplice: prendi le differenze di coppie consecutive, prendi la più grande e prendi il segno di quella più grande.

(Sento che deve esistere un linguaggio in cui questo algoritmo è di 3 byte ....)

Per quanto riguarda un array con una singola voce: Differencesrestituisce un elenco vuoto; Maxdi una lista vuota dà -∞(!); e Sign[-∞]valuta -1(!!). Quindi funziona davvero su questo caso d'angolo. Devo amare Mathematica a volte. (In effetti, la funzione identifica correttamente anche un elenco vuoto come strettamente decrescente.)

Haskell, 40 38 37 byte

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

ritorna

• GT per Monotone in forte calo
• EQ per Monotone non crescente
• LT altro

compareconfronta due numeri e restituisce GT( EQ, LT) se il primo numero è maggiore di (uguale a, minore di) il secondo numero. zipWith compare<*>tailconfronta gli elementi vicini. foldl min GTriduce l'elenco dei risultati del confronto con la funzione min iniziano GT (nota: LT< EQ< GT).

Modifica: @xnor ha trovato 2 3 byte. Grazie!

Lisp comune, 43 40 byte

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

Questo richiede di ingresso come una lista Lisp, e ritorna (T T), (NIL T)e (NIL NIL)di distinguere le 3 categorie. Qui è in esecuzione sui casi di test forniti:

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 byte

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

-1per rigorosamente decrescente, 0per debolemente decrescente, +1per non decrescente

Usando cmpper confrontare elementi consecutivi e prende il massimo. Questo viene fatto rimuovendo il primo elemento di una copia dell'elenco, quindi il mapping cmp. Ad esempio, l=[2,2,1]dà

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

che ha max0 perché esiste un'uguaglianza.

L'elenco più breve viene automaticamente esteso con None, che è inferiore a tutti i numeri e quindi innocuo. Questo elemento fantasma isola anche dal prendere minun elenco vuoto quando l'input ha lunghezza 1.

Brachylog , 7 byte

>,1|>=,

Provalo online!

Questo stampa 1per decrescente rigoroso, 0per non crescente e false.altrimenti.

Spiegazione

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

Altre soluzioni da 7 byte

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

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

Legge l'input da stdin e stampa quanto segue a seconda dell'input:

Produzione:

[1] FALSE TRUE: Monotono non crescente

[1] TRUE FALSE: Monotono rigorosamente in calo

[1] FALSE FALSE: Nessuno dei precedenti

JavaScript (ES6), 51 byte

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

Restituisce 0 per decrescente rigorosa, 1 per non crescente, 2 altrimenti.

05AB1E ,5 8 byte

Bug risolto da Emigna, grazie! Utilizza lo stesso metodo di 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

Provalo online!

L'output è:

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

Rubino, 37 byte

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

Uscita: [true,true], [true,false]o[false,false]

Mathematica, 15 11 byte

##>0|##>=0&

Questa è una funzione variadica, prendendo tutti gli interi di input come argomenti separati.

• Riduzione rigorosa: True | True
• Non crescente: False | True
• Né: False | False

Nota che | non è Or, ma Alternatives, che fa parte della sintassi pattern matching, il che spiega il motivo per cui queste espressioni non vengono valutate per True, True, Falserispettivamente.

Il codice stesso è principalmente un'applicazione di questo suggerimento . Ad esempio ##>0è Greater[##, 0]ma poi si ##espande a tutti i valori di input in modo da ottenere qualcosa di simile Greater[5, 3, 2, 0], che a sua volta significa5>3>2>0 .

Racchetta , 44 byte

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

invocato:

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

Risultato:

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

C ++ 14, 85 byte

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

Restituisce 3 (0b11) per decrescente rigoroso, 1 (0b01) per non crescente e 0 in caso contrario.

Ungolfed:

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

Ho pensato che questo fosse un problema perfetto per le espressioni pieghevoli di C ++ 17:

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

Sfortunatamente non incatena gli operatori relazionali ma lo fa

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

che non è stato voluto.

Python 2, 61 74 byte

+13 byte per l'ingresso a singolo numero

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

Richiede input in forma di elenco parentesi come [3,2,1] . Restituisce 2 per decrescente rigorosa, 1 per non crescente e 0 in caso contrario.

Vecchia soluzione:

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

Python 3, 81 52 byte (grazie a FryAmTheEggMan )

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

Provalo online!

Befunge, 50 byte

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

Provalo online!

Accetta l'input come una sequenza di int separata da spazi e restituisce 0 se diminuisce rigorosamente, 1 se diminuisce non rigorosamente, 2 altrimenti.

Dato che leggere befunge è un po 'impossibile se non conosci la lingua, questo è l'algoritmo in pseudocodice:

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

* nella memoria di befunge è uno stack che inizia con una quantità infinita di 0 su di esso. pop (), push (x), input () e output (x) sono autoesplicativi, le altre pseudofunzioni che ho usato funzionano in questo modo:

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!

Versione precedente, solo 41 byte ma non valida poiché richiede uno 0 per terminare la sequenza di input (o utilizzando un interprete come questo )

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

Provalo online!

J, 14 byte

Verbo monadico che prende l'elenco a destra, ritornando 1per decrescente rigoroso, 0per decrescente debolmente, e _1altrimenti.

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

Prende il segno *del minimo <./delle differenze consecutive 2-/\dell'elenco. J non scambia l'ordine delle differenze quando le prende, ad es. La sequenza è strettamente decrescente se tutte sono positive. In particolare, <./restituisce l'infinito positivo sugli elenchi di elementi zero.

In uso presso il REPL:

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

C, 68 67 byte

Una funzione f, a cui viene passata una matrice di ints ( l) preceduta dalla sua lunghezza (n , anche un int). Restituisce 3 se la monotonia è in costante diminuzione, 1 se la monotono non è in aumento, ma non in modo rigorosamente decrescente, 0 in 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);}

Senza golf leggermente per leggibilità:

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

Riorganizzato e commentato per mostrare la logica:

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

Casi di test (cortesia 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 byte

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

Provalo online!(La prima riga abilita una suite di test separata da avanzamento riga.)

• Riduzione rigorosa: 2
• Non crescente: 3
• Né: 1

Spiegazione

\d+
$*

Converte l'input unario.

A`\b(1+) 1\1

La regex qui corrisponde a una coppia crescente di numeri consecutivi. In tal caso, l'ingresso non può chiaramente non essere in aumento. Lo Aindica come uno stadio "anti-grep", il che significa che la riga di input viene scartata e sostituita con la stringa vuota se il regex corrisponde.

S`\b$

Questo è uno stadio diviso che viene utilizzato per aggiungere un avanzamento di riga all'ingresso solo se l'ingresso non è stato scartato. Quindi finora abbiamo ottenuto due risultati possibili: input non crescenti ricevono un avanzamento di riga alla fine e altri sono ancora vuoti.

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

Infine, contiamo il numero di corrispondenze di questa regex. La regex corrisponde a numeri identici (e quindi tutto alla fine della stringa per evitare più corrispondenze di questo tipo per input come1 1 1 1 ), oppure la "fine dell'input". Esaminiamo i tre tipi di input:

• Riduzione rigorosa: la prima parte della regex non può corrispondere perché tutti i valori sono unici, ma le $corrispondenze. Adesso$ no esattamente "la fine della stringa". Può anche corrispondere davanti a un avanzamento di riga finale. Quindi avremo effettivamente due corrispondenze da esso, una alla fine dell'input e una dopo l'avanzamento della riga che abbiamo inserito.
• Non crescente: ora anche la prima parte del regex fornisce una corrispondenza e finiamo con tre partite.
• Né: ricorda che ci siamo preoccupati di trasformare l'input in una stringa vuota, quindi ora $corrisponde solo una volta.

Assioma, 114 byte

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

risultati

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

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

Nota: immettere un array di elementi come ad es. a←1⍴3Altrimenti:a←4 3 2 1

Interpretazione dell'output:

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

Idea: testare la monotonia confrontando l'array originale con quello ordinato, verificando che non sia crescente confrontando l'array con i duplicati rimossi.

(E penso che possa essere migliorato ...)

Haskell, 36 byte

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

(+x)è perché haskell interpreta in modo errato (-x)un valore anziché una sezione. Mi chiedo se l'intera espressione possa essere proficuamente resa inutile.

LabVIEW, 12 nodi, 18 fili ==> 48 byte per convenzione

Nessuna funzione nascosta negli altri frame del case, solo un singolo filo attraverso.

Ceylon, 86 byte

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

La funzione accetta l'input come parametro e restituisce una tupla pari a zero o uno booleano: [false]per Monotone strettamente decrescente , [true]per Monotone non crescente, ma non strettamente decrescente , e []per Nessuno dei precedenti .

Può essere usato in questo modo:

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

Produzione:

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

Una versione non modificata e commentata:

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

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

Molto diretto, ritorna 1per se strettamente in calo, 2se non in aumento e in nilaltro modo.

Ho anche provato a evitarlo applycon le macro ~@ma è solo più lungo con 43 caratteri (questo si traduce in [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 byte

O$>g$>=g

Programma completo. Prende l'elenco di input come argomenti della riga di comando. Uscite 11per riduzione rigorosa, 01per non aumento,00 per nessuno dei due.

Provalo online!

Spiegazione

Questo approccio funziona perché gli operatori di confronto di Pip, come Python, si uniscono insieme: 4>3>2è vero, piuttosto che essere (4>3)>2(falso) come in C. E lo stesso comportamento vale quando gli operatori di confronto vengono modificati con il $meta-operatore fold.

          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 byte

Uscite -1per "monotono decrescente", 0per "monotono non in aumento" e in 1altro modo.

än rw g

Provalo

1 byte salvato grazie a Oliver .

R , 34 byte

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

Provalo online!

Porta la risposta MATL di DJ .

R , 43 byte

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

Provalo online!

ritorna 2 per decrescente, 1per non crescente e in 0altro modo.

all(x==cummin(x)) è TRUE (converte in 1quando usato in aritmetica) se e solo sef non è in aumento, incluso il caso rigoroso.

all(diff(x)<0)è TRUEsolo quando fsta diminuendo rigorosamente.