Défi

Étant donné une liste, déterminez si le regroupement de la liste en séries d'éléments croissants et décroissants se traduira par une liste de listes de taille égale.

En d'autres termes, les «points tournants» de la liste sont régulièrement espacés.

Exemple

Voici un exemple: 0, 3, 7, 5, 2, 3, 6

0, 3, 7augmente, 7, 5, 2diminue et 2, 3, 6augmente. C'est donc vrai.

Un autre exemple: 1, 4, 6, 8, 5, 3, 5, 7, 9

1, 4, 6, 8augmente, 8, 5, 3diminue et 3, 5, 7, 9augmente. C'est donc de la fausse.

Règles et spécifications

• Aucun élément adjacent ne sera égal
• Tous les numéros peuvent être supposés être dans la plage de numéros raisonnable de votre langue
• Vous pouvez supposer que tous les nombres sont des nombres entiers, si cela vous aide à jouer votre soumission
• C'est le golf de code , donc la réponse la plus courte l'emporte
• Entrée sous forme de liste dans toute représentation raisonnable et sortie sous forme de toute valeur véridique / fausse. Les deux valeurs doivent être cohérentes.

Cas de test

Input -> Output
1, 3, 5, 8, 6, 4, 2, 3, 5, 7, 6, 4, 2, 5, 7, 9, 6, 4, 2 -> True
1, 3, 5, 7, 6, 4, 5, 7, 9, 8, 6, 4, 2, 3, 5 -> False
2, 3, 6, 4, 2, 3, 7, 5, 3, 4, 6 -> True
3, 6, 4, 8, 5, 7, 3, 5, 2 -> True
8 -> True
1, 3, 5, 7 -> True
4, 5, 7, 6, 8, 9 -> False
6, 4, 2, 3, 5, 4, 2 -> True
8, 5, 3, 2, 4, 6, 5, 3, 2, 5, 7 -> False

