Nous avons de nouveaux modérateurs de shérif en ville, Mego et DJMcMayhem . Nous avons besoin d'un défi pour bien les honorer pour leurs nouveaux postes, alors c'est parti.

Voici quelque chose qui a attiré mon attention lorsque je survole leurs profils: leurs identifiants d'utilisateur sont et 45941 . Si vous effectuez une soustraction numérique, vous remarquerez quelque chose d'assez excitant (bien sûr, en prenant les différences absolues):$31716$$45941$

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

Le nombre généré par l'algorithme ci-dessus est . Cet entier a quelque chose de spécial: il ne se compose que de chiffres consécutifs , triés par ordre croissant, mais l' un des chiffres n'est pas placé correctement - $14235$$4$ .

Nous appellerons une paire d’entiers positifs une paire DJMcMego si les différences absolues en chiffres sont des entiers consécutifs, triés par ordre croissant, mais l’un d’eux n’est pas celui auquel il appartient. C'est-à-dire qu'il est possible de déplacer exactement un chiffre du résultat de la soustraction numérique vers une autre position, de sorte que le nombre entier obtenu ne comporte que des chiffres consécutifs, triés par ordre croissant.$(a, b)$

Dans notre exemple ci-dessus, la paire est une paire DJMcMego , car si 4 est déplacé entre 3 et 5 , le résultat est 12345 , ce qui répond aux critères. Notez que les chiffres du nombre résultant ne doivent pas nécessairement commencer par 1 , ils doivent simplement être consécutifs. Lorsqu'une personne ne sait pas quelle décision elle devrait prendre, elle peut toujours compter sur l'aide de l'autre pour régler le problème.$(31716, 45941)$$4$$3$$5$$12345$$1$

Votre tâche consiste à générer une valeur vérité / fausseté selon que la paire d'entiers positifs donnée en entrée est une paire DJMcMego.

• Vous avez la garantie que et b auront le même nombre de chiffres, toujours au moins 4.$a$$b$

• Vous pouvez prendre les entiers dans n'importe quel format raisonnable (entiers natifs, chaînes, listes de chiffres, etc.)

• Vous pouvez concurrencer dans n’importe quel langage de programmation et prendre des entrées et des sorties selon n’importe quelle méthode standard , tout en prenant note que ces failles sont interdites par défaut. C'est du code-golf , donc la soumission la plus courte (en octets) pour chaque langue gagne.

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

Ou, dans un autre format .

05AB1E , 18 octets

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

Essayez-le en ligne!

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

• Merci à Stan Strum pour l’insertion d’un golf d’un octet.
• Sauvegardé quatre octets en jonglant avec certaines initialisations de variables.
• Sauvegardé un octet en jouant for(...;l++)b*=B[l]==-~B[l-1];au golf for(...;b*=B[l]==-~B[~-l++]);(reposant probablement sur un comportement indéfini, car il faut d'abord évaluer B[l]suivi de -~B[~-l++]).
• Enregistré trois cinq octets.
• Sauvé quinze vingt-six octets grâce à 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;}

Essayez-le en ligne!

Explication (version de 248 octets)

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

Essayez-le en ligne!

JavaScript (ES6), 130 octets

Prend les entrées sous forme de deux tableaux de chiffres en syntaxe de curry (a)(b). Retourne un booléen.

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

Essayez-le en ligne!

SWI-Prolog, 157 octets

Pas très court, mais le problème semblait particulièrement bien adapté aux prédicats déclaratifs, aux liaisons variables et à la récursivité, c'est-à-dire 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([_],[_]).

Appeler avec, par exemple, n([3,1,7,1,6],[4,5,9,4,1]).

