Lassen Sie uns die Monotonie verringern

33

... aber hey, keine Notwendigkeit, streng zu sein.

Bestimmen Sie bei einem nicht leeren Array von streng positiven Ganzzahlen, ob es sich um Folgendes handelt:

  1. Monoton streng abnehmend . Dies bedeutet, dass jeder Eintrag kleiner ist als der vorherige.
  2. Monoton nicht steigend, aber nicht streng fallend . Dies bedeutet, dass jeder Eintrag kleiner oder gleich dem vorhergehenden ist und das Array nicht in die obige Kategorie fällt.
  3. Nichts von alledem .

Beachten Sie die folgenden Eckfälle:

  • Ein Array mit einer einzelnen Zahl ist monoton und nimmt streng ab (vakuus).
  • Ein Array mit der gleichen Anzahl von Wiederholungen ist monoton, nicht ansteigend, aber nicht streng absteigend.

Regeln

Sie können ein Programm oder eine Funktion bereitstellen

Die Eingabe kann in jedem vernünftigen Format erfolgen: Array, Liste, Zeichenfolge mit durch Leerzeichen getrennten Zahlen, ...

Sie können jeweils drei konsistente Ausgaben für die drei Kategorien auswählen. Zum Beispiel können die Ausgänge Zahlen sein 0, 1, 2; oder Strings 1 1, 1 0, leeren String.

Kürzester Code in Bytes gewinnt

Testfälle

Monoton streng abnehmend:

7 5 4 3 1
42 41
5

Monoton nicht steigend, aber nicht streng fallend:

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

Nichts des oben Genannten:

1 2 3 2
10 9 8 7 12
4 6 4 4 2
Luis Mendo
quelle
Fällt das Schreiben einer variablen Funktion (bei der die Eingabewerte überhaupt nicht in einen Datentyp eingeschlossen werden, sondern alle als Argumente direkt an die Funktion übergeben werden) unter ein "angemessenes Format"?
Martin Ender
@ Martin Ja, das tut es!
Luis Mendo

Antworten:

9

Jelly , 10 9 5 Bytes

-Methode von DrMcMoylex gefunden, geben Sie etwas Anerkennung!

;0IṠṀ

TryItOnline! oder führen Sie alle Tests durch

Rückgabe: -1= monoton streng abnehmend; 0= monoton nicht ansteigend; 1= andere.

Wie?

;0IṠṀ - Main link: list
;0    - concatenate with a zero
  I   - incremental differences
   Ṡ  - sign
    Ṁ - maximum
Jonathan Allan
quelle
Ist das diakretische MZeichen Teil einer 8-Bit-Zeichentabelle? Sie können nicht sagen, dass es 5 Bytes sind, weil es nicht ist. CP1252 hat es zum Beispiel nicht.
Euri Pinhollow
2
@EuriPinhollow Jelly verwendet diese benutzerdefinierte Codepage zum Zählen von Bytes, die mit dem Wort bytein der Kopfzeile dieses Beitrags verknüpft sind .
Fatalize
@Fatalize: Danke, verstanden.
Euri Pinhollow
22

Perl 6 , 17 Bytes

{[>](@_)+[>=] @_}
  • Monoton streng abnehmend: 2
  • Monoton, nicht ansteigend: 1
  • Andere: 0

Erweitert:

{            # bare block lambda with implicit parameter list 「@_」
  [>]( @_ )  # reduce using 「&infix:« > »」
  +
  [>=] @_    # reduce using 「&infix:« >= »」
}
Brad Gilbert b2gills
quelle
4
Perl ist magisch
Nic Hartley
Dies kann erweitert werden, um mit jedem Typ zu arbeiten, wenn >mit afterund >=mit gewechselt wurde !before. say {[after](@_)+[!before] @_}(<d c b a>) #=> 2
Brad Gilbert b2gills
13

MATL , 10 , 7 Bytes

0hdX>ZS

Probieren Sie es online! oder überprüfe alle Testfälle!

3 Bytes gespart, dank @LuisMendo!

Die Ausgänge sind

  • Streng abnehmend: -1

  • Nicht steigend: 0

  • Sonstiges: 1

