Tenemos algunos nuevos moderadores del sheriff en la ciudad, Mego y DJMcMayhem . Necesitamos un desafío para honrarlos adecuadamente por sus nuevos puestos, así que ahí vamos.

Aquí hay algo que me ha llamado la atención al pasar el mouse sobre sus perfiles: sus ID de usuario son y . Si realiza una resta de dígitos, notará algo bastante emocionante (por supuesto, tomando las diferencias absolutas):$31716$$45941$

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

El número generado por el algoritmo anterior es . Hay algo especial en este número entero: consta solo de dígitos consecutivos , ordenados en orden ascendente, pero exactamente uno de los dígitos no está colocado correctamente - .$14235$$4$

Llamaremos a un par de enteros positivos un par DJMcMego si las diferencias absolutas en dígitos son enteros consecutivos, ordenados en orden ascendente, pero exactamente uno de ellos no está donde pertenece. Es decir, es posible mover exactamente un dígito del resultado de la resta por dígitos a otra posición, de modo que el entero obtenido solo tenga dígitos consecutivos, ordenados en orden ascendente.$(a, b)$

En nuestro ejemplo anterior, el par $(31716, 45941)$ es un par DJMcMego , porque si $4$ se mueve entre $3$ y $5$ , el resultado es $12345$ , que cumple con los criterios. Tenga en cuenta que los dígitos del número resultante no necesitan comenzar en $1$ , solo deben ser consecutivos. Cuando uno no está seguro de qué decisión deben tomar, siempre puede confiar en la ayuda del otro para resolver las cosas.

Su tarea es generar un valor verdadero / falso dependiendo de si un par de enteros positivos dados como entrada es un par DJMcMego.

• Usted está garantizado que $a$ y $b$ tendrán el mismo número de dígitos, siempre por lo menos 4.

• Puede tomar los enteros en cualquier formato razonable (es decir, enteros nativos, cadenas, listas de dígitos, etc.)

• Puede competir en cualquier lenguaje de programación y puede tomar entradas y proporcionar salidas a través de cualquier método estándar , mientras toma nota de que estas lagunas están prohibidas por defecto. Este es el código de golf , por lo que gana el envío más corto (en bytes) para cada idioma .

Casos de prueba

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

O, en otro formato .

05AB1E , 18 bytes

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

Pruébalo en línea!

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

• Gracias a Stan Strum por inspring un golf de un byte.
• Ahorró cuatro bytes haciendo malabarismos con algunas inicializaciones variables.
• Se guardó un byte jugando for(...;l++)b*=B[l]==-~B[l-1];al golf for(...;b*=B[l]==-~B[~-l++]);(lo más probable es que dependa de un comportamiento indefinido, ya que requiere primero una evaluación B[l]seguida de -~B[~-l++])
• Guardado tres cinco bytes.
• Ahorró quince veintiséis bytes gracias a 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;}

Pruébalo en línea!

Explicación (versión de 248 bytes)

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

Pruébalo en línea!

JavaScript (ES6), 130 bytes

Toma datos como dos matrices de dígitos en la sintaxis de curry (a)(b). Devuelve un booleano.

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

Pruébalo en línea!

SWI-Prolog, 157 bytes

No muy breve, pero el problema parecía particularmente adecuado para predicados declarativos, enlace variable y recursividad, es decir, 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([_],[_]).

Llamar con, por ejemplo, n([3,1,7,1,6],[4,5,9,4,1]).

Explicación: mueva un elemento en ambas listas a una nueva posición (usando el SWI-Prolog nth0incorporado) y verifique si la diferencia de las nuevas listas es consecutiva.

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 bytes

−8 bytes gracias a FrownyFrog

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

Pruébalo en línea!

Solución inicial:

J , 35 bytes

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

Pruébalo en línea!

Explicación

Toma listas de dígitos como entrada

|@- encuentra la diferencia absoluta entre los dígitos de las listas

1=1#.0<2-/\]Comprueba si solo un dígito está fuera de su lugar. Primero encuentro las diferencias entre todos los pares de dígitos adyacentes y verifico si solo uno de ellos es positivo.

* Multiplique el resultado de la prueba anterior (1 o 0) con la siguiente prueba:

