Chúng tôi có một số người điều hành cảnh sát trưởng mới trong thị trấn, Mego và DJMcMayhem . Chúng tôi cần một thử thách để tôn vinh họ đúng đắn cho vị trí mới của họ, vì vậy chúng tôi đi.

Đây là một cái gì đó đã thu hút sự chú ý của tôi khi di chuột qua hồ sơ của họ - ID người dùng của họ là và . Nếu bạn thực hiện phép trừ số, bạn sẽ nhận thấy một điều khá thú vị (tất nhiên, có sự khác biệt tuyệt đối):$31716$$45941$

3|1|7|1|6
4|5|9|4|1
-+-+-+-+- (-)
1|4|2|3|5

Số được tạo bởi thuật toán trên là . Có một điều đặc biệt về số nguyên này: Nó chỉ bao gồm các chữ số liên tiếp , được sắp xếp theo thứ tự tăng dần, nhưng chính xác một trong các chữ số không được đặt chính xác - .$14235$$4$

Chúng ta sẽ gọi một cặp số nguyên dương là cặp DJMcMego nếu sự khác biệt tuyệt đối về mặt số là các số nguyên liên tiếp, được sắp xếp theo thứ tự tăng dần, nhưng chính xác một trong số chúng không phải là nơi thuộc về nó. Nghĩa là, có thể di chuyển chính xác một chữ số kết quả của phép trừ thông minh chữ số sang vị trí khác, sao cho số nguyên thu được chỉ có các chữ số liên tiếp, được sắp xếp theo thứ tự tăng dần.$(a, b)$

Trong ví dụ của chúng tôi ở trên, cặp là cặp DJMcMego , vì nếu được di chuyển giữa và , kết quả là , đáp ứng các tiêu chí. Lưu ý rằng các chữ số của số kết quả không cần phải bắt đầu , chúng chỉ nên liên tiếp. Khi một người không chắc chắn về quyết định nào họ nên đưa ra, họ luôn có thể dựa vào sự giúp đỡ của người kia để sắp xếp mọi thứ.$(31716, 45941)$$4$$3$$5$$12345$$1$

Nhiệm vụ của bạn là đưa ra một giá trị trung thực / giả mạo tùy thuộc vào việc một cặp số nguyên dương được đưa ra làm đầu vào có phải là một cặp DJMcMego hay không.

• Bạn được đảm bảo rằng và sẽ có cùng số chữ số, luôn luôn có ít nhất 4 chữ số.$a$$b$

• Bạn có thể lấy các số nguyên ở bất kỳ định dạng hợp lý nào (ví dụ: số nguyên, chuỗi, danh sách các chữ số, v.v.)

• Bạn có thể cạnh tranh trong bất kỳ ngôn ngữ lập trình nào và có thể nhận đầu vào và cung cấp đầu ra thông qua bất kỳ phương thức tiêu chuẩn nào , trong khi lưu ý rằng các lỗ hổng này bị cấm theo mặc định. Đây là môn đánh gôn , vì vậy bài nộp ngắn nhất (tính bằng byte) cho mọi ngôn ngữ sẽ thắng.

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

a, b -> Output

31716, 45941 -> Truthy
12354, 11111 -> Truthy
56798, 22222 -> Truthy
23564, 11111 -> Truthy
1759,  2435  -> Truthy
12345, 11111 -> Falsy
3333,  2101  -> Falsy
22354, 22222 -> Falsy
31717, 45941 -> Falsy
14325, 11111 -> Falsy
89789, 78865 -> Falsy
14954, 61713 -> Falsy
25631, 11114 -> Falsy

Hoặc, trong định dạng khác .

05AB1E , 18 byte

