Zmniejszmy monotonię


33

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

Czy pisanie funkcji variadic (gdzie wartości wejściowe nie są w ogóle pakowane w żaden typ danych, ale wszystkie są przekazywane bezpośrednio do funkcji jako argumenty) mieści się w „jakimkolwiek rozsądnym formacie”?
Martin Ender,

@Martin Tak, robi to!
Luis Mendo,

Odpowiedzi:


9

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

Czy diakryt Mjest częścią dowolnej 8- bitowej mapy postaci? Nie można powiedzieć, że ma 5 bajtów, ponieważ tak nie jest. CP1252 nie ma go na przykład.
Euri Pinhollow,

2
@EuriPinhollow Jelly używa tej niestandardowej strony kodowej do liczenia bajtów, która jest połączona ze słowem bytew nagłówku tego postu.
Fatalize

@Fatalize: thx, rozumiem.
Euri Pinhollow

22

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:« >= »」
}

4
Perl jest magiczny
pozew fundacji Moniki

Ten może być przedłużony do pracy z każdym typem, jeśli >został włączony do afteri >=z !before. say {[after](@_)+[!before] @_}(<d c b a>) #=> 2
Brad Gilbert b2gills,

13

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

1
Nie możesz dołączyć 0zamiast poprzedniej ostatniej plus 1? Coś w stylu0hdX>ZS
Luis Mendo,

2
@LuisMendo Ah, to geniusz! Dziękuję Ci!
DJMcMayhem

Nie pomaga, ale w celu zaciemnienia możesz również użyć: 0hdX>0/- Pytanie do ciebie i @LuisMendo: Czy można wykorzystać fakt, że sortowanie ma tylko 1 znak (w przeciwieństwie do X>), w jakiś sposób pośrednio używając ostatniej wartości?
Dennis Jaheruddin

@DennisJaheruddin Też myślałem o użyciu S, ale nie znalazłem sposobu, aby go skrócić ...
Luis Mendo

9

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


Widzę, że DrMcMoylex pokonał mnie o 7 minut! :)
Greg Martin

2
Wydaje mi się, że musi istnieć jakiś język, w którym ten algorytm ma 3 bajty” chat.stackexchange.com/transcript/message/33720906#33720906 :(
Martin Ender

7

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!


Czy możesz dołączyć LT zamiast dodawać 0?
xnor

@xnor: Tak, dziękuję, ale to musi być GT, ponieważ potrzebujemy minimum listy (miałem maksimum, co było złe i relikt z wczesnej wersji, w której użyłem =<<zamiast <*>).
nimi

1
Widzę. Co powiesz na to foldl min GT?
xnor

6

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

