Abbiamo alcuni nuovi moderatori di sceriffi in città, Mego e DJMcMayhem . Abbiamo bisogno di una sfida per onorarli adeguatamente per le loro nuove posizioni, quindi eccoci.

Ecco qualcosa che ha attirato la mia attenzione quando si passa il mouse sui loro profili: i loro ID utente sono e . Se esegui una sottrazione a livello di cifre, noterai qualcosa di piuttosto eccitante (ovviamente, prendendo le differenze assolute):$31716$$45941$

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

Il numero generato dall'algoritmo sopra è . C'è qualcosa di speciale in questo numero intero: consiste solo di cifre consecutive , ordinate in ordine crescente, ma esattamente una delle cifre non è posizionata correttamente - .$14235$$4$

Chiameremo una coppia di numeri interi positivi una coppia DJMcMego se le differenze assolute in termini di cifre sono numeri interi consecutivi, ordinati in ordine crescente, ma esattamente uno di questi non è dove appartiene. Cioè, è possibile spostare esattamente una cifra del risultato della sottrazione cifra in un'altra posizione, in modo tale che l'intero ottenuto abbia solo cifre consecutive, ordinate in ordine crescente.$(a, b)$

Nel nostro esempio sopra, la coppia è una coppia DJMcMego , perché se viene spostato tra e , il risultato è , che soddisfa i criteri. Si noti che le cifre del numero risultante non devono iniziare da , devono solo essere consecutive. Quando uno non è sicuro di quale decisione prendere, può sempre fare affidamento sull'aiuto dell'altro per risolvere le cose.4 3 5 12345 $(31716, 45941)$$4$$3$$5$$12345$$1$

Il tuo compito è generare un valore di verità / falsità a seconda che una coppia di numeri interi positivi forniti come input sia una coppia DJMcMego.

• Si sono garantiti che e avranno lo stesso numero di cifre, sempre almeno 4.$a$$b$

• Puoi prendere gli interi in qualsiasi formato ragionevole (es. Interi nativi, stringhe, elenchi di cifre, ecc.)

• Puoi competere in qualsiasi linguaggio di programmazione e puoi prendere input e fornire output attraverso qualsiasi metodo standard , tenendo presente che queste scappatoie sono vietate per impostazione predefinita. Questo è code-golf , quindi vince l'invio più breve (in byte) per ogni lingua .

Casi test

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

Oppure, in un altro formato .

05AB1E , 18 byte

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

Provalo online!

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

• Grazie a Stan Strum per aver insegnato un golf da un byte.
• Quattro byte salvati gestendo alcune inizializzazioni variabili.
• Salvato un byte giocando for(...;l++)b*=B[l]==-~B[l-1];a golf for(...;b*=B[l]==-~B[~-l++]);(molto probabilmente basandosi su un comportamento indefinito, poiché richiede una prima valutazione B[l]seguita da -~B[~-l++]).
• Salvati tre cinque byte.
• Risparmiato quindici e ventisei byte grazie 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;}

Provalo online!

Spiegazione (versione 248 byte)

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

Provalo online!

JavaScript (ES6), 130 byte

Accetta input come due matrici di cifre nella sintassi del curry (a)(b). Restituisce un valore 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]))))

Provalo online!

SWI-Prolog, 157 byte

Non molto breve, ma il problema sembrava particolarmente adatto per predicati dichiarativi, rilegatura variabile e ricorsione, ovvero 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([_],[_]).

Chiama con, ad es. n([3,1,7,1,6],[4,5,9,4,1]).

Spiegazione: spostare un elemento in entrambi gli elenchi in una nuova posizione (utilizzando il SWI-Prolog nth0integrato) e verificare se la differenza dei nuovi elenchi è 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 byte

-8 byte grazie a FrownyFrog

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

Provalo online!

Soluzione iniziale:

J , 35 byte

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

Provalo online!

Spiegazione

Accetta gli elenchi di cifre come input

|@- trova la differenza assoluta tra le cifre degli elenchi

1=1#.0<2-/\]Verifica se una sola cifra è fuori posto. Per prima cosa trovo le differenze tra tutte le coppie di cifre adiacenti e controllo per vedere se solo una di esse è positiva.

* Moltiplicare il risultato dal test sopra (1 o 0) con il seguente test:

