Viết chương trình để xác định xem một chuỗi số nguyên dương có định tính hay không, với mỗi số nguyên nxảy ra trong chuỗi, không bao giờ có nhiều hơn ncác số nguyên khác giữa hai lần xuất hiện liên tiếp n.

Ví dụ: 2, 3, 5, 2, 3, 6, 2, 3, 5, 2, 3, 6, ...không có thuộc tính này: mọi cặp lần xuất hiện liên tiếp 2có nhiều nhất hai số nguyên giữa chúng (chẳng hạn như 2, 3, 5, 2và 2, 3, 6, 2mỗi cặp lần xuất hiện liên tiếp 3có nhiều nhất ba số nguyên giữa chúng và cùng một 5và cho 6.

Tuy nhiên, 2, 3, 5, 2, 3, 4, 2, 3, 5, 2, 3, 4, ...không có thuộc tính này: hai lần xuất hiện liên tiếp 4, cụ thể là 4, 2, 3, 5, 2, 3, 4, có nhiều hơn bốn số nguyên giữa chúng.

Đầu vào : một biểu diễn hợp lý của một chuỗi số nguyên dương. Ví dụ, một danh sách hữu hạn như {2, 3, 5, 2, 3, 6}có thể biểu diễn chuỗi vô hạn đầu tiên 2, 3, 5, 2, 3, 6, 2, 3, 5, 2, 3, 6, ...ở trên. (Đối với vấn đề đó, vấn đề có thể được nêu ra đối với các danh sách hữu hạn bao quanh thay vì danh sách định kỳ vô hạn.)

Đầu ra : một giá trị trung thực / giả.

Ví dụ thật:

{1}
{8, 9}
{2, 3, 4}
{5, 5, 3, 3, 6}
{2, 3, 5, 2, 3, 6}
{6, 7, 3, 5, 3, 7}
{9, 4, 6, 7, 4, 5}
{1, 1, 1, 1, 1, 100, 1}
{1, 9, 1, 8, 1, 7, 1, 11}

Ví dụ giả mạo:

{1, 2, 3}
{2, 3, 9, 5}
{3, 5, 4, 4, 6}
{2, 3, 5, 2, 3, 4}
{3, 5, 7, 5, 9, 3, 7}
{5, 6, 7, 8, 9, 10, 11}
{1, 9, 1, 8, 1, 6, 1, 11}

Đây là codegolf , vì vậy mã ngắn nhất sẽ thắng. Câu trả lời trong tất cả các ngôn ngữ được khuyến khích.

Haskell, 60 57 56 55 byte

f(a:b)=b==[]||length(fst$span(/=a)b)<=a&&f b
g x=f$x++x

Giả sử rằng danh sách đầu vào chứa ít nhất một yếu tố.

Ví dụ sử dụng: g [1]-> True. Hãy thử trực tuyến!

Hãy alà người đứng đầu của danh sách và bđuôi. Kết quả là Truenếu btrống hoặc số phần tử ở đầu bkhông bằng akhông lớn hơn avà cuộc gọi đệ quy của f bcũng là True, khác False. Bắt đầu với hai lần danh sách đầu vào.

Chỉnh sửa: @Leo lưu 3 byte. Cảm ơn!

Chỉnh sửa 2: @Laikoni lưu 1 byte. Cảm ơn!

Python , 57 56 byte

-1 byte nhờ Dennis (thay thế i+1:i+v+2với i:i-~vvới một ibù đắp trong tổng số 1 từ enumerate)

lambda a:all(v in(a+a)[i:i-~v]for i,v in enumerate(a,1))

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

Chức năng giấu tên tham gia một danh sách, avà thử nghiệm với điều kiện là mỗi giá trị, v, xuất hiện inslice có liên quan đến quyền của mình trong một nối của avới chính nó, (a+a)[i:i-~v]nơi chỉ số 1 dựa trên vtrong a, i, được cung cấp bởi enumerate(a,1).

JavaScript (ES6), 67 65 55 54 51 49 byte

Đã lưu 3B nhờ @ETHproductions và 2B nhờ @Arnauld

a=>!a.some((b,c)=>a.concat(a).indexOf(b,++c)>b+c)

Giải trình

Điều này xác định một hàm lấy một mảng alàm đầu vào. Sau đó, .somephương thức lặp lại trên mảng đó, thực thi một hàm khác cho mọi phần tử.

Hàm bên trong này có hai đối số, bvà c, giá trị hiện tại và chỉ mục của nó. Hàm tìm chỉ mục của giá trị hiện tại, bắt đầu từ chỉ mục c + 1. Sau đó, nó kiểm tra nếu chỉ số này lớn hơn giá trị hiện tại cộng với chỉ số hiện tại (chênh lệch giữa hai lần xuất hiện của cùng một giá trị lớn hơn b). Lưu ý rằng điều này trả về chính xác ngược lại với những gì chúng ta muốn.

Nếu một trong các giá trị trả về này là true, .somehàm cũng trả về true. Nếu không có kiểm tra nào trả về true, .somehàm sẽ trả về false. Một lần nữa ngược lại với giá trị chúng tôi muốn trả về, vì vậy kết quả này bị phủ định và sau đó được trả về.

Kiểm tra nó

Hãy thử tất cả các trường hợp thử nghiệm ở đây:

let f=
a=>!a.some((b,c)=>a.concat(a).indexOf(b,++c)>b+c)

let truthy = [[1], [8, 9], [2, 3, 4], [5, 5, 3, 3, 6], [2, 3, 5, 2, 3, 6], [6, 7, 3, 5, 3, 7], [9, 4, 6, 7, 4, 5], [1, 1, 1, 1, 1, 100, 1], [1, 9, 1, 8, 1, 7, 1, 11]];
let falsy  = [[1, 2, 3], [2, 3, 9, 5], [3, 5, 4, 4, 6], [2, 3, 5, 2, 3, 4], [3, 5, 7, 5, 9, 3, 7], [5, 6, 7, 8, 9, 10, 11], [1, 9, 1, 8, 1, 6, 1, 11]];

console.log("Truthy test cases:");
for (let test of truthy) {
    console.log(`${test}: ${f(test)}`);
}

console.log("Falsy test cases:");
for (let test of falsy) {
    console.log(`${test}: ${f(test)}`);
}

Thạch , 11 byte

ṣZL
;çЀ<‘P

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

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

;çЀ<‘P  Main link. Argument: A (array)

;        Concatenate A with itself.
 çD€     For each n in A, call the helper with left arg. A + A and right arg. n.
     ‘   Increment all integers in A.
    <    Perform element-wise comparison of the results to both sides.
      P  Take the product of the resulting Booleans.


ṣZL      Helper link. Left argument: A. Right argument: n

ṣ        Split A at all occurrences of n.
 Z       Zip to transpose rows and columns.
  L      Length; yield the number of rows, which is equal to the number of columns
         of the input to Z.

Thạch , 8 byte

ṙJḣ"‘Œpċ

Insipred bởi câu trả lời Python của @ Jonathan ALLan .

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

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

ṙJḣ"‘Œpċ  Main link. Argument: A (array)

 J        Yield the indicies of A, i.e., [1, ..., len(A)].
ṙ         Rotate; yield A, rotated 1, ..., and len(A) units rotated to the left.
    ‘     Increment; add 1 to all elements of A.
  ḣ"      Head zipwith; truncate the n-th rotation to length A[n]+1.
     Œp   Take the Cartesian product of all resulting truncated rotations.
       ċ  Count the number of times A appears in the result.

SWI-Prolog, 83 byte

a(L,[H|R]):-nth0(X,R,H),H>=X,a(L,R);length(R,N),nth0(X,L,H),H>=N+X,a(L,R).
a(_,[]).

Danh sách nên được nhập hai lần:

a([1,2,3],[1,2,3]).

Nếu điều này không được coi là chấp nhận được, bạn có thể thêm vị ngữ

a(L):-a(L,L).

có thêm 14 byte.

Dùng thử trực tuyến

nb: bạn có thể kiểm tra các trường hợp sai khác nhau cùng một lúc bằng cách tách các truy vấn của bạn bằng ';' (hoặc) và kiểm tra các trường hợp thực tế khác nhau bằng cách tách bằng ',' (và)

tức là sử dụng các ví dụ OP:

a([1],[1]),
a([8, 9],[8, 9]),
a([2, 3, 4],[2, 3, 4]),
a([5, 5, 3, 3, 6],[5, 5, 3, 3, 6]),
a([2, 3, 5, 2, 3, 6],[2, 3, 5, 2, 3, 6]),
a([6, 7, 3, 5, 3, 7],[6, 7, 3, 5, 3, 7]),
a([9, 4, 6, 7, 4, 5],[9, 4, 6, 7, 4, 5]),
a([1, 1, 1, 1, 1, 100, 1],[1, 1, 1, 1, 1, 100, 1]),
a([1, 9, 1, 8, 1, 7, 1, 11],[1, 9, 1, 8, 1, 7, 1, 11]).

và

a([1, 2, 3],[1, 2, 3]);
a([2, 3, 9, 5],[2, 3, 9, 5]);
a([3, 5, 4, 4, 6],[3, 5, 4, 4, 6]);
a([2, 3, 5, 2, 3, 4],[2, 3, 5, 2, 3, 4]);
a([3, 5, 7, 5, 9, 3, 7],[3, 5, 7, 5, 9, 3, 7]);
a([5, 6, 7, 8, 9, 10, 11],[5, 6, 7, 8, 9, 10, 11]);
a([1, 9, 1, 8, 1, 6, 1, 11],[1, 9, 1, 8, 1, 6, 1, 11]).

PHP, 52 byte

for(;$n=$argv[++$i];$$n=$i)!$$n|$i-$$n<$n+2?:die(1);

lấy chuỗi từ các đối số dòng lệnh; thoát với mã 1cho giả, 0cho sự thật.
Chạy với -nr.

• lặp $nqua các đối số:
  • nếu không có sự xuất hiện trước đó hoặc nó đã đủ gần đây
    thì không làm gì cả, hãy thoát bằng mã khác1
  • nhớ sự xuất hiện trước đó trong $$n( biến số )
• thoát với mã 0(ẩn)

Võng mạc , 50 byte

$
,$`
M!&`\b(1+),.*?\b\1\b
+%`(^1*)1,1+
$1
M`1,
^0

Nhập dưới dạng danh sách các số đơn nguyên phân tách bằng dấu phẩy.

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

Giải trình

$
,$`

Sao chép đầu vào để chúng tôi có thể kiểm tra các bước bao quanh cuối.

M!&`\b(1+),.*?\b\1\b

Khớp và trả lại từng phần (ngắn nhất) giữa hai giá trị giống nhau, ví dụ 11,111,1,11.

+%`(^1*)1,1+
$1

Liên tục xóa một chữ số từ số đầu tiên, cùng với toàn bộ số sau nó. Nếu khoảng cách đủ nhỏ, điều này sẽ loại bỏ hoàn toàn số đầu tiên. Nếu không, ít nhất một chữ số sẽ vẫn còn.

M`1,

Đếm tần suất 1,xuất hiện trong tất cả các dòng. Nếu nó xuất hiện ở bất cứ đâu, một trong những bước quá rộng.

^0

Cố gắng khớp một số bắt đầu bằng 0(chỉ có 0chính nó). Đây thực sự là một sự phủ định logic của đầu ra.

JavaScript (ES6), 47 byte

a=>![...a,...a].some((n,i)=>a[-n]-(a[-n]=i)<~n)

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

Chúng tôi sử dụng lại mảng đầu vào ađể lưu trữ vị trí của lần xuất hiện cuối cùng của mỗi số nguyên trong a. Chúng tôi sử dụng chìa khóa -nđể lưu trữ vị trí này để nó không can thiệp vào các chỉ số ban đầu của a.

Khi a[-n]tồn tại, thử nghiệm thực tế xảy ra. Khi a[-n]không tồn tại, biểu thức a[-n] - (a[-n] = i)bằng undefined - i == NaNvà so sánh ~nluôn luôn sai lệch, đó là kết quả mong đợi.

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

f=
a=>![...a,...a].some((n,i)=>a[-n]-(a[-n]=i)<~n)

console.log('Truthy cases:');
console.log(f([1]));
console.log(f([8, 9]));
console.log(f([2, 3, 4]));
console.log(f([5, 5, 3, 3, 6]));
console.log(f([2, 3, 5, 2, 3, 6]));
console.log(f([6, 7, 3, 5, 3, 7]));
console.log(f([9, 4, 6, 7, 4, 5]));
console.log(f([1, 1, 1, 1, 1, 100, 1]));
console.log(f([1, 9, 1, 8, 1, 7, 1, 11]));

console.log('Falsy cases:');
console.log(f([1, 2, 3]));
console.log(f([2, 3, 9, 5]));
console.log(f([3, 5, 4, 4, 6]));
console.log(f([2, 3, 5, 2, 3, 4]));
console.log(f([3, 5, 7, 5, 9, 3, 7]));
console.log(f([5, 6, 7, 8, 9, 10, 11]));
console.log(f([1, 9, 1, 8, 1, 6, 1, 11]));

Võng mạc ,  41 39 byte

Nhân tiện, 2 byte được chơi nhờ Martin Ender, nhân tiện đã giới thiệu cho tôi các nhóm cân bằng với hướng dẫn tuyệt vời của anh ấy về SO

$
,$`,
((1)+,)(?=(?<-2>1+,)*(\1|$))

^$

Đầu vào là một danh sách các số đơn nguyên được phân tách bằng dấu phẩy. Đầu ra là 0sai và 1đúng.

Hãy thử trực tuyến! (Bộ kiểm tra tự động chuyển đổi từ số thập phân)

Gần đây tôi đã tìm hiểu về các nhóm cân bằng, vì vậy tôi muốn thử chúng. Chúng không phải là một trong những công cụ dễ sử dụng nhất, nhưng chắc chắn chúng rất mạnh.

Giải trình

$
,$`,

Như nhiều bài nộp khác, chúng tôi nhân đôi danh sách để xử lý gói. Chúng tôi cũng thêm dấu phẩy ở cuối, vì vậy mọi số được theo sau bởi dấu phẩy (điều này làm cho mọi thứ sau này dễ dàng hơn một chút)

((1)+,)(?=(?<-2>1+,)*(\1|$))

Đây là nơi mọi thứ trở nên thú vị. Đây là giai đoạn thay thế, chúng tôi thay thế mọi thứ khớp với dòng đầu tiên bằng dòng thứ hai, trong trường hợp này chúng tôi đang tìm cách loại bỏ tất cả các số nkhông theo saun+1 các số khác nhau.

Để làm như vậy, trước tiên chúng ta khớp số, bắt từng 1nhóm trong một nhóm (chụp nhóm số 2 trong trường hợp này). Sau đó, với một cái nhìn tích cực, để có một khẳng định độ rộng bằng không, chúng tôi liên tục cố gắng khớp trong một nhóm cân bằng -2, điều đó sẽ thành công không nhiều hơn số lần chụp theo nhóm 2, một số theo sau là dấu phẩy. Sau dãy số này, chúng tôi hài lòng nếu chúng tôi đạt được số đầu tiên một lần nữa hoặc cuối dòng.

Lưu ý: biểu thức này có thể chỉ khớp với phần cuối của một số, nếu nó không tìm được kết quả khớp với số đầy đủ. Đây không phải là một vấn đề, bởi vì sau đó phần đầu tiên của số sẽ vẫn nằm trong chuỗi và chúng ta sẽ biết rằng sự thay thế đã không hoàn toàn thành công.

^$

Cuối cùng, kết quả phải là sự thật nếu chúng tôi đã loại bỏ hoàn toàn tất cả các số trong danh sách. Chúng tôi cố gắng khớp chuỗi trống và trả về số lượng kết quả tìm thấy.

Thạch , 11 byte

ẋ2ĠṢI_2<"QȦ

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

ẋ2ĠṢI_2<"QȦ  Main link. Argument: A (array)

ẋ2           Repeat A twice to account for wrap-around.
  Ġ          Group all indices of A + A by their respective values, sorting the
             index groups by the associated values.
   Ṣ         Sort the groups lexicographically, i.e., by first appearance in A.
    I        Increments; compute the forward differences of adjacent indices in
             each of the groups.
     _2      Subtract 2 from the differences.
         Q   Unique; yield A, deduplicated.
       <"    Compare all differences in the index group corresponding to the n-th
             unique value in A with the n-th unqiue value in A.
          Ȧ  All; yield 1 if and only if none of the comparisons returned 0.

Python 3 , 101 byte

lambda l:all(v>=(l[i+1:].index(v)if v in l[i+1:]else len(l[i+1:])+l.index(v))for i,v in enumerate(l))

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

Röda , 50 byte

f a{seq 0,#a-1|[indexOf(a[_],a[_1+1:]..a)<=a[_1]]}

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

Cuối cùng! Tôi đã được chờ đợi cho thách thức này ...

Đó là một hàm trả về giá trị trung thực hoặc giả. Nó nhận một đối số, mảng.

Nó lặp đi lặp lại qua một luồng các chỉ số và kiểm tra cho mỗi chỉ số _1rằng khoảng cách của chỉ mục hiện tại và chỉ mục tiếp theo a[_1]không lớn hơn a[_1].

05AB1E , 13 byte

Dì©v®¦©yky›_P

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

Dì             # duplicate input and prepend the copy to the original
  ©            # store a copy in the register
   v           # for each element in the list
    ®          # push the list from register
     ¦©        # remove the first element and store a copy in the register
       yk      # get the index of the current element in the list
         y›_   # check if it's less than or equal to the current element
            P  # product of stack