Wyzwanie

Biorąc pod uwagę listę, ustal, czy pogrupowanie listy w serie rosnących i malejących elementów da listę o jednakowych rozmiarach.

Innymi słowy, „punkty zwrotne” listy są rozmieszczone równomiernie.

Przykład

Oto przykład: 0, 3, 7, 5, 2, 3, 6

0, 3, 7wzrasta, 7, 5, 2maleje i 2, 3, 6wzrasta. Dlatego jest to prawdą.

Inny przykład: 1, 4, 6, 8, 5, 3, 5, 7, 9

1, 4, 6, 8wzrasta, 8, 5, 3maleje i 3, 5, 7, 9wzrasta. Dlatego jest to fałsz.

Zasady i specyfikacje

• Żadne sąsiednie elementy nie będą sobie równe
• Można założyć, że wszystkie liczby mieszczą się w rozsądnym zakresie liczb w Twoim języku
• Możesz założyć, że wszystkie liczby są liczbami całkowitymi, jeśli pomoże ci to w golfie
• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź
• Wprowadź jako listę w dowolnej uzasadnionej reprezentacji i wyślij jako dowolną wartość prawdy / fałszu. Dwie wartości muszą być spójne.

Przypadki testowe

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

Uwaga : Nie możesz zakładać, że wszystkie cyfry są jednocyfrowe (chyba że tylko twój język jest w stanie obsłużyć); przypadki testowe odzwierciedlają to tylko dlatego, że łatwiej jest mi wpisać przypadki w ten sposób: P Oto kilka przypadków testowych z liczbami spoza tego zakresu:

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 bajtów

dZS&Y'da~

Wypróbuj online!

Oszczędność jednego bajtu dzięki Luisowi Mendo!

Wyjaśnienie:

Załóżmy, że dane wejściowe to [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

Galaretka , 6 bajtów

IṠŒgAE

Wypróbuj online!

Zapisano 1 bajt dzięki Adnan !

Jak to działa

IṠŒgAE - Pełny program.

I - Przyrosty (delty).
 Ṡ - Znak każdego. -1 jeśli ujemne, 0 jeśli zerowe, 1 jeśli dodatnie.
  --G - Grupuj przebiegi sąsiednich elementów.
    A - Wartość bezwzględna. Wektoryzuje. Odwzorowuje -1 i 1 na tę samą wartość.
     E - Czy wszyscy są równi?

Podczas gry w golfa, odkryłem trochę chłodny, dłuższe alternatywy: IṠŒgL€E, IṠŒrṪ€E(używa run-length zakodować zamiast).

Oktawa , 54 50 bajtów

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

Wypróbuj online!

Wyjaśnienie

@(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 bajtów

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

Wypróbuj online!

Wyjaśnienie

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 bajtów

¥0.SγaË

Wypróbuj online!

-1 dzięki Adnan.

C (gcc) , 143 140 138 136 135 132 bajtów

• Zapisano trzy bajty; za pomocą zmiennej rdo przechowywania logicznej wartości zwracanej przez funkcję zamiast kończenia za pomocą return.
• Zapisano dwa bajty; gra int A[]w golfa do int*A(za pomocą wskaźnika zamiast tablicy).
• Zaoszczędzono dwa bajty dzięki Steadybox ; grać f(int*A,int a)w golfa f(A,a)int*A;.
• Zapisano bajt; grać if(d!=...w golfa if(d-....
• Zapisano trzy bajty; grać ;j++...j+1w golfa ;...++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;}

Wypróbuj online!

Definiuje funkcję, fktóra patrzy na każdy element na liście, ale ostatni i określa stosunek tego elementu do następnego elementu na liście. Liczba kolejnych równych porównań jest zapisywana za pierwszym razem, gdy relacja się zmienia, dowolne przebiegi po początkowym przebiegu, które różnią się długością od zapamiętanej długości, dają wynik fałszowania. Na koniec sprawdzana jest relacja drugiego do ostatniego elementu, tak aby pasowała do reszty listy.

Pyth , 11 bajtów

qFlM.g._k.+

Wypróbuj tutaj.

Python 2 , 107 105 103 97 96 94 91 bajtów

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

Wypróbuj online!

Python 3 , 102 100 97 bajtów

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

Wypróbuj online!

Łuska , 7 bajtów

EmLġ±Ẋ-

Wypróbuj online!

Jak to działa

EmLġ ± Ẋ- ~ Pełny program.

     Ẋ ~ Mapuj nad parami sąsiednich elementów.
      - ~ Z odejmowaniem (to oblicza delty)
   Group ~ Grupuj za pomocą predykatu równości.
    ± ~ Znak.
 mL ~ Uzyskaj długości.
E ~ Czy wszyscy są równi?

Kilka uroczych alternatyw:

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

JavaScript (ES6), 81 bajtów

To wydaje się za długie. Ja chyba czegoś brakuje tutaj ... Powraca albo truealbo 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)

Poszukuje okresu 0 <p <a. Długości tak, że wszystkie zmiany kierunku następują co p elementów.

Przypadki testowe

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 bajtów

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

Wypróbuj online! Wyjście przez kod wyjścia: crash (1) jest falsey, czyste wyjście (0) jest prawdą.

Python 2 , 106 bajtów

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

Wypróbuj online!

Haskell , 79 78 77 bajtów

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

Wypróbuj online!

Biorąc pod uwagę listę s, zipWith(<)s$tail ssprawdza, czy każdy element jest mniejszy niż jego następca, np . s=[2,3,6,4,2,3,7,5,3]Daje plon [True,True,False,False,True,True,False,False]. Następnie groupuruchamia te same elementy razem:[[True,True],[False,False],[True,True],[False,False]] . Aby sprawdzić, czy wszystkie te listy mają taką samą długość, zastąpić ich elementów z 1( zobacz tę końcówkę ) plonowanie [[1,1],[1,1],[1,1],[1,1]]i sprawdzić, czy wszystkie elementy ogona ttej listy równa głowę h: all(==h)t.

Takie podejście nie działa dla pojedynczych list, ale ponieważ są zawsze prawdziwe, możemy je obsługiwać w ich przypadku: g[_]=1<3.

R , 57 bajtów

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

Wypróbuj online!

Japt , 15 bajtów

ä- mg ò¦ mÊä¥ e

Wypróbuj online!

Wyjaśnienie

ä- 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 bajtów

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

diffoblicza kolejne różnice, a następnie signzmniejsza je do ± 1. rlenastępnie koduje ich długość. Wszystkie elementy tego rlepowinny być takie same, tzn. Wektor ma odchylenie standardowe zero. !następnie tworzy poprawne wyjście logiczne.

Haskell (Lambdabot), 59 bajtów

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

Na podstawie odpowiedzi @ Laikoni

Java (OpenJDK 8) , 437 302 256 188 bajtów

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

Wypróbuj online!

Clojure, 70 bajtów

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

Zwraca 1jako prawda i nil(AKA null) jako fałsz.

Java (OpenJDK 8) , 135 bajtów

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

Wypróbuj online!

Objaśnienia

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 bajtów

-11 bajtów dzięki @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

Wypróbuj online!

Rubinowy , 57 bajtów

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

Wypróbuj online!