Kami memiliki beberapa moderator sheriff baru di kota, Mego dan DJMcMayhem . Kami membutuhkan tantangan untuk menghormati mereka dengan benar untuk posisi baru mereka, jadi begitulah.

Berikut adalah sesuatu yang menarik perhatian saya ketika mengarahkan profil mereka - ID pengguna mereka adalah dan 45.941 . Jika Anda melakukan pengurangan digit-bijaksana, Anda akan melihat sesuatu yang cukup menarik (tentu saja, mengambil perbedaan absolut):$31716$$45941$

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

Jumlah yang dihasilkan oleh algoritma di atas adalah . Ada sesuatu yang istimewa tentang bilangan bulat ini: Terdiri dari hanya digit berturut - turut , diurutkan dalam urutan naik, tetapi tepat satu dari digit tidak ditempatkan dengan benar - 4 .$14235$$4$

Kami akan memanggil sepasang bilangan bulat positif suatu pasangan DJMcMego jika perbedaan mutlak digit-bijaksana adalah bilangan bulat berturut-turut, diurutkan dalam urutan menaik, tapi tepat satu dari mereka tidak di tempatnya. Artinya, adalah mungkin untuk memindahkan tepat satu digit dari hasil pengurangan digit ke posisi lain, sehingga bilangan bulat yang diperoleh hanya memiliki digit berurutan, diurutkan dalam urutan menaik.$(a, b)$

Dalam contoh kami di atas, pasangan adalah pasangan DJMcMego , karena jika 4 dipindahkan antara 3 dan 5 , hasilnya adalah 12345 , yang memenuhi kriteria. Perhatikan bahwa angka-angka dari angka yang dihasilkan tidak perlu mulai dari 1 , mereka hanya harus berturut-turut. Ketika seseorang tidak yakin tentang keputusan apa yang harus mereka ambil, mereka selalu dapat mengandalkan bantuan pihak lain untuk menyelesaikan masalah.$(31716, 45941)$$4$$3$$5$$12345$$1$

Tugas Anda adalah untuk menghasilkan nilai kebenaran / kepalsuan tergantung pada apakah sepasang bilangan bulat positif yang diberikan sebagai input adalah pasangan DJMcMego.

• Anda dijamin bahwa dan b akan memiliki jumlah digit yang sama, selalu setidaknya 4.$a$$b$

• Anda dapat mengambil bilangan bulat dalam format apa pun yang wajar (yaitu bilangan bulat asli, string, daftar digit, dll.)

• Anda dapat bersaing dalam bahasa pemrograman apa pun dan dapat mengambil input dan memberikan output melalui metode standar apa pun , sambil memperhatikan bahwa celah ini dilarang secara default. Ini adalah kode-golf , jadi pengiriman terpendek (dalam byte) untuk setiap bahasa menang.

Uji kasus

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

Atau, dalam format lain .

05AB1E , 18 byte

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

Cobalah online!

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

• Terima kasih kepada Stan Strum karena menginspirasikan golf satu byte.
• Disimpan empat byte dengan menyulap beberapa inisialisasi variabel.
• Disimpan byte dengan bermain golf for(...;l++)b*=B[l]==-~B[l-1];untuk for(...;b*=B[l]==-~B[~-l++]);(kemungkinan besar mengandalkan perilaku undefined, karena memerlukan pertama mengevaluasi B[l]diikuti oleh -~B[~-l++]).
• Disimpan tiga lima byte.
• Disimpan lima belas dua puluh enam byte berkat 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;}

Cobalah online!

Penjelasan (versi 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

Cobalah online!

JavaScript (ES6), 130 byte

Mengambil input sebagai dua larik digit dalam sintaks currying (a)(b). Mengembalikan 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]))))

Cobalah online!

SWI-Prolog, 157 byte

Tidak terlalu singkat tetapi masalahnya tampaknya sangat cocok untuk predikat deklaratif, pengikatan variabel dan rekursi, yaitu, 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([_],[_]).

Panggil dengan, misalnya, n([3,1,7,1,6],[4,5,9,4,1]).

Penjelasan: pindahkan elemen di kedua daftar ke posisi baru (menggunakan SWI-Prolog bawaan nth0) dan periksa apakah perbedaan daftar baru berturut-turut.

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 berkat FrownyFrog

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

Cobalah online!

Solusi awal:

