ขณะนี้มีบางส่วนใหม่นายอำเภอผู้ดูแลในเมืองชำเลืองและDJMcMayhem เราต้องการความท้าทายเพื่อให้เกียรติพวกเขาอย่างเหมาะสมสำหรับตำแหน่งใหม่ของพวกเขาดังนั้นเราจึงไปที่นั่น

นี่คือสิ่งที่ได้จับความสนใจของฉันเมื่อโฉบเหนือโปรไฟล์ของพวกเขา - รหัสผู้ใช้ของพวกเขาและ45941หากคุณทำการลบเลขด้วยปัญญาคุณจะสังเกตเห็นบางสิ่งที่น่าตื่นเต้นทีเดียว$31716$$45941$

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

จำนวนที่สร้างโดยขั้นตอนวิธีการดังกล่าวข้างต้นคือ14235มีบางอย่างที่พิเศษเกี่ยวกับจำนวนเต็มนี้คือมันประกอบด้วยติดต่อกันตัวเลขเท่านั้นเรียงตามลำดับจากน้อยไปมาก แต่ตรงหนึ่งของตัวเลขที่ไม่ได้วางไว้อย่างถูกต้อง - 4$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

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 ไบต์

(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 ไบต์

by8 ไบต์ขอบคุณ 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 ไบต์

มีการถกเถียงกันว่าฉันควรโพสต์สิ่งนี้หรือไม่เป็นเวลาสองสามชั่วโมง มาสายเร็ว ๆ นี้เมื่อคืนนี้ แต่ไม่มีเวลาที่จะทำการทดสอบอย่างถูกต้อง ( และฉันคิดว่ามันอาจจะนานเกินไป!) โอลิเวอร์ได้โพสต์โซลูชันที่คล้ายกัน (ซึ่งเมื่อโพสต์นี้ถูกโพสต์ครั้งแรกไม่ถูกต้อง) ดังนั้นหากเขาหรือชุมชนรู้สึกว่าสิ่งนี้คล้ายกันมากเกินไปฉันจะลบมันอย่างมีความสุข

จะเข้าเป็นอาร์เรย์ 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 ไบต์

ขอขอบคุณเควินอีกครั้งสำหรับอีก 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)

ให้ตัวเลขเป็น 2 บรรทัดบน STDIN ซึ่งเป็นบรรทัดสุดท้ายโดยไม่ขึ้นบรรทัดใหม่

พิมพ์สตริงส่วนต่างสูงสุด 2 เท่าสำหรับจริงไม่มีอะไรเป็นเท็จ

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 , 124 113 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}*

ลองออนไลน์!

กำหนดฟังก์ชั่นแลมบ์ดาที่รับสองรายการของตัวเลขเป็นอินพุต แสดงผลเป็นจำนวนเต็มบวกหารด้วย24 ¹สำหรับคู่ DJMcMego, 0 เป็นอย่างอื่น

_{1: ถ้านี่เป็นข้อ จำกัด เกินไปก็จะส่งออกจำนวนเต็มบวกสำหรับคู่ DJMcMego และ0 เป็นอย่างอื่น}

มันทำงานอย่างไร

ที่นี่เราทำการตรวจสอบ 4 ครั้งเพื่อตรวจสอบว่าอินพุตนั้นถูกต้องหรือไม่ ส่วนต่าง ๆ ของรหัสที่ทำการตรวจสอบเหล่านั้นคือ

BcB_€|B]dBkbUBSVcGbU£>sVcGB]V

ที่นี่เรารับรายการความแตกต่างของตัวเลขหลักจากนั้นนับจำนวนคู่ที่ทับซ้อนกันซึ่งเรียงลำดับจากมากไปน้อย ทุกคู่ DJMcMego สร้างผลลัพธ์1แต่ไม่ซ้ำกันในด้านนี้ นอกจากนี้เรายังจัดเก็บความแตกต่างของตัวเลขสัมบูรณ์ของอินพุตเพื่อบันทึกไบต์ในภายหลัง อาร์เรย์นี้จะเรียกว่าAตลอด

BKB#BKBcB_0º>b]

ต่อไปเราจะต้องมีความแตกต่างระหว่าง elementwise และเรียงลำดับก่อนที่จะยืนยันว่าอย่างน้อยหนึ่งของความแตกต่างเหล่านั้นเป็นลบ

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

สามเราตรวจสอบว่าคู่[1, 2]มีอยู่ในทีละข้าง สิ่งนี้จะตรวจสอบว่าอย่างน้อยหนึ่งตำแหน่งของAจะถูกเรียงลำดับซึ่งเป็นเกณฑ์สำหรับคู่ DJMcMego

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

ขณะที่การตรวจสอบล่าสุดของเราเรายืนยันว่าองค์ประกอบที่สองของไม่เคย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 , 110 106 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 ไบต์ไร้สาระประหยัด!

workhorse นี่คือadistซึ่งให้ "generalized Levenshtein edit distance" ระหว่างสองสตริง โดยค่าเริ่มต้นระยะทางคือการนับจำนวนน้อยที่สุดของการแทรกการลบและการแทนที่ที่จำเป็นในการแปลงสตริงหนึ่งเป็นสตริงอื่น แต่adistอนุญาตให้คุณชั่งน้ำหนักสิ่งที่คุณชอบ - ดังนั้นฉันจึงให้น้ำหนักการแทนที่แต่ละอันเพื่อบวก 9 กับระยะทางมากกว่า 1 ซึ่งจะเป็นการบังคับอัลกอริทึมให้ค้นหาการแทรกและการลบเท่านั้น

รหัสนี้ยอมรับเวกเตอร์ของจำนวนเต็มคำนวณความแตกต่าง elementwise แน่นอนและแปลผลที่จะเริ่มต้นวันที่ 1 wเรียกมันว่า

จากนั้น Levenshtein ระยะทางถ่วงน้ำหนักที่กำหนดเองคือการคำนวณระหว่างwวางร่วมกันเพื่อให้สตริงและสตริง"1234..."(ที่จริง UTF-8 "\001\002\003\004..." แต่adistไม่ได้ดูแล.) wที่มีหมายเลขเดียวกันของตัวละครเป็น

วิธีเดียวที่สตริงสามารถมีได้หนึ่งหลักที่ไม่ถูกต้องคือถ้าคุณทำการลบหนึ่งครั้งและแทรกหนึ่งครั้งโดยให้ระยะห่างเป็น 2

JavaScript, 137 136 135 134 132 123 ไบต์

จะเข้าเป็นสองอาร์เรย์ของตัวเลขในความดีความชอบไวยากรณ์, เอาท์พุท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 ไบต์

ขอบคุณ Mr. Xcoder สำหรับการ116->84ตัด แต่ฉันพบว่าฉันพลาดเกณฑ์ "หมายเลขที่ต่อเนื่องกัน" ดังนั้นจึงมีการเพิ่ม 26 ไบต์สำหรับวัตถุประสงค์นั้น :(

หลังจากนั้น -1 Mr. Thanks Xcoder และ -13 Thanks 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 bytes

(#)=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ที่ให้วิธีที่เป็นไปได้ทั้งหมดในการแบ่งรายการออกเป็นสองส่วนใช้เพื่อดึงองค์ประกอบออกมาแล้วแทรกเข้าไปที่อื่น

ลองออนไลน์!