Kasaba, Mego ve DJMcMayhem'de bazı yeni şerif moderatörlerimiz var . Onları yeni pozisyonları için doğru şekilde onurlandırmak için bir mücadeleye ihtiyacımız var, o yüzden işte gidiyoruz.

İşte onların profillerine üzerine gelindiğinde dikkatimi çekti şeydir - kendi kullanıcı kimlikleri ve . Rakam şeklinde çıkarma işlemi gerçekleştirirseniz, oldukça heyecan verici bir şey fark edeceksiniz (elbette, mutlak farkları alarak):$31716$$45941$

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

Yukarıdaki algoritma tarafından üretilen sayı $14235$ . Bu tamsayı ile ilgili özel bir şey var: Artan sırayla sıralanmış, yalnızca ardışık basamaklardan oluşur , ancak tam olarak rakamlardan biri doğru şekilde yerleştirilmez - $4$ .

Rakam-bilgili mutlak farklar ardışık tamsayılar ise, artan düzende sıralanmışsa, tam olarak bunlardan biri ait değilse, bir DJMcMego çifti çifti (a, b) pozitif tamsayı olarak adlandıracağız. Yani, rakamlı çıkarma sonucunun tam olarak bir basamağını başka bir konuma taşımak mümkündür , böylece elde edilen tamsayı artan sırayla sadece ardışık basamaklara sahip olur.$(a, b)$

Yukarıdaki örneğimizde, çift , bir DJMcMego çiftidir, çünkü , ve arasında taşınırsa sonuç, ; bu, kriterleri yerine getirir. Ortaya çıkan sayının basamak unutmayın yok de başlamak gerekir , onlar sadece ardışık olmalı. Biri, hangi kararı vermesi gerektiğinden emin olmadığı zaman, işleri çözmek için daima diğerinin yardımına güvenebilir.4 3 5 12345 $(31716, 45941)$$4$$3$$5$$12345$$1$

Göreviniz, giriş olarak verilen bir çift pozitif tamsayının bir DJMcMego çifti olup olmamasına bağlı olarak bir gerçeği / sahte değeri vermektir.

• ve her zaman en az 4 olmak üzere aynı sayıda haneye sahip olacağının garantisi vardır .$a$$b$

• Tamsayıları herhangi bir makul formatta (yani yerel tamsayılar, dizeler, rakam listeleri vb.) Alabilirsiniz.

• Herhangi bir programlama dilinde rekabet edebilir ve herhangi bir standart yöntemle girdi alabilir ve çıktı alabilirsiniz ; bu boşluklar varsayılan olarak yasaklanmıştır. Bu kod golf , yani her dil için en kısa sürede (bayt cinsinden) kazanıyor.

Test durumları

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

Veya, başka bir biçimde .

05AB1E , 18 bayt

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

Çevrimiçi deneyin!

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

• Bir baytlık golfü ilham alan Stan Strum'a teşekkürler .
• Bazı değişken başlatmalar hokkabazlık yaparak dört bayt kurtarıldı.
• Golf ile bir byte Kaydedilen for(...;l++)b*=B[l]==-~B[l-1];için for(...;b*=B[l]==-~B[~-l++]);(ilk değerlendirilmesiyle gerektirir olarak büyük olasılıkla, istenmeyen davranışlara dayanarak B[l]ardından -~B[~-l++]).
• Üç beş bayt kaydedildi .
• Ceilingcat sayesinde on beş byte kurtarıldı .

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

Çevrimiçi deneyin!

Açıklama (248 bayt versiyonu)

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

Çevrimiçi deneyin!

JavaScript (ES6), 130 bayt

Körme sözdiziminde girdiyi iki basamak dizisi olarak alır (a)(b). Bir boole döndürür.

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

Çevrimiçi deneyin!

SWI-Prolog, 157 bayt

Çok kısa değil, ancak sorun, özellikle bildirimsel tahminler, değişken bağlama ve özyineleme, yani Prolog :) için çok uygun görünüyordu.

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([_],[_]).

Örneğin, n([3,1,7,1,6],[4,5,9,4,1]).

Açıklama: her iki listedeki bir öğeyi (SWI-Prolog nth0yerleşikini kullanarak) yeni bir konuma taşıyın ve yeni listelerdeki farkın ardışık olup olmadığını kontrol edin.

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 bayt

Wn8 byte FrownyFrog sayesinde

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

Çevrimiçi deneyin!

İlk çözüm:

J , 35 bayt

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