Erläuterung:

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
quelle
1
Können Sie nicht ein anhängen, 0anstatt das letzte Plus voranzustellen 1? So etwas wie0hdX>ZS
Luis Mendo
2
@ LuisMendo Ah, das ist Genie! Vielen Dank!
DJMcMayhem
Hilft nicht, aber zur Verschleierung könnten Sie auch 0hdX>0/Folgendes verwenden: - Frage an Sie und @LuisMendo: Ist es möglich, die Tatsache zu nutzen, dass sort nur 1 Zeichen (im Gegensatz zu X>) ist, indem Sie implizit den letzten Wert verwenden?
Dennis Jaheruddin
@ TennisJaheruddin Ich dachte auch über die Verwendung S, aber ich habe keinen Weg gefunden, um es kürzer zu machen ...
Luis Mendo
9

Mathematica, 22 Bytes

Sign@*Max@*Differences

Unbenannte Funktion, die eine Liste von Zahlen als Eingabe verwendet. Gibt zurück, -1wenn die Liste stark abnimmt, 0nicht zunimmt, aber nicht stark abnimmt und 1keine.

Ziemlich einfacher Algorithmus: Nimm die Differenzen von aufeinanderfolgenden Paaren, nimm das größte und nimm das Vorzeichen des größten.

(Ich glaube, es muss eine Sprache geben, in der dieser Algorithmus 3 Bytes lang ist ....)

In Bezug auf ein Array mit einem einzelnen Eintrag: Differencesergibt eine leere Liste; Maxvon einer leeren Liste gibt -∞(!); und Sign[-∞]wertet aus -1(!!). Also funktioniert es tatsächlich bei diesem Eckfall. Muss Mathematica manchmal lieben. (Tatsächlich kennzeichnet die Funktion eine leere Liste auch korrekt als streng absteigend.)

Greg Martin
quelle
Ich sehe, wie DrMcMoylex mich um 7 Minuten schlägt! :)
Greg Martin
2
"Ich glaube, es muss eine Sprache geben, in der dieser Algorithmus 3 Byte lang ist" chat.stackexchange.com/transcript/message/33720906#33720906 :(
Martin Ender
7

Haskell, 40 38 37 Bytes

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

Kehrt zurück

  • GT für Monotone streng abnehmend
  • EQ für monoton nicht ansteigend
  • LT sonst

comparevergleicht zwei Zahlen und gibt GT( EQ, LT) zurück , wenn die erste Zahl größer als (gleich, kleiner als) die zweite Zahl ist. zipWith compare<*>tailvergleicht Nachbarelemente. foldl min GTreduziert die Liste der Vergleichsergebnisse mit der min - Funktion mit GT starten (Anmerkung: LT< EQ< GT).

Edit: @xnor 2 3 Bytes gefunden. Vielen Dank!

nimi
quelle
Können Sie einen LT voranstellen, anstatt eine 0 anzufügen?
Xnor
@xnor: Ja, danke, aber es muss ein sein GT, weil wir das Minimum der Liste brauchen (ich hatte ein Maximum, was falsch war und ein Relikt aus einer frühen Version, in der ich =<<stattdessen verwendet habe <*>).
nimi
1
Aha. Wie wäre es eigentlich foldl min GT?
25.
6

Common Lisp, 43 40 Bytes

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

