Напишіть програму, щоб визначити, чи має періодична послідовність додатних цілих чисел властивість, що для кожного цілого числа, nщо виникає в послідовності, nміж двома послідовними входженнями ніколи не буває більше, ніж інших цілих чисел n.

Наприклад, 2, 3, 5, 2, 3, 6, 2, 3, 5, 2, 3, 6, ...чи має це властивість: кожна пара послідовних подій 2має максимум два цілих числа між ними (наприклад, 2, 3, 5, 2та 2, 3, 6, 2; кожна пара послідовних входжень 3має максимум три цілих числа між ними; однакове для 5і 6.

Однак 2, 3, 5, 2, 3, 4, 2, 3, 5, 2, 3, 4, ...не має цієї властивості: два послідовних входження 4, а саме 4, 2, 3, 5, 2, 3, 4, мають більше чотирьох цілих чисел між ними.

Введення : розумне подання періодичної послідовності натуральних чисел. Наприклад, кінцевий список, такий як {2, 3, 5, 2, 3, 6}може представляти першу нескінченну послідовність 2, 3, 5, 2, 3, 6, 2, 3, 5, 2, 3, 6, ...вище. (З цього приводу проблема може бути вказана для кінцевих списків, які обгортаються замість нескінченних періодичних списків.)

Вихід : значення "фальшива / хибна".

Прості приклади:

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

Фальшиві приклади:

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

Це codegolf , тому виграє найкоротший код. Відповіді на всіх мовах заохочуються.

Haskell, 60 57 56 55 байт

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

Передбачається, що список введення містить щонайменше один елемент.

Приклад використання: g [1]-> True. Спробуйте в Інтернеті!

Нехай aбуде голова списку і bхвіст. Результат: Trueякщо bпорожній або кількість елементів на початку, bщо не дорівнює a, не перевищує aрекурсивний викликf b також True- інше False. Почніть з подвійного списку введення.

Редагувати: @Leo збережено 3 байти. Спасибі!

Редагувати 2: @Laikoni збережено 1 байт. Спасибі!

Пітон , 57 56 байт

-1 байт завдяки Dennis (замінити i+1:i+v+2з i:i-~vз iзміщенням від 1 enumerate)

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

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

Без імені функція приймає список, aі тестування умови , що кожне значення, v, з'являється inвідповідний фрагмент свого право на конкатенації aз самими собою, (a+a)[i:i-~v]де 1 на основі індекс vв a, i, забезпечуються enumerate(a,1).

JavaScript (ES6), 67 65 55 54 51 49 байт

Збережено 3B завдяки @ETHproductions та 2B завдяки @Arnauld

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

Пояснення

Це визначає функцію, яка приймає масив aяк вхідний. Потім .someметод повторює цей масив, виконуючи іншу функцію для кожного елемента.

Ця внутрішня функція приймає два аргументи, bі c, поточне значення та його індекс. Функція знаходить індекс поточного значення, починаючи з індексу c + 1. Потім він перевіряє, чи не перевищує цей показник поточне значення плюс поточний індекс (різниця між двома вхождениями одного і того ж значення більша, ніжb ). Зауважте, що це повертає прямо протилежне тому, що ми хочемо.

Якщо одне з цих повернених значень true, .someфункція також повертається true. Якщо жоден із чеків не повертається true, .someфункція повертаєтьсяfalse . Ще раз протилежне значення, яке ми хочемо повернути, тому цей результат нівелюється, а потім повертається.

Перевірте це

Спробуйте всі тестові приклади тут:

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

Желе , 11 байт

ṣZL
;çЀ<‘P

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

Як це працює

;çЀ<‘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.

Желе , 8 байт

ṙJḣ"‘Œpċ

Натхненний відповіддю @ JonathanAllan на Python .

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

Як це працює

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

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(_,[]).

Список слід вводити двічі:

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

Якщо це не вважається прийнятним, ви можете додати присудок

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

що додає зайвих 14 байт.

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

nb: ви можете протестувати одразу різні помилкові випадки, розділивши запити на ';' (або) і перевірити різні справжні випадки, розділивши з ',' (і)

тобто, використовуючи приклади ОП:

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]).