Çevrimiçi deneyin!

açıklama

Girdi olarak rakam listelerini alır

|@- Listelerin rakamları arasındaki mutlak farkı bulur

1=1#.0<2-/\]Yerinde yalnızca bir rakam olup olmadığını kontrol eder. İlk önce bütün bitişik basamak çiftleri arasındaki farkları buluyorum ve sadece bir tanesinin pozitif olup olmadığını kontrol ediyorum.

* Yukarıdaki testteki sonucu (1 veya 0) aşağıdaki testle çarpın:

1=[:*/2-/\\:~Tüm rakamlar ardışık mı? Listeyi sıralıyorum, tüm bitişik basamak çiftleri arasındaki farkları alıyorum, onları çarpıyorum ve eşit olup olmadığını kontrol ediyorum 1

Jöle , 14 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

ạµṢ_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 bayt

Bunu birkaç saatliğine göndermem gerekip gerekmediğini tartışıyorum. Dün gece hızla geç geldi ama düzgün bir şekilde test etmek için zamanı yoktu ( ve çok uzun olabileceğini düşündüm!). Oliver o zamandan beri benzer bir çözüm yayınladı (bu, aslında ilk yayınlandığı zaman geçersizdi), o ya da topluluk, bunun çok benzer olduğunu hissederse , mutlu bir şekilde silerim.

2 basamaklı diziler, çıkış olarak girişi alır 0için trueya da herhangi bir başka sayıda false.

íaV
ä> x*Un än × É

Deneyin veya tüm test durumlarını kontrol edin

açıklama

                   :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

Ve birkaç test vakasında bu süreçten geçmek için:

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

($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 içinde test:

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 Bayt

~ 29 bayt tasarruf için Kevin teşekkürler

Başka bir 6 byte için tekrar Kevin teşekkürler

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

Aynı yöntemi takip etti Galen J cevabı için geldi.

Çevrimiçi deneyin!

Retina , 102 bayt

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

Çevrimiçi deneyin! Link, test durumlarını içerir. Her iki basamak da diğerinden geçilebileceğinden, düz bir takas için 2 olan, artan bir sıra elde etmek için basamakların hareket ettirilebileceği sayı sayısını döndürür. Açıklama:

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

Rakamları eşleştirin.

\d
*

Birliğe dönüştür.

(_*),\1
_

Farkı yakalayın, ancak daha sonra 1 ekleyin, çünkü Retina'da sıfırla çalışmak zordur.

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

Tam olarak bir rakam hareket ettirilerek elde edilen rakam dizilerinin tümünü listele.

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

Ardışık basamakları kontrol edin.

Perl 5 , -F 87 84 83 bayt

Eski stil sayımı: 86 bayt ( +3için -F)

Sonunda yeni bir satır olmadan son satır olan STDIN'de 2 satır sayıları verin.

Fark dizesini doğru değer için 2 defa, yanlış değer için hiçbir şey yazdırmaz

Uzun A0123456789dize gerçekten can sıkıcı bir durum.

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

Çevrimiçi deneyin!

Bunun 79geçerli sayıldığından eminim :

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

Geçerli bir çift için çöküyor, bu yüzden sıfır olmayan bir çıkış kodu alıyorsunuz. Bir çift olmasa ve çıkış kodu 0 ile çıkarsa hiçbir şey yapmaz. Sonucun çıkış kodu ile döndürülmesine izin verildiğini biliyorum, ancak düzgün bir şekilde kaba ve sahte mi, yoksa aslında tersine çevrilmiş mi (kabuk 0doğru)?

Ruby , 124 113 99 95 bayt

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

Çevrimiçi deneyin!

Pyt , 20 18 bayt

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

Çevrimiçi deneyin!

Açıklama:

       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 bayt ekle

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

Çevrimiçi deneyin!

Giriş olarak iki basamak listesi alan bir lambda işlevini tanımlar. Bölünebilen bir pozitif tamsayıyı çıktılar 24 ¹ DJMcMego çiftleri için, 0 , aksi.

_{1: Bu çok kısıtlayıcıysa, DJMcMego çiftleri için pozitif bir tamsayı, aksi takdirde 0 değerini verir.}

Nasıl çalışır

Burada, girişin geçerli olup olmadığını belirlemek için 4 kontrol gerçekleştiriyoruz. Kodun bu kontrolleri yapan kısımları,

BcB_€|B]dBkbUBSVcGbU£>sVcGB]V