Explication: déplacez un élément des deux listes vers un nouvel emplacement (à l'aide de SWI-Prolog nth0intégré) et vérifiez si la différence entre les nouvelles listes est consécutive.

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 octets

−8 octets grâce à FrownyFrog

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

Essayez-le en ligne!

Solution initiale:

J , 35 octets

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

Essayez-le en ligne!

Explication

Prend des listes de chiffres en entrée

|@- trouve la différence absolue entre les chiffres des listes

1=1#.0<2-/\]Vérifie si un seul chiffre est déplacé. Tout d'abord, je trouve les différences entre toutes les paires de chiffres adjacents et vérifie si un seul d'entre eux est positif.

* Multipliez le résultat du test ci-dessus (1 ou 0) avec le test suivant:

1=[:*/2-/\\:~Tous les chiffres sont-ils consécutifs? Je trie la liste, prends les différences pour toutes les paires de chiffres adjacents, les multiplie et vérifie si elle est égale à 1

Gelée , 14 octets

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

Essayez-le en ligne!

Comment ça fonctionne

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

Je me demandais si je devais poster ceci ou non pendant quelques heures. Je suis arrivé rapidement tard dans la nuit mais je n'ai pas eu le temps de le tester correctement ( et j'ai pensé que ce serait trop long!). Oliver a depuis posté une solution similaire (qui était invalide lors de la publication de celle-ci), donc si lui-même, ou la communauté, estime que cela est trop similaire, je le supprimerai volontiers.

Prend les entrées sous forme de tableaux à 2 chiffres, de sorties 0pour trueou de tout autre nombre pour false.

íaV
ä> x*Un än × É

Essayez-le ou vérifiez tous les cas de test

Explication

                   :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

Et, pour parcourir ce processus sur quelques autres cas de 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 octets

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

Merci à Kevin pour avoir économisé environ 29 octets

Merci encore à Kevin pour 6 autres octets

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

Suit le même schéma que Galen propose pour sa réponse en J.

Essayez-le en ligne!

Rétine , 102 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Renvoie le nombre de façons dont les chiffres peuvent être déplacés pour obtenir une séquence ascendante, ce qui correspond à 2 pour un échange simple, car l'un ou l'autre chiffre peut être déplacé au-delà de l'autre dans ce cas. Explication:

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

Associez les chiffres.

\d
*

Convertir en unaire.

(_*),\1
_

Prenez la différence, mais ajoutez ensuite 1 parce que travailler avec zéro dans Retina is hard ™.

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

Répertoriez toutes les séquences de chiffres obtenues en déplaçant exactement un chiffre.

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

Recherchez des chiffres consécutifs.

Perl 5 , -F 87 84 83 octets

Comptage de style ancien: 86 octets ( +3pour -F)

Donne les nombres sous forme de 2 lignes sur STDIN, la dernière ligne sans fin de nouvelle ligne.

Imprime la chaîne de différence jusqu'à 2 fois pour vrai, rien pour faux

La longue A0123456789ficelle est vraiment énervante.

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

Essayez-le en ligne!

Je suis habitué si cela 79compte comme valide:

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

Il se bloque pour une paire valide, vous obtenez donc un code de sortie non nul. Cela ne fait rien si ce n'est une paire et sort avec le code de sortie 0. Je sais que renvoyer le résultat via le code de sortie est autorisé, mais sont-ils correctement véridiques et faux, ou en fait inversés (car le shell 0est vrai)?

Ruby , 124 113 99 95 octets

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

Essayez-le en ligne!

Pyt , 20 18 octets

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

Essayez-le en ligne!

Explication:

       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

Ajouter ++ , 105 octets

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

Essayez-le en ligne!

Définit une fonction lambda qui prend deux listes de chiffres en entrée. Renvoie un entier positif divisible par 24 ¹ pour les paires DJMcMego, 0 sinon.

_{1: Si cela est trop restrictif, il génère également un entier positif pour les paires DJMcMego, et 0 sinon}

Comment ça fonctionne

Ici, nous effectuons 4 contrôles pour déterminer si l'entrée est valide. Les parties du code qui effectuent ces vérifications sont

BcB_€|B]dBkbUBSVcGbU£>sVcGB]V