і

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

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

приймає послідовність з аргументів командного рядка; виходи з кодом для помилки 1, 0для truthy.
Бігайте з -nr.

• цикл $nчерез аргументи:
  • якщо раніше не було випадків, або це було досить недавно,
    тоді нічого не робити, інакше вийдіть з кодом1
  • запам'ятати попереднє виникнення в $$n( змінних змінних )
• вихід з кодом 0(неявний)

Сітківка , 50 байт

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

Введіть як список уніарних чисел, розділених комами.

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

Пояснення

$
,$`

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

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

Зрівняйте і поверніть кожен (найкоротший) розділ між двома однаковими значеннями, наприклад 11,111,1,11.

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

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

M`1,

Порахуйте, як часто 1,з’являється у всіх рядках. Якщо вона з’являється де-небудь, один із кроків був занадто широким.

^0

Спробуйте співставити число, починаючи з 0(тобто лише 0самого себе). Це фактично логічне заперечення результату.

JavaScript (ES6), 47 байт

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

Як це працює

Ми знову використовуємо вхідний масив aдля зберігання позиції останнього зустрічаючого виникнення кожного цілого числа в a. Ми використовуємо ключ -nдля зберігання цієї позиції, щоб вона не заважала початковим індексам a.

Коли a[-n]існує, відбувається власне тест. Коли a[-n]не існує, вираз a[-n] - (a[-n] = i)дорівнює undefined - i == NaNі порівняння з~n завжди є хибним, що є очікуваним результатом.

Тестові кейси

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]));

Сітківка ,  41 39 байт

2 байти в гольф завдяки Мартину Ендеру, який, до речі, познайомив мене з балансуванням груп із його фантастичним керівництвом по SO

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

^$

Введення - це розділений комою список одинарних чисел. Вихідні дані є 0хибними та 1істинними.

Спробуйте в Інтернеті!(Тестовий набір, який автоматично перетворюється з десяткової)

Нещодавно я дізнався про врівноважувальні групи, тому хотів спробувати їх. Вони не серед найпростіших інструментів для використання, але впевнені, що вони потужні.

Пояснення

$
,$`,

Як і багато інших матеріалів, ми дублюємо список, щоб вирішити обговорення. Також ми додаємо кому в кінці, тому за кожним числом слідує кома (це полегшує справи згодом)

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

Ось де речі стають цікавими. Це етап заміни, ми заміняємо все, що відповідає першому рядку, другим рядком, в цьому випадку ми шукаємо видалити всі числаn не відповідають n+1інші різні числа.

Для цього ми спочатку співставляємо число, захоплюючи кожне 1 в групі (захоплюючи групу №2 у цьому випадку). Тоді з позитивним пошуком, щоб мати твердження нульової ширини, ми неодноразово намагаємося поєднати в балансувальній групі -2, що досягне успіху не більше ніж кількість захоплень, зроблених групою2 , число, за яким слідує кома. Після цієї послідовності чисел ми задоволені, якщо знову досягнемо або першого числа, або кінця рядка.

Примітка: цей вираз може відповідати лише заключній частині числа, якщо він не в змозі знайти збіг з повним числом. Це не проблема, оскільки тоді перша частина числа залишиться в рядку, і ми будемо знати, що заміна не вдалася повністю.

^$

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

Желе , 11 байт

ẋ2ĠṢI_2<"QȦ

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

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

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

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

Рода , 50 байт

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

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

Нарешті! Я чекав на цей виклик ...

Це функція, яка повертає значення truthy або хибного значення. Він займає один аргумент, масив.

Він повторює потік індексів і перевіряє для кожного індексу, _1що відстань поточного індексу та наступного індексу a[_1]не більше ніж a[_1].

05AB1E , 13 байт

Dì©v®¦©yky›_P

Спробуйте в Інтернеті! або як тестовий набір

Пояснення

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