Недавно я прошел тест по математике и заметил, что определенное число в тесте соответствует интересной схеме. Число ( 28384) соответствует общей последовательности цифр, которая выглядит следующим образом

(n)(x)(n+1)(x)(n+2)(x)(n+3) etc...

где nи xоднозначные целые числа. Последовательность может начинаться либо xили nи заканчиваются либо xили n+y.

Ваша задача, учитывая многозначное положительное целое, вывести истинное или ложное значение, в зависимости от того, соответствует ли входное значение шаблону. Длина ввода будет от 4 до 18 цифр. Вы можете принять ввод как строковое представление целого числа. Ввод не будет начинаться с 0, но может содержать или заканчиваться 0.

n+y всегда будет однозначным числом (отсюда и ограничение длины 18).

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

Это должно вывести истинное значение

182838485868788898
4344
85868
12223242526

И это должно быть фальсией

12345
6724013635
36842478324836
1222232425
5859510511

Как и во всех гольф-кодах, выигрывает самый короткий код! Удачи и пусть шансы, будь всегда в твою пользу!

Python 2 , 84 81 80 79 байтов

-1 байт благодаря овсу

lambda x:g(x,1)|g(x,0)
g=lambda x,a:len(set(x[a::2]))==(x[a<1::2]in"123456789")

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

Python 3 , 82 79 78 77 байт

lambda x:g(x,1)|g(x,0)
g=lambda x,a:len({*x[a::2]})==(x[a<1::2]in"123456789")

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

Немного короче в Python 3, но я не думаю, что он заслуживает своего собственного ответа.

объяснение

Мы создали функцию, gкоторая принимает строку и индекс (либо 1, либо 0). gзатем возвращает значение len(set(x[a::2])), равное или нет , то есть число уникальных цифр в любой другой позиции, равно (x[a==0::2]in"123456789")или нет, находятся ли другие цифры в порядке возрастания. Если цифры расположены в порядке возрастания, возвращается тот факт, являются ли они одинаковыми или нет, если нет, то будет задан вопрос, является ли набор пустым, чего не может быть, поэтому всегда возвращается значение false.

Желе , 13 11 байт

Ds2ZI’M¦Ẏ¬Ạ

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

Объяснение:

Ds2ZI’M¦Ẏ¬Ạ Accepts an integer
D           Get individual digits
  2         2
 s          Split into chunks of specific length
   Z        Zip
    I       Take deltas
     ’      Decrement
      M     Take maximal indices
       ¦    Apply at specific indices
        Ẏ   Reduce dimensionality
         ¬  Vectorized NOT
          Ạ Check if all are truthy

05AB1E , 15 байтов

TG9LNýN.øŒ})˜Iå

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

объяснение

TG9LNýN.øŒ})˜Iå
TG        }     # For 1 to 9...
  9L             # Push [1 .. 9]
    Ný           # Join with current value 
      N.ø        # surround with current value
         Π      # Push substrings
           )    # Wrap stack to array
            ˜   # Deep flatten the array
             I  # Push input
              å # Is the input in the array?
                # Implicit print

Это должно работать (тестовые случаи сделали), но если вы обнаружите какие-либо недостатки, пожалуйста, дайте мне знать.

14 байт, если нет выходных данных, считается ложным:

TG9LNýN.øŒIåi1

D, 117 байт

int f(string n){int o=n[0]!=n[2],x=n[o];foreach(i,c;n){if(i%2!=o&&i>1&&c!=n[i-2]+1||i%2==o&&c!=x)return 0;}return 1;}

Определенно неоптимальный, но работает нормально

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

Haskell, 108 113 97 95 байт

d(x:_:r)=x:d r
d r=r
c(x:n:r)=and$all(==x)(d r):zipWith(==)(d$n:r)[n..]
f s@(_:n:_)=c s||c(n:s)

Пример вызова: f "182838485868788898"доходностьTrue