1=[:*/2-/\\:~Tutte le cifre sono consecutive? Ordino l'elenco in basso, prendo le differenze per tutte le coppie di cifre adiacenti, le moltiplico e controllo se è uguale a 1

Gelatina , 14 byte

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

Provalo online!

Come funziona

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

Ho discusso se dovrei pubblicare questo o meno per un paio d'ore. Ci siamo andati rapidamente la sera scorsa ma non ho avuto il tempo di testarlo correttamente ( e ho pensato che potrebbe essere troppo lungo!). Da allora Oliver ha pubblicato una soluzione simile (che era, quando questa era originariamente pubblicata, non valida) quindi se lui, o la comunità, ritiene che questa sia troppo simile, la cancellerò felicemente.

Accetta input come array a 2 cifre, output 0per trueo qualsiasi altro numero per false.

íaV
ä> x*Un än × É

Provalo o controlla tutti i casi di test

Spiegazione

                   :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, per seguire questo processo su alcuni altri casi di test:

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

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

Test in 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 byte

Grazie a Kevin per aver salvato ~ 29 byte

Grazie ancora a Kevin per altri 6 byte

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

Seguì lo stesso schema che Galeno trovò per la sua risposta.

Provalo online!

Retina , 102 byte

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

Provalo online! Il link include casi di test. Restituisce il numero di modi in cui le cifre possono essere spostate per ottenere una sequenza crescente, che è 2 per uno scambio diretto poiché in quel caso entrambe le cifre possono essere spostate oltre l'altra. Spiegazione:

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

Associare le cifre.

\d
*

Converti in unario.

(_*),\1
_

Prendi la differenza, ma poi aggiungi 1 perché lavorare con zero in Retina è difficile ™.

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

Elenca tutte le sequenze di cifre ottenute spostando esattamente una cifra.

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

Verificare la presenza di cifre consecutive.

Perl 5 , -F 87 84 83 byte

Conteggio vecchio stile: 86 byte ( +3per -F)

Dagli numeri come 2 righe su STDIN, l'ultima riga senza una nuova riga finale.

Stampa la stringa della differenza fino a 2 volte per true, niente per false

La lunga A0123456789corda è davvero fastidiosa.

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

Provalo online!

Sono sicuro che questo 79sia valido:

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

Si arresta in modo anomalo per una coppia valida, quindi ottieni un codice di uscita diverso da zero. Non fa nulla se non una coppia ed esce con il codice di uscita 0. So che è consentito restituire il risultato tramite il codice di uscita, ma sono correttamente veritieri e falsi o in realtà invertiti (perché la shell 0è vera)?

Rubino , 124113 99 95 byte

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

Provalo online!

Pyt , 20 18 byte

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

Provalo online!

Spiegazione:

       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

Aggiungi ++ , 105 byte

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

Provalo online!

Definisce una funzione lambda che accetta due elenchi di cifre come input. Emette un numero intero positivo divisibile per 24 ¹ per le coppie DJMcMego, 0 altrimenti.

_{1: se questo è troppo restrittivo, genera anche un numero intero positivo per le coppie DJMcMego e 0 altrimenti}

Come funziona

Qui eseguiamo 4 controlli per determinare se l'input è valido. Le parti del codice che eseguono tali controlli sono

BcB_€|B]dBkbUBSVcGbU£>sVcGB]V

Qui, prendiamo l'elenco delle differenze assolute di cifre, quindi contiamo il numero di coppie sovrapposte che sono ordinate in ordine decrescente. Ogni coppia DJMcMego produce un risultato di 1 , ma non sono unici in questo aspetto. Inoltre, memorizziamo le differenze di cifre assolute degli input, per salvare i byte in un secondo momento. Questa matrice verrà definita A in tutto.

BKB#BKBcB_0º>b]

Quindi, prendiamo le differenze elementalmente tra A e A , prima di affermare che almeno una di quelle differenze è negativa.

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

Terzo, si controlla se la coppia [1, 2] è contenuta nei passi in avanti di A . Questo verifica che, in almeno una posizione di A , sia ordinato, che è un criterio per le coppie DJMcMego.

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

Come ultimo controllo, affermiamo che il secondo elemento di A non è mai 0 . Affinché una coppia, X e Y , sia una coppia DJMcMego, possiamo supporre che la loro A sia sempre unica, poiché un array con duplicati non può mai essere consecutivo scambiando un singolo valore con un altro.

Infine, controlliamo che i primi tre di questi test abbiano restituito 1 e che il quarto abbia restituito un valore x tale che x ≠ 0

Un passaggio per il passaggio attraverso il codice è il seguente

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 byte

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

Provalo online!

@JayCe con un ridicolo risparmio di 22 byte!

Il cavallo di battaglia qui è adist, che fornisce una "distanza di modifica di Levenshtein generalizzata" tra due stringhe. Per impostazione predefinita, la distanza è il conteggio del numero minimo di inserzioni, eliminazioni e sostituzioni necessarie per trasformare una stringa in un'altra. Ma adistti consente di ponderare le cose come preferisci, quindi ho soppesato ogni sostituzione per aggiungere 9 alla distanza anziché 1. Ciò costringe efficacemente l'algoritmo a cercare solo inserimenti ed eliminazioni.

Questo codice accetta vettori di numeri interi, calcola le differenze assolute elementalmente e traduce il risultato in modo che inizi da 1, chiamandolo w.

Quindi la distanza personalizzata di Levenshtein viene calcolata tra wincollate insieme per creare una stringa e la stringa "1234..."(in realtà utf-8 "\001\002\003\004..."ma adistnon importa.) Con lo stesso numero di caratteri di w.

L'unico modo in cui la stringa può avere esattamente una cifra fuori posto è se si effettua una cancellazione e un inserimento, dando una distanza di 2.

JavaScript, 137 136 135 134 132 123 byte

Accetta input come due matrici di cifre nella sintassi del curry, output 0per truee qualsiasi altro numero per 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

Casi test

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 byte

Grazie Mr. Xcoder per il 116->84taglio, ma ho scoperto che ho perso i criteri del "numero consecutivo", quindi sono stati aggiunti 26 byte a tale scopo :(

Dopodiché, -1 in più Grazie Mr. Xcoder e -13 Grazie 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)

Provalo online!

Quello sotto risolve il 25634 - 11111problema ma con doppia lunghezza ( 211 206 145 142B) ... 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)

Provalo online!

E congratulazioni ai nuovi moderatori :)

Spiegazione:

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

Genera l'elenco delle differenze assolute delle cifre.

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

Calcola l'offset dalla posizione corretta.

sum(r)==0

Se la sequenza non è continua, la somma di offset "di solito" non sarà 0. Ma anche se è uguale a 0, i successivi li bloccheranno.

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

Solo 0 o 1 articolo avrà un offset assoluto maggiore di 1 (quello con posizione errata e 0 è nel caso simile 1,2,3,5,4)

any(r)

Blocca il caso quando i numeri sono tutti nella posizione corretta

Haskell , 182 163 162 132 byte

(#)=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]]

Accetta input come un elenco di cifre. La funzione di aiuto pche offre tutti i modi possibili per dividere un elenco in due parti viene utilizzata per estrarre un elemento più volte per inserirlo altrove.

Provalo online!