MegoとDJMcMayhemの新しい保安官のモデレーターがいます。彼らの新しい地位を適切に称えるための挑戦が必要なので、そこに行きます。

プロファイルにと、私の注意を引いたものがあります。ユーザーIDは31716および45941です。桁単位の減算を実行すると、かなりエキサイティングなものに気付くでしょう（もちろん、絶対的な差をとる）：$31716$$45941$

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

上記のアルゴリズムによって生成される数はです。この整数には特別なことがあります。昇順でソートされた連続した数字のみで構成されていますが、正確に1つの数字が正しく配置されていません— 4。$14235$$4$

桁ごとの絶対差が昇順でソートされた連続した整数である場合、正の整数のペアをDJMcMegoペアと呼びますが、正確にそのうちの1つは属していません。つまり、桁ごとの減算の結果の1桁だけを別の位置に移動し、取得した整数が連続した数字のみで昇順でソートされるようにすることができます。$(a, b)$

上記の例では、一対でDJMcMegoの場合ので、対4の間で移動される3及び5、結果は12345の基準を満たしています。結果の数値の桁は1から始まる必要がないことに注意してください。$(31716, 45941)$$4$$3$$5$$12345$$1$、連続しているます。どちらの決定をすべきかわからないときは、相手の助けに頼って物事を整理することができます。

あなたの仕事は、入力として与えられた正の整数のペアがDJMcMegoのペアであるかどうかに応じて、真偽値を出力することです。

• とbの桁数は同じで、常に少なくとも4になることが保証されています。$a$$b$

• 任意の合理的な形式（つまり、ネイティブ整数、文字列、数字のリストなど）で整数を取ることができます。

• デフォルトではこれらの抜け穴は禁止されていることに注意しながら、任意のプログラミング言語で競争し、任意の標準的な方法で入力を取得し、出力を提供できます。これはcode-golfであるため、すべての言語の最短の送信（バイト単位）が優先されます。

テストケース

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 222バイト

• 1バイトのゴルフをインスプリングしてくれたStan Strumに感謝します。
• いくつかの変数の初期化をジャグリングすることで4バイトを節約しました。
• ゴルフでバイトを保存for(...;l++)b*=B[l]==-~B[l-1];するfor(...;b*=B[l]==-~B[~-l++]);（それが最初に評価する必要がありとして最も可能性が高い、未定義の動作に依存B[l]が続きます-~B[~-l++]）。
• 3 5バイトを保存しました。
• 保存された15二十-6バイトのおかげでするceilingcat。

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

オンラインでお試しください！

説明（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バイト

入力をカリー化構文の2つの数字配列として受け取ります(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]).

説明：両方のリストの要素を新しい位置に移動し（組み込みのSWI-Prologを使用nth0）、新しいリストの違いが連続しているかどうかを確認します。

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バイト

FrownyFrogのおかげで8バイト

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

オンラインでお試しください！

初期ソリューション：

J、35バイト

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

オンラインでお試しください！

説明

入力として数字のリストを受け取ります

|@- リストの数字の絶対差を見つける

1=1#.0<2-/\]1桁のみがその場所から外れているかどうかをチェックします。最初に、隣接する数字のすべてのペアの違いを見つけ、そのうちの1つだけが正であるかどうかを確認します。

* 上記のテスト（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バイト

数時間これを投稿するかどうかを議論していました。昨夜遅くそれをすぐに見つけましたが、適切にテストする時間はありませんでした（そして、私はそれが長すぎるかもしれないと思いました！）。オリバーは、以来、掲載している同様のソリューションを（この1が最初に掲載されたときに、無効だった）ので、彼、またはコミュニティは、これがあると感じる場合は、あまりにも似て、私は喜んでそれを削除します。

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バイト

〜29バイトを節約してくれたKevinに感謝

さらに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
_

違いはありますが、Retinaでゼロを操作するのは難しいため、1を追加します。

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

正確に1桁移動することによって取得されたすべての数字列をリストします。

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

連続した数字を確認します。

Perl 5、-F 87 84 83バイト

オールドスタイルカウント：86バイト（+3用-F）

STDINの最後の行に末尾の改行がない2行の数字を付けます。

trueの場合は最大2回、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ですか（シェルがtrueの場合）？

ルビー、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

Add ++、105バイト

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

オンラインでお試しください！

入力として2つの数字リストを受け取るラムダ関数を定義します。DJMcMegoペアの場合は24 ¹で割り切れる正の整数を出力し、それ以外の場合は0を出力します。

_{1：制限が強すぎる場合、DJMcMegoペアに対して正の整数も出力し、そうでない場合は0を出力します}

使い方

ここでは、入力が有効かどうかを判断するために4つのチェックを実行します。これらのチェックを行うコードの部分は

BcB_€|B]dBkbUBSVcGbU£>sVcGB]V

ここでは、絶対桁差のリストを取得し、降順でソートされた重複ペアの数をカウントします。すべてのDJMcMegoペアは、結果生成1を、彼らはこの面では一意ではありません。また、後でバイトを節約するために、入力の絶対数字の差も保存します。この配列は、全体を通してAと呼ばれます。

BKB#BKBcB_0º>b]

次に、AとAの要素ごとの違いをソートし、それらの違いの少なくとも1つが負であると主張します。

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

3番目に、ペア[1、2]がAの前方増分に含まれているかどうかを確認します。これは、Aの少なくとも1つの位置でソートされていることをチェックします。これはDJMcMegoペアの基準です。

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

最後のチェックとして、Aの2番目の要素が0になることはないと断言します。ペアのためには、XとY、DJMcMegoのペアであることを、私たちは彼らのことを仮定することができAそれで重複した配列が相互に単一の値を交換することにより、連続した作られたことは決してできないよう、常にユニークです。

最後に、これらのテストの最初の3つが1を返し、4番目がx≠0のような値xを返したことを確認します

コードのステップウォークスルーの手順は次のとおりです。

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、2つの文字列間の「一般化されたレーベンシュタイン編集距離」を提供します。デフォルトでは、距離は、ある文字列を別の文字列に変換するために必要な挿入、削除、および置換の最小数のカウントです。しかしadist、あなたは好きなように物事に重みを付けることができます-したがって、各置換に重みを付けて、1ではなく9を距離に追加します。これにより、アルゴリズムは事実上挿入と削除のみを検索します。

このコードは整数のベクトルを受け入れ、要素ごとの絶対差を計算し、結果を1から始まるように変換して呼び出します w。

次に、w貼り付けられたカスタムウェイトレーベンシュタイン距離が計算され、文字列と、同じ文字数の文字列"1234..."（実際はutf-8 "\001\002\003\004..."ですadistが、気にしません。）が作成されwます。

文字列が1桁だけ正確に配置されない唯一の方法は、1つの削除と1つの挿入を行い、距離を2にすることです。

JavaScriptを、137の 136 135 134 132 123バイト

入力をカリー化構文の2つの数字の配列として、出力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>

パイソン2、116の 119 106バイト

Xcoder氏に感謝し116->84ますが、「連続番号」の基準を逃したことがわかったため、そのために26バイトが追加されました:(

その後、Xcoder氏に-1を追加し、ovsに-13を追加します

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問題を修正しますが、2倍の長さ（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の場合は0です1,2,3,5,4）

any(r)

数字がすべて正しい位置にある場合をブロックします

ハスケル、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リストを2つの部分に分割するすべての可能な方法を提供するヘルパー関数を使用して、要素を取り出し、再び別の場所に挿入します。

オンラインでお試しください！