Temos alguns novos moderadores de xerife na cidade, Mego e DJMcMayhem . Precisamos de um desafio para honrá-los adequadamente por suas novas posições, então vamos lá.

Aqui está algo que chamou minha atenção ao passar o mouse sobre seus perfis - seus IDs de usuário são e . Se você executar uma subtração em dígitos, notará algo bastante emocionante (é claro, considerando as diferenças absolutas):$31716$$45941$

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

O número gerado pelo algoritmo acima é . Há algo de especial nesse número inteiro: ele consiste apenas em dígitos consecutivos , classificados em ordem crescente, mas exatamente um dos dígitos não está colocado corretamente - .$14235$$4$

Chamaremos um par de números inteiros positivos um par DJMcMego se as diferenças absolutas em dígitos forem números inteiros consecutivos, classificados em ordem crescente, mas exatamente um deles não é o seu lugar. Ou seja, é possível mover exatamente um dígito do resultado da subtração digitada para outra posição, de modo que o número inteiro obtido tenha apenas dígitos consecutivos, classificados em ordem crescente.$(a, b)$

No exemplo acima, o par é um par DJMcMego , porque se é movido entre e , o resultado é , que atende aos critérios. Observe que os dígitos do número resultante não precisam começar em , eles devem ser consecutivos. Quando alguém não tem certeza sobre qual decisão deve tomar, sempre pode contar com a ajuda do outro para resolver as coisas.4 3 5 12345 $(31716, 45941)$$4$$3$$5$$12345$$1$

Sua tarefa é gerar um valor de verdade / falsidade, dependendo se um par de números inteiros positivos fornecido como entrada é um par DJMcMego.

• Está garantido que e terá o mesmo número de dígitos, sempre pelo menos 4.$a$$b$

• Você pode pegar os números inteiros em qualquer formato razoável (por exemplo, números inteiros nativos, seqüências de caracteres, listas de dígitos, etc.)

• Você pode competir em qualquer linguagem de programação e pode receber e fornecer saída por qualquer método padrão , observando que essas brechas são proibidas por padrão. Isso é código-golfe , então a submissão mais curta (em bytes) para todos os idiomas vence.

Casos de teste

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

Ou, em outro formato .

05AB1E , 18 bytes

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

Experimente online!

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

• Agradecimentos a Stan Strum por manter um byte de golfe.
• Economizou quatro bytes manipulando algumas inicializações variáveis.
• Salva um byte jogando golfe for(...;l++)b*=B[l]==-~B[l-1];em for(...;b*=B[l]==-~B[~-l++]);(provavelmente dependendo de um comportamento indefinido, pois requer avaliação inicial B[l]seguida por -~B[~-l++]).
• Salvo três cinco bytes.
• Economizou quinze vinte e seis bytes graças ao 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;}

Experimente online!

Explicação (versão 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

Experimente online!

JavaScript (ES6), 130 bytes

Recebe a entrada como duas matrizes de dígitos na sintaxe de currying (a)(b). Retorna um 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]))))

Experimente online!

SWI-Prolog, 157 bytes

Não é muito curto, mas o problema parecia particularmente adequado para predicados declarativos, ligação e recursão variáveis, ou seja, 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([_],[_]).

Ligue com, por exemplo, n([3,1,7,1,6],[4,5,9,4,1]).

Explicação: mova um elemento nas duas listas para uma nova posição (usando o SWI-Prolog interno nth0) e verifique se a diferença das novas listas é 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 graças ao FrownyFrog

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

Experimente online!

Solução inicial:

J , 35 bytes

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

Experimente online!

Explicação

Leva listas de dígitos como entrada

|@- encontra a diferença absoluta entre os dígitos das listas

1=1#.0<2-/\]Verifica se apenas um dígito está fora de seu lugar. Primeiro, encontro as diferenças entre todos os pares de dígitos adjacentes e verifico se apenas um deles é positivo.

* Multiplique o resultado do teste acima (1 ou 0) com o seguinte teste:

1=[:*/2-/\\:~Todos os dígitos são consecutivos? Classifico a lista, pego as diferenças de todos os pares de dígitos adjacentes, multiplico-os e verifico se é igual a 1

Gelatina , 14 bytes

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

Experimente online!

Como 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.

Japonês , 18 bytes

Estou discutindo se devo postar isso ou não por algumas horas. Cheguei com ele rapidamente tarde da noite passada, mas não tive tempo de testá-lo adequadamente ( e pensei que poderia ser muito longo!). Desde então, Oliver postou uma solução semelhante (que era, quando esta foi postada originalmente, inválida); portanto, se ele ou a comunidade sentirem que isso é muito parecido, eu vou excluí-lo com prazer.

Recebe entradas como matrizes de 2 dígitos, saídas 0para trueou qualquer outro número para false.

íaV
ä> x*Un än × É

Experimente ou verifique todos os casos de teste

Explicação

                   :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

E, para percorrer esse processo em mais alguns casos de teste:

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

Teste no 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

Agradecimentos a Kevin por salvar ~ 29 bytes

Graças a Kevin novamente por mais 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;}

Seguiu o mesmo padrão que Galen criou para sua resposta em J.

Experimente online!

Retina , 102 bytes

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

Experimente online! O link inclui casos de teste. Retorna o número de maneiras que os dígitos podem ser movidos para obter uma sequência ascendente, que é 2 para uma troca direta, pois um dos dígitos pode ser movido além do outro nesse caso. Explicação:

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