Burada, mutlak basamak farkları listesini alırız, sonra azalan düzende sıralanan örtüşen çiftlerin sayısını sayarız. Her DJMcMego çifti 1 sonucu üretir , ancak bu açıdan benzersiz değillerdir. Girdilerin daha sonra alabilmesi için girdilerin mutlak rakam farklarını da saklıyoruz. Bu dizi boyunca A olarak anılacaktır .

BKB#BKBcB_0º>b]

Daha sonra, bu farklılıklardan en az birinin negatif olduğunu iddia etmeden önce A ve A arasındaki elemente göre elementel farklılıkları ele alıyoruz .

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

Üçüncü olarak, [1, 2] çiftinin A'nın ileri artışlarında yer alıp almadığını kontrol ederiz . Bu, A'nın en az bir konumunda, DJMcMego çiftleri için bir kriter olan sıralandığını kontrol eder.

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

Son kontrolümüzde, A'nın ikinci öğesinin asla 0 olmadığını iddia ediyoruz . Bir çift, için için X ve Y bir DJMcMego çifti olmaya, onların varsayabiliriz bir başka tek bir değer değiştirerek ardışık yapılabilir asla içinde tekrarlar da bir dizi olarak, her zaman eşsizdir.

Son olarak, bu testlerin ilk üç geri kontrol 1 ve dördüncü bir değer döndü x öyle ki ≠ 0 x

Kodun içinde adım adım ilerlemek için bir adım aşağıdaki gibidir

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 bayt

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

Çevrimiçi deneyin!

Saçma bir 22 byte ile @JayCe kaydedin!

Buradaki işgücü adist, iki dizi arasında "genelleştirilmiş bir Levenshtein düzenleme mesafesi" veren. Varsayılan olarak mesafe, bir dizgiyi diğerine dönüştürmek için gereken en az ekleme, silme ve değiştirme sayısının sayısıdır. Ancak adist, istediğiniz gibi şeyleri ağırlıklandırmanıza izin verir - bu yüzden her sübstitüyonu 1 yerine mesafeye 9 ekleyerek ağırlıklandırdım.

Bu kod, tamsayı vektörlerini kabul eder, mutlak elementel farklılıkları hesaplar ve sonucu 1'de başlamak üzere çevirir w.

Daha sonra, özel ağırlıklı Levenshtein mesafesi, wbir dize yapmak için birbirine yapıştırılanlar arasında hesaplanır ve dize "1234..."(aslında utf-8 "\001\002\003\004..."ama adistumursamaz.) Karakterleriyle aynı sayıdadır w.

Dizginin tam olarak bir basamağa sahip olabilmesi için tek yol, bir silme ve bir yerleştirme yaparsanız, 2'lik bir mesafedir.

JavaScript, 137 136 135 134 132 123 bayt

Söz dizimi, çıkışları currying basamak iki dizi olarak girişi alır 0için trueve başka bir numara 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

Test Kılıfları

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 bayt

116->84Kesim için teşekkürler Bay Xcoder , ancak "ardışık sayı" ölçütlerini kaçırdığımı fark ettim, bu nedenle 26 bayt bu amaç için eklendi :(

Ondan sonra -1 tane daha teşekkürler Bay Xcoder ve -13 teşekkürler.

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)

Çevrimiçi deneyin!

Aşağıdakilerden biri 25634 - 11111sorunu çözüyor ancak iki katı uzunluğunda ( 211 206 145 142B) ... Golf ...

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)

Çevrimiçi deneyin!

Ve yeni moderatörlere tebrikler :)

Açıklama:

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

Rakamların mutlak farklılıklarının listesini oluşturur.

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

Ofseti uygun pozisyondan hesaplar.

sum(r)==0

Dizi sürekli değilse, ofset toplamı "genellikle" 0 olamaz. Ancak 0'a eşit olsa bile, sonrakiler onları engeller.

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

Yalnızca 0 veya 1 öğe 1'den büyük mutlak ofset değerine sahip olacaktır (yanlış konumdaki ve 0 gibi 1,2,3,5,4)

any(r)

Sayıların tümü doğru konumdayken durumu engeller

Haskell , 182 163 162 132 bayt

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

Girdiyi basamak listesi olarak alır. pBir listeyi iki parçaya bölmenin tüm olası yollarını gösteren yardımcı işlev , bir öğeyi çıkarmak ve başka bir yere yerleştirmek için tekrar kullanılır.

Çevrimiçi deneyin!