Wir haben einige neue Sheriff- Moderatoren in der Stadt, Mego und DJMcMayhem . Wir brauchen eine Herausforderung, um sie für ihre neuen Positionen angemessen zu ehren.

als Maus über die Profile : Die Benutzer-IDs lauten und . Wenn Sie ziffernweise subtrahieren, werden Sie etwas ziemlich Aufregendes bemerken (natürlich unter Berücksichtigung der absoluten Unterschiede):$31716$$45941$

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

Die vom obigen Algorithmus generierte Zahl ist . Diese Ganzzahl hat etwas Besonderes: Sie besteht nur aus aufeinanderfolgenden Ziffern, die in aufsteigender Reihenfolge sortiert sind, aber genau eine der Ziffern ist nicht richtig platziert - .$14235$$4$

Wir werden ein Paar positiver Ganzzahlen als DJMcMego-Paar bezeichnen, wenn die ziffernweisen absoluten Differenzen aufeinanderfolgende Ganzzahlen sind, die in aufsteigender Reihenfolge sortiert sind, von denen jedoch genau eine nicht dort ist, wo sie hingehören. Das heißt, es ist möglich, genau eine Ziffer des Ergebnisses der ziffernweisen Subtraktion an eine andere Position zu verschieben, so dass die erhaltene Ganzzahl nur aufeinanderfolgende Ziffern aufweist, die in aufsteigender Reihenfolge sortiert sind.$(a, b)$

In unserem obigen Beispiel ist das Paar ein DJMcMego- Paar, denn wenn zwischen und verschoben wird , ist das Ergebnis , was die Kriterien erfüllt. Beachten Sie, dass die Ziffern der resultierenden Nummer nicht bei , sondern nur fortlaufend sein sollten. Wenn einer sich nicht sicher ist, welche Entscheidung er treffen soll, kann er sich immer auf die Hilfe des anderen verlassen, um die Dinge zu regeln.4 3 5 12345 $(31716, 45941)$$4$$3$$5$$12345$$1$

Ihre Aufgabe ist es, einen Wahrheits- / Falschwert auszugeben, abhängig davon, ob es sich bei einem als Eingabe angegebenen Paar positiver Ganzzahlen um ein DJMcMego-Paar handelt.

• Es wird garantiert, dass und dieselbe Anzahl von Ziffern haben, immer mindestens 4.$a$$b$

• Sie können die Ganzzahlen in jedem vernünftigen Format verwenden (z. B. native Ganzzahlen, Zeichenfolgen, Ziffernlisten usw.).

• Sie können in jeder Programmiersprache antreten und über jede Standardmethode Eingaben und Ausgaben vornehmen. Beachten Sie jedoch, dass diese Lücken standardmäßig verboten sind. Dies ist Codegolf , daher gewinnt die kürzeste Übermittlung (in Bytes) für jede Sprache .

Testfälle

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

Oder in einem anderen Format .

05AB1E , 18 Bytes

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

Probieren Sie es online!

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

• Vielen Dank an Stan Strum für die Entwicklung eines Ein-Byte-Golfs.
• Vier Bytes durch Jonglieren mit Variableninitialisierungen gespart.
• Speichert ein Byte durch Golfen for(...;l++)b*=B[l]==-~B[l-1];auf for(...;b*=B[l]==-~B[~-l++]);(höchstwahrscheinlich unter Berufung auf undefiniertes Verhalten, da zuerst ausgewertet und B[l]anschließend -~B[~-l++]).
• Drei fünf Bytes gespeichert .
• Dank ceilingcat fünfzehn Bytes gespart .

j,k,l,L,r,b;f(char*A,char*B){for(j=r=0;A[L=j];)A[j++]=-~abs(A[j]-B[j]);for(j=0;j-L;j++)for(k=~0;L-++k;r|=!b)if(j-k){strcpy(B,A);for(l=j;A[l];B[~-l]=B[++l]);for(l=L;l-k;B[-~l]=B[--l]);B[k]=A[j];for(l=b=0;B[++l];b|=B[l]+~B[~-l]);}A=r;}

Probieren Sie es online!

Erläuterung (248-Byte-Version)

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

Probieren Sie es online!

JavaScript (ES6), 130 Byte

Übernimmt die Eingabe als zwei Ziffernfelder in der aktuellen Syntax (a)(b). Gibt einen Booleschen Wert zurück.

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

Probieren Sie es online!

SWI-Prolog, 157 Bytes

Nicht sehr kurz, aber das Problem schien für deklarative Prädikate, variable Bindung und Rekursion, dh Prolog, besonders gut geeignet zu sein :)

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([_],[_]).

Rufen Sie an mit zB n([3,1,7,1,6],[4,5,9,4,1]).