Emparelhe os dígitos.

\d
*

Converta para unário.

(_*),\1
_

Faça a diferença, mas adicione 1 porque trabalhar com zero no Retina é difícil ™.

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

Liste todas as seqüências de dígitos obtidas movendo exatamente um dígito.

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

Verifique se há dígitos consecutivos.

Perl 5 , -F 87 84 83 bytes

Contagem de estilos antigos: 86 bytes ( +3para -F)

Dê a ele números como 2 linhas em STDIN, a última linha sem uma nova linha à direita.

Imprime a sequência de diferenças até 2 vezes para true, nada para false

A A0123456789corda longa é realmente irritante.

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

Experimente online!

Eu sou usure se isso 79conta como válido:

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

Trava para um par válido, para que você obtenha um código de saída diferente de zero. Ele não faz nada se não um par e sai com o código de saída 0. Eu sei que é permitido retornar o resultado via código de saída, mas eles são realmente verdadeiros e falsos ou de fato invertidos (pois o shell 0é verdadeiro)?

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

Experimente online!

Pyt , 20 18 bytes

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

Experimente online!

Explicação:

       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

Adicionar ++ , 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}*

Experimente online!

Define uma função lambda que recebe duas listas de dígitos como entrada. Emite um número inteiro positivo divisível por 24 ¹ para pares DJMcMego, 0 caso contrário.

_{1: Se for muito restritivo, ele também gera um número inteiro positivo para os pares DJMcMego e 0, caso contrário}

Como funciona

Aqui, realizamos 4 verificações para determinar se a entrada é válida. As partes do código que fazem essas verificações são

BcB_€|B]dBkbUBSVcGbU£>sVcGB]V

Aqui, pegamos a lista de diferenças absolutas de dígitos e contamos o número de pares sobrepostos que são classificados em ordem decrescente. Todo par DJMcMego produz um resultado de 1 , mas eles não são exclusivos nesse aspecto. Também armazenamos as diferenças absolutas de dígitos das entradas, para salvar os bytes posteriormente. Essa matriz será chamada de A por toda parte.

BKB#BKBcB_0º>b]

Em seguida, analisamos as diferenças elementares entre A e A antes de afirmar que pelo menos uma dessas diferenças é negativa.

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

Em terceiro lugar, podemos verificar se o par [1, 2] está contido nos incrementos de frente de Uma . Isso verifica se, em pelo menos uma posição de A , ele é classificado, o que é um critério para os pares DJMcMego.

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

Como nossa última verificação, afirmamos que o segundo elemento de A nunca é 0 . Para que um par, X e Y , seja um par DJMcMego, podemos assumir que seu A é sempre único, pois uma matriz com duplicatas nunca pode ser tornada consecutiva trocando um valor único por outro.

Finalmente, verificamos que os três primeiros desses testes retornaram 1 e que o quarto retornou um valor x tal que x ≠ 0

Um passo a passo do código é o seguinte

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

Experimente online!

@JayCe com um ridículo salvamento de 22 bytes!

O cavalo de batalha aqui é adist, o que fornece uma "distância de edição generalizada de Levenshtein" entre duas cordas. Por padrão, a distância é a contagem do número mínimo de inserções, exclusões e substituições necessárias para transformar uma sequência em outra. Mas adistpermite ponderar as coisas como você gosta - então, pesei cada substituição para adicionar 9 à distância, em vez de 1. Isso efetivamente força o algoritmo a procurar apenas inserções e exclusões.

Este código aceita vetores de números inteiros, calcula as diferenças absolutas entre elementos e converte o resultado para começar em 1, chamando-o w.

Em seguida, a distância de Levenshtein ponderada personalizada é calculada entre wcoladas para formar uma sequência e a sequência "1234..."(na verdade, utf-8 "\001\002\003\004...", mas adistnão se importa.) Com o mesmo número de caracteres que w.

A única maneira pela qual a string pode ter exatamente um dígito fora do lugar é se você fizer uma exclusão e uma inserção, dando uma distância de 2.

JavaScript, 137 136 135 134 132 132 123 bytes

Recebe entrada como duas matrizes de dígitos na sintaxe de curry, saídas 0para truee qualquer outro 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 teste

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

Obrigado, Sr. Xcoder, pelo 116->84corte, mas descobri que perdi os critérios de "número consecutivo", então 26 bytes são adicionados para esse fim :(

Depois disso, -1 mais obrigado Sr. Xcoder e -13 obrigado 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)

Experimente online!

Aquele abaixo corrige o 25634 - 11111problema, mas com comprimento duplo ( 211 206 145 142B) ... Golfe ...

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)

Experimente online!

E parabéns aos novos moderadores :)

Explicação:

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

Gera a lista de diferenças absolutas dos dígitos.

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

Calcula o deslocamento da posição correta.

sum(r)==0

Se a sequência não for contínua, a soma deslocada "normalmente" não será 0. Mas, mesmo que seja igual a 0, as próximas as bloquearão.

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

Apenas 0 ou 1 item terá deslocamento absoluto maior que 1 (aquele com posição incorreta e 0 é o caso 1,2,3,5,4)

any(r)

Bloqueia o caso quando todos os números estão nas posições corretas

Haskell , 182 163 162 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]]

Recebe a entrada como uma lista de dígitos. A função auxiliar pque oferece todas as formas possíveis de dividir uma lista em duas partes é usada para retirar um elemento e inseri-lo novamente em outro lugar.

Experimente online!