¿Oscila periódicamente?

19

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 , 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
Hiperneutrino
fuente
¿La primera ejecución siempre aumentará o la entrada puede comenzar con una ejecución decreciente?
Jordan
@ Jordan podría comenzar a disminuir. Agregaré un caso de prueba para eso.
HyperNeutrino
¿Los grupos siempre están completos? Por ejemplo, ¿ 1, 2, 3, 2sería una entrada válida, y si se considera verdadero o falso? En ese ejemplo, el siguiente valor que sea un 1 lo haría verdadero, pero un 3 lo haría falso.
Tom Carpenter
1
@TomCarpenter Eso se considera falso. Deben ser todos de la misma longitud (y por lo tanto todos completos).
HyperNeutrino

Respuestas:

9

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
Stewie Griffin
fuente
8

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

Sr. Xcoder
fuente
Creo que IṠŒgḂEdebería guardar un byte
Adnan
@Adnan ¿Puede A(valor absoluto) sustituir o hay un truco que no entiendo ?
Sr. Xcoder
Cualquier función que unifique 1 y -1 con el mismo número debería ser suficiente
Adnan
7

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
Luis Mendo
fuente
6

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 *)
JungHwan Min
fuente
Equal@@(1^Split@Sign@Differences@#)&es 2 bytes más corto y Equal@@Im@Split@Sign@Differences@#&es 1 byte más más corto que eso.
Misha Lavrov
Y ahora que estoy pensando en números complejos, usar en Arglugar de Signguardar otro byte.
Misha Lavrov
5

05AB1E , 8 7 bytes

¥0.SγaË

Pruébalo en línea!

-1 gracias a Adnan.

Urna de pulpo mágico
fuente
¥0.SγaËdebería guardar un byte
Adnan
¿Qué es? aNo puedo encontrarlo en los documentos. is_letter(a)???
Magic Octopus Urn
sí, eso es correcto
Adnan
@Adnan ahhh ... idea extraña, buena idea.
Magic Octopus Urn
4

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.

Jonathan Frech
fuente
Puedes usar en f(A,a)int*A;lugar de f(int*A,int a).
Steadybox
3

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!

TFeld
fuente
puede usar {...}en su lugar set(...)para guardar 3 bytes
Rod
3

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ġ±Ẋ-
Sr. Xcoder
fuente
2

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

Arnauld
fuente
2

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!

Lynn
fuente
No estoy seguro, aunque (...)[:l]<dpuede ser lo contrario de (...)[:l]==d.
Jonathan Frech
2

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.

Laikoni
fuente
1

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
Oliver
fuente
1

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.

JDL
fuente
1

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

Alondra
fuente
Bien, no sabía que Lamdabot tenía ViewPatterns habilitado. Falta un espacio en g_=1<3.
Laikoni
@Laikoni Yo tampoco, pero en realidad fui a #haskell y lo probé
BlackCap
0

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!

Roberto Graham
fuente
0

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.

NikoNyrh
fuente
0

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.
}
Olivier Grégoire
fuente
0

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!

ovs
fuente
Puede guardar algunos bytes calculando las diferencias dobles comoexec"d=map(cmp,d[:-1],d[1:]);"*2
Lynn