我们在城镇Mego和DJMcMayhem中有一些新的警长主持人。我们需要挑战以适当地尊重他们的新职位，所以我们走了。

将悬停在他们的个人资料上时，引起了我的注意-他们的用户ID为和。如果执行数位减法，您会发现一些令人兴奋的事情（当然，要考虑绝对差值）：$31716$$45941$

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

上述算法生成的数字为。此整数有一些特殊之处：它仅包含连续的数字，并以升序排列，但是恰好其中一个数字未正确放置。$14235$$4$

如果数字绝对差是按升序排序的连续整数，但我们将其中的一个正整数称为DJMcMego对，则它们中的一个不属于它。即，可以将逐位减法的结果的确切一位移动到另一位置，使得所获得的整数仅具有以升序排序的连续数字。$(a, b)$

在上面的示例中，该对是DJMcMego对，因为如果在和之间移动，则结果为，这满足条件。请注意，结果数字的数字不必以开头，它们应该是连续的。当一个人不确定应该做出什么决定时，他们总是可以依靠另一个人的帮助来解决问题。4 3 5 12345 $(31716, 45941)$$4$$3$$5$$12345$$1$

您的任务是根据输入的正整数对是否为DJMcMego对来输出真实/虚假值。

• 您可以确保和的位数相同，始终至少为4。$a$$b$

• 您可以采用任何合理格式的整数（即本机整数，字符串，数字列表等）。

• 您可以使用任何编程语言进行竞争，并且可以通过任何标准方法接受输入并提供输出，同时请注意，默认情况下会禁止这些漏洞。这是代码高尔夫球，因此每种语言的最短提交（以字节为单位）将获胜。

测试用例

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

或者，以另一种格式。

05AB1E，18个字节

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

在线尝试！

C（GCC） ，259个 258 254 253 250 248 233字节

• 感谢Stan Strum在春天为一字节高尔夫打下基础。
• 通过处理一些变量初始化节省了四个字节。
• 通过高尔夫保存一个字节for(...;l++)b*=B[l]==-~B[l-1];来for(...;b*=B[l]==-~B[~-l++]);（最有可能依靠不确定的行为，因为它首先需要评估B[l]之后-~B[~-l++]）。
• 保存了三个五个字节。
• 多亏了ceilingcat，节省了15个字节。

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

在线尝试！

说明（248字节版本）

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

在线尝试！

JavaScript（ES6），130个字节

以currying语法将输入作为两个数字数组(a)(b)。返回一个布尔值。

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

在线尝试！

SWI-Prolog，157个字节

不是很短，但是该问题似乎特别适合于声明性谓词，变量绑定和递归，即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([_],[_]).

致电，例如 n([3,1,7,1,6],[4,5,9,4,1]).

说明：将两个列表中的元素移动到新位置（使用nth0内置的SWI-Prolog ），并检查新列表中的差异是否连续。

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个字节

−8字节归功于FrownyFrog

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

在线尝试！

初始解决方案：

J，35个字节

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

在线尝试！

说明

将数字列表作为输入

|@- 查找列表数字之间的绝对差

1=1#.0<2-/\]检查是否只有一位数字不正确。首先，我找到所有相邻数字对之间的差异，并检查它们中只有一个是否为正。

* 将以上测试（1或0）的结果与以下测试相乘：

1=[:*/2-/\\:~所有数字都是连续的吗？我对列表进行排序，取所有相邻数字对的差，将它们相乘并检查是否等于1

果冻，14字节

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

在线尝试！

这个怎么运作

ạµṢ_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个字节

讨论了我是否应该发布此消息达几个小时。昨晚迅速下旬就想出了但没有时间好好测试它（和我想这可能是太久了！）。自那以后，奥利弗（Oliver）发布了一个类似的解决方案（这是最初发布时无效的解决方案），因此，如果他（或社区）觉得这太相似了，我会很乐意将其删除。

将输入作为2位数的数组，将输入0为true或将其作为任何其他数字false。

íaV
ä> x*Un än × É

尝试或检查所有测试用例

说明

                   :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

并且，通过更多的测试用例来完成该过程：

---------------------------------------------------------------
| 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字节

($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

在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字节

感谢Kevin节省了〜29个字节

再次感谢凯文另外6个字节

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

遵循相同的模式，Galen提出了他的J答案。

在线尝试！

视网膜，102字节

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

在线尝试！链接包括测试用例。返回数字可以移动以实现升序的方式的数目，对于直接交换，该数字为2，因为在这种情况下，任何一个数字都可以移动到另一个数字的上方。说明：

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

配对数字。

\d
*

转换为一元。

(_*),\1
_

求差，但是加1，因为在Retina中使用零是很难的。

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

列出通过精确移动一位而获得的所有数字序列。

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

检查连续的数字。

Perl 5，-F 87 84 83字节

旧样式计数：86个字节（+3用于-F）

在STDIN上给他数字为2行，最后一行不带换行符。

最多将差异字符串打印两次，如果为true，则为false

长A0123456789字符串真的很烦人。

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

在线尝试！

我敢肯定这是否79有效：

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

有效对会崩溃，因此您得到一个非零的退出代码。如果不是一对，则不执行任何操作，并以退出代码0退出。我知道允许通过退出代码返回结果，但是它们是否正确且虚假，或者实际上是反向的（对于外壳而言，0是真的）？

Ruby，124113 99 95字节

->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]*''}

