... mais bon, pas besoin d'être strict.

Étant donné un tableau d'entiers strictement positifs non vide, déterminez s'il s'agit:

1. Monotone strictement décroissant . Cela signifie que chaque entrée est strictement inférieure à la précédente.
2. Monotone non croissant, mais pas strictement décroissant . Cela signifie que chaque entrée est inférieure ou égale à la précédente et que le tableau ne relève pas de la catégorie ci-dessus.
3. Aucune de ces réponses .

Notez les cas de coin suivants:

• Un tableau avec un seul numéro est monotone décroissant strictement (de manière vide).
• Un tableau avec le même nombre répété est monotone, non croissant, mais non strictement décroissant.

Règles

Vous pouvez fournir un programme ou une fonction

Les entrées peuvent être prises dans n'importe quel format raisonnable: tableau, liste, chaîne avec des nombres séparés par des espaces, ...

Vous pouvez choisir trois sorties cohérentes pour les trois catégories respectivement. Par exemple, les sorties peuvent être des nombres 0, 1, 2; ou des chaînes 1 1, 1 0chaîne vide.

Le code le plus court en octets gagne

Cas de test

Monotone strictement décroissant:

7 5 4 3 1
42 41
5

Monotone non croissant, mais pas strictement décroissant:

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

Aucune de ces réponses:

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

Gelée , 10 9 5 octets

-Méthode trouvée par DrMcMoylex, allez donner du crédit!

;0IṠṀ

TryItOnline! ou exécuter tous les tests

Retours: -1= monotone strictement décroissant; 0= monotone non croissant; 1= autre.

Comment?

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

Perl 6 , 17 octets

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

• Monotone strictement décroissant: 2
• Monotone non croissant: 1
• Autre: 0

Étendu:

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

MATL , 10 , 7 octets

0hdX>ZS

Essayez-le en ligne! ou vérifier tous les cas de test!

3 octets sauvés, grâce à @LuisMendo!

Les sorties sont

• Strictement décroissant: -1

• Non croissant: 0

• Autre: 1

Explication:

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 octets

Sign@*Max@*Differences

Fonction sans nom prenant une liste de nombres en entrée. Retourne -1si la liste est strictement décroissante, 0si elle ne diminue pas mais ne diminue pas strictement, et 1si ce n'est ni l'un ni l'autre.

Algorithme assez simple: prendre les différences de paires consécutives, prendre le plus grand, et prendre le signe de ce plus grand.