J , 35 byte

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

Cobalah online!

Penjelasan

Mengambil daftar digit sebagai input

|@- menemukan perbedaan mutlak antara digit daftar

1=1#.0<2-/\]Cek apakah hanya satu digit yang keluar dari tempatnya. Pertama saya menemukan perbedaan antara semua pasangan digit yang berdekatan dan memeriksa untuk melihat apakah hanya satu dari mereka yang positif.

* Lipat gandakan hasil dari tes di atas (1 atau 0) dengan tes berikut:

1=[:*/2-/\\:~Apakah semua digit berurutan? Saya mengurutkan daftar, mengambil perbedaan untuk semua pasangan digit yang berdekatan, kalikan dan periksa apakah sama dengan 1

Jelly , 14 byte

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

Cobalah online!

Bagaimana itu bekerja

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

Pernah diperdebatkan apakah saya harus memposting ini atau tidak selama beberapa jam. Datang dengan cepat tadi malam tapi tidak punya waktu untuk mengujinya dengan benar ( dan saya pikir mungkin terlalu lama!). Oliver sejak itu memposting solusi yang sama (yang, ketika ini awalnya diposting, tidak valid) jadi jika dia, atau komunitas, merasa ini terlalu mirip, saya akan dengan senang hati menghapusnya.

Mengambil input sebagai array 2 digit, output 0untuk trueatau nomor lainnya untuk false.

íaV
ä> x*Un än × É

Cobalah atau periksa semua test case

Penjelasan

                   :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

Dan, untuk menjalani proses itu pada beberapa kasus uji lagi:

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

Tes dalam 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 Bytes

Terima kasih kepada Kevin karena telah menghemat ~ 29 byte

Terima kasih kepada Kevin lagi untuk 6 byte lagi

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

Mengikuti pola yang sama Galen datang dengan jawaban J-nya.

Cobalah online!

Retina , 102 byte

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

Cobalah online! Tautan termasuk kasus uji. Mengembalikan jumlah cara digit dapat dipindahkan untuk mencapai urutan naik, yaitu 2 untuk swap lurus karena salah satu digit dapat dipindahkan melewati yang lain dalam kasus itu. Penjelasan:

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

Pasangkan digit.

\d
*

Konversikan ke unary.

(_*),\1
_

Ambil perbedaannya, tetapi kemudian tambahkan 1 karena bekerja dengan nol di Retina adalah hard ™.

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

Daftar semua urutan digit yang diperoleh dengan menggerakkan tepat satu digit.

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

Periksa digit berturut-turut.

Perl 5 , -F 87 84 83 byte

Penghitungan gaya lama: 86 byte ( +3untuk -F)

Beri dia angka 2 baris pada STDIN, baris terakhir tanpa baris tambahan.

Mencetak string perbedaan hingga 2 kali untuk true, nothing for false

A0123456789Tali panjangnya benar-benar menjengkelkan.

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

Cobalah online!

Saya yakin jika ini 79dianggap valid:

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

Ini macet untuk pasangan yang valid, sehingga Anda mendapatkan kode keluar bukan nol. Ia tidak melakukan apa-apa jika bukan sepasang dan keluar dengan kode keluar 0. Saya tahu mengembalikan hasilnya melalui kode keluar diperbolehkan, tetapi apakah mereka benar-benar benar dan salah atau bahkan terbalik (karena shell 0itu benar)?

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

Cobalah online!

Pyt , 20 18 byte

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

Cobalah online!

Penjelasan:

       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

Tambahkan ++ , 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}*

Cobalah online!

Menentukan fungsi lambda yang mengambil dua daftar digit sebagai input. Menghasilkan bilangan bulat positif yang dapat habis dibagi 24 ¹ untuk pasangan DJMcMego, 0 sebaliknya.

_{1: Jika ini terlalu ketat, itu juga menghasilkan bilangan bulat positif untuk pasangan DJMcMego, dan 0 sebaliknya}

Bagaimana itu bekerja

Di sini kami melakukan 4 pemeriksaan untuk menentukan apakah input tersebut valid. Bagian dari kode yang melakukan pemeriksaan tersebut adalah

BcB_€|B]dBkbUBSVcGbU£>sVcGB]V

