У нас є кілька нових шерифи модераторів в місті, Mego і DJMcMayhem . Нам потрібен виклик, щоб належним чином вшанувати їх на нових посадах, тому ми йдемо.

Ось щось, що привернуло мою увагу під час наведення на їхні профілі - їх ідентифікатори користувачів - 31716 та 45941 . Якщо ви здійснюєте цифрове віднімання, ви помітите щось досить захоплююче (звичайно, беручи абсолютні відмінності):$31716$$45941$

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

Кількість, генерована вищевказаним алгоритмом, становить . У цьому цілому цілому є щось особливе: воно складається лише з послідовних цифр, відсортованих у порядку зростання, але точно одна з цифр розміщена неправильно - 4 .$14235$$4$

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

У нашому прикладі вище, пара - пара DJMcMego , тому що якщо 4 переміщується між 3 та 5 , результат 12345 , що відповідає критеріям. Зауважте, що цифри отриманого числа не потрібно починати з 1 , вони просто повинні бути послідовними. Коли хтось не впевнений у тому, яке рішення він повинен прийняти, він завжди може покластися на допомогу іншого, щоб розібратися.$(31716, 45941)$$4$$3$$5$$12345$$1$

Ваше завдання - вивести значення truthy / false, залежно від того, чи є пара позитивних цілих чисел, поданих як вхід, пара DJMcMego.

• Вам гарантовано, що у і b буде однакова кількість цифр, завжди принаймні 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++]).
• Збережено три п’ять байтів.
• Збережено п'ятнадцять двадцять шість байтів завдяки стельовому коту .

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

Пояснення: перемістіть елемент в обох списках на нове місце (використовуючи 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 байт

Обговорювались, чи варто публікувати це чи ні пару годин. Прийшов з ним швидко пізно вчора ввечері, але не встиг його перевірити належним чином ( і я подумав, що це може бути занадто довго!). Олівер відтоді опублікував подібне рішення (яке, коли це було спочатку розміщено, недійсне), тож якщо він чи громада вважає, що це занадто схоже, я з радістю видалю його.

Приймає вхід у вигляді двозначних масивів, виходів 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

Тест на баш:

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] міститься в прямому збільшень . Це перевіряє, що, принаймні в одному положенні А , його сортують, що є критерієм для пар 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 байт

Приймає введення як два масиви цифр у синтаксисі currying, виводи 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 спасибі ов

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яка дає всі можливі способи розділити список на дві частини, використовується для виймання елемента і знову для вставки його в інше місце.

Спробуйте в Інтернеті!