Erläuterung: Verschieben Sie ein Element in beiden Listen an eine neue Position (mithilfe des integrierten SWI-Prolog nth0) und überprüfen Sie, ob die Unterschiede der neuen Listen aufeinanderfolgend sind.

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

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

Probieren Sie es online!

Anfangslösung:

J , 35 Bytes

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

Probieren Sie es online!

Erläuterung

Übernimmt Ziffernlisten als Eingabe

|@- Findet den absoluten Unterschied zwischen den Ziffern der Listen

1=1#.0<2-/\]Prüft, ob nur eine Ziffer falsch ist. Zuerst finde ich die Unterschiede zwischen allen Paaren benachbarter Ziffern und überprüfe, ob nur eines davon positiv ist.

* Multiplizieren Sie das Ergebnis des obigen Tests (1 oder 0) mit dem folgenden Test:

1=[:*/2-/\\:~Sind alle Ziffern aufeinanderfolgend? Ich sortiere die Liste nach unten, nehme die Differenzen für alle Paare benachbarter Ziffern, multipliziere sie und überprüfe, ob sie gleich 1 sind

Jelly , 14 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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

Ich habe überlegt, ob ich das für ein paar Stunden posten soll oder nicht. Kam schnell spät in der Nacht dazu, hatte aber keine Zeit, es richtig zu testen ( und ich dachte, es könnte zu lang sein!). Oliver hat seitdem eine ähnliche Lösung veröffentlicht (diese war ursprünglich ungültig). Wenn er oder die Community der Meinung sind, dass dies zu ähnlich ist, werde ich sie gerne löschen.

Nimmt Eingaben als zweistellige Arrays, Ausgaben 0für trueoder eine andere Zahl für an false.

íaV
ä> x*Un än × É

Probieren Sie es aus oder überprüfen Sie alle Testfälle

Erläuterung

                   :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

Und um diesen Prozess an einigen weiteren Testfällen durchzugehen:

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

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 Bytes

Vielen Dank an Kevin für das Speichern von ~ 29 Bytes

Nochmals vielen Dank an Kevin für weitere 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;}

Befolgte dasselbe Muster, das Galen für seine J-Antwort aufgestellt hatte.

Probieren Sie es online!

Netzhaut , 102 Bytes

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

Probieren Sie es online! Link enthält Testfälle. Gibt die Anzahl der Wege zurück, auf denen Ziffern verschoben werden können, um eine aufsteigende Reihenfolge zu erreichen. Dies ist 2 für einen direkten Tausch, da in diesem Fall eine Ziffer an der anderen vorbei verschoben werden kann. Erläuterung:

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

Koppeln Sie die Ziffern.

\d
*

In Unary konvertieren.

(_*),\1
_

Nehmen Sie den Unterschied, aber addieren Sie dann 1, da die Arbeit mit Null in Retina schwierig ist.

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

Listen Sie alle Ziffernfolgen auf, die durch Verschieben genau einer Ziffer erhalten werden.

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

Überprüfen Sie, ob aufeinanderfolgende Ziffern vorhanden sind.

Perl 5 , -F 87 84 83 Bytes

Zählung nach alter Art: 86 Bytes ( +3für -F)

Geben Sie die Zahlen als 2 Zeilen auf STDIN an, die letzte Zeile ohne abschließenden Zeilenumbruch.

Druckt die Differenzzeichenfolge bis zu zweimal für wahr, nichts für falsch

Die lange A0123456789Saite ist echt nervig.

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

Probieren Sie es online!

Ich bin mir sicher, ob dies 79als gültig gilt:

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

Es stürzt bei einem gültigen Paar ab, sodass Sie einen Exit-Code ungleich Null erhalten. Es macht nichts, wenn es kein Paar ist, und wird mit Exit-Code 0 beendet. Ich weiß, dass die Rückgabe des Ergebnisses über Exit-Code zulässig ist, aber sind sie richtig wahr und falsch oder tatsächlich umgekehrt (denn die Shell 0ist wahr)?

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

Probieren Sie es online!

Pyt , 20 bis 18 Bytes

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

Probieren Sie es online!

Erläuterung:

       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

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

Probieren Sie es online!

Definiert eine Lambda-Funktion, die zwei Ziffernlisten als Eingabe verwendet. Gibt für DJMcMego-Paare eine positive ganze Zahl aus, die durch 24 ¹ teilbar ist, andernfalls 0 .

_{1: Wenn dies zu restriktiv ist, wird auch eine positive Ganzzahl für DJMcMego-Paare und ansonsten 0 ausgegeben}

Wie es funktioniert

Hier führen wir 4 Überprüfungen durch, um festzustellen, ob die Eingabe gültig ist. Die Teile des Codes, die diese Prüfungen durchführen, sind

BcB_€|B]dBkbUBSVcGbU£>sVcGB]V