1=[:*/2-/\\:~¿Son todos los dígitos consecutivos? Ordeno la lista, tomo las diferencias para todos los pares de dígitos adyacentes, los multiplico y verifico si es igual a 1

Jalea , 14 bytes

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

Pruébalo en línea!

Cómo funciona

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

He estado debatiendo si debería publicar esto o no durante un par de horas. Se me ocurrió rápidamente anoche, pero no tuve tiempo de probarlo correctamente (¡ y pensé que podría ser demasiado largo!). Desde entonces, Oliver ha publicado una solución similar (que era, cuando esta se publicó originalmente, no válida), por lo que si él o la comunidad sienten que es demasiado similar, la eliminaré con mucho gusto.

Toma la entrada como matrices de 2 dígitos, salidas 0para trueo cualquier otro número para false.

íaV
ä> x*Un än × É

Pruébelo o verifique todos los casos de prueba

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

Y, para recorrer ese proceso en algunos casos de prueba más:

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

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

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

Gracias a Kevin por guardar ~ 29 bytes

Gracias a Kevin nuevamente por otros 6 bytes

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

Siguió el mismo patrón que Galen ideó para su respuesta J.

Pruébalo en línea!

Retina , 102 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Devuelve el número de formas en que los dígitos se pueden mover para lograr una secuencia ascendente, que es 2 para un intercambio directo, ya que cualquier dígito se puede mover más allá del otro en ese caso. Explicación:

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

Empareja los dígitos.

\d
*

Convierte a unario.

(_*),\1
_

Tome la diferencia, pero luego agregue 1 porque trabajar con cero en Retina es difícil ™.

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

Enumere todas las secuencias de dígitos obtenidas moviendo exactamente un dígito.

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

Verifique los dígitos consecutivos.

Perl 5 , -F 87 84 83 bytes

Conteo de estilo antiguo: 86 bytes ( +3para -F)

Déle los números como 2 líneas en STDIN, la última línea sin una nueva línea al final.

Imprime la cadena de diferencia hasta 2 veces para verdadero, nada para falso

La larga A0123456789cadena es realmente molesta.

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

Pruébalo en línea!

Estoy seguro si esto 79cuenta como válido:

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

Se bloquea por un par válido, por lo que obtienes un código de salida distinto de cero. No hace nada si no es un par y sale con el código de salida 0. Sé que devolver el resultado a través del código de salida está permitido, pero ¿son correctamente verdaderos y falsos o de hecho están invertidos (porque el shell 0es verdadero)?

Ruby , 124113 99 95 bytes

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

Pruébalo en línea!

Pyt , 20 18 bytes

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

Pruébalo en línea!

Explicación:

       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

Agregar ++ , 105 bytes

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

Pruébalo en línea!

Define una función lambda que toma dos listas de dígitos como entrada. Emite un entero positivo divisible por 24 ¹ para pares DJMcMego, 0 de lo contrario.

_{1: Si esto es demasiado restrictivo, también genera un número entero positivo para pares DJMcMego, y 0 en caso contrario}

Cómo funciona

Aquí realizamos 4 verificaciones para determinar si la entrada es válida. Las partes del código que hacen esas verificaciones son

BcB_€|B]dBkbUBSVcGbU£>sVcGB]V

Aquí, tomamos la lista de diferencias absolutas de dígitos, luego contamos el número de pares superpuestos que se ordenan en orden descendente. Cada par DJMcMego produce un resultado de 1 , pero no son únicos en este aspecto. También almacenamos las diferencias absolutas de dígitos de las entradas, para guardar bytes más adelante. Esta matriz se denominará A en todo momento.

BKB#BKBcB_0º>b]

A continuación, tomamos las diferencias por elementos entre A y A ordenadas, antes de afirmar que al menos una de esas diferencias es negativa.

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

En tercer lugar, comprobamos si el par [1, 2] está contenido en los incrementos de avance de A . Esto verifica que, al menos en una posición de A , esté ordenada, lo cual es un criterio para los pares DJMcMego.

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

Como nuestra última comprobación, afirmamos que el segundo elemento de A nunca es 0 . Para que un par, X e Y , sean un par DJMcMego, podemos suponer que su A siempre es única, ya que una matriz con duplicados nunca se puede hacer consecutiva intercambiando un solo valor con otro.

Finalmente, verificamos que las primeras tres de estas pruebas devolvieron 1 , y que la cuarta devolvió un valor x tal que x ≠ 0

Un paso a paso del código es el siguiente

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 bytes

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

Pruébalo en línea!

¡@JayCe con un ridículo ahorro de 22 bytes!

El caballo de batalla aquí es adist, que da una "distancia de edición de Levenshtein generalizada" entre dos cadenas. Por defecto, la distancia es el recuento del número mínimo de inserciones, eliminaciones y sustituciones necesarias para transformar una cadena en otra. Pero le adistpermite ponderar las cosas como desee, por lo que he ponderado cada sustitución para agregar 9 a la distancia en lugar de 1. Esto efectivamente obliga al algoritmo a buscar solo inserciones y eliminaciones.

Este código acepta vectores de enteros, calcula las diferencias absolutas por elementos y traduce el resultado para comenzar en 1, llamándolo w.

Luego, la distancia de Levenshtein ponderada personalizada se calcula entre wpegada para hacer una cadena y la cadena "1234..."(en realidad utf-8 "\001\002\003\004..."pero adistno le importa) con el mismo número de caracteres que w.

La única forma en que la cadena puede tener exactamente un dígito fuera de lugar es si realiza una eliminación y una inserción, dando una distancia de 2.

JavaScript, 137 136 135 134 132 123 bytes

Toma la entrada como dos matrices de dígitos en la sintaxis de curry, salidas 0para truey cualquier otro número para 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

Casos de prueba

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 bytes

Gracias Sr. Xcoder por el 116->84corte, pero descubrí que no cumplí con los criterios de "número consecutivo", por lo que se agregan 26 bytes para ese propósito :(

Después de eso, -1 más Gracias Sr. Xcoder, y -13 Gracias 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)

Pruébalo en línea!

El siguiente soluciona el 25634 - 11111problema pero con doble longitud ( 211 206 145 142B) ... Jugar al 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)

Pruébalo en línea!

Y felicidades a los nuevos moderadores :)

Explicación:

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

Genera la lista de diferencias absolutas de los dígitos.

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

Calcula el desplazamiento desde la posición correcta.

sum(r)==0

Si la secuencia no es continua, entonces la suma de compensación "generalmente" no será 0. Pero incluso si es igual a 0, las siguientes las bloquearán.

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

Solo 0 o 1 elemento tendrá un desplazamiento absoluto mayor que 1 (el que tiene una posición incorrecta, y 0 es en el caso similar 1,2,3,5,4)

any(r)

Bloquea el caso cuando los números están todos en las posiciones correctas

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

Toma la entrada como una lista de dígitos. La función auxiliar pque ofrece todas las formas posibles de dividir una lista en dos partes se utiliza para extraer un elemento y nuevamente para insertarlo en otro lugar.

Pruébalo en línea!