(Je pense qu'il doit exister une langue dans laquelle cet algorithme est de 3 octets ....)

En ce qui concerne un tableau avec une seule entrée: Differencesdonne une liste vide; Maxd'une liste vide donne -∞(!); et Sign[-∞]évalue à -1(!!). Donc, cela fonctionne réellement sur ce cas de coin. Je dois aimer Mathematica parfois. (En effet, la fonction attribue également une liste strictement décroissante à une liste vide.)

Haskell, 40 38 37 octets

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

Résultats

• GT pour monotone strictement décroissant
• EQ pour monotone non croissant
• LT autre

comparecompare deux nombres et renvoie GT( EQ, LT) si le premier nombre est supérieur au deuxième nombre (égal à, inférieur à). zipWith compare<*>tailcompare les éléments voisins. foldl min GTréduit la liste des résultats de la comparaison avec la fonction min en commençant par GT (note: LT< EQ< GT).

Edit: @xnor trouvé 2 à 3 octets. Merci!

Common Lisp, 43 à 40 octets

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

Ceci prend l'entrée comme une liste Lisp, et retourne (T T), (NIL T)et (NIL NIL)distingue les 3 catégories. Ici, il tourne sur les cas de test fournis:

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 octets

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

-1strictement décroissant, 0faiblement décroissant, +1non décroissant

Utiliser cmppour comparer des éléments consécutifs, et prend le maximum. Pour ce faire, supprimez le premier élément d'une copie de la liste, puis mappez cmp. Par exemple, l=[2,2,1]donne

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

qui a max0 car une égalité existe.

La liste plus courte est automatiquement étendue avec None, ce qui est inférieur à tous les nombres et donc inoffensif. Cet élément fantôme empêche également de prendre minune liste vide lorsque l'entrée a une longueur égale à 1.

Brachylog , 7 octets

>,1|>=,

Essayez-le en ligne!

Ceci imprime 1pour décroissant strictement, 0pour non croissant et false.autrement.

Explication

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

Autres solutions 7 octets

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

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

Lit l’entrée de stdin et imprime ce qui suit en fonction de l’entrée:

Sortie:

[1] FALSE TRUE: Monotone non croissant

[1] TRUE FALSE: Monotone strictement décroissant

[1] FALSE FALSE: Aucune de ces réponses

JavaScript (ES6), 51 octets

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

Retourne 0 pour une diminution stricte, 1 pour une non-augmentation, 2 sinon.

05AB1E ,5 8 octets

Bug corrigé par Emigna, merci! Il utilise la même méthode que 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

Essayez-le en ligne!

La sortie est:

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

Ruby, 37 octets

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

Sortie: [true,true], [true,false]ou[false,false]

Mathematica, 15 à 11 octets

##>0|##>=0&

C'est une fonction variadique, prenant tous les entiers en entrée comme arguments séparés.

• Strictement décroissant: True | True
• Non croissant: False | True
• Ni: False | False

Notez que |n'est pas Ormais Alternativesqui fait partie de la syntaxe de correspondance de motif, ce qui explique pourquoi ces expressions ne sont pas évalués à True, True, Falserespectivement.

Le code lui-même est principalement une application de cette astuce . Par exemple, ##>0est, Greater[##, 0]mais ##étend ensuite à toutes les valeurs en entrée afin que nous obtenions quelque chose comme Greater[5, 3, 2, 0], ce qui signifie en soi 5>3>2>0.

Raquette , 44 octets

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

Invoqué:

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

Résultat:

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

C ++ 14, 85 octets

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

Retourne 3 (0b11) pour une diminution stricte, 1 (0b01) pour une non-augmentation et 0 sinon.

Ungolfed:

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

Je pensais que c'était un problème parfait pour les expressions de pliage de C ++ 17:

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

Malheureusement, il n’enchaîne pas les opérateurs relationnels mais

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

ce qui n'était pas recherché.

Python 2, 61 74 octets

+13 octets pour l'entrée à numéro unique

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

Nécessite une entrée sous forme de liste de crochets, comme [3,2,1]. Retourne 2 pour décroissant strict, 1 pour non croissant et 0 sinon.

Ancienne solution:

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

Python 3, 81 52 octets (Merci à FryAmTheEggMan )

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

Essayez-le en ligne!

Befunge, 50 octets

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

Essayez-le en ligne!

Accepte l'entrée comme une séquence d'int séparées par des espaces et renvoie 0 s'il décroît strictement, 1 s'il décroît de manière non stricte, 2 sinon.

Puisque lire befunge est un peu impossible si vous ne connaissez pas la langue, voici l'algorithme en 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())

* dans la mémoire befunge est une pile qui commence avec une quantité infinie de 0 dessus. pop (), push (x), input () et output (x) s'expliquent d'elles-mêmes, les autres pseudofonctions que j'ai utilisées fonctionnent de la manière suivante:

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!

Version précédente, seulement 41 octets mais invalide car il faut un 0 pour terminer la séquence d'entrée (ou utiliser un interpréteur comme celui-ci )

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

Essayez-le en ligne!

J, 14 octets

Verbe monadique prenant la liste à droite, revenant 1pour décroissant strictement, 0pour décroissant faiblement, _1etc.

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

Prend le signe *du minimum <./de différences consécutives 2-/\de la liste. J n’échange pas l’ordre des différences lorsqu’on les prend, par exemple, la séquence décroît strictement si elles sont toutes positives. En particulier, <./renvoie l'infini positif sur les listes d'éléments zéro.

En usage sur le REPL:

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

C, 68 67 octets

Une fonction à flaquelle est transmis un tableau de ints ( l) précédé de sa longueur ( n, également un int). Retourne 3 si monotone diminue strictement, 1 si monotone n'augmente pas, mais ne diminue pas strictement, 0 sinon.

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

Légèrement non golfé pour plus de lisibilité:

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

Réorganisé et commenté pour montrer la logique:

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

Cas de test (courtoisie 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 octets

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

Essayez-le en ligne! (La première ligne active une suite de tests séparée par saut de ligne.)

• Strictement décroissant: 2
• Non croissant: 3
• Ni: 1

Explication

\d+
$*

Convertit l'entrée unaire.

A`\b(1+) 1\1

La regex ici correspond à une paire croissante de nombres consécutifs. Si tel est le cas, l'entrée ne peut manifestement pas augmenter. Le le Adésigne comme une étape "anti-grep", ce qui signifie que la ligne d'entrée est ignorée et remplacée par la chaîne vide si l'expression régulière correspond.

S`\b$

Il s'agit d'une étape fractionnée utilisée pour ajouter un saut de ligne à l'entrée uniquement si l'entrée n'a pas été ignorée. Nous avons donc jusqu'à présent deux résultats possibles: les entrées non croissantes reçoivent un saut de ligne à la fin et les autres sont toujours vides.

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

Enfin, nous comptons le nombre de correspondances de cette regex. La regex correspond soit à des nombres identiques (puis à la fin de la chaîne pour éviter plusieurs correspondances de ce type pour des entrées telles que 1 1 1 1), soit à la "fin de l'entrée". Passons en revue les trois types d’entrées:

• Strictement décroissant: la première partie de la regex ne peut pas correspondre car toutes les valeurs sont uniques, mais les $correspondances. Maintenant, ce $n'est pas exactement "la fin de la chaîne". Il peut également correspondre à un saut de ligne de fuite. Nous allons donc obtenir deux correspondances: une à la fin de l’entrée et une après le saut de ligne que nous avons inséré.
• Non croissant: la première partie de l'expression régulière fournit également une correspondance et nous obtenons trois correspondances.
• Ni l'un ni l'autre: souvenez-vous que nous avons pris soin de transformer l'entrée en une chaîne vide, elle ne $correspond donc plus qu'une fois.

Axiome, 114 octets

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

Résultats

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

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

Remarque: entrez un tableau d'éléments comme par exemple a←1⍴3:a←4 3 2 1

Interprétation de la sortie:

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

Idée: testez la monotonie en comparant le tableau d'origine au tableau trié, recherchez la non-augmentation en comparant le tableau avec les duplications supprimées.

(Et je pense que ça peut être amélioré ...)

Haskell, 36 octets

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

(+x)C'est parce que haskell interprète mal (-x)comme une valeur plutôt que comme une section. Je me demande si toute cette expression peut être utilement rendue inutile.

LabVIEW, 12 nœuds, 18 fils ==> 48 octets par convention

Aucune fonction cachée dans les autres cas, un seul fil de travers.

Ceylan, 86 octets

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

La fonction prend l'entrée comme ses paramètres et retourne un tuple de zéro ou une booléens - [false]pour Monotone strictement décroissante , [true]pour Monotone non croissante, mais pas strictement décroissante , et []pour aucune de ce qui précède .

Il peut être utilisé comme ceci:

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

Sortie:

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

Une version non golfée et commentée:

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

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

Très simple, retourne 1si strictement décroissant, 2sinon non croissant nil.

Aussi essayé d'éviter applyavec les macros, ~@mais il est juste plus long à 43 caractères (cela se traduit par [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 octets

O$>g$>=g

Programme complet. Prend la liste d'entrée en tant qu'arguments de ligne de commande. Sorties 11strictement décroissantes, 01non croissantes, 00pour aucun.

Essayez-le en ligne!

Explication

Cette approche fonctionne parce que les opérateurs de comparaison de Pip, comme Python, enchaînent: 4>3>2true, plutôt que d'être (4>3)>2(false) comme en C. Et le même comportement se produit lorsque les opérateurs de comparaison sont modifiés avec le $méta-opérateur 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 octets

Les sorties -1pour "monotone strictement décroissant", 0pour "monotone non croissant" et 1autres.

än rw g

L'essayer

1 octet sauvé merci à Oliver .

R , 34 octets

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

Essayez-le en ligne!

La réponse MATL de Ports DJ .

R , 43 octets

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

Essayez-le en ligne!

Retours 2strictement décroissants, 1non croissants et 0autres.

all(x==cummin(x))is TRUE(convertit en 1utilisé en arithmétique) si et seulement si fest non croissant, y compris le cas strict.

all(diff(x)<0)est TRUEseulement quand fest strictement décroissant.