Безголовая версия с объяснениями:

-- Take every other element from the string, starting with the first
d (x:_:r) = x : d r
d r       = r
c (x:n:r) = and $ all (== x) (d r)              -- Every other char is equal to the first
                : zipWith (==) (d $ n:r) [n..]  -- The remaining chars are a prefix of n(n+1)(n+2)...
f s@(_:n:_) = c s      -- The case where s already starts with x
           || c (n:s)  -- If not, prepend a dummy x and try again

JavaScript (ES6), 66 63 60 байт

Принимает ввод в виде строки.

s=>[...s].every((d,i)=>d-s[j^(k=i+j&1)]==k*i>>1,j=s[2]-s[0])

Контрольные примеры

let f =

s=>[...s].every((d,i)=>d-s[j^(k=i+j&1)]==k*i>>1,j=s[2]-s[0])

console.log('[Truthy]');
console.log(f("182838485868788898"))
console.log(f("4344"))
console.log(f("85868"))
console.log(f("12223242526"))

console.log('[Falsy]');
console.log(f("12345"))
console.log(f("6724013635"))
console.log(f("36842478324836"))
console.log(f("1222232425"))

C (gcc), 123 байта

#define X*s&&*s++-++n&&(r=0)
t,n,x,r;f(char*s){t=*s==s[2];for(r=1,n=s[t],x=s[!t],s+=2;*s;)t||X,*s&&*s++-x&&(r=0),t&&X;n=r;}

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

Python 3 , 99 96 89 байт

• Сохранено 3 байта: использование all()функции
• @WheatWizard сэкономил 7 байт: сокращение & |и замена дополнительной переменной наk<1

lambda x,g=lambda x,k:(x[k<1::2]in'123456789')&all(j==x[k]for j in x[k::2]):g(x,0)|g(x,1)

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

Объяснение:

Сначала разбейте строку на два списка: один с нечетным индексом, а другой с четным элементом. Предполагается, что два списка A и B таковы:

1. A содержит одно и то же число, а B содержит последовательные числа в порядке возрастания.

ИЛИ как раз наоборот

2. B содержит одно и то же число, а A содержит последовательные числа в порядке возрастания.

Последовательное условие проверяется: a in '123456789'

Условие того же номера проверяется: all(i=a[x] for i in a)

PHP , 68 байт

for(;$v<10;)$s.=strstr(+$v.join(+$v,range(1,9)).+$v++,$argn);echo$s;

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

Вывести часть строки поиска, начиная с первого вхождения ввода и до конца строки поиска, в качестве истинного значения и ничего для фальши

2 байта больше , вы можете заменить echo$s;с , !!echo$s;чтобы получить в 1качестве truthy значения

Найти вхождение ввода в одной из следующих строк в массиве

Array
(
    [0] => 0102030405060708090
    [1] => 1112131415161718191
    [2] => 2122232425262728292
    [3] => 3132333435363738393
    [4] => 4142434445464748494
    [5] => 5152535455565758595
    [6] => 6162636465666768696
    [7] => 7172737475767778797
    [8] => 8182838485868788898
    [9] => 9192939495969798999
)

JavaScript (ES6), 54 байта

f=
s=>[...s].every((e,i)=>i<2|e-s[i-2]==(s[2]!=s[0])^i%2)

<input oninput=o.textContent=this.value[3]?f(this.value):``><pre id=o>

Принимает ввод в виде строки.

MATL , 15 байт

2L&),duw]hSFTX=

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

С помощью @LuisMendo в чате. Обратите внимание, что если пустые выходные данные + ошибка также считаются ложными, то Xих можно пропустить, увеличив счет до 14 байт .

