도시, 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$

• 적절한 형식 (예 : 기본 정수, 문자열, 숫자 목록 등)으로 정수를 사용할 수 있습니다.

• 모든 프로그래밍 언어로 경쟁 할 수 있으며 표준 방법을 통해 입력을 받고 출력을 제공 할 수 있지만 이러한 허점 은 기본적으로 금지되어 있습니다. 이것은 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 바이트

• 덕분에 스탠 스트 럼 한 바이트 골프를 inspring합니다.
• 일부 변수 초기화를 저글링하여 4 바이트를 절약했습니다.
• 골프 의해 저장된 바이트 for(...;l++)b*=B[l]==-~B[l-1];에 for(...;b*=B[l]==-~B[~-l++]);(이 먼저 평가하는 필요로 가장 가능성이 정의되지 않은 동작에 의존 B[l]하였다 -~B[~-l++]).
• 세 개의 5 바이트를 저장했습니다 .
• 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

온라인으로 사용해보십시오!

자바 스크립트 (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- 프롤로그, 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 또는 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.

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

펄 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

자바 (8) , 245 (227) 223 194 188 바이트

~ 29 바이트를 절약 한 Kevin에게 감사

다른 6 바이트에 대해 Kevin에게 다시 감사드립니다.

 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에서 0으로 작업하는 것이 어렵 기 때문에 1을 더하십시오.

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

정확히 한 자리를 움직여 얻은 모든 일련의 자릿수를 나열합니다.

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

연속 숫자를 확인하십시오.

Perl 5 , -F 87 84 83 바이트

이전 스타일 계산 : 86 바이트 ( +3for -F)

STDIN에서 두 줄로 번호를 지정하십시오. 마지막 줄은 줄 바꿈이 없습니다.

차이 문자열을 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으로 종료되지 않고 종료되지 않으면 아무것도하지 않습니다. 종료 코드를 통해 결과를 반환하는 것이 허용되지만 알기 쉽고 사실이 틀리거나 실제로는 셸 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

++ 추가 , 105 바이트

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

온라인으로 사용해보십시오!

두 자릿수 목록을 입력으로 사용하는 람다 함수를 정의합니다. DJMcMego 쌍의 경우 24 ¹ 로 나눌 수있는 양의 정수를 출력하고 , 그렇지 않으면 0을 출력 합니다.

_{1 : 이것이 너무 제한적인 경우 DJMcMego 쌍에 대해 양의 정수를 출력하고 그렇지 않으면 0 을 출력합니다.}

작동 원리

여기서 입력이 유효한지 확인하기 위해 4 가지 검사를 수행합니다. 이러한 검사를 수행하는 코드 부분은

BcB_€|B]dBkbUBSVcGbU£>sVcGB]V

여기에서는 절대 자릿수 차이 목록을 가져온 다음 내림차순으로 정렬되는 겹치는 페어 수를 계산합니다. 모든 DJMcMego 쌍은 1 의 결과를 생성 하지만이 측면에서는 고유하지 않습니다. 또한 바이트를 절약하기 위해 입력의 절대 자릿수 차이를 저장합니다. 이 배열을 전체적으로 A 라고합니다 .

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) , 제 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

온라인으로 사용해보십시오!

어리석은 22 바이트 저장으로 @JayCe!

여기서 중요한 것은 adist두 문자열 사이에 "일반화 된 레 벤슈 테인 편집 거리"를 제공합니다. 기본적으로 거리는 한 문자열을 다른 문자열로 변환하는 데 필요한 최소한의 삽입, 삭제 및 대체 수입니다. 그러나 adist원하는대로 가중치를 부여 할 수 있습니다. 따라서 각 치환에 가중치를 부여하여 1이 아닌 거리에 9를 더했습니다. 이렇게하면 알고리즘이 효과적으로 삽입 및 삭제 만 찾도록합니다.

이 코드는 정수로 구성된 벡터를 받아들이고 절대적인 요소 별 차이를 계산하고 결과를 1에서 시작하여이를 호출하도록 변환합니다 w.

그런 다음 맞춤 가중 Levenshtein 거리는 w함께 붙여 넣어 사이에 계산되어 문자열과 문자열 "1234..."(실제로 utf-8 "\001\002\003\004..."이지만 adist상관 없음)을 동일한 수의 문자로 w만듭니다.

문자열이 한 자리에서 정확히 한 자리를 가질 수있는 유일한 방법은 한 번의 삭제와 한 번의 삽입으로 거리가 2 인 경우입니다.

자바 스크립트, 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>

파이썬 (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문제이지만 이중 길이 ( 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)

숫자가 모두 올바른 위치에있는 경우를 차단

하스켈 , 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목록을 두 부분으로 나누는 가능한 모든 방법을 제공하는 도우미 기능 은 요소를 꺼내서 다른 곳에 삽입하는 데 사용됩니다.

온라인으로 사용해보십시오!