Remarque : Vous ne pouvez pas supposer que tous les numéros sont à un seul chiffre (sauf si c'est tout ce que votre langue est capable de gérer); les cas de test reflètent cela simplement parce qu'il m'est plus facile de taper les cas de cette façon: P Voici quelques cas de test avec des nombres en dehors de cette plage:

1, 5, 10, 19, 15, 13, 8, 13, 18, 23, 19, 18, 14 -> True
15, 14, 17, 16, 19, 18 -> True
12, 16, 19, 15, 18, 19 -> False

MATL , 10 9 octets

dZS&Y'da~

Essayez-le en ligne!

Un octet enregistré grâce à Luis Mendo!

Explication:

Supposons que l'entrée soit [0, 3, 7, 5, 2, 3, 6]::

            % Implicit input:                                [0, 3, 7, 5, 2, 3, 6]
d           % Difference between adjacent elements:          [3, 4, -2, -3,  1,  3]
 ZS         % Sign of the differences:                       [1, 1, -1, -1, 1, 1]
   &Y'      % Length of runs of consecutive elements:        [2, 2, 2]
     d      % Difference between the lengths:                [0, 0]
      a     % Any non-zero elements:                         False
       ~    % Negate, to get a truthy value if all are zero: True

Gelée , 6 octets

IṠŒgAE

Essayez-le en ligne!

1 octet enregistré grâce à Adnan !

Comment ça fonctionne

IṠŒgAE - Programme complet.

I - Incréments (Deltas).
 Ṡ - Signe de chacun. -1 si négatif, 0 si nul, 1 si positif.
  Œg - Grouper des éléments adjacents.
    A - Valeur absolue. Vectorise. Cela mappe -1 et 1 à la même valeur.
     E - Sont-ils tous égaux?

Alors que le golf, j'ai découvert un peu cool, des solutions de rechange plus: IṠŒgL€E, IṠŒrṪ€E(utilisations de longueur de encode à la place).

Octave , 54 50 octets

@(x)nnz(unique(diff(find([diff(diff(x)>0) 1]))))<2

Essayez-le en ligne!

Explication

@(x)nnz(unique(diff(find([diff(diff(x)>0) 1]))))<2

@(x)                                                % Define anonymous function    
                               diff(x)              % Deltas (consecutive differences)
                                      >0            % Positive? Gives signs
                          diff(         )           % Deltas between signs
                         [                1]        % Append 1 to "close" last group
                    find(                   )       % Indices of nonzeros
               diff(                         )      % Deltas. Gives group lengths
        unique(                               )     % Remove duplicates
    nnz(                                       )    % Number of nonzeros. Gives length
                                                <2  % If 1 or 0: input is periodic

Wolfram Language (Mathematica) , 38 octets

Equal@@(1^Differences@#~SplitBy~Sign)&

Essayez-le en ligne!

Explication

Equal@@(1^Differences@#~SplitBy~Sign)&  (* Input:                {3, 6, 4, 8, 5, 7, 3, 5, 2} *)

          Differences@#                 (* Take differences:     {3, -2, 4, -3, 2, -4, 2, -3} *)
                       ~SplitBy~Sign    (* Split by sign:        {{3}, {-2}, {4}, {-3}, {2}, {-4}, {2}, {-3}} *)
        1^                              (* Raise to power of 1:  {{1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}} *)
Equal@@                                 (* Check equal:          True *)

05AB1E , 8 7 octets

¥0.SγaË

Essayez-le en ligne!

-1 merci à Adnan.

C (gcc) , 143 140 138 136 135 135 132 octets

• Enregistré trois octets; en utilisant une variable rpour stocker le retour booléen de la fonction au lieu de terminer l'utilisation de return.
• Enregistré deux octets; jouer int A[]au golf int*A(en utilisant un pointeur au lieu d'un tableau).
• Enregistré deux octets grâce à Steadybox ; jouer f(int*A,int a)au golf àf(A,a)int*A; .
• Enregistré un octet; jouer if(d!=...au golf àif(d-... .
• Enregistré trois octets; jouer ;j++...j+1au golf ;...++j.

j,d,e,l,m,r;f(A,a)int*A;{for(d=A[0]>A[1],r=1,j=m=l=0;j-~-a;){l++;if(d-(e=A[j]>A[++j]))d=e,j--,r*=l>=(m=!m?l:m),l=0;}r*=-~l==m||m<1;}

Essayez-le en ligne!

Définit une fonction fqui examine chaque élément de la liste sauf le dernier et détermine la relation de cet élément avec l'élément suivant de la liste. Le nombre de comparaisons égales consécutives est stocké la première fois que la relation bascule, tout cycle après le cycle initial qui diffère en longueur à la longueur stockée entraîne une sortie fausse. À la fin, la relation de l'avant-dernier élément au dernier élément est examinée afin qu'elle corresponde au reste de la liste.

Pyth , 11 octets

qFlM.g._k.+

Essayez-le ici.

Python 2 , 107 105 103 97 96 94 91 octets

lambda l:len({sum(g)**2for k,g in groupby(map(cmp,l[:-1],l[1:]))})<2
from itertools import*

Essayez-le en ligne!

Python 3 , 102 100 97 octets

lambda l:len({len([*g])for k,g in groupby(x>y for x,y in zip(l,l[1:]))})<2
from itertools import*

Essayez-le en ligne!

Husk , 7 octets

EmLġ±Ẋ-

Essayez-le en ligne!

Comment ça marche

EmLġ ± Ẋ- ~ Programme complet.

     Ẋ ~ Carte sur des paires d'éléments adjacents.
      - ~ Avec soustraction (cela calcule les deltas)
   ġ ~ Groupe utilisant un prédicat d'égalité.
    ± ~ Signe.
 mL ~ Obtenez les longueurs.
E ~ Sont-ils tous égaux?

Quelques alternatives mignonnes:

εġLġ±Ẋ-
εüLġ±Ẋ-

JavaScript (ES6), 81 octets

Cela semble trop long. Il me manque probablement quelque chose ici ... Retourne soit trueou undefined.

f=(a,p=1)=>a.every((n,i)=>!i|!(1/(y=a[i+1]))|!(i%p)^y>n^a[i-1]>n)||a[p]&&f(a,p+1)

Recherche une période 0 <p <a.longueur telle que tous les changements de direction se produisent tous les p éléments.

Cas de test

f=(a,p=1)=>a.every((n,i)=>!i|!(1/(y=a[i+1]))|!(i%p)^y>n^a[i-1]>n)||a[p]&&f(a,p+1)

console.log(f([1, 3, 5, 8, 6, 4, 2, 3, 5, 7, 6, 4, 2, 5, 7, 9, 6, 4, 2])) // -> True
console.log(f([1, 3, 5, 7, 6, 4, 5, 7, 9, 8, 6, 4, 2, 3, 5])) // -> False
console.log(f([2, 3, 6, 4, 2, 3, 7, 5, 3, 4, 6])) // -> True
console.log(f([3, 6, 4, 8, 5, 7, 3, 5, 2])) // -> True
console.log(f([8])) // -> True
console.log(f([1, 3, 5, 7])) // -> True
console.log(f([4, 5, 7, 6, 8, 9])) // -> False
console.log(f([15, 14, 17, 16, 19, 18])) // -> True
console.log(f([19, 15, 14, 17, 18, 17, 16, 19, 20])) // -> True

Python 2 , 96 octets

import re
def f(x):exec"x=map(cmp,x[1:],x[:-1]);"*2;re.match('.([^1]*)(-?1, \\1)*9',`x+[9]`)<0<_

Essayez-le en ligne! Sortie via le code de sortie: crash (1) est falsey, clean exit (0) est véridique.

Python 2 , 106 octets

def f(x):d=map(cmp,x[1:],x[:-1]);l=len(d);s=(d+[0])[0];k=(d+[-s]).index(-s);print((k*[s]+k*[-s])*l)[:l]==d

Essayez-le en ligne!

Haskell , 79 78 77 octets

import Data.List
g s|h:t<-(1<$)<$>group(zipWith(<)s$tail s)=all(==h)t
g _=1<3

Essayez-le en ligne!

Étant donné une liste s, zipWith(<)s$tail steste pour chaque élément s'il est plus petit que son successeur, par exemple les s=[2,3,6,4,2,3,7,5,3]rendements [True,True,False,False,True,True,False,False]. Ensuite , groupcourt des mêmes éléments ensemble: [[True,True],[False,False],[True,True],[False,False]]. Pour vérifier si toutes ces listes ont la même longueur, remplacer leurs éléments avec 1( voir cette astuce ) pour donner [[1,1],[1,1],[1,1],[1,1]]et vérifier si tous les éléments de la queue tde cette liste égale la tête h: all(==h)t.

Cette approche ne fonctionne pas pour les listes singleton, mais parce que ce sont toujours vrai, nous pouvons les gérer dans leur propre cas: g[_]=1<3.

R , 57 octets

function(x){d=diff
sum(rle(d(which(!!d(d(x)>0))))$v^0)<2}

Essayez-le en ligne!

Japt , 15 octets

ä- mg ò¦ mÊä¥ e

Essayez-le en ligne!

Explication

ä- mg ò¦ mÊä¥ e                                                  [0,3,7,5,2,3,6]
ä-                // Difference between neighboring elements     [-3,-4,2,3,-1,-3]
   mg             // Get the sign of each element                [-1,-1,1,1,-1,-1]
      ò¦          // Partition between different elements        [[-1,-1],[1,1],[-1,-1]]
         mÊ       // Get the length of each element              [2,2,2]
           ä¥     // Check for uniqueness                        [true,true]
              e   // Return true if all elements are truthy      true

R, 36 octets

function(n)!sd(rle(sign(diff(n)))$l)

diffcalcule les différences successives, puis les signécrase à ± 1. rlepuis run-length les encode. Tous les éléments rledoivent être identiques, c'est-à-dire que le vecteur a un écart type nul. !produit ensuite la sortie logique correcte.

Haskell (Lambdabot), 59 octets

g(map(1<$).group.ap(zipWith(<))tail->h:t)=all(==h)t;g _=1<3

D'après la réponse de @ Laikoni

Java (OpenJDK 8) , 437 302 256 188 octets

a->{int i=0,g=0,x=0,l=0;String d="";for(;i<~-a.length;d+=a[0].compare(a[i+1],a[i++])+1);for(String s:d.split("(?<=(.))(?!\\1)"))if(g++<1)x=s.length();else if(s.length()!=x)l++;return l<1;}

Essayez-le en ligne!

Clojure, 70 octets

#({0 1 1 1}(count(set(map count(partition-by pos?(map -(rest %)%))))))

Renvoie 1la vérité et nil(AKA null) la fausse.

Java (OpenJDK 8) , 135 octets

a->{Integer i=0,c,d=0,p=0,r=0;for(;++i<a.length;)d+=(i<2|(c=i.signum(a[i-1]-a[i]))<0?d<0:d>0)?c:p==0|p==-d?c-(p=d):1-(r=1);return r<1;}

Essayez-le en ligne!

Explications

a->{                    // int array
 Integer i=0,c,d=0,p=0,r=0;
                        // variable definitions, use Integer to abuse static calls
 for(;++i<a.length;)    // Loop from 1 till length - 1
  d+=                   // Change d
   (i<2                 // First iteration?
     |(c=i.signum(a[i-1]-a[i]))<0?d<0:d>0
   )                    // Or do c and d have the same sign?
    ?c                  // then increase the magnitude of d.
    :p==0|p==-d         // else we're in a u-turn. Is it the first? Or is the magnitude the same as previously?
     ?c-(p=d)           // assign the new magnitude with sign to p and reset d to -1 (if was positive) or 1 (if was negative)
     :1-(r=1);          // else just do r=1 (technically: "add 1-1=0 to d" as well)
 return r<1;            // return whether there were wrong amplitudes.
}

Python 2 , 110 99 octets

-11 octets grâce à @Lynn

d=input()
exec"d=map(cmp,d[:-1],d[1:]);"*2
x=[i+1for i,e in enumerate(d)if e]
for i in x:i%x[0]>0<q

Essayez-le en ligne!

Rubis , 57 octets

->a{!a.each_cons(2).chunk{|x,y|x>y}.uniq{|*,x|x.size}[1]}

Essayez-le en ligne!