在线尝试！

Pyt，20 18 字节

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

在线尝试！

说明：

       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

加++，105字节

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

在线尝试！

定义一个lambda函数，该函数将两个数字列表作为输入。输出DJMcMego对的可被24 ¹整除的正整数，否则输出0。

_{1：如果限制太严格，它也会为DJMcMego对输出一个正整数，否则为0}

这个怎么运作

在这里，我们执行4次检查以确定输入是否有效。执行这些检查的代码部分是

BcB_€|B]dBkbUBSVcGbU£>sVcGB]V

在这里，我们获取绝对数字差的列表​​，然后计算按降序排序的重叠对的数量。每个DJMcMego对产生的结果为1，但是在这方面它们并不是唯一的。我们还存储输入的绝对位数差异，以稍后保存字节。此阵列将被称为甲贯穿。

BKB#BKBcB_0º>b]

接下来，我们断言A和A之间的元素差异是有区别的，然后断言这些差异中至少有一个是负数。

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

第三，我们检查对[1、2]是否包含在A的前向增量中。这检查是否在A的至少一个位置对其进行了排序，这是DJMcMego对的标准。

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

作为最后的检查，我们断言A的第二个元素永远不会为0。为了使X和Y对成为DJMcMego对，我们可以假定它们的A始终是唯一的，因为其中的重复项永远无法通过将一个值与另一个交换来连续。

最后，我们检查这些测试中的前三个返回1，并且第四个返回值x使得x≠0

逐步执行代码的步骤如下

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，110106 84字节

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

在线尝试！

@JayCe保存了一个荒谬的22个字节！

这里的主力是adist，它给出了两个字符串之间的“广义Levenshtein编辑距离”。默认情况下，距离是将一个字符串转换为另一个字符串所需的最小插入，删除和替换次数的计数。但是adist，您可以根据自己的喜好对事物进行加权-因此，我已对每次替换加权，使距离增加9，而不是1。这有效地迫使算法仅查找插入和删除。

该代码接受整数向量，计算元素之间的绝对差，并将结果转换为从1开始的值，将其称为w。

然后，将自定义的加权Levenshtein距离计算为w粘贴在一起以构成字符串和具有与相同数量字符的字符串"1234..."（实际上是utf-8 "\001\002\003\004...“，但adist无关紧要）之间的距离w。

字符串的唯一正确位置可能只有一位数字，如果您进行一次删除和一次插入，则距离为2。

JavaScript中，137个 136 135 134 132 123字节

以currying语法将输入作为两个数字数组，将输出0为true，将其他任意数字输出为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

测试用例

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字节

感谢Xcoder先生的116->84剪切，但是我发现我错过了“连续数”标准，因此为此添加了26个字节:(

之后，再感谢-1，感谢Xcoder先生和-13，感谢ovs

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)

在线尝试！

下面的那个解决了25634 - 11111问题，但是长度加倍（211 206 145 142B）...打高尔夫球...

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)

在线尝试！

并祝贺新的主持人：）

说明：

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

生成数字的绝对差列表。

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

计算与正确位置的偏移量。

sum(r)==0

如果序列不连续，则偏移总和“通常”将不为0。但是，即使其等于0，下一个也会将其阻止。

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

只有0或1个项目的绝对偏移量大于1（位置错误的项目，而在情况下为0 1,2,3,5,4）

any(r)

阻止所有数字都位于正确位置的情况

Haskell中，182个 163 162 132字节

(#)=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]]

将输入作为数字列表。p提供所有可能方式将列表分为两部分的Helper函数用于取出元素，然后再次将其插入到其他位置。

在线尝试！