2L&)     % Split the input into odd and even-indexed elements
    ,   ] % Do twice (new feature since MATL v20.0), i.e., on both halves of the input
     d     % Pairwise differences of the array. Results in [0,0,...] for the 'constant' part,
            %  and [1,1,...] for the 'increasing' part.
      u      % Get unique elements. Results in [0] for the constant part, [1] for the increasing part.
       w      % Swap the stack to do the same for the other half of the input.
         hS    % Horizontal concatenation followed by sort. Results in [0,1] for the desired string.
           FTX= % Check if the result is indeed [0,1]. Implicit display.

Mathematica, 121 байт

(m[x_]:=Take[s=IntegerDigits@#,{x,Length@s,2}];w[b_,n_]:=Union@Differences@m@b=={1}&&Length@Union@m@n==1;w[1,2]||w[2,1])&

Pyth , 20 байт

ASm.+sMd.Tcz2&-GZ-H1

Выводится, []когда число соответствует шаблону цифр, в противном случае - иначе.

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

Пояснения (пример с вводом 85868)

ASm.+sMd.Tcz2&-GZ-H1

          cz2           # Chop the input in pairs: ['85', '86', '8']
        .T              # Transpose, ignore absences: ['888', '56']
     sM                 # Convert to integers: [[8, 8, 8], [5, 6]]
  m.+  d                # Compute deltas: [[0, 0], [1]]
 S                      # Sort: [[0, 0], [1]]
A                       # Assign first list to G and second list to H
              -GZ       # Filter 0 on G (on absence): [0, 0] -> []
                 -H1    # Filter 1 on H (on absence): [1] -> []
             &          # Check both lists are empty (logical and): [] & [] -> []

Pyth, 17 байт

qU2Ssm{.+d.TcjQT2

Попробуй здесь

Тот же алгоритм, что и у моего желе-ответа.

Объяснение:

qU2Ssm{.+d.TcjQT2 Accepts an integer
             jQT  Take digits of input
            c   2 Split in pairs
          .T      Transpose
     m            Map the following on each of the two resulting lists:
       .+d          Take deltas
      {             Deduplicate
    s             The list is now in [[a, b, ...], [A, B, ...]] format, convert it to [a, b, ..., A, B, ...]
   S              Sort
qU2               Check if equal to [0, 1]

Python 3 , 167 161 157 131 106 байт

-55 байт благодаря предложениям @ WheatWizard

def g(t):k,c,f,j=t[::2],t[1::2],'123456789',''.join;return(len({*k})and j(c)in f)or(len({*c})and j(k)in f)

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

Java (OpenJDK 8) , 128 119 118 108 107 104 байта

s->{int i=3,a=s[2]-s[0],b=s[3]-s[1];for(;++i<s.length;)a+=b-(b=s[i]-s[i-2]==a?a:2);return(a|b)==1&a!=b;}

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

Объяснение:

s->{                             // lambda
  int i=3,                       //  iterating index
      a=s[2]-s[0],               //  diff of even-indexed characters
      b=s[3]-s[1];               //  diff of odd-indexed characters
  for(;++i<s.length;)            //  iterate
    a+=b-(b=                     //   swap a and b
        s[i]-s[i-2]==a?a:2       //    or set b to 2 if the diffs don't match
      ));                        //
  return (a|b)==1                //  return true if both a and b are in (0,1)
        &a!=b;                   //         but different
}

Сетчатка , 47 байт

.
$*11;
(1+)(?<=\1;1+;\1)

^1+;1+

^;?(;1;)+;?$

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

Выводит 1, если соответствует шаблону, 0, если нет

объяснение

.
$*11;

Преобразовать каждую цифру n в n + 1 в одинарных, разделенных точкой с запятой

(1+)(?<=\1;1+;\1)

(Завершающий перевод строки) преобразует каждую цифру в разницу между собой и двумя предыдущими

^1+;1+

(Завершающий перевод строки) удаляет первые 2 цифры

^;?(;1;)+;?$

Подсчитывает количество совпадений этого шаблона, который проверяет наличие чередующихся 0 и 1