Di sini, kami mengambil daftar perbedaan digit absolut, kemudian menghitung jumlah pasangan yang tumpang tindih yang diurutkan dalam urutan menurun. Setiap pasangan DJMcMego menghasilkan hasil 1 , tetapi mereka tidak unik dalam aspek ini. Kami juga menyimpan perbedaan digit absolut input, untuk menyimpan byte di lain waktu. Array ini akan disebut sebagai A seluruh.

BKB#BKBcB_0º>b]

Selanjutnya, kami mengambil perbedaan elementwise antara A dan A yang diurutkan, sebelum menyatakan bahwa setidaknya salah satu dari perbedaan tersebut adalah negatif.

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

Ketiga, kita memeriksa apakah pasangan [1, 2] terkandung dalam penambahan maju dari A . Ini memeriksa bahwa, dalam setidaknya satu posisi A , itu diurutkan, yang merupakan kriteria untuk pasangan DJMcMego.

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

Sebagai pemeriksaan terakhir kami, kami menyatakan bahwa elemen kedua A tidak pernah 0 . Agar pasangan, X dan Y , menjadi pasangan DJMcMego, kita dapat mengasumsikan bahwa A mereka selalu unik, karena array dengan duplikat di dalamnya tidak pernah dapat dibuat berurutan dengan menukar nilai tunggal dengan yang lain.

Akhirnya, kami memeriksa bahwa tiga tes pertama mengembalikan 1 , dan yang keempat mengembalikan nilai x sehingga x ≠ 0

Langkah untuk langkah berjalan melalui kode adalah sebagai berikut

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

Cobalah online!

@JayCe dengan hemat 22 byte yang konyol!

Pekerja keras di sini adalah adist, yang memberikan "jarak edit Levenshtein yang digeneralisasi" antara dua string. Secara default jarak adalah hitungan jumlah minimal penyisipan, penghapusan, dan penggantian yang diperlukan untuk mengubah satu string menjadi yang lain. Tetapi adistmemungkinkan Anda untuk menimbang hal-hal yang Anda suka - jadi saya telah membobot masing-masing substitusi untuk menambahkan 9 ke jarak daripada 1. Ini secara efektif memaksa algoritma untuk mencari penyisipan dan penghapusan saja.

Kode ini menerima vektor bilangan bulat, menghitung perbedaan elemen absolut, dan menerjemahkan hasilnya untuk mulai pada 1, menyebutnya w.

Kemudian jarak Levenshtein tertimbang kustom dihitung antara wdisisipkan bersama untuk membuat string dan string "1234..."(sebenarnya utf-8 "\001\002\003\004..."tetapi adisttidak peduli.) Dengan jumlah karakter yang sama seperti w.

Satu-satunya cara string dapat memiliki tepat satu digit dari tempatnya adalah jika Anda membuat satu penghapusan dan satu penyisipan, memberikan jarak 2.

JavaScript, 137 136 135 134 132 123 byte

Mengambil input sebagai dua larik digit dalam sintaks currying, output 0untuk truedan nomor lainnya untuk 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

Uji Kasus

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

Terima kasih Tn. Xcoder untuk 116->84pemangkasan, tetapi saya menemukan saya telah melewatkan kriteria "angka berurutan", jadi 26 byte ditambahkan untuk tujuan itu :(

Setelah itu, -1 lagi Terima kasih Tn. Xcoder, dan -13 Terima kasih

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)

Cobalah online!

Yang di bawah ini memperbaiki 25634 - 11111masalah tetapi dengan panjang ganda ( 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)

Cobalah online!

Dan selamat untuk moderator baru :)

Penjelasan:

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

Menghasilkan daftar perbedaan mutlak digit.

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

Hitung offset dari posisi yang tepat.

sum(r)==0

Jika urutan tidak kontinu, maka jumlah offset akan "biasanya" tidak menjadi 0. Tetapi bahkan jika itu sama dengan 0, yang berikutnya akan memblokir mereka.

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

Hanya 0 atau 1 item yang memiliki offset absolut lebih besar dari 1 (item dengan posisi yang salah, dan 0 dalam kasus seperti 1,2,3,5,4)

any(r)

Memblokir kasing ketika semua nomor dalam posisi yang benar

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

Mengambil input sebagai daftar digit. Fungsi helper pyang memberikan semua cara yang mungkin untuk membagi daftar menjadi dua bagian digunakan untuk mengeluarkan elemen dan memasukkannya lagi ke tempat lain.

Cobalah online!