Dies nimmt die Eingabe als Lisp - Liste und kehrt (T T), (NIL T)und (NIL NIL)die drei Kategorien zu unterscheiden. Hier läuft es auf den mitgelieferten Testfällen:

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
quelle
1
Genau so viele Bytes wie (defun f(x)(mapcar'apply'(> >=)`(,x,x))). Beachten Sie, dass Sie nur schreiben können (lambda(x)...), um kürzer zu sein.
Coredump
6

Python 2, 30 Bytes

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

-1für streng abnehmend, 0für schwach abnehmend, +1für nicht abnehmend

Verwenden Sie cmp, um aufeinanderfolgende Elemente zu vergleichen, und nimmt das Maximum an. Dies erfolgt durch Entfernen des ersten Elements einer Kopie der Liste und anschließendes Zuordnen cmp. Zum Beispiel l=[2,2,1]gibt

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

die max0 hat, weil eine Gleichheit besteht.

Die kürzere Liste wird automatisch mit erweitert None, was weniger ist als alle Nummern und somit harmlos. Dieses Phantomelement schützt auch vor dem Aufnehmen mineiner leeren Liste, wenn der Eingang die Länge 1 hat.

xnor
quelle
Selbst mit dem sehr kleinen Python weiß ich, wie großartig diese Antwort ist
Luis Mendo
5

Brachylog , 7 Bytes

>,1|>=,

Probieren Sie es online!

Dies druckt 1zum strikten Verringern, 0zum Nichterhöhen und auf false.andere Weise.

Erläuterung

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

Andere 7-Byte-Lösungen

>=!>,;1           Returns 0 for strictly decreasing, false. for non-increasing, 1 otherwise.

>=!>,1|           Returns 1 for strictly decreasing, false. for non-increasing, 0 otherwise.
Tödlich
quelle
4

R, 44 Bytes

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

Liest die Eingabe von stdin und gibt abhängig von der Eingabe Folgendes aus:

Ausgabe:

[1] FALSE TRUE: Monoton, nicht ansteigend

[1] TRUE FALSE: Monoton streng abnehmend

[1] FALSE FALSE: Nichts des oben Genannten

Billywob
quelle
d=diff(scan());ifelse(all(d<=0),!prod(d),2)ist 1 Byte kürzer. Es gibt 0 zurück, wenn es streng monoton ist, 1, wenn es nicht monoton ist und 2, wenn keines der oben genannten Merkmale vorliegt. Nicht sicher, ob es erlaubt ist, nichts zurückzugeben, wenn keines der oben genannten, aber Sie könnten es weiter vereinfachen d=diff(scan());if(all(d<=0))!prod(d).
JAD
Ist eigentlich d=diff(scan());if(all(d<=0))any(!d)ein Byte besser.
JAD
3

JavaScript (ES6), 51 Byte

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

Liefert 0 für striktes Verringern, 1 für nicht steigendes, 2 andernfalls.

Neil
quelle
3

05AB1E ,5 8 Bytes

Fehler behoben von Emigna, danke! Es verwendet die gleiche Methode wie 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

Probieren Sie es online!

Ausgabe ist:

-1 if strictly decreasing sequence
 0 if non-strictly decreasing sequence
 1 otherwise
Osable
quelle
1
®¸ì¥Z0.Swürde das einzelne Element Problem beheben.
Emigna
Nett, danke! Ich denke, 0 am Anfang würde auch funktionieren, da alle Zahlen positiv sind (streng standardmäßig, denke ich).
Osable
Ja, 0 würde auch funktionieren, aber es ist schön, dass es für Eingaben mit 0 funktioniert (obwohl per Definition nicht) :)
Emigna
Unterhaltsame Tatsache: Auf Französisch bedeutet "positiv" positiv oder null, und Sie müssen "streng positiv" angeben, um dieselbe Bedeutung wie "positiv" auf Englisch zu erreichen.
Osable
3

Ruby, 37 Bytes

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

Ausgang: [true,true], [true,false]oder[false,false]

GB
quelle
2

Mathematica, 15 11 Bytes

##>0|##>=0&

Dies ist eine variable Funktion, bei der alle Eingabe-Ganzzahlen als separate Argumente verwendet werden.

  • Streng abnehmend: True | True
  • Nicht steigend: False | True
  • Weder: False | False

Beachten Sie, dass dies |nicht Orbut Alternativesist. Dies ist Teil der Pattern-Matching-Syntax. Dies erklärt, warum diese Ausdrücke nicht ausgewertet Truewerden True.False , respectively.

Der Code selbst ist meist eine Anwendung dieses Tipps . Zum Beispiel ##>0wird Greater[##, 0]dann aber ##auf alle Eingabewerte erweitert, so dass wir so etwas wie bekommen Greater[5, 3, 2, 0], was selbst bedeutet 5>3>2>0.

Martin Ender
quelle
2

Schläger , 44 Bytes

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

Aufgerufen:

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

Ergebnis:

'((#t #t)
 (#t #t)
 (#t #t)
 (#f #t)
 (#f #t)
 (#f #t)
 (#f #f)
 (#f #f)
 (#f #f))
Matthew Butterick
quelle
Es ist eine Schande, dass Racket den Fall von Arity 1 nicht >als wahr definiert. Common Lisp macht das richtig, definiert aber nicht den Fall arity 0 (was auch wahr sein sollte).
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...);}

Gibt 3 (0b11) für das strikte Verringern, 1 (0b01) für das Nichterhöhen und 0 ansonsten zurück.

Ungolfed:

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

Ich dachte, dies sei ein perfektes Problem für die Folding-Ausdrücke von C ++ 17:

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

Leider verkettet es die Vergleichsoperatoren nicht, tut es aber

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

was nicht gewollt war.

Karl Napf
quelle
2

Python 2, 61 74 Bytes

+13 Bytes für die Eingabe einer einzelnen Zahl

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

Benötigt Eingabe in Klammerlistenform wie [3,2,1]. Gibt 2 für das strikte Verringern, 1 für das Nichterhöhen und 0 ansonsten zurück.

Alte Lösung:

print eval(">".join(x))+eval(">=".join(x))
Karl Napf
quelle
2

Python 3, 81 52 Bytes (Dank an FryAmTheEggMan )

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

Probieren Sie es online!

Sygmei
quelle
sorted(s)[::-1]ist kürzer zum Umkehren einer sortierten Liste. In Python 3 können Sie {*a}eine Reihe von Elementen von abrufen a. sortedGibt eine Liste zurück, sodass Sie den Satz auch nicht in eine Liste umwandeln müssen. Auch das Hinzufügen von Booleschen Werten ist absolut koscher! Schließlich können Sie ein anonymes Lambda einreichen, das Sie also nicht benötigen f=. Ich bekomme am Ende 52 Bytes. repl.it/E7eG/2
FryAmTheEggman
2

Befunge, 50 Bytes

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

Probieren Sie es online!

Akzeptiert Eingaben als eine durch Leerzeichen getrennte Folge von int und gibt 0 zurück, wenn sie streng abnehmen, 1, wenn sie nicht streng abnehmen, 2, sonst.

Da das Lesen von Befunge unmöglich ist, wenn Sie die Sprache nicht kennen, ist dies der Algorithmus im Pseudocode:

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

* im befunge Speicher ist ein Stapel, der mit einer unendlichen Menge von 0 beginnt. pop (), push (x), input () und output (x) sind selbsterklärend, die anderen verwendeten Pseudofunktionen funktionieren so:

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!


Vorherige Version, nur 41 Byte, aber ungültig, da zum Beenden der Eingabesequenz eine 0 erforderlich ist (oder ein Interpreter wie dieser verwendet wird )

&:  >&:|>:0`|
1\v@.$_<[email protected]_
- >:v  >^   >

Probieren Sie es online!

Löwe
quelle
Ich fürchte, ein Trailing 0zählt nicht als gültiges Eingabeformat. Ich denke, es fällt unter die Kategorie "vorverarbeitete Eingabe". Tatsächlich hängen einige Antworten ein 0im Code an (also auch das in der Byteanzahl). Ich wäre akzeptabel, wenn Sie könnten Können Sie das 0durch ein nicht numerisches Zeichen ersetzen ? Das wäre akzeptabel
Luis Mendo
@LuisMendo Tatsächlich gibt EOF mit diesem Interpreter (mit dem ich den Code entwickelt habe) 0 zurück, sodass der Eingabe nichts hinzugefügt werden muss. Ich konnte nicht herausfinden, wie das beabsichtigte Verhalten aussehen soll, daher weiß ich nicht, ob diese Annahme Standard ist oder nicht. Eine Sache, die ich möglicherweise falsch interpretiert habe, ist: Können Nullen Teil der Eingabesequenz sein? In diesem Fall müsste ich den Code trotzdem ändern.
Leo
Nein, Nullen können nicht Teil der Sequenz sein (bei einem nicht leeren Array positiver Ganzzahlen meine ich streng positive Ganzzahlen). Bei einigen Antworten wird jedoch ein durch den Code0 eingefügtes verwendet , um den Fall zu behandeln, dass die Eingabe nur einen Eintrag enthält. Das ist einer der Gründe, warum ich der Meinung bin, dass 0die Eingabe nicht gültig ist. Wie auch immer, wenn ein Dolmetscher ist , dass es nicht braucht, können Sie diesen Interpreter zu beweisen , dass Ihre Antwort ohne die gültige ist 0. Wenn der Try-it-Online-Dolmetscher dies benötigt, 0können Sie es zu Demonstrationszwecken mit einer entsprechenden Erläuterung hinzufügen
Luis Mendo,
@JamesHolderness auf tryonline ~ funktioniert so wie es sollte und hat ein seltsames Verhalten bei EOF, das anscheinend die letzte Eingabe für immer wiederholt. Siehe hier für ein Beispiel
Leo
1
Ich habe die Antwort mit James 'Ansatz bearbeitet, jetzt wird die Eingabe von EOF
Leo
2

J, 14 Bytes

Monadisches Verb, das die Liste auf der rechten Seite aufnimmt und zurückkehrt, 1um streng zu verringern, 0schwach zu verringern und auf _1andere Weise.

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

Nimmt das Vorzeichen *des Minimums <./aufeinanderfolgender Unterschiede 2-/\der Liste. J vertauscht die Reihenfolge der Differenzen nicht, wenn sie genommen werden, so dass z. B. die Reihenfolge streng abnimmt, wenn diese alle positiv sind. Gibt insbesondere bei <./Listen mit Nullelementen eine positive Unendlichkeit zurück.

Im Einsatz bei der REPL:

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

C 68 67 Bytes

Eine Funktion f, der ein Array von ints ( l) übergeben wird, dem die Länge ( nauch ein int) vorausgeht . Gibt 3 zurück, wenn die Monotonie stark abnimmt, 1, wenn die Monotonie nicht zunimmt, aber nicht stark abnimmt, andernfalls 0.

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

Aus Gründen der Lesbarkeit leicht ungespielt:

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

Neu angeordnet und kommentiert, um die Logik zu zeigen:

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

Testfälle (mit freundlicher Genehmigung von 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
hmmwasdasdo
quelle
2

Retina , 41 Bytes

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

Probieren Sie es online! (Die erste Zeile aktiviert eine durch Zeilenvorschub getrennte Testsuite.)

  • Streng abnehmend: 2
  • Nicht steigend: 3
  • Weder: 1

Erläuterung

\d+
$*

Konvertiert die Eingabe unär.

A`\b(1+) 1\1

Der reguläre Ausdruck entspricht hier einem zunehmenden Paar aufeinanderfolgender Zahlen. Wenn dies der Fall ist, kann der Eingang eindeutig nicht nicht ansteigend sein. Die Abezeichnet er als ein „anti-grep“ -Stufe was bedeutet , dass die Eingangsleitung verworfen wird und mit dem leeren String , wenn die Regex Einstimmungen ersetzt.

S`\b$

Dies ist eine geteilte Stufe, mit der ein Zeilenvorschub nur dann an den Eingang angehängt wird, wenn der Eingang nicht verworfen wurde. Wir haben also zwei mögliche Ergebnisse: Nicht ansteigende Eingaben erhalten am Ende einen Zeilenvorschub und andere sind noch leer.

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

Schließlich zählen wir die Anzahl der Übereinstimmungen dieses regulären Ausdrucks. Der reguläre Ausdruck stimmt entweder mit identischen Zahlen überein (und dann alles bis zum Ende der Zeichenfolge, um mehrfache Übereinstimmungen dieser Art für Eingaben wie zu vermeiden 1 1 1 1) oder mit dem "Ende der Eingabe". Lassen Sie uns die drei Arten von Eingaben durchgehen:

  • Streng abnehmend: Der erste Teil des regulären Ausdrucks kann nicht übereinstimmen, da alle Werte eindeutig sind $ Übereinstimmungen. Jetzt $ist nicht genau "das Ende der Zeichenfolge". Es kann auch vor einem nachfolgenden Zeilenvorschub passen. Wir erhalten also tatsächlich zwei Übereinstimmungen, eine am Ende der Eingabe und eine nach dem Zeilenvorschub, den wir eingefügt haben.
  • Nicht steigend: Jetzt liefert der erste Teil des regulären Ausdrucks auch ein Match, und wir haben am Ende drei Matches.
  • Weder noch: Denken Sie daran, dass wir darauf geachtet haben, die Eingabe in eine leere Zeichenfolge umzuwandeln, sodass sie jetzt $nur einmal übereinstimmt.
Martin Ender
quelle
1

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

Ergebnisse

(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
quelle
1
Forse dovresti tradurre i commenti all'inglese :-)
Luis Mendo
1

APL, 16 Bytes

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

Hinweis: Geben Sie ein Elementarray wie z a←1⍴3 ansonsten:a←4 3 2 1

Ausgabe interpretieren:

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

Idee: Testen Sie die Monotonie, indem Sie das Original mit dem sortierten Array vergleichen, und prüfen Sie, ob keine Erhöhung vorliegt, indem Sie das Array mit entfernten Duplikaten vergleichen.

(Und ich denke, es kann verbessert werden ...)

Roman Susi
quelle
Geändert zu einer Nummer. Bytes um 2 erhöht ...
Roman Susi
1

Haskell, 36 Bytes

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

(+x)Das liegt daran, dass haskell nicht (-x)als Abschnitt, sondern als Wert falsch interpretiert . Ich frage mich, ob der ganze Ausdruck gewinnbringend sinnlos gemacht werden kann.

xnor
quelle
1

LabVIEW, 12 Knoten, 18 Drähte ==> 48 Bytes gemäß Konvention

Bildbeschreibung hier eingeben

Keine Funktionen in den anderen Gehäuserahmen verborgen, nur ein einziger Draht über.

SRM
quelle
1

Ceylon, 86 Bytes

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

Die Funktion nimmt die Eingabe als Parameter und gibt ein Tupel mit null oder einem Booleschen Wert zurück - [false]für Monotone, das streng abnimmt , [true]für Monotone, das nicht zunimmt, aber nicht streng abnimmt , und []für keines der oben genannten .

Es kann so verwendet werden:

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

Ausgabe:

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

Eine ungolfed und kommentierte Version:

// 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
quelle
1

Clojure, 34 Bytes

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

Sehr einfach, kehrt zurück, 1wenn sie streng abnimmt, 2wenn sie nicht zunimmt und nilansonsten.

Auch versucht, applymit Makros zu vermeiden , ~@aber es ist nur länger bei 43 Zeichen (dies führt zu [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
quelle
1

Pip , 8 Bytes

O$>g$>=g

Volles Programm. Nimmt die Eingabeliste als Befehlszeilenargumente. Outputs 11für streng abnehmende, 01für nicht ansteigende, 00für keine.

Probieren Sie es online!

Erläuterung

Dieser Ansatz funktioniert, weil die Vergleichsoperatoren von Pip, wie die von Python, miteinander verkettet sind: 4>3>2ist wahr und nicht (4>3)>2(falsch) wie in C. Und dasselbe Verhalten gilt, wenn die Vergleichsoperatoren mit dem $Fold-Metaoperator geändert werden.

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

Japt , 9 8 7 Bytes

Ausgänge -1für "monoton streng abnehmend", 0für "monoton nicht inkrementierend" und 1sonst.

än rw g

Versuch es

1 Byte gespeichert, danke an Oliver .

Zottelig
quelle
@ Oliver, ja; Andernfalls wird standardmäßig ... Warten Sie, was? Warum funktioniert das ?!än mg rwliefert die falschen Ergebnisse ohne das, Jaber das ist bei nicht der Fall än rw g. Seltsam.
Shaggy
1

R , 34 Bytes

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

Probieren Sie es online!

Ports DJs MATL Antwort .

R , 43 Bytes

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

Probieren Sie es online!

Rückgabe 2für streng abnehmend, 1für nicht steigend und 0sonst.

all(x==cummin(x))is TRUE(konvertiert in, 1wenn es in der Arithmetik verwendet wird) nur dann, wenn fes nicht ansteigt, einschließlich der Groß- und Kleinschreibung.

all(diff(x)<0) ist TRUE nur, wenn fes streng abnimmt.

Giuseppe
quelle