Hier nehmen wir die Liste der absoluten Ziffernunterschiede und zählen dann die Anzahl der überlappenden Paare, die in absteigender Reihenfolge sortiert sind. Jedes DJMcMego-Paar ergibt ein Ergebnis von 1 , aber diesbezüglich sind sie nicht eindeutig. Wir speichern auch die absoluten Ziffernunterschiede der Eingänge, um später Bytes zu sparen. Dieses Array wird durchgehend mit A bezeichnet .

BKB#BKBcB_0º>b]

Als nächstes nehmen wir die elementweisen Unterschiede zwischen A und A sortiert, bevor wir behaupten, dass mindestens einer dieser Unterschiede negativ ist.

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

Drittens prüfen wir, ob das Paar [1, 2] in den Vorwärtsinkrementen von A enthalten ist . Dies prüft, ob an mindestens einer Position von A sortiert ist, was ein Kriterium für DJMcMego-Paare ist.

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

Bei unserer letzten Überprüfung wird angenommen, dass das zweite Element von A niemals 0 ist . Damit ein Paar, X und Y , ein DJMcMego-Paar ist, können wir davon ausgehen, dass ihr A immer eindeutig ist, da ein Array mit Duplikaten niemals durch Austauschen eines einzelnen Werts mit einem anderen konsekutiv gemacht werden kann.

Schließlich überprüfen wir , dass die ersten drei dieser Tests zurück 1 , und dass der vierte Wert zurückgegeben x , so daß x ≠ 0

Ein schrittweises Durchlaufen des Codes ist wie folgt

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

Probieren Sie es online!

@ JayCe mit einer lächerlichen 22-Byte-Speicherung!

Das Arbeitspferd ist hier adist, das einen "verallgemeinerten Levenshtein-Bearbeitungsabstand" zwischen zwei Saiten angibt. Standardmäßig ist der Abstand die Anzahl der minimalen Einfügungen, Löschungen und Ersetzungen, die erforderlich sind, um eine Zeichenfolge in eine andere umzuwandeln. Aber adistSie können Dinge wie gewünscht gewichten. Deshalb habe ich jede Ersetzung gewichtet, um 9 zur Distanz anstatt 1 hinzuzufügen. Dadurch wird der Algorithmus effektiv gezwungen, nur nach Einfügungen und Löschungen zu suchen.

Dieser Code akzeptiert Vektoren von ganzen Zahlen, berechnet die absoluten elementweisen Differenzen und übersetzt das Ergebnis so, dass es bei 1 beginnt und es aufruft w.

Dann wird der benutzerdefinierte gewichtete Levenshtein-Abstand zwischen dem wEinfügen einer Zeichenfolge und der Zeichenfolge "1234..."(tatsächlich utf-8 "\001\002\003\004...", adistaber egal.) Mit der gleichen Anzahl von Zeichen wie berechnet w.

Die Zeichenfolge kann nur dann genau eine Stelle haben, wenn Sie eine Löschung und eine Einfügung mit einem Abstand von 2 vornehmen.

JavaScript, 137 136 135 134 132 123 Bytes

Nimmt Eingaben als zwei Ziffernfelder in der aktuellen Syntax, Ausgaben 0für trueund jede andere Zahl für 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

Testfälle

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

Vielen Dank an Herrn Xcoder für den 116->84Schnitt, aber ich habe festgestellt, dass ich die Kriterien für die "fortlaufende Nummer" verpasst habe. Zu diesem Zweck werden 26 Bytes hinzugefügt :(

Danach noch -1 Danke Mr. Xcoder und -13 Danke 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)

Probieren Sie es online!

Das folgende behebt das 25634 - 11111Problem, aber mit doppelter Länge ( 211 206 145 142B) ... Golfen ...

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)

Probieren Sie es online!

Und Glückwunsch an neue Moderatoren :)

Erläuterung:

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

Erzeugt die Liste der absoluten Differenzen der Ziffern.

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

Berechnet den Versatz von der richtigen Position.

sum(r)==0

Wenn die Sequenz nicht kontinuierlich ist, ist die Versatzsumme "normalerweise" nicht 0. Aber selbst wenn sie gleich 0 ist, werden sie von den nächsten ausgeblendet.

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

Nur 0 oder 1 haben einen absoluten Versatz größer als 1 (der mit der falschen Position und 0 ist in dem Fall wie 1,2,3,5,4)

any(r)

Blockiert den Fall, wenn sich alle Zahlen an der richtigen Position befinden

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

Übernimmt die Eingabe als Ziffernliste. Mit der Hilfsfunktion p, mit der eine Liste auf alle möglichen Arten in zwei Teile aufgeteilt werden kann, wird ein Element herausgenommen und erneut an einer anderen Stelle eingefügt.

Probieren Sie es online!