Gần đây tôi có một bài kiểm tra Toán và nhận thấy rằng một số lượng nhất định trong bài kiểm tra phù hợp với một mô hình thú vị. Số ( 28384) khớp với một chuỗi chữ số chung giống như thế này

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

trong đó nvà xlà số nguyên đơn. Chuỗi có thể bắt đầu với một trong hai xhoặc nvà kết thúc với một trong hai xhoặc n+y.

Nhiệm vụ của bạn là, được cung cấp một số nguyên dương nhiều chữ số, đưa ra giá trị trung thực hoặc falsey, tùy thuộc vào việc đầu vào có khớp với mẫu không. Đầu vào sẽ dài từ 4 đến 18 chữ số. Bạn có thể lấy đầu vào làm đại diện chuỗi của số nguyên. Đầu vào sẽ không bắt đầu bằng 0 nhưng có thể chứa hoặc kết thúc bằng 0.

n+y sẽ luôn là một số có một chữ số (do đó tại sao giới hạn độ dài là 18).

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

Chúng nên tạo ra một giá trị trung thực

182838485868788898
4344
85868
12223242526

Và những thứ này nên là chim ưng

12345
6724013635
36842478324836
1222232425
5859510511

Như với tất cả các mã golf, mã ngắn nhất sẽ thắng! Chúc may mắn và có thể tỷ lệ cược, được bao giờ có lợi cho bạn!

Python 2 , 84 81 80 79 byte

-1 byte nhờ vào lò nướng

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

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

Python 3 , 82 79 78 77 byte

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

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

Hơi ngắn hơn trong Python 3, nhưng tôi không nghĩ nó xứng đáng với câu trả lời của riêng mình.

Giải trình

Chúng tôi thiết lập một hàm glấy chuỗi và chỉ mục (1 hoặc 0). gsau đó trả về việc có hay không len(set(x[a::2])), đó là số chữ số duy nhất ở mọi vị trí khác, bằng (x[a==0::2]in"123456789"), cho dù các chữ số khác có theo thứ tự tăng dần hay không. Nếu các chữ số theo thứ tự tăng dần, điều này trả về dù chúng có giống nhau hay không, nếu không nó sẽ hỏi xem tập hợp có trống không, do đó không thể trả về sai.

Thạch , 13 11 byte

Ds2ZI’M¦Ẏ¬Ạ

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

Giải trình:

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 byte

TG9LNýN.øŒ})˜Iå

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

Giải trình

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

Nó sẽ hoạt động (trường hợp thử nghiệm đã làm) nhưng nếu bạn tìm thấy bất kỳ sai sót xin vui lòng cho tôi biết.

14 byte nếu không có đầu ra được tính là sai:

TG9LNýN.øŒIåi1

D, 117 byte

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

Chắc chắn là tối ưu, nhưng nó hoạt động tốt

Dùng thử trực tuyến!

Haskell, 108 113 97 95 byte

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)

Cuộc gọi mẫu: f "182838485868788898"sản lượngTrue

Phiên bản Ungolfed với lời giải thích:

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

Đưa đầu vào dưới dạng một chuỗi.

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

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

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 byte

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

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

Python 3 , 99 96 89 byte

• Đã lưu 3 byte: sử dụng all()hàm
• @WheatWizard đã lưu 7 byte: tốc ký & |và thay thế biến phụ bằng cáchk<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)

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

Giải trình:

Đầu tiên, chia chuỗi thành hai danh sách: một danh sách có chỉ số lẻ và danh sách khác có các phần tử được lập chỉ mục chẵn. Hai danh sách A và B được cho là sao cho:

1. A chứa cùng một số và B chứa các số liên tiếp theo thứ tự tăng dần.

HOẶC ngược lại

2. B chứa cùng một số và A chứa các số liên tiếp theo thứ tự tăng dần.

Các điều kiện liên tiếp được kiểm tra bởi: a in '123456789'

Điều kiện cùng số được kiểm tra bởi: all(i=a[x] for i in a)

PHP , 68 byte

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

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

Phần đầu ra của chuỗi tìm kiếm bắt đầu từ và bao gồm lần xuất hiện đầu tiên của đầu vào đến cuối chuỗi tìm kiếm là giá trị trung thực và không có gì cho giả mạo

để có thêm 2 byte bạn có thể thay thế echo$s;bằng !!echo$s;để có được 1giá trị trung thực

Tìm sự xuất hiện của đầu vào trong một trong các chuỗi sau trong mảng

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

JavaScript (ES6), 54 byte

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>

Đưa đầu vào dưới dạng một chuỗi.

MATL , 15 byte

2L&),duw]hSFTX=

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

Với sự giúp đỡ của @LuisMendo trong trò chuyện. Lưu ý rằng, nếu đầu ra trống + lỗi cũng được coi là 'sai lệch', thì Xcó thể bỏ qua, đưa điểm số lên 14 byte .

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.

Toán học, 121 byte

(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])&

Bình thường , 20 byte

ASm.+sMd.Tcz2&-GZ-H1

Đầu ra [] khi số phù hợp với mẫu chữ số, bất cứ điều gì khác.

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

Giải thích (ví dụ với đầu vào 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): [] & [] -> []

Bình thường, 17 byte

qU2Ssm{.+d.TcjQT2

Hãy thử nó ở đây

Thuật toán tương tự như câu trả lời Jelly của tôi.

Giải trình:

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 byte

-55 byte nhờ các đề xuất của @ 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)

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

Java (OpenJDK 8) , 128 119 118 108 107 104 byte

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

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

Giải trình:

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
}

Võng mạc , 47 byte

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

^1+;1+

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

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

Đầu ra 1 nếu nó khớp với mẫu, 0 nếu không

Giải trình

.
$*11;

Chuyển đổi từng chữ số n thành n + 1 trong unary, cách nhau bằng dấu chấm phẩy

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

(Trailing newline) chuyển đổi từng chữ số thành sự khác biệt giữa chính nó và một 2 điểm trước nó

^1+;1+

(Trailing newline) xóa 2 chữ số đầu tiên

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

Đếm số lượng trùng khớp của mẫu này, kiểm tra xen kẽ 0 và 1