Вызов

По заданному списку определите, приведет ли группировка списка к возрастающим и убывающим элементам в результате получится список списков одинакового размера.

Другими словами, «поворотные точки» списка расположены равномерно.

пример

Вот пример: 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увеличивается. Поэтому это ложь.

Правила и характеристики

• Никакие смежные элементы не будут равны
• Можно предположить, что все числа находятся в пределах разумного диапазона номеров вашего языка
• Вы можете предположить, что все числа являются целыми числами, если это поможет вам подать заявку
• Это код-гольф , поэтому выигрывает самый короткий ответ
• Вводить в виде списка в любом разумном представлении и выводить как любое значение «истина / ложь». Два значения должны быть согласованы.

Тестовые случаи

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 - Полная программа.

Я - Приращения (Дельты).
 Sign - знак каждого. -1 если отрицательный, 0 если ноль, 1 если положительный.
  Œg - Группировка прогонов смежных элементов.
    А - Абсолютное значение. Векторизация. Это отображает -1 и 1 на одно и то же значение.
     E - Все равны?

В то время как игра в гольф, я обнаружил некоторые прохладно, более длинные варианты: 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

Wolfram Language (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ġ ± Ẋ- ~ Полная программа.

     Map ~ Карта над парами смежных элементов.
      - ~ С вычитанием (это вычисляет дельты)
   Group ~ Группа с использованием предиката равенства.
    ± ~ Знак
 мл ~ Получить длины.
E ~ Все равны?

Несколько милых альтернатив:

εġ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<_

Попробуйте онлайн! Вывод через код выхода: crash (1) - false, чистый выход (0) - true.

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

На основании ответа @ Laikoni

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

Попробуйте онлайн!