도전

목록이 주어지면 목록을 증가 및 감소 요소로 그룹화하여 동일한 크기의 목록 목록을 생성하는지 확인하십시오.

즉, 목록의 "전환 지점"이 균등하게 배치됩니다.

예

예를 들면 다음과 같습니다. 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증가합니다. 그러므로 이것은 거짓입니다.

규칙 및 사양

• 인접한 요소가 동일하지 않습니다
• 모든 숫자는 해당 언어의 합리적인 숫자 범위 내에 있다고 가정 할 수 있습니다
• 제출물을 골프화하는 데 도움이된다면 모든 숫자가 정수라고 가정 할 수 있습니다
• 이것은 code-golf 이므로 가장 짧은 답변이 이깁니다.
• 합리적인 표현으로 목록으로 입력하고 진실 / 거짓 값으로 출력합니다. 두 값은 일치해야합니다.

테스트 사례

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

참고 : 모든 숫자가 한 자리수라고 가정 할 수는 없습니다 (모든 언어가 처리 할 수있는 경우가 아니라면). 테스트 사례는 내가 이런 방식으로 사례를 입력하는 것이 더 쉽기 때문에 다음과 같이 반영합니다.

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~

온라인으로 사용해보십시오!

Luis Mendo 덕분에 1 바이트를 절약했습니다!

설명:

입력이 다음 [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

온라인으로 사용해보십시오!

Adnan 덕분에 1 바이트 절약 !

작동 원리

IṠŒgAE-전체 프로그램.

I-증분 (델타).
 Ṡ-각각의 부호. 음수이면 -1, null이면 0, 양수이면 1
  Œg-인접한 요소로 구성된 그룹 런.
    A-절대 값. 벡터화합니다. -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Ë

온라인으로 사용해보십시오!

Adnan에게 -1 감사합니다.

C (GCC) , 143 (140) 138 136 135 132 바이트

• 3 바이트를 절약했습니다. 를 사용하여 r종료하는 대신 변수 를 사용하여 함수의 반환 부울을 저장합니다 return.
• 2 바이트를 절약했습니다. 골퍼 int A[]에게 int*A(배열 대신 포인터 사용).
• Steadybox 덕분에 2 바이트를 절약했습니다 . 골프 f(int*A,int a)에 f(A,a)int*A;.
• 바이트를 저장했습니다. 골프 if(d!=...에 if(d-....
• 3 바이트를 절약했습니다. 골프 ;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.+

여기에서 시도하십시오.

파이썬 (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*

온라인으로 사용해보십시오!

파이썬 (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ġ ± Ẋ- ~ 전체 프로그램.

     Ẋ ~ 인접한 요소 쌍에 매핑합니다.
      -~ 빼기 (델타 계산)
   ġ ~ 등호 술어를 사용하여 그룹화합니다.
    ± ~ 부호.
 mL ~ 길이를 얻습니다.
E ~ 모두 평등합니까?

몇 가지 귀여운 대안 :

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

자바 스크립트 (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)

모든 방향 변화가 p 요소 마다 발생 하도록주기 0 <p <a.length를 찾습니다 .

테스트 사례

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

파이썬 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)가 사실입니다.

파이썬 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

온라인으로 사용해보십시오!

하스켈 , 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는 같아야합니다. 즉, 벡터의 표준 편차는 0입니다. !그런 다음 올바른 논리 출력을 생성합니다.

하스켈 (Lambdabot), 59 바이트

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

@Laikoni의 답변을 바탕으로

자바 (오픈 JDK 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;}

온라인으로 사용해보십시오!

클로저, 70 바이트

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

1진실로 반환 하고 허위로 nil(AKA null) 반환합니다.

자바 (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.
}

파이썬 2 , 110 99 바이트

@Lynn 덕분에 -11 바이트

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

온라인으로 사용해보십시오!