1
Dokładna taka sama liczba bajtów jak (defun f(x)(mapcar'apply'(> >=)`(,x,x))). Pamiętaj, że możesz po prostu pisać, (lambda(x)...)aby być krótszym.
coredump

6

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.


Nawet przy bardzo małym Pythonie wiem, że potrafię docenić, jak wspaniała jest ta odpowiedź
Luis Mendo

5

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.

4

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


d=diff(scan());ifelse(all(d<=0),!prod(d),2)jest o 1 bajt krótszy. Zwraca 0, jeśli ściśle monotonowy, 1, jeśli monotoniczny nie rośnie i 2, jeśli żaden z powyższych. Nie jestem pewien, czy wolno nic nie zwracać, jeśli żadna z powyższych opcji, ale można to jeszcze bardziej uprościć d=diff(scan());if(all(d<=0))!prod(d).
JAD

W rzeczywistości d=diff(scan());if(all(d<=0))any(!d)jest o jeden bajt lepszy.
JAD

3

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.


3

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

1
®¸ì¥Z0.Snaprawiłby problem z jednym elementem.
Emigna,

Fajnie dzięki! Myślę, że 0 na początku też by działało, ponieważ wszystkie liczby są dodatnie (domyślnie ściśle domyślnie).
Osable,

Tak, 0 też by działało, ale fajnie, że działa dla danych wejściowych zawierających 0 (chociaż z definicji nie będzie) :)
Emigna

Ciekawostka: po francusku „pozytywny” oznacza pozytywny lub zerowy i musisz podać „ściśle pozytywny”, aby osiągnąć to samo znaczenie, co „pozytywny” w języku angielskim.
Osable,

3

Rubinowy, 37 bajtów

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

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


2

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.


2

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

Szkoda, że ​​rakieta nie określa przypadku arity 1 >jako prawdziwego. Common Lisp robi to dobrze, ale nie definiuje przypadku arity 0 (co również powinno być prawdą).
Omar,

2

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.


2

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

2

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

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

Wypróbuj online!


sorted(s)[::-1]jest krótszy do odwracania posortowanej listy. W Python 3 możesz zrobić, {*a}aby uzyskać zestaw elementów a. sortedzwraca listę, więc nie musisz też rzutować zestawu na listę. Również dodawanie wartości logicznych jest koszerne! Wreszcie możesz przesłać anonimową lambdę, więc nie potrzebujesz f=. W końcu mam 52 bajty. repl.it/E7eG/2
FryAmTheEggman

2

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!


Obawiam się, że trailing 0nie liczy się jako prawidłowy format wejściowy. Myślę, że należy do kategorii „wstępnie przetworzonych danych wejściowych”. W rzeczywistości niektóre odpowiedzi dodają a 0do kodu (włączając w to odpowiedź do liczby bajtów). Byłbym akceptowalny, gdybyś mógł. Czy możesz zastąpić 0jakiś znak nienumeryczny? To byłoby do przyjęcia
Luis Mendo,

@LuisMendo Właściwie dzięki temu interpreterowi (którego użyłem do opracowania kodu) EOF zwraca 0, więc nie trzeba dodawać niczego do danych wejściowych. Nie byłem w stanie odkryć, jakie powinno być zamierzone zachowanie, więc nie wiem, czy to założenie jest standardowe, czy nie. Rzeczą, którą mogłem źle zinterpretować, jest: czy zera mogą być częścią sekwencji wejściowej? Jeśli tak, i tak musiałbym zmodyfikować kod.
Lew

Nie zera nie może być częścią sekwencji (podana niepusty tablica pozytywnych integers_ miałem na myśli ściśle dodatnie liczby całkowite). Ale niektóre odpowiedzi używają 0wstawionego przez kod kodu, aby rozpatrzyć przypadek, w którym dane wejściowe mają tylko jeden wpis. To jeden z powodów, dla których uważam, że uwzględnienie tego 0w danych wejściowych jest nieprawidłowe. W każdym razie, jeśli istnieje tłumacz, który go nie potrzebuje, możesz go użyć, aby udowodnić, że twoja odpowiedź jest poprawna bez 0. Jeśli potrzebuje tego tłumacz online Try-it-online 0, możesz dołączyć go do celów demonstracyjnych, z odpowiednim wyjaśnieniem
Luis Mendo,

@JamesHolderness podczas tryonline ~ działa tak, jak powinien, i działa dziwnie na EOF, najwyraźniej powtarzając ostatnie wejście na zawsze. Zobacz tutaj przykład
Leo

1
Zredagowałem odpowiedź przy użyciu podejścia Jamesa, teraz wprowadzanie danych jest zakończone przez EOF
Leo

2

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

2

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

2

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.

1

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] 

1
Forse dovresti tradurre i commenti all'inglese :-)
Luis Mendo

1

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


Zmieniono na jeden numer. Liczba bajtów wzrosła o 2 ...
Roman Susi

1

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.


1

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

wprowadź opis zdjęcia tutaj

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


1

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

1

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

1

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)

1

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 .


@Oliver, tak; w przeciwnym razie domyślnie będzie ... Czekaj, co? Dlaczego to działa ?! än mg rwzwraca złe wyniki bez, Jale tak nie jest än rw g. Dziwne.
Kudłaty

1

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.

Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.