αDæIg<ùʒD{Q}gĀ*{¥P

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

C (gcc) , 259 258 254 253 250 248 233 222 byte

• Cảm ơn Stan Strum đã cho một đứa trẻ chơi gôn một byte.
• Đã lưu bốn byte bằng cách tung hứng một số khởi tạo biến.
• Lưu một byte bằng cách chơi golf for(...;l++)b*=B[l]==-~B[l-1];để for(...;b*=B[l]==-~B[~-l++]);(rất có thể dựa vào hành vi undefined, vì nó đòi hỏi đầu tiên đánh giá những B[l]tiếp theo -~B[~-l++]).
• Lưu ba năm byte.
• Đã lưu mười lăm hai mươi sáu byte nhờ trần .

j,k,l,L,r,b;f(char*A,char*B){for(j=r=0;k=A[L=j];)A[j++]=-~abs(A[j]-B[j]);for(;k-L;k++)for(j=~0;L-++j;r|=!b)if(k-j)for(bcopy(B-~l,strcpy(B,A)+l,strlen(A+l)),bcopy(B+j,B-~j,L+~j),B[j]=A[k],l=b=0;B[++l];b|=B[l]+~B[~-l]);A=r;}

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

Giải thích (phiên bản 248 byte)

j,k,l,L,r,b;                            // global variables
f(char*A,char*B){                       // function takes two strings
 for(j=r=0;A[j];L=j)                    // loop through A, compute array length L
  A[j++]=-~abs(A[j]-B[j]);              // set every entry in A to the absolute
                                        // difference of A and B at that position
                                        /* Test out all possible movements of        *
                                         * characters and see if any one             *
                                         * results in a sorted list => DJMcMego pair */
 for(j=0;j-L;j++)                       // loop through array
  for(k=~0;L-++k;r|=!b)                 // loop through array
   if(j-k){                             // j is not equal to k
    for(l=0;A[l];B[l++]=A[l]);          // copy A to B
    for(l=j;A[l];B[~-l]=B[++l]);        // shift part of B
    for(l=L;l-k;B[-~l]=B[--l]);         // shift part of B
    B[k]=A[j];                          // insert character at correct position
    for(l=b=0;B[++l];b|=B[l]+~B[~-l]);} // test if B is sorted
 A=r;}                                  // return if there was a DJMcMego pair found

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

JavaScript (ES6), 130 byte

Lấy đầu vào là hai mảng chữ số trong cú pháp currying (a)(b). Trả về một boolean.

a=>b=>a.some((_,i)=>a.some((_,j)=>i-j&&!(A=a.map((v,i)=>Math.abs(v-b[i]))).some(v=>v-A[~k--]-1,A.splice(i,0,A.splice(j,1)[k=0]))))

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

SWI-Prolog, 157 byte

Không ngắn lắm nhưng vấn đề có vẻ đặc biệt phù hợp với các vị từ khai báo, ràng buộc và đệ quy biến, tức là Prolog :)

n(T,Y):-s(T,Q,I,J),s(Y,W,I,J),m(Q,W).
s(T,Q,I,J):-nth0(I,T,X,R),nth0(J,Q,X,R),I\=J.
m([A,B|T],[C,D|Y]):-1 is abs(B-D)-abs(A-C),m([B|T],[D|Y]).
m([_],[_]).

Gọi với, ví dụ, n([3,1,7,1,6],[4,5,9,4,1]).

Giải thích: di chuyển một yếu tố trong cả hai danh sách sang vị trí mới (sử dụng SWI-Prolog tích nth0hợp) và kiểm tra xem sự khác biệt của danh sách mới có liên tiếp không.

s(T,Q,I,J)    % switch (yet unbounded) index I and J in list T, store in Q
s(Y,W,I,J)    % switch (now bounded) I and J in list Y
m(Q,W)        % check new lists
s(T,Q,I,J) :- nth0(I,T,X,R) % X (unbounded) is the I-th (unbounded) element 
                            % of list T with rest R (=prefix+postfix) 
nth0(J,Q,X,R) % the same X is the J-th element in list Q with the same rest R
I\=J          % I and J are unequal
m([A,B|T],[C,D|Y]) :-  % consider first two elements of both lists
1 is abs(B-D)-abs(A-C) % check if differences are consecutive                          
m([B|T],[D|Y])         % recursion starting with the second element
m([_],[_]).            % stop recursion at last element in the list

J , 27 byte

8 byte nhờ FrownyFrog

1"0(-:(2-/\|\:|),1#.2>/\|)-

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

Giải pháp ban đầu:

J , 35 byte

