Sfida

Dato un elenco, determinare se raggruppare l'elenco in esecuzioni di elementi crescenti e decrescenti si tradurrà in un elenco di elenchi di dimensioni uguali.

In altre parole, i "punti di svolta" dell'elenco sono distribuiti uniformemente.

Esempio

Ecco un esempio: 0, 3, 7, 5, 2, 3, 6

0, 3, 7aumenta, 7, 5, 2diminuisce e 2, 3, 6aumenta. Quindi questo è vero.

Un altro esempio: 1, 4, 6, 8, 5, 3, 5, 7, 9

1, 4, 6, 8aumenta, 8, 5, 3diminuisce e 3, 5, 7, 9aumenta. Quindi questo è falso.

Regole e specifiche

• Nessun elemento adiacente sarà uguale
• Si può presumere che tutti i numeri rientrino nell'intervallo di numeri ragionevole della tua lingua
• Puoi presumere che tutti i numeri siano numeri interi, se ti aiuta a golfare la tua presentazione
• Questo è code-golf , quindi vince la risposta più breve
• Immettere come elenco in qualsiasi rappresentazione ragionevole e output come qualsiasi valore di verità / falsità. I due valori devono essere coerenti.

Casi 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

Nota : non si può presumere che tutti i numeri siano composti da una sola cifra (a meno che non sia in grado di gestire tutta la lingua); i casi di test riflettono che solo perché è più facile per me digitare i casi in questo modo: P Ecco alcuni casi di test con numeri al di fuori di tale intervallo:

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 byte

dZS&Y'da~

Provalo online!

Salvato un byte grazie a Luis Mendo!

Spiegazione:

Supponiamo che l'input sia [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

Gelatina , 6 byte

IṠŒgAE

Provalo online!

Salvato 1 byte grazie ad Adnan !

Come funziona

IṠŒgAE - Programma completo.

I - Incrementi (delta).
 Ṡ - Segno di ciascuno. -1 se negativo, 0 se nullo, 1 se positivo.
  --G - Esecuzioni di gruppo di elementi adiacenti.
    A - Valore assoluto. Vettorizza. Questo mappa -1 e 1 allo stesso valore.
     E - Sono tutti uguali?

Mentre golf, ho scoperto un po 'fredda, le alternative più lunghe: IṠŒgL€E, IṠŒrṪ€E(run-length-codificare usi invece).

Ottava , 54 50 byte

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

Provalo online!

Spiegazione

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

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

Provalo online!

Spiegazione

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 byte

¥0.SγaË

Provalo online!

-1 grazie ad Adnan.

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

• Tre byte salvati; usando una variabile rper memorizzare il valore booleano di ritorno della funzione invece di terminare usando return.
• Due byte salvati; giocare int A[]a golf int*A(usando un puntatore anziché un array).
• Due byte salvati grazie a Steadybox ; giocare f(int*A,int a)a golf a f(A,a)int*A;.
• Salvato un byte; giocare if(d!=...a golf a if(d-....
• Tre byte salvati; giocare ;j++...j+1a golf a ;...++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;}

Provalo online!

Definisce una funzione fche esamina tutti gli elementi nell'elenco ma l'ultimo e determina la relazione di questo elemento con l'elemento successivo nell'elenco. Il numero di confronti uguali consecutivi viene memorizzato la prima volta che viene invertita la relazione, le eventuali corse successive alla corsa iniziale che differiscono in lunghezza rispetto alla lunghezza memorizzata producono un output errato. Alla fine, viene esaminata la relazione tra il penultimo e l'ultimo elemento in modo che corrisponda al resto dell'elenco.

Pyth , 11 byte

qFlM.g._k.+

Provalo qui.

Python 2 , 107 105 103 97 96 94 91 byte

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

Provalo online!

Python 3 , 102 100 97 byte

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

Provalo online!

Buccia , 7 byte

EmLġ±Ẋ-

Provalo online!

Come funziona

EmLġ ± Ẋ- ~ Programma completo.

     Map ~ Mappa su coppie di elementi adiacenti.
      - ~ Con sottrazione (calcola i delta)
   Group ~ Raggruppa usando il predicato di uguaglianza.
    ± ~ Segno.
 mL ~ Ottieni le lunghezze.
E ~ Sono tutti uguali?

Alcune alternative carine:

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

JavaScript (ES6), 81 byte

Questo sembra troppo lungo. Probabilmente mi manca qualcosa qui ... Restituisce 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)

Cerca un periodo 0 <p <a.length tale che tutti i cambiamenti di direzione si verifichino ogni elemento p .

Casi 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 byte

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

Provalo online! Uscita tramite codice di uscita: crash (1) è falso, clean exit (0) è vero.

Python 2 , 106 byte

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

Provalo online!

Haskell , 79 78 77 byte

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

Provalo online!

Dato un elenco s, zipWith(<)s$tail sverifica per ogni elemento se è inferiore al suo successore, ad esempio s=[2,3,6,4,2,3,7,5,3]rese [True,True,False,False,True,True,False,False]. Poi groupcorre degli stessi elementi insieme: [[True,True],[False,False],[True,True],[False,False]]. Per verificare se tutte queste liste hanno la stessa lunghezza, sostituire gli elementi con 1( vedi questa punta ) cedevole [[1,1],[1,1],[1,1],[1,1]]e controllare se tutti gli elementi nella coda tdi questa lista uguale la testa h: all(==h)t.

Questo approccio non funziona per le liste Singleton, ma perché quelle sono sempre vero, li possiamo gestire nel loro caso: g[_]=1<3.

R , 57 byte

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

Provalo online!

Japt , 15 byte

ä- mg ò¦ mÊä¥ e

Provalo online!

Spiegazione

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

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

diffcalcola le differenze successive, quindi signriduce quelle a ± 1. rlequindi la lunghezza di esecuzione li codifica. Tutti gli elementi di questo rledovrebbero essere gli stessi, cioè il vettore ha deviazione standard zero. !quindi produce l'output logico corretto.

Haskell (Lambdabot), 59 byte

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

Basato sulla risposta di @ Laikoni

Java (OpenJDK 8) , 437 302 256 188 byte

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

Provalo online!

Clojure, 70 byte

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

Restituisce 1come verità e nil(AKA null) come falsa.

Java (OpenJDK 8) , 135 byte

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

Provalo online!

spiegazioni

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 byte

-11 byte grazie 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

Provalo online!

Rubino , 57 byte

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

Provalo online!