Ici, nous prenons la liste des différences absolues en chiffres, puis comptons le nombre de paires qui se chevauchent et qui sont triées par ordre décroissant. Chaque paire DJMcMego produit un résultat égal à 1 , mais ils ne sont pas uniques à cet égard. Nous enregistrons également les différences de chiffres absolus des entrées, pour économiser des octets plus tard. Ce tableau sera appelé A tout au long.

BKB#BKBcB_0º>b]

Ensuite, nous prenons les différences élémentaires entre A et A triées, avant d’affirmer qu’au moins une de ces différences est négative.

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

Troisièmement, nous vérifions si la paire [1, 2] est contenue dans les incréments à terme de A . Ceci vérifie que, dans au moins une position de A , il est trié, ce qui est un critère pour les paires DJMcMego.

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

Lors de notre dernier contrôle, nous affirmons que le deuxième élément de A n’est jamais égal à 0 . Pour qu'un couple, X et Y , soit un couple DJMcMego, nous pouvons supposer que leur A est toujours unique, puisqu'un tableau contenant des doublons ne peut jamais être rendu consécutif en échangeant une seule valeur avec un autre.

Enfin, nous vérifions que les trois premiers de ces tests ont retourné 1 et que le quatrième a retourné une valeur x telle que x ≠ 0

Une marche à suivre du code est la suivante

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 octets

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

Essayez-le en ligne!

@JayCe avec une sauvegarde ridicule de 22 octets!

Le cheval de travail est ici adist, ce qui donne une "distance de levée généralisée Levenshtein" entre deux chaînes. Par défaut, la distance est le nombre minimal d'insertions, de suppressions et de substitutions nécessaires pour transformer une chaîne en une autre. Mais adistvous permet de pondérer les choses comme vous le souhaitez - j'ai pondéré chaque substitution pour ajouter 9 à la distance au lieu de 1. Cela force efficacement l'algorithme à rechercher uniquement les insertions et les suppressions.

Ce code accepte les vecteurs d’entiers, calcule les différences absolues par élément et traduit le résultat de manière à ce qu'il commence par 1, en l’appelant w.

Ensuite, la distance de Levenshtein pondérée personnalisée est calculée entre wcollé pour former une chaîne et la chaîne "1234..."(en réalité, utf-8 "\001\002\003\004..."mais adistne s’en soucie pas.) Avec le même nombre de caractères que w.

La seule façon dont la chaîne peut avoir exactement un chiffre déplacé est si vous effectuez une suppression et une insertion, ce qui donne une distance de 2.

JavaScript, 137 136 135 134 132 123 123 octets

Prend les entrées sous forme de deux tableaux de chiffres dans la syntaxe de curry, les sorties 0pour trueet tout autre nombre pour 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

Cas de 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 octets

Merci M. Xcoder pour la 116->84coupe, mais j'ai constaté que j'ai manqué le critère de "numéro consécutif", donc 26 octets sont ajoutés à cet effet :(

Après cela, -1 merci de plus M. Xcoder, et -13 Merci 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)

Essayez-le en ligne!

Celui ci-dessous corrige le 25634 - 11111problème mais avec double longueur ( 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)

Essayez-le en ligne!

Et félicitations aux nouveaux modérateurs :)

Explication:

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

Génère la liste des différences absolues des chiffres.

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

Calcule le décalage à partir de la position appropriée.

sum(r)==0

Si la séquence n'est pas continue, la somme de décalage ne sera "généralement" pas égale à 0. Mais même si elle est égale à 0, les suivantes la bloqueront.

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

Seul 0 ou 1 élément aura un décalage absolu supérieur à 1 (celui avec la mauvaise position et 0 dans le cas comme 1,2,3,5,4)

any(r)

Bloque le cas quand les nombres sont tous dans les positions correctes

Haskell , 182 163 162 132 octets

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

Prend la saisie sous forme de liste de chiffres. La fonction d'assistance pqui donne toutes les manières possibles de scinder une liste en deux parties permet d'extraire un élément et de l'insérer à un autre endroit.

Essayez-le en ligne!