[:((1=[:*/2-/\\:~)*1=1#.0<2-/\])|@-

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

Giải trình

Lấy danh sách các chữ số làm đầu vào

|@- tìm thấy sự khác biệt tuyệt đối giữa các chữ số của danh sách

1=1#.0<2-/\]Kiểm tra nếu chỉ có một chữ số là ra khỏi vị trí của nó. Đầu tiên tôi tìm thấy sự khác biệt giữa tất cả các cặp chữ số liền kề và kiểm tra xem chỉ một trong số chúng là dương.

* Nhân kết quả từ thử nghiệm trên (1 hoặc 0) với thử nghiệm sau:

1=[:*/2-/\\:~Có phải tất cả các chữ số liên tiếp? Tôi sắp xếp danh sách xuống, lấy sự khác biệt cho tất cả các cặp chữ số liền kề, nhân chúng và kiểm tra xem nó có bằng 1 không

Thạch , 14 byte

ạµṢ_JEċ@Œ¿-Ƥ%L

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

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

ạµṢ_JEċ@Œ¿-Ƥ%L  Main link. Arguments: A, B (digit arrays)

ạ               Take the elementwise absolute difference. Call the result R.
 µ              New chain. Argument: R
  Ṣ             Sort R.
    J           Indices; yield [1, ..., len(R)].
   _            Take the elementwise difference.
     E          Test if all differences are equal.
                The result is 1 if R consists of consecutive digits, 0 otherwise.
          -Ƥ    For all outfixes of R, generated by dropping one of its elements:
        Œ¿        Get its permutation index (1 if sorted, higher if not).
      ċ@        Count the number of times the Boolean from the left appears in the
                array to the right. If the Boolean is 1, the count represents the
                number of ways a single digit can be deleted to yield a sorted
                array. The count has to be positive for a DJMcMego pair, but less
                than the length of R, since R may not be sorted.
            %L  Take the result modulo len(R), mapping len(R) to 0.

Japt , 18 byte

Đang tranh luận liệu tôi có nên đăng bài này hay không trong một vài giờ. Đã đến với nó nhanh chóng vào đêm qua nhưng không có thời gian để kiểm tra nó đúng cách ( và tôi nghĩ rằng nó có thể quá dài!). Oliver đã đăng một giải pháp tương tự (đó là, khi cái này ban đầu được đăng, không hợp lệ) vì vậy nếu anh ta hoặc cộng đồng cảm thấy điều này quá giống nhau, tôi sẽ vui vẻ xóa nó.

Lấy đầu vào là mảng 2 chữ số, đầu ra 0cho truehoặc bất kỳ số nào khác cho false.

íaV
ä> x*Un än × É

Hãy thử hoặc kiểm tra tất cả các trường hợp thử nghiệm

Giải trình

                   :Implicit input of digit arrays U and V               :[3,1,7,1,6],[4,5,9,4,1]
í V                :Interleave V with U                                  :[[3,4],[1,5],[7,9],[1,4],[6,1]]
 a                 :Get the absolute difference of each pair             :[1,4,2,3,5]
\n                 :Assign that new array to variable U
ä>                 :Is each element greater than the next?               :[false,true,false,false]
     Un            :Sort U                                               :[1,2,3,4,5]
        än         :Get the deltas                                       :[1,1,1,1]
           ×       :Reduce by multiplication                             :1
    *              :Multiply each element in the boolean array by that   :[0,1,0,0]
   x               :Reduce by addition                                   :1
             É     :Subtract 1                                           :0

Và, để thực hiện quy trình đó trong một vài trường hợp thử nghiệm khác:

---------------------------------------------------------------
| U   | [2,3,5,6,4] | [1,2,3,4,5] | [3,1,7,1,7] | [1,4,9,5,4] |
| V   | [1,1,1,1,1] | [1,1,1,1,1] | [4,5,9,4,1] | [6,1,7,1,3] |
|-----|-------------|-------------|-------------|-------------|
| íaV | [1,2,4,5,3] | [0,1,2,3,4] | [1,4,2,3,6] | [5,3,2,4,1] |
|-----|-------------|-------------|-------------|-------------|
| ä>  | [F,F,F,T]   | [F,F,F,F]   | [F,T,F,F]   | [T,T,F,T]   |
|-----|-------------|-------------|-------------|-------------|
| Un  | [1,2,3,4,5] | [0,1,2,3,4] | [1,2,3,4,6] | [1,2,3,4,5] |
| än  | [1,1,1,1]   | [1,1,1,1]   | [1,1,1,2]   | [1,1,1,1]   |
| ×   | 1           | 1           | 2           | 1           |
|-----|-------------|-------------|-------------|-------------|
| *   | [0,0,0,1]   | [0,0,0,0]   | [0,2,0,0]   | [1,1,0,1]   |
| x   | 1           | 0           | 2           | 3           |
| É   | 0           | -1          | 1           | 2           |
---------------------------------------------------------------

Perl, 121 118 byte

($a,$b)=map[split//],@ARGV;
$s+=$l>$_,$l=$_ for@c=map abs($$a[$i]-$$b[$i++]),@$a;
@c=sort@c;
say$s==1&&$c[-1]-$c[0]==$#$a

Kiểm tra trong bash:

function golf {
   perl -E'($a,$b)=map[split//],@ARGV;$s+=$l>$_,$l=$_ for@c=map abs($$a[$i]-$$b[$i++]),@$a;@c=sort@c;say$s==1&&$c[-1]-$c[0]==$#$a' $1 $2
}
golf 31716 45941       #says 1, true
golf 12354 11111       #says 1, true
golf 56798 22222       #says 1, true
golf 46798 22222       #says nothing, false
golf 22354 22222       #says nothing, false
golf 1759 2435         #says 1, true
golf 12345 11111       #says nothing, false
golf 89789 78865       #says nothing, false
golf 14954 61713       #says nothing, false

Java 8 , 245 227 223 194 188 byte

Cảm ơn Kevin vì đã tiết kiệm ~ 29 byte

Cảm ơn Kevin một lần nữa cho 6 byte khác

 z->{int l=z.length/2,c[]=new int[l],i=0,j=0;for(;i<l;)c[i]=Math.abs(z[i]-z[i+++l]);java.util.Arrays.sort(z=c.clone());for(i=0;i<l-1;j+=z[i]-z[i-1]!=1?1:0)j+=c[i]-c[++i]>0?1:0;return j==1;}

Theo mô hình tương tự Galen đã đưa ra cho câu trả lời J của mình.

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

Võng mạc , 102 byte

+`(.)(.*¶)(.)(.*)
$2$4;$1,$3
\d
*
(_*),\1
_
L$w`(;_+\b)(.*)(;_+\b)
$%`$2$3$1$%"$3$1$2$'
m`(^;_+|\1_)+$

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Trả về số cách các chữ số có thể được di chuyển để đạt được một chuỗi tăng dần, là 2 cho một trao đổi thẳng vì một trong hai chữ số có thể được di chuyển qua chữ số khác trong trường hợp đó. Giải trình:

+`(.)(.*¶)(.)(.*)
$2$4;$1,$3

Ghép các chữ số.

\d
*

Chuyển đổi sang unary.

(_*),\1
_

Lấy sự khác biệt, nhưng sau đó thêm 1 vì làm việc với số 0 trong Retina là khó ™.

L$w`(;_+\b)(.*)(;_+\b)
$%`$2$3$1$%"$3$1$2$'

Liệt kê tất cả các chuỗi chữ số thu được bằng cách di chuyển chính xác một chữ số.

m`(^;_+|\1_)+$

Kiểm tra các chữ số liên tiếp.

Perl 5 , -F 87 84 83 byte

Đếm kiểu cũ: 86 byte ( +3cho -F)

Cung cấp cho anh ta số là 2 dòng trên STDIN, dòng cuối cùng mà không có dòng mới.

In chuỗi chênh lệch lên tới 2 lần cho đúng, không có gì sai

Chuỗi dài A0123456789thực sự gây phiền nhiễu.

#!/usr/bin/perl -F
$_=<>;s%.%abs$&-$F[pos]%eg;s%%"'$`$''=~s:|:A0123456789=~/\$`$&\$'/>//&&say:reg"%eeg

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

Tôi đang sử dụng nếu điều này 79được coi là hợp lệ:

$_=<>;s%.%abs$&-$F[pos]%eg;s,,$a=$&;"$`$'"=~s:|:A0123456789=~/$`$a$'/%//:reg,eg

Nó gặp sự cố đối với một cặp hợp lệ, do đó bạn nhận được mã thoát không. Sẽ không có gì nếu không phải là một cặp và thoát với mã thoát 0. Tôi biết việc trả lại kết quả thông qua mã thoát được cho phép, nhưng chúng có đúng sự thật và giả mạo hay thực tế là đảo ngược (đối với trình bao 0là đúng)?

Ruby , 124 113 99 95 byte

->l,b,d=-1{m=l.map!{|i|(i-b[d+=1]).abs}.sort;l.any?{|*i|m-i==l-i}&&m!=l&&/#{m*''}/=~[*0..9]*''}

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

Pyt , 20 18 byte

ą←ą-ÅĐʁ>Ʃ1=⇹ş₋Π1=∧

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

Giải trình:

       Implicitly get the first number
ą      Convert to list of digits
←      Get the second number
ą      Convert to list of digits
-Å     Take the absolute value of the differences of the lists element-wise
Đ      Duplicate the list of differences
ʁ>     Reduce by greater than
Ʃ1=    Is the sum of that array equal to 1
⇹      Swap the top two items on the stack
ş      Sort the top of the stack ascending
₋      Reduce by subtraction (from the right)
Π1=    Is the product of the array equal to 1
∧      bitwise-AND (in this case, also logical AND) the top two items on the stack
       Implicit print

Thêm ++ , 105 byte

D,w,@~,Ñ_€|BSVcGbU1b]2b]+º=
D,k,@,BPB*
L,BcB_€|B]dBkbUBSVcGbU£>sVcGB]VBKB#BKBcB_0º>b]GBK{w}b]++b*1=BK{k}*

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

Xác định hàm lambda lấy hai danh sách các chữ số làm đầu vào. Xuất ra một số nguyên dương chia hết cho 24 ¹ cho các cặp DJMcMego, 0 nếu không.

_{1: Nếu điều này quá hạn chế, nó cũng xuất ra một số nguyên dương cho các cặp DJMcMego và 0 nếu không}

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

Ở đây chúng tôi thực hiện 4 kiểm tra để xác định xem đầu vào có hợp lệ không. Các phần của mã thực hiện các kiểm tra đó là

BcB_€|B]dBkbUBSVcGbU£>sVcGB]V

Ở đây, chúng tôi lấy danh sách các khác biệt về chữ số tuyệt đối, sau đó đếm số lượng các cặp chồng chéo được sắp xếp theo thứ tự giảm dần. Mỗi cặp DJMcMego tạo ra kết quả là 1 , nhưng chúng không phải là duy nhất trong khía cạnh này. Chúng tôi cũng lưu trữ sự khác biệt về chữ số tuyệt đối của đầu vào, để lưu byte sau này. Mảng này sẽ được gọi là A trong suốt.

BKB#BKBcB_0º>b]

Tiếp theo, chúng tôi lấy sự khác biệt về yếu tố giữa A và A được sắp xếp, trước khi khẳng định rằng ít nhất một trong những khác biệt đó là âm.

D,w,@~,Ñ_€|BSVcGbU1b]2b]+º=
GBK{w}b]

Thứ ba, chúng tôi kiểm tra nếu các cặp [1, 2] được chứa trong các gia số về phía trước của Một . Điều này kiểm tra rằng, trong ít nhất một vị trí của A , nó được sắp xếp, đó là một tiêu chí cho các cặp DJMcMego.

D,k,@,BPB*
BK{k}

Như kiểm tra cuối cùng của chúng tôi, chúng tôi khẳng định rằng phần tử thứ hai của A không bao giờ là 0 . Để một cặp, X và Y trở thành một cặp DJMcMego, chúng ta có thể giả sử rằng chữ A của chúng luôn là duy nhất, vì một mảng có các bản sao trong đó không bao giờ có thể được tạo liên tiếp bằng cách hoán đổi một giá trị với một giá trị khác.

Cuối cùng, chúng tôi kiểm tra ba thử nghiệm đầu tiên trong số này đã trả về 1 và lần thứ tư trả về giá trị x sao cho x 0

Một bước để bước qua mã như sau

D,w,		; Define a function w;
		;   This takes an array of integers
		;   Returns whether the pair [1, 2] appears in the absolute forward differences
		;
	@	; Take one argument
	~,	; Splat that argument to the stack
		;   Example argument:		[1 4 2 3 5]
		;
	Ñ_	; Increments;		STACK = [3 -2 1 2]
	€|	; Magnitudes;		STACK = [3 2 1 2]
	BSVcGbU	; Overlapping pairs;	STACK = [[3 2] [2 1] [1 2]]
	1b]2b]+	; Push [1 2];		STACK = [[3 2] [2 1] [1 2] [1 2]]
	º=	; Any equal [1 2];	STACK = [1]

; ============= ;

D,k,		; Define a function k;
		;   This function takes an array of integers
		;   Returns whether the second element is 0;
		;
	@,	; Take one argument and push to the stack
		;   Example argument:		[[1 4 2 3 5]]
		;
	BP	; Behead;		STACK = [[4 2 3 5]] 
	B*	; Product;		STACK = [120]
		;
		; In DJMcMego pairs, A may begin with a 0
		; For example, 12354 and 11111, so we need to remove the first element
		; Taking the product yields 0 if any element is 0
		; However, in order to be a DJMcMego pair, two digits at the same index
		;   cannot be the same, otherwise their digit-wise difference will be 0

; ============= ;

L,		; Define a lambda function
		;
		; This lambda function takes two arrays of digits as input
		; Returns an integer to determine if those digits represent a DJMcMego pair
		;
		; A lambda function is shorter to define than a normal function
		; However, when called inside functions with the ] command,
		;   they consume the entire stack as arguments, meaning that using functions
		;   allows us to preserve important values
		;
		; Example arguments:		[[3 1 7 1 6] [4 5 9 4 1]]
		;
		; First check:
		;
	BcB_	; Digit differences;	STACK = [-1 -4 -2 -3 5]
	€|	; Magnitudes;		STACK = [1 4 2 3 5]
	B]dBkbU	; Save a copy, A	STACK = [1 4 2 3 5]			A: [1 4 2 3 5]
	BSVcGbU	; Overlapping pairs;	STACK = [[1 4] [4 2] [2 3] [3 5]]
	£>	; Sorted descendingly?	STACK = [0 1 0 0]
	sVcG	; How many?		STACK = [1]
	B]V	; Save a copy;		STACK = []				Register: [1]
		;
		; Second check:
		;
	BK	; Retrieve A;		STACK = [[1 4 2 3 5]]
	B#	; Sort;			STACK = [[1 2 3 4 5]]
	BK	; Retrieve A;		STACK = [[1 2 3 4 5] [1 4 2 3 5]]
	BcB_	; Element differences;	STACK = [0 -2 1 1 0]
	0º>b]	; Any negatives;	STACk = [[1]]
		;
		; Third and fourth checks:
		;
	G	; Retrieve register;	STACK = [[1] [1]]
	BK	; Retreive A;		STACK = [[1] [1] [1 4 2 3 5]]
	{w}b]	; Run w;		STACK = [[1] [1] [1]]
	++	; Concatenate;		STACK = [[1 1 1]]
	b*1=	; Product = 1;		STACK = [1]
	BK{k}	; Run k;		STACK = [1 120]
	*	; Multiply;		STACK = [120]

		; To force output as 1 and 0 values,
		;   append a ? to the end, to output the sign (forces boolean conversion)

R , 110 106 84 byte

function(x,y,z=abs(x-y),w=z-min(z)+1)adist(p(1:max(w)),p(w),c("s"=9))==2
p=intToUtf8

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

@JayCe với một tiết kiệm 22 byte vô lý!

Điều đặc biệt ở đây là adist, cung cấp một "khoảng cách chỉnh sửa Levenshtein tổng quát" giữa hai chuỗi. Theo mặc định, khoảng cách là số lượng tối thiểu của các lần chèn, xóa và thay thế cần thiết để chuyển đổi một chuỗi thành một chuỗi khác. Nhưng adistcho phép bạn cân nhắc mọi thứ theo cách bạn muốn - vì vậy tôi đã tính trọng số cho mỗi lần thay thế để thêm 9 vào khoảng cách thay vì 1. Điều này có hiệu quả buộc thuật toán chỉ tìm kiếm các phần chèn và xóa.

Mã này chấp nhận các vectơ của số nguyên, tính toán sự khác biệt nguyên tố tuyệt đối và dịch kết quả để bắt đầu từ 1, gọi nó w.

Sau đó, khoảng cách Levenshtein có trọng số tùy chỉnh được tính giữa các lần wdán với nhau để tạo thành một chuỗi và chuỗi "1234..."(thực ra là utf-8 "\001\002\003\004..."nhưng adistkhông quan tâm.) Với cùng số lượng ký tự như w.

Cách duy nhất mà chuỗi có thể có chính xác một chữ số nằm ngoài vị trí là nếu bạn thực hiện một lần xóa và một lần chèn, cho khoảng cách là 2.

JavaScript, 137 136 135 134 132 123 byte

Lấy đầu vào là hai mảng chữ số theo cú pháp currying, đầu ra 0cho truevà bất kỳ số nào khác cho false.

a=>b=>(c=a.map((x,y)=>(x-=b[y])<0?-x:x)).map(x=>t+=x>c[++j]&(d=[...c].sort()).slice(i=0,-1).every(x=>d[++i]-x&1),t=j=0)|t^1

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

f=
a=>b=>(c=a.map((x,y)=>(x-=b[y])<0?-x:x)).map(x=>t+=x>c[++j]&(d=[...c].sort()).slice(i=0,-1).every(x=>d[++i]-x&1),t=j=0)|t^1
o.innerText=`${l=`-`.repeat(21)}\n|   #1  |   #2  | f |${m=`\n|${`|`.padStart(8,`-`).repeat(2)}---|\n`}${[[31716,45941],[12354,11111],[56798,22222],[23564,11111],[1759,2435],[12345,11111],[3333,2101],[22354,22222],[31717,45941],[89789,78865],[14954,61713]].map(([x,y])=>`| ${JSON.stringify(x).padEnd(6)}| ${JSON.stringify(y).padEnd(6)}| ${f([...``+x])([...``+y])} |`).join(m)}\n`+l

<pre id=o></pre>

Python 2 , 116 119 106 byte

Cảm ơn ông Xcoder đã 116->84cắt giảm, nhưng tôi thấy tôi đã bỏ lỡ tiêu chí "số liên tiếp", vì vậy 26 byte được thêm vào cho mục đích đó :(

Sau đó, -1 cảm ơn ông Xcoder và -13 Cảm ơn các lò nướng

def m(a,b):l=[abs(x-y)for x,y in zip(a,b)];print sum(e>f for e,f in zip(l,l[1:]))==1==len(l)-max(l)+min(l)

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

Điều đó dưới đây khắc phục sự 25634 - 11111cố nhưng với chiều dài gấp đôi ( 211 206 145 142B) ... Chơi gôn ...

def m(a,b):l=[abs(x-y)for x,y in zip(a,b)];r=[l[i]-i-min(l)for i in range(len(l))];print(sum(r)==0)&(len([x for x in r if abs(x)>1])<2)&any(r)

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

Và xin chúc mừng người điều hành mới :)

Giải trình:

l=[abs(x-y)for x,y in zip(a,b)]

Tạo danh sách các khác biệt tuyệt đối của các chữ số.

r=[l[i]-i-min(l)for i in range(len(l))]

Tính toán bù từ vị trí thích hợp.

sum(r)==0

Nếu chuỗi không liên tục, thì tổng bù sẽ "thường" không bằng 0. Nhưng ngay cả khi nó bằng 0, các chuỗi tiếp theo sẽ chặn chúng.

len([x for x in r if abs(x)>1])<2

Chỉ có 0 hoặc 1 mục sẽ có độ lệch tuyệt đối lớn hơn 1 (mục có vị trí sai và 0 trong trường hợp như 1,2,3,5,4)

any(r)

Chặn trường hợp khi các số đều ở đúng vị trí

Haskell , 182 163 162 132 byte

(#)=zipWith(-)
a&b|s<-abs<$>a#b=or[all(==1)$tail a#a|(x,h:y)<-p s,(q,r)<-p$x++y,a<-[q++h:r],a/=s]
p l=[splitAt k l|k<-[0..length l]]

Lấy đầu vào là một danh sách các chữ số. Hàm trợ giúp pcung cấp tất cả các cách có thể để chia danh sách thành hai phần được sử dụng để lấy một phần tử ra và một lần nữa để chèn nó vào nơi khác.

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