... ale hej, nie trzeba być surowym.

Biorąc pod uwagę niepustą tablicę ściśle dodatnich liczb całkowitych, określ, czy jest to:

1. Monotonia ściśle maleje . Oznacza to, że każdy wpis jest ściśle mniejszy niż poprzedni.
2. Monotonia nie wzrasta, ale nie ściśle maleje . Oznacza to, że każda pozycja jest mniejsza lub równa poprzedniej, a tablica nie należy do powyższej kategorii.
3. Żadne z powyższych .

Zwróć uwagę na następujące przypadki narożne:

• Tablica z pojedynczą liczbą jest monotoniczna, a jej wartość maleje (próżniowo).
• Tablica z tą samą liczbą powtórzeń jest monotoniczna, nie wzrasta, ale nie zmniejsza się ściśle.

Zasady

Możesz podać program lub funkcję

Dane wejściowe można przyjmować w dowolnym rozsądnym formacie: tablica, lista, ciąg znaków z liczbami oddzielonymi spacjami, ...

Możesz wybrać dowolne trzy spójne wyniki odpowiednio dla trzech kategorii. Na przykład, wyniki mogą być liczbami 0, 1, 2; lub ciągi 1 1, 1 0, pusty łańcuch.

Najkrótszy kod w bajtach wygrywa

Przypadki testowe

Monotonia ściśle maleje:

7 5 4 3 1
42 41
5

Monotonia nie wzrasta, ale nie zmniejsza się ściśle:

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

Żadne z powyższych:

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

Galaretka , 10 9 5 bajtów

-Metoda znaleziona przez DrMcMoylex, idź, daj kredyt!

;0IṠṀ

TryItOnline! lub uruchom wszystkie testy

Zwraca: -1= monotonicznie ściśle maleje; 0= monotoniczny nie rosnący; 1= inny

W jaki sposób?

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

Perl 6 , 17 bajtów

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

• Monotonia ściśle maleje: 2
• Monotoniczny nie rosnący: 1
• Inny: 0

Rozszerzony:

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

MATL , 10 , 7 bajtów

0hdX>ZS

Wypróbuj online! lub zweryfikuj wszystkie przypadki testowe!

3 bajty zapisane dzięki @LuisMendo!

Wyjściami są

• Ściśle malejące: -1

• Bez wzrostu: 0

• Inne: 1

Wyjaśnienie:

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 bajty

Sign@*Max@*Differences

Nienazwana funkcja przyjmuje listę liczb jako dane wejściowe. Zwraca, -1jeśli lista ściśle się zmniejsza, 0jeśli nie rośnie, ale nie zmniejsza się ściśle, a 1jeśli nie jest żadna.

Całkiem prosty algorytm: weź różnice między kolejnymi parami, weź największą i weź znak tej największej.

(Wydaje mi się, że musi istnieć jakiś język, w którym ten algorytm ma 3 bajty ....)

W odniesieniu do tablicy z jednym wpisem: Differenceszwraca pustą listę; Maxpustej listy daje -∞(!); i Sign[-∞]ocenia na -1(!!). Tak naprawdę to działa w tym przypadku rogu. Czasami kocham Mathematica. (Rzeczywiście, funkcja poprawnie określa również pustą listę jako ściśle malejącą).

Haskell, 40 38 37 bajtów

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

Zwroty

• GT dla Monotone ściśle maleje
• EQ dla monotonu nie wzrasta
• LT jeszcze

compareporównuje dwie liczby i zwraca GT( EQ, LT), jeśli pierwsza liczba jest większa niż (równa, mniejsza niż) druga liczba. zipWith compare<*>tailporównuje elementy sąsiadów. foldl min GTZmniejsza to wykaz wyników porównania z funkcją min począwszy od GT (uwaga: LT< EQ< GT).

Edycja: @ xnor znaleziono 2 3 bajty. Dzięki!

Common Lisp, 43 40 bajtów

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

Trwa to wejście jako lista Lisp i powraca (T T), (NIL T)i (NIL NIL)aby wyróżnić 3 kategorie. Tutaj działa na podanych przypadkach testowych:

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 bajtów

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

-1za ściśle malejące, 0za słabo malejące, +1za nie malejące

Używając cmpdo porównywania kolejnych elementów i bierze maksimum. Odbywa się to poprzez usunięcie pierwszego elementu jednej kopii listy, a następnie mapowanie cmp. Na przykład l=[2,2,1]daje

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

która ma max0, ponieważ istnieje równość.

Krótsza lista jest automatycznie przedłużana o None, która jest mniejsza niż wszystkie liczby, a więc nieszkodliwa. Ten element fantomowy izoluje również od pobrania minpustej listy, gdy wejście ma długość 1.

Brachylog , 7 bajtów

>,1|>=,

Wypróbuj online!

Wydruki są 1ściśle malejące, 0nie rosnące i false.inne.

