У нас есть несколько новых модераторов шерифов в городе, Mego и DJMcMayhem . Нам нужен вызов, чтобы должным образом почтить их за их новые должности, так что мы идем.

Вот что привлекло мое внимание при наведении на их профили - их идентификаторы пользователей и . Если вы выполните вычитание с помощью цифр, вы заметите нечто довольно захватывающее (конечно, с учетом абсолютных различий):$31716$$45941$

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

Число, сгенерированное вышеупомянутым алгоритмом, составляет . В этом целом числе есть что-то особенное: оно состоит только из последовательных цифр, отсортированных по возрастанию, но ровно одна из цифр размещена неправильно - .$14235$$4$

Мы назовем пару положительных целых чисел парой DJMcMego, если абсолютные разности по цифрам являются последовательными целыми числами, отсортированными в порядке возрастания, но точно одно из них не там, где оно принадлежит. То есть возможно переместить ровно одну цифру результата посимвольного вычитания в другую позицию, так что полученное целое число имеет только последовательные цифры, отсортированные в порядке возрастания.$(a, b)$

В нашем примере выше, пара является парой DJMcMego , потому что если перемещается между и , результат равен , что соответствует критериям. Обратите внимание, что цифры результирующего числа не обязательно должны начинаться с , они просто должны быть последовательными. Когда кто-то не уверен в том, какое решение он должен принять, он всегда может рассчитывать на помощь другого, чтобы разобраться.$(31716, 45941)$$4$5 $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 222 байта

• Спасибо Стэну Струму за создание однобайтового гольфа.
• Сохранено четыре байта путем жонглирования некоторых переменных инициализации.
• Сохранение байта путем игры for(...;l++)b*=B[l]==-~B[l-1];в гольф for(...;b*=B[l]==-~B[~-l++]);(скорее всего, полагаясь на неопределенное поведение, так как оно требует сначала оценки, B[l]а затем - -~B[~-l++]).
• Сохранено три пять байтов.
• Сохранено пятнадцать двадцать шесть байтов благодаря функциюcatcat .

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 байт

Принимает ввод в виде двух массивов цифр в синтаксисе карри (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]).

Объяснение: переместите элемент в обоих списках на новую позицию (используя nth0встроенный SWI-Prolog ) и проверьте, является ли различие новых списков последовательным.

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 байт

−8 байт благодаря 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;}

Следуя той же схеме, что придумал Гален для своего 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 раз для true, ничего для 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это правда)?

Рубин , 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]*''}

Попробуйте онлайн!

Пыть , 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]

Далее мы берем поэлементные различия между отсортированными 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 , а четвертый вернул значение 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-байтовым сохранением!

Рабочая лошадка здесь adist, которая дает «обобщенное расстояние редактирования Левенштейна» между двумя строками. По умолчанию расстояние - это количество минимальных количеств вставок, удалений и замен, необходимых для преобразования одной строки в другую. Но adistпозволяет вам взвешивать вещи так, как вам нравится - поэтому я взвесил каждую замену, чтобы добавить 9 к расстоянию, а не 1. Это фактически заставляет алгоритм искать только вставки и удаления.

Этот код принимает векторы целых чисел, вычисляет абсолютные поэлементные различия и переводит результат в 1, вызывая его w.

Затем вычисляемое пользователем взвешенное расстояние Левенштейна вычисляется между 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 байт

Спасибо г-ну Xcoder за 116->84сокращение, но я обнаружил, что пропустил критерий «порядковый номер», поэтому для этой цели добавлено 26 байтов :(

После этого еще -1 спасибо, мистер Xcoder, и -13 спасибо 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 байта

(#)=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которая дает все возможные способы разбить список на две части, используется для извлечения элемента и его повторной вставки в другое место.

Попробуйте онлайн!