Desafío

Dada una lista, determine si agrupar la lista en series de elementos crecientes y decrecientes dará como resultado una lista de listas de igual tamaño.

En otras palabras, los "puntos de inflexión" de la lista están espaciados de manera uniforme.

Ejemplo

Aquí hay un ejemplo: 0, 3, 7, 5, 2, 3, 6

0, 3, 7aumenta, 7, 5, 2disminuye y 2, 3, 6aumenta. Por lo tanto, esto es verdad.

Otro ejemplo: 1, 4, 6, 8, 5, 3, 5, 7, 9

1, 4, 6, 8aumenta, 8, 5, 3disminuye y 3, 5, 7, 9aumenta. Por lo tanto, esto es falso.

Reglas y especificaciones

• Ningún elemento adyacente será igual
• Se puede suponer que todos los números están dentro del rango de números razonable de su idioma
• Puede suponer que todos los números son enteros, si le ayuda a jugar golf su envío
• Este es el código de golf , por lo que gana la respuesta más corta
• Entrada como una lista en cualquier representación razonable y salida como cualquier valor verdadero / falso. Los dos valores deben ser consistentes.

Casos de prueba

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

Nota : No puede suponer que todos los números son de un solo dígito (a menos que sea todo lo que su idioma sea capaz de manejar); los casos de prueba reflejan eso solo porque es más fácil para mí escribir los casos de esta manera: P Aquí hay algunos casos de prueba con números fuera de ese rango:

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 bytes

dZS&Y'da~

Pruébalo en línea!

¡Ahorré un byte gracias a Luis Mendo!

Explicación:

Suponga que la entrada es [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

Jalea , 6 bytes

IṠŒgAE

Pruébalo en línea!

¡Guardado 1 byte gracias a Adnan !

Cómo funciona

IṠŒgAE - Programa completo.

I - Incrementos (Deltas).
 Ṡ - Signo de cada uno. -1 si es negativo, 0 si es nulo, 1 si es positivo.
  Œg - Agrupa ejecuciones de elementos adyacentes.
    A - Valor absoluto. Vectoriza Esto asigna -1 y 1 al mismo valor.
     E - ¿Son todos iguales?

Mientras jugaba al golf, descubrí algunas alternativas geniales y más largas: (en su lugar IṠŒgL€E, IṠŒrṪ€Eutiliza run-length-encode).

Octava , 54 50 bytes

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

Pruébalo en línea!

Explicación

@(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 bytes

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

Pruébalo en línea!

Explicación

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 bytes

¥0.SγaË

Pruébalo en línea!

-1 gracias a Adnan.

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

• Guardado tres bytes; usando una variable rpara almacenar el retorno booleano de la función en lugar de terminar usando return.
• Guardado dos bytes; jugando int A[]al golf int*A(usando un puntero en lugar de una matriz).
• Guardado dos bytes gracias a Steadybox ; golf f(int*A,int a)a f(A,a)int*A;.
• Guardado un byte; golf if(d!=...a if(d-....
• Guardado tres bytes; golf ;j++...j+1a ;...++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;}

Pruébalo en línea!

Define una función fque examina cada elemento de la lista pero el último y determina la relación de este elemento con el siguiente elemento de la lista. El número de comparaciones iguales consecutivas se almacena la primera vez que la relación cambia, cualquier ejecución después de la ejecución inicial que difiera en longitud a la longitud almacenada da como resultado una salida falsa. Al final, se mira la relación del penúltimo elemento con el último elemento para que coincida con el resto de la lista.

Pyth , 11 bytes

qFlM.g._k.+

Pruébalo aquí

Python 2 , 107 105 103 97 96 94 91 bytes

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

Pruébalo en línea!

Python 3 , 102 100 97 bytes

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

Pruébalo en línea!

Casco , 7 bytes

EmLġ±Ẋ-

Pruébalo en línea!

Como funciona esto

EmLġ ± Ẋ- ~ Programa completo.

     Map ~ Mapa sobre pares de elementos adyacentes.
      - ~ Con sustracción (esto calcula los deltas)
   Group ~ Agrupar utilizando el predicado de igualdad.
    ± ~ signo.
 mL ~ Obtenga las longitudes.
E ~ ¿Son todos iguales?

Algunas lindas alternativas:

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

JavaScript (ES6), 81 bytes

Esto parece demasiado largo. Probablemente me estoy perdiendo algo aquí ... Devuelve trueo 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)

Busca un período 0 <p <a.longitud tal que todos los cambios de dirección ocurran en cada elemento p .

Casos de prueba

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 bytes

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

Pruébalo en línea! Salida a través del código de salida: crash (1) es falsey, la salida limpia (0) es verdadera.

Python 2 , 106 bytes

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

Pruébalo en línea!

Haskell , 79 78 77 bytes

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

Pruébalo en línea!

Dada una lista s, zipWith(<)s$tail sprueba para cada elemento si es más pequeño que su sucesor, por ejemplo, s=[2,3,6,4,2,3,7,5,3]rendimientos [True,True,False,False,True,True,False,False]. A continuación, groupse ejecuta por los mismos elementos juntos: [[True,True],[False,False],[True,True],[False,False]]. Para comprobar si todas esas listas tienen la misma longitud, sustituir sus elementos con 1( ver esta punta ) produciendo [[1,1],[1,1],[1,1],[1,1]]y comprobar si todos los elementos en la cola tde esta lista son iguales a la cabeza h: all(==h)t.

Este enfoque no funciona para listas simples, sino porque esas son siempre verdad, podemos manejar en su propio caso: g[_]=1<3.

R , 57 bytes

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

Pruébalo en línea!

Japt , 15 bytes

ä- mg ò¦ mÊä¥ e

Pruébalo en línea!

Explicación

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

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

diffcalcula las diferencias sucesivas, luego signlas reduce a ± 1. rleluego la longitud de ejecución los codifica. Todos los elementos de esto rledeberían ser iguales, es decir, el vector tiene una desviación estándar cero. !luego produce la salida lógica correcta.

Haskell (Lambdabot), 59 bytes

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

Basado en la respuesta de @ Laikoni

Java (OpenJDK 8) , 437 302 256 188 bytes

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

Pruébalo en línea!

Clojure, 70 bytes

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

Devuelve 1como verdadero y nil(también conocido como nulo) como falso.

Java (OpenJDK 8) , 135 bytes

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

Pruébalo en línea!

Explicaciones

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 bytes

-11 bytes gracias a @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

Pruébalo en línea!

Ruby , 57 bytes

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

Pruébalo en línea!