Виклик

Давши список, визначте, чи групування списку у прогонки елементів, що збільшуються та зменшуються, призведе до списку рівних розмірів.

Іншими словами, "поворотні точки" списку розподіляються рівномірно.

Приклад

Ось приклад: 0, 3, 7, 5, 2, 3, 6

0, 3, 7збільшується, 7, 5, 2зменшується і 2, 3, 6збільшується. Тому це правда.

Інший приклад: 1, 4, 6, 8, 5, 3, 5, 7, 9

1, 4, 6, 8збільшується, 8, 5, 3зменшується і 3, 5, 7, 9збільшується. Тому це хибність.

Правила та технічні характеристики

• Жодні сусідні елементи не будуть рівними
• Можна вважати, що всі цифри знаходяться в межах розумного числа вашої мови
• Ви можете припустити, що всі числа є цілими числами, якщо це допоможе вам відіграти ваш подання
• Це код-гольф , тому найкоротша відповідь виграє
• Введіть як список у будь-якому розумному поданні та виведіть як будь-яке значення truthy / false. Дві значення повинні відповідати.

Випробування

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

Примітка . Ви можете не припускати, що всі числа є одноцифровими (якщо це не вся ваша мова, яка може обробити); тестові приклади відображають це лише тому, що мені простіше ввести справи таким чином: P Ось декілька тестових випадків із цифрами поза цим діапазоном:

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 байт

dZS&Y'da~

Спробуйте в Інтернеті!

Збережено один байт завдяки Луїсу Мендо!

Пояснення:

Припустимо, вхід: [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

Желе , 6 байт

IṠŒgAE

Спробуйте в Інтернеті!

Збережено 1 байт завдяки Аднану !

Як це працює

IṠŒgAE - Повна програма.

I - збільшення (дельти).
 Ṡ - Знак кожного. -1 якщо від’ємний, 0 якщо нульовий, 1 якщо позитивний.
  Œg - Групові пробіги суміжних елементів.
    A - Абсолютне значення. Векторизує. Це відображає -1 і 1 на одне значення.
     Е - чи всі рівні?

У той час як гра в гольф, я виявив деякі прохолодно, довші варіанти: IṠŒgL€E, IṠŒrṪ€E(використання по довжині прогону закодувати , а).

Октава , 54 50 байт

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

Спробуйте в Інтернеті!

Пояснення

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

Мова Вольфрама (Mathematica) , 38 байт

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

Спробуйте в Інтернеті!

Пояснення

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 байт

¥0.SγaË

Спробуйте в Інтернеті!

-1 завдяки Аднану.

C (gcc) , 143 140 138 136 135 132 байт

• Збережено три байти; за допомогою змінноїr для зберігання бульової функції функції замість припинення використання return.
• Збережено два байти; гольфint A[] на int*A(використовуючи вказівник замість масиву).
• Збережено два байти завдяки Steadybox ; гольфf(int*A,int a) до f(A,a)int*A;.
• Збережено байт; гольфif(d!=... до if(d-....
• Збережено три байти; гольф ;j++...j+1до ;...++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;}

Спробуйте в Інтернеті!

Визначає функцію, fяка переглядає кожен елемент у списку, але останній, і визначає відношення цього елемента до наступного елемента у списку. Кількість послідовних рівних порівнянь зберігається вперше, коли відношення перевертається, а будь-який пробіг після початкового пробігу, який відрізняється за довжиною до збереженої довжини, призводить до помилкового виходу. Наприкінці розглядається відношення другого до останнього елемента до останнього елемента, щоб воно відповідало решті списку.

Pyth , 11 байт

qFlM.g._k.+

Спробуйте тут.

Python 2 , 107 105 103 97 96 94 91 байт

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

Спробуйте в Інтернеті!

Python 3 , 102 100 97 байт

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

Спробуйте в Інтернеті!

Лушпиння , 7 байт

EmLġ±Ẋ-

Спробуйте в Інтернеті!

Як це працює

EmLġ ± Ẋ- ~ Повна програма.

     Ẋ ~ Позначте пару пар суміжних елементів.
      - ~ З відніманням (це обчислює дельти)
   ġ ~ Групуйте за допомогою присудка рівності.
    ± ~ Знак.
 мл ~ Отримайте довжини.
Е ~ Чи всі рівні?

Деякі милі варіанти:

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

JavaScript (ES6), 81 байт

Це здається занадто довгим. Я, мабуть, щось тут пропускаю ... Повертається trueабо 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)

Шукає період 0 <p <a.length такий, що всі зміни напрямку відбуваються на всіх p елементах.

Тестові справи

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 байт

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

Спробуйте в Інтернеті!Вихід через вихідний код: аварія (1) - фальси, чистий вихід (0) - правда.

Python 2 , 106 байт

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

Спробуйте в Інтернеті!

Haskell , 79 78 77 байт

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

Спробуйте в Інтернеті!

Дано список s, zipWith(<)s$tail sтестуючи для кожного елемента, чи менший він від його наступника, наприклад, s=[2,3,6,4,2,3,7,5,3]урожайність [True,True,False,False,True,True,False,False]. Потім groupвиконується з тих же елементів , а також : [[True,True],[False,False],[True,True],[False,False]]. Щоб перевірити, чи мають усі ці списки однакову довжину, замініть їхні елементи на 1( див. Цю пораду ), [[1,1],[1,1],[1,1],[1,1]]і перевірте, чи всі елементи в кінці tцього списку рівні головці h:all(==h)t .

Такий підхід не працює для одноелементні списків, а тому , що ті завжди вірні, ми можемо звертатися з ними в їх власному випадку: g[_]=1<3.

R , 57 байт

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

Спробуйте в Інтернеті!

Japt , 15 байт

ä- mg ò¦ mÊä¥ e

Спробуйте в Інтернеті!

Пояснення

ä- 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 байт

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

diffобчислює послідовні відмінності, а потім signприбирає їх до ± 1. rleпотім кодова довжина кодує їх. Усі елементи цього rleповинні бути однаковими, тобто вектор має стандартне нульове відхилення. !потім виробляє правильний логічний висновок.

Haskell (Lambdabot), 59 байт

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

На основі відповіді @ Лайконі

Java (OpenJDK 8) , 437 302 256 188 байт

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

Спробуйте в Інтернеті!

Clojure, 70 байт

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

Повертається 1як істинна і nil(AKA null) як хибна.

Java (OpenJDK 8) , 135 байт

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

Спробуйте в Інтернеті!

Пояснення

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 байт

-11 байт завдяки @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

Спробуйте в Інтернеті!

Рубін , 57 байт

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

Спробуйте в Інтернеті!