Wyjaśnienie

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

Inne 7 bajtowe rozwiązania

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

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

Odczytuje dane wejściowe ze standardowego wejścia i drukuje następujące informacje w zależności od danych wejściowych:

Wydajność:

[1] FALSE TRUE: Monotoniczny nie rośnie

[1] TRUE FALSE: Monotonia ściśle maleje

[1] FALSE FALSE: Żadne z powyższych

JavaScript (ES6), 51 bajtów

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

Zwraca 0 dla ścisłego zmniejszania, 1 dla niewrastającego, 2 w przeciwnym razie.

05AB1E ,5 8 bajtów

Błąd naprawiony przez Emignę, dzięki! Wykorzystuje tę samą metodę, co 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

Wypróbuj online!

Dane wyjściowe to:

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

Rubinowy, 37 bajtów

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

Wyjście: [true,true], [true,false]lub[false,false]

Mathematica, 15 11 bajtów

##>0|##>=0&

Jest to funkcja variadic, biorąc wszystkie liczby całkowite wejściowe za osobne argumenty.

• Ściśle malejące: True | True
• Nie rośnie: False | True
• Ani: False | False

Zauważ, że |nie jest Or, ale Alternatives, co jest częścią składni dopasowania wzorca, co wyjaśnia, dlaczego te wyrażenia nie daj się ocenić na True, True, False, odpowiednio.

Sam kod jest głównie zastosowaniem tej wskazówki . Na przykład ##>0jest, Greater[##, 0]ale następnie ##rozwija się do wszystkich wartości wejściowych, więc otrzymujemy coś podobnego Greater[5, 3, 2, 0], co samo w sobie oznacza 5>3>2>0.

Rakieta , 44 bajty

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

Wywołano:

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

Wynik:

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

C ++ 14, 85 bajtów

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

Zwraca 3 (0b11) dla ścisłego zmniejszania, 1 (0b01) dla niewrastającego i 0 w przeciwnym razie.

Nie golfowany:

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

Pomyślałem, że to idealny problem dla wyrażeń składanych w C ++ 17:

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

Niestety nie łączy łańcuchów operatorów relacyjnych, ale tak

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

co nie było potrzebne.

Python 2, 61 74 bajtów

+13 bajtów dla wprowadzenia pojedynczej liczby

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

Wymaga wprowadzenia w formie listy nawiasów jak [3,2,1]. Zwraca 2 dla ścisłego zmniejszania, 1 dla niewrastającego i 0 w przeciwnym razie.

Stare rozwiązanie:

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

Python 3, 81 52 bajtów (Dzięki FryAmTheEggMan )

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

Wypróbuj online!

Befunge, 50 bajtów

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

Wypróbuj online!

Akceptuje dane wejściowe jako sekwencję liczb całkowitych oddzielonych spacjami i zwraca 0, jeśli ściśle maleje, 1, jeśli nie ściśle maleje, 2 w przeciwnym razie.

Ponieważ czytanie befunge jest trochę niemożliwe, jeśli nie znasz języka, jest to algorytm w pseudokodzie:

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

* w pamięci befunge znajduje się stos, który zaczyna się od nieskończonej ilości 0 na nim. pop (), push (x), input () i output (x) są oczywiste, pozostałe używane przez nas pseudo-funkcje działają w następujący sposób:

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

Fajnie!

Poprzednia wersja, zaledwie 41 bajtów, ale nieważne, ponieważ wymaga się od 0 do zakończenia sekwencji wejściowej (lub za pośrednictwem tłumacza, jak ten )

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

Wypróbuj online!

J, 14 bajtów

Czasownik monadyczny, biorąc listę po prawej stronie, wracając 1do ściśle malejącego, 0dla słabo malejącego, i _1inaczej.

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

Staje się znakiem *minimum <./następujących po sobie różnic2-/\ na liście. J nie zmienia kolejności różnic podczas ich przyjmowania, więc np. Sekwencja ściśle maleje, jeśli wszystkie są dodatnie. Warto zauważyć, że <./zwraca pozytywny nieskończoność na listach zero elementów.

W użyciu w REPL:

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

C, 68 67 bajtów

Funkcja f, która jest przekazywana do tablicy ints ( l) poprzedzonej jej długością ( nrównież int). Zwraca 3, jeśli monotonicznie ściśle maleje, 1, jeśli monotonicznie nie rośnie, ale nie ściśle maleje, 0 w przeciwnym razie.

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

Nie grał lekko w golfa dla czytelności:

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

Zmieniono układ i skomentowano, aby pokazać logikę:

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

