Thử thách

Đưa ra một danh sách, xác định xem việc nhóm danh sách thành các phần tử tăng và giảm sẽ dẫn đến một danh sách các danh sách có kích thước bằng nhau.

Nói cách khác, "bước ngoặt" của danh sách được đặt cách đều nhau.

Thí dụ

Đây là một ví dụ: 0, 3, 7, 5, 2, 3, 6

0, 3, 7tăng, 7, 5, 2giảm và 2, 3, 6tăng Vì vậy, đây là sự thật.

Một vi dụ khac: 1, 4, 6, 8, 5, 3, 5, 7, 9

1, 4, 6, 8tăng, 8, 5, 3giảm và 3, 5, 7, 9tăng Vì vậy, đây là giả.

Quy tắc và thông số kỹ thuật

• Không có phần tử liền kề sẽ bằng nhau
• Tất cả các số có thể được coi là nằm trong phạm vi số hợp lý của ngôn ngữ của bạn
• Bạn có thể cho rằng tất cả các số là số nguyên, nếu nó giúp bạn đánh bài
• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất sẽ thắng
• Nhập dưới dạng danh sách trong bất kỳ biểu diễn và đầu ra hợp lý nào dưới dạng giá trị trung thực / giả. Hai giá trị phải nhất quán.

Các trường hợp thử nghiệm

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

Lưu ý : Bạn không được cho rằng tất cả các số là một chữ số (trừ khi đó là tất cả ngôn ngữ của bạn có khả năng xử lý); các trường hợp thử nghiệm phản ánh rằng chỉ vì tôi dễ dàng nhập các trường hợp theo cách này: P Dưới đây là một vài trường hợp thử nghiệm có số nằm ngoài phạm vi đó:

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~

Hãy thử trực tuyến!

Đã lưu một byte nhờ Luis Mendo!

Giải trình:

Giả sử đầu vào là [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

Thạch , 6 byte

IṠŒgAE

Hãy thử trực tuyến!

Đã lưu 1 byte nhờ Adnan !

Làm thế nào nó hoạt động

IṠŒgAE - Chương trình đầy đủ.

I - Số tăng (Deltas).
 Ṡ - Dấu hiệu của mỗi. -1 nếu âm, 0 nếu null, 1 nếu dương.
  Œg - Nhóm chạy các phần tử liền kề.
    A - Giá trị tuyệt đối. Vector hóa. Điều này ánh xạ -1 và 1 đến cùng một giá trị.
     E - Tất cả có bằng nhau không?

Trong khi chơi golf, tôi phát hiện ra một số lựa chọn thay thế dài hơn, mát mẻ hơn : IṠŒgL€E, IṠŒrṪ€E(sử dụng mã hóa chiều dài chạy thay thế).

Octave , 54 50 byte

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

Hãy thử trực tuyến!

Giải trình

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

Ngôn ngữ Wolfram (Mathicala) , 38 byte

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

Hãy thử trực tuyến!

Giải trình

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Ë

Hãy thử trực tuyến!

-1 cảm ơn Ad Nam.

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

• Đã lưu ba byte; sử dụng một biến rđể lưu trữ boolean trả về của hàm thay vì kết thúc bằng cách sử dụng return.
• Đã lưu hai byte; chơi golf int A[]để int*A(sử dụng một con trỏ thay vì một mảng).
• Đã lưu hai byte nhờ Steadybox ; chơi golf f(int*A,int a)để f(A,a)int*A;.
• Đã lưu một byte; chơi golf if(d!=...để if(d-....
• Đã lưu ba byte; chơi golf ;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;}

Hãy thử trực tuyến!

Xác định một hàm fxem xét mọi phần tử trong danh sách nhưng phần cuối cùng và xác định mối quan hệ của phần tử này với phần tử tiếp theo trong danh sách. Số lượng so sánh bằng nhau liên tiếp được lưu trữ trong lần đầu tiên quan hệ lật, bất kỳ lần chạy nào sau lần chạy ban đầu khác nhau về chiều dài với chiều dài được lưu trữ dẫn đến đầu ra sai lệch. Cuối cùng, mối quan hệ của yếu tố thứ hai đến cuối cùng với yếu tố cuối cùng được xem xét để nó phù hợp với phần còn lại của danh sách.

Bình thường , 11 byte

qFlM.g._k.+

Hãy thử nó ở đây.

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*

Hãy thử trực tuyến!

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*

Hãy thử trực tuyến!

Husk , 7 byte

EmLġ±Ẋ-

Hãy thử trực tuyến!

Làm thế nào điều này hoạt động

EmLġ ±-~ Chương trình đầy đủ.

     Ẋ ~ Ánh xạ qua các cặp phần tử liền kề.
      - ~ Với phép trừ (cái này tính toán vùng đồng bằng)
   ~ Nhóm sử dụng vị ngữ đẳng thức.
    ± ~ Dấu hiệu.
 mL ~ Lấy độ dài.
E ~ Có phải tất cả đều bằng nhau?

Một số lựa chọn thay thế dễ thương:

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

JavaScript (ES6), 81 byte

Điều này dường như quá dài. Có lẽ tôi đang thiếu một cái gì đó ở đây ... Trả về truehoặc 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)

Tìm kiếm một khoảng thời gian 0 <p <a.length sao cho tất cả các thay đổi hướng xảy ra mọi yếu tố p .

Các trường hợp thử nghiệm

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

Hãy thử trực tuyến! Đầu ra thông qua mã thoát: crash (1) là falsey, sạch exit (0) là đúng.

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

Hãy thử trực tuyến!

Haskell , 79 78 77 byte

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

Hãy thử trực tuyến!

Đưa ra một danh sách s, zipWith(<)s$tail skiểm tra cho từng yếu tố cho dù nó nhỏ hơn so với người kế nhiệm của nó, ví dụ như s=[2,3,6,4,2,3,7,5,3]sản lượng [True,True,False,False,True,True,False,False]. Sau đó groupchạy các yếu tố tương tự với nhau : [[True,True],[False,False],[True,True],[False,False]]. Để kiểm tra xem tất cả các danh sách đó có cùng độ dài hay không, hãy thay thế các phần tử của chúng bằng 1( xem mẹo này ) [[1,1],[1,1],[1,1],[1,1]]và kiểm tra xem tất cả các phần tử trong đuôi tcủa danh sách này có bằng phần đầu không h: all(==h)t.

Cách tiếp cận này không hoạt động cho các danh sách đơn lẻ, nhưng vì những điều đó luôn đúng, chúng tôi có thể xử lý chúng trong trường hợp của riêng họ : g[_]=1<3.

R , 57 byte

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

Hãy thử trực tuyến!

Japt , 15 byte

ä- mg ò¦ mÊä¥ e

Hãy thử trực tuyến!

Giải trình

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

difftính toán sự khác biệt liên tiếp, sau đó signsquish những khác biệt xuống đến 1. rlesau đó run-length mã hóa chúng. Tất cả các yếu tố của điều này rlenên giống nhau, tức là vectơ có độ lệch chuẩn bằng không. !sau đó tạo ra đầu ra logic chính xác.

Haskell (Lambdabot), 59 byte

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

Dựa trên câu trả lời của @ 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;}

Hãy thử trực tuyến!

Clojure, 70 byte

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

Trả về 1là sự thật và nil(AKA null) là giả.

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

Hãy thử trực tuyến!

Giải thích

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 nhờ @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

Hãy thử trực tuyến!

Ruby , 57 byte

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

Hãy thử trực tuyến!