Przypadki testowe (dzięki uprzejmości 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

Siatkówka , 41 bajtów

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

Wypróbuj online! (Pierwszy wiersz włącza pakiet testowy oddzielony od linii).

• Ściśle malejące: 2
• Nie rośnie: 3
• Ani: 1

Wyjaśnienie

\d+
$*

Konwertuje wejście unary.

A`\b(1+) 1\1

Wyrażenie regularne tutaj dopasowuje rosnącą parę kolejnych liczb. W takim przypadku nakłady nie mogą wyraźnie wzrosnąć. W Aoznacza je jako „anty-grep” etap co oznacza, że linia wejścia jest odrzucane i zastępowane przez puste jeśli wyrażenia regularnego dopasowania.

S`\b$

Jest to etap rozłam, który służy do dołączania wysuw do wejścia tylko wtedy, gdy dane wejściowe nie zostały odrzucone. Mamy więc do tej pory dwa możliwe wyniki: nie zwiększające się dane wejściowe otrzymują na końcu linię, a inne są nadal puste.

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

Na koniec zliczamy liczbę dopasowań tego wyrażenia regularnego. Wyrażenie regularne albo pasuje do identycznych liczb (a następnie wszystkiego na końcu ciągu, aby uniknąć wielu dopasowań tego rodzaju dla danych wejściowych takich jak1 1 1 1 ), lub „na końcu danych wejściowych”. Przejdźmy przez trzy typy danych wejściowych:

• Ściśle maleje: pierwsza część wyrażenia regularnego nie może się zgadzać, ponieważ wszystkie wartości są unikalne, ale $pasują. Teraz $nie jest dokładnie „koniec łańcucha”. Może również pasować przed końcowym podawaniem linii. Tak więc otrzymamy z niego dwa dopasowania, jeden na końcu wejścia, a drugi po wstawionym wierszu.
• Nie rośnie: teraz pierwsza część wyrażenia regularnego zapewnia dopasowanie, a my kończymy na trzech dopasowaniach.
• Żadne: pamiętaj, że zadbaliśmy o to, aby zmienić dane wejściowe w pusty ciąg znaków, więc teraz $dopasowuje się tylko raz.

Aksjomat, 114 bajtów

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)

Bez golfa

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

Wyniki

(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 bajtów

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

Uwaga: wprowadź tablicę jednego elementu, np. W a←1⍴3przeciwnym razie:a←4 3 2 1

Tłumaczenie ustne:

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

Pomysł: przetestuj monotoniczność, porównując tablicę oryginalną z posortowaną, sprawdź, czy nie występuje wzrost, porównując do tablicy z usuniętymi duplikacjami.

(I myślę, że można to poprawić ...)

Haskell, 36 bajtów

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

(+x)to dlatego, że haskell błędnie interpretuje (-x)jako wartość zamiast sekcji. Zastanawiam się, czy całe wyrażenie może być opłacalne bez sensu.

LabVIEW, 12 węzłów, 18 przewodów ==> 48 bajtów zgodnie z konwencją

Żadnych funkcji ukrytych w ramkach innych obudów, tylko jeden przewód.

Cejlon, 86 bajtów

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

Funkcja przyjmuje dane wejściowe jako parametry i zwraca krotkę zerową lub jeden wynik booleanów - [false]dla Monotone ściśle maleje , [true]dla Monotone nie rośnie, ale nie ściśle maleje , i []dla Żadnego z powyższych .

Można go użyć w następujący sposób:

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

Wydajność:

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

Wersja nieposkromiona i skomentowana:

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

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

Bardzo proste, zwraca, 1jeśli ściśle maleje, 2jeśli nie zwiększa się inil inaczej.

Próbowałem także unikać applymakr, ~@ale ma tylko 43 znaki (skutkuje to [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 bajtów

O$>g$>=g

Pełny program Pobiera listę danych wejściowych jako argumenty wiersza polecenia. Wydajności 11dla ściśle malejących, 01dla nie rosnących,00 dla żadnego.

Wypróbuj online!

Wyjaśnienie

To podejście działa, ponieważ operatory porównania Pip, takie jak Python, łączą się w łańcuch: 4>3>2jest prawdziwe, a nie jest (4>3)>2(fałsz) jak w C. To samo zachowanie zachowuje się, gdy operatory porównania są modyfikowane za pomocą $meta-operatora 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 bajtów

Dane wyjściowe -1dla „monotonicznego spadku ściśle”, 0dla „monotonicznego bez inkrementacji” i w 1inny sposób.

än rw g

Spróbuj

1 bajt zapisany dzięki Oliverowi .

R , 34 bajty

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

Wypróbuj online!

Porty odpowiedzi MATL DJ-a .

R , 43 bajty

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

Wypróbuj online!

Zwraca 2za wartość ściśle zmniejszającą się, 1za wartość nieodrastającą oraz0 inaczej.

all(x==cummin(x))jest TRUE(konwertuje na, 1gdy jest stosowany w arytmetyce) wtedy i tylko wtedy, gdyf nie rośnie, w tym przypadek ścisły.

all(diff(x)<0)jest TRUEtylko wtedy, gdy fściśle maleje.