Mamy kilku nowych moderatorów szeryfa w mieście, Mego i DJMcMayhem . Potrzebujemy wyzwania, aby odpowiednio uhonorować ich za nowe stanowiska, więc proszę bardzo.

Oto coś, co przykuło moją uwagę podczas najechania kursorem na ich profile - ich identyfikatory użytkowników to i . Jeśli odejmiesz cyfrowo, zauważysz coś bardzo ekscytującego (oczywiście biorąc absolutne różnice):$31716$$45941$

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

Liczba wygenerowana przez powyższy algorytm wynosi . Jest coś wyjątkowego w tej liczbie całkowitej: składa się tylko z następujących po sobie cyfr, posortowanych w porządku rosnącym, ale dokładnie jedna z cyfr nie jest poprawnie umieszczona - .$14235$$4$

Będziemy nazywać parę liczb całkowitych dodatnich para DJMcMego jeżeli różnice bezwzględne cyfra mądry są kolejnymi liczbami całkowitymi, sortowane w porządku rosnącym, ale dokładnie jeden z nich nie jest miejsce, gdzie należy. Oznacza to, że możliwe jest przeniesienie dokładnie jednej cyfry wyniku cyfrowego odejmowania do innej pozycji, tak że uzyskana liczba całkowita ma tylko kolejne cyfry, posortowane w porządku rosnącym.$(a, b)$

W naszym powyższym przykładzie para jest parą DJMcMego , ponieważ jeśli zostanie przesunięte między a , wynik to , który spełnia kryteria. Zauważ, że cyfry wynikowej liczby nie muszą zaczynać się od , powinny być po prostu kolejne. Kiedy jeden nie jest pewien, jaką decyzję powinien podjąć, zawsze może polegać na pomocy drugiej strony, aby rozwiązać problem.4 3 5 12345 $(31716, 45941)$$4$$3$$5$$12345$$1$

Twoim zadaniem jest wyprowadzenie wartości prawda / fałsz w zależności od tego, czy para liczb całkowitych dodatnich podana jako dane wejściowe jest parą DJMcMego.

• Masz gwarancję, że i będą miały taką samą liczbę cyfr, zawsze co najmniej 4.$a$$b$

• Możesz wziąć liczby całkowite w dowolnym rozsądnym formacie (tj. Natywne liczby całkowite, ciągi znaków, listy cyfr itp.)

• Możesz konkurować w dowolnym języku programowania i możesz przyjmować dane wejściowe i generować dane wyjściowe za pomocą dowolnej standardowej metody , zwracając uwagę, że te luki są domyślnie zabronione. To jest golf golfowy , więc wygrywa najkrótsze przesłanie (w bajtach) dla każdego języka .

Przypadki testowe

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

Lub w innym formacie .

05AB1E , 18 bajtów

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

Wypróbuj online!

C (gcc) , 259 258 254 253 250 248 233 bajtów

• Dziękujemy Stanowi Strumowi za inspekcję jednobajtowego golfa.
• Zaoszczędzono cztery bajty, żonglując niektórymi zmiennymi inicjalizacjami.
• Zapisano bajt, grając for(...;l++)b*=B[l]==-~B[l-1];w golfa for(...;b*=B[l]==-~B[~-l++]);(najprawdopodobniej polegając na niezdefiniowanym zachowaniu, ponieważ wymaga to najpierw oceny, B[l]a następnie -~B[~-l++]).
• Zapisano trzy pięć bajtów.
• Oszczędność piętnastu bajtów dzięki pułapowi cat .

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

Wypróbuj online!

Objaśnienie (wersja 248 bajtów)

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

Wypróbuj online!

JavaScript (ES6), 130 bajtów

Pobiera dane wejściowe jako dwie tablice cyfr w składni curry (a)(b). Zwraca wartość logiczną.

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

Wypróbuj online!

SWI-Prolog, 157 bajtów

Nie bardzo krótki, ale problem wydawał się szczególnie odpowiedni dla deklaratywnych predykatów, zmiennych wiązania i rekurencji, tj. 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([_],[_]).

Zadzwoń, np. n([3,1,7,1,6],[4,5,9,4,1]).

Objaśnienie: przenieś element z obu list do nowej pozycji (za pomocą nth0wbudowanego programu SWI-Prolog ) i sprawdź, czy różnica między nowymi listami jest następująca po sobie.

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 bajtów

−8 bajtów dzięki FrownyFrog

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

Wypróbuj online!

Wstępne rozwiązanie:

J , 35 bajtów

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

Wypróbuj online!

Wyjaśnienie

Pobiera na wejściu listy cyfr

|@- znajduje bezwzględną różnicę między cyframi list

1=1#.0<2-/\]Sprawdza, czy tylko jedna cyfra jest na swoim miejscu. Najpierw znajduję różnice między wszystkimi parami sąsiadujących cyfr i sprawdzam, czy tylko jedna z nich jest dodatnia.

* Pomnóż wynik z powyższego testu (1 lub 0) przez następujący test:

1=[:*/2-/\\:~Czy wszystkie cyfry są następujące po sobie? Sortuję listę, biorę różnice dla wszystkich par sąsiednich cyfr, mnożę je i sprawdzam, czy jest równa 1

Galaretka , 14 bajtów

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

Wypróbuj online!

Jak to działa

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

Zastanawiałem się, czy powinienem to opublikować, czy nie przez kilka godzin. Szybko doszło do tego późną nocą, ale nie miałem czasu, aby go poprawnie przetestować ( i pomyślałem, że może to być za długie!). Od tego czasu Oliver opublikował podobne rozwiązanie (które było pierwotnie nieważne), więc jeśli on lub społeczność uważa, że ​​jest to zbyt podobne, chętnie go usunę.

Pobiera dane wejściowe jako 2-cyfrowe tablice, wyjścia 0dla truelub dowolną inną liczbę dla false.

íaV
ä> x*Un än × É

Wypróbuj lub sprawdź wszystkie przypadki testowe

Wyjaśnienie

                   :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

Aby przejść przez ten proces w kilku kolejnych przypadkach testowych:

---------------------------------------------------------------
| 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 bajtów

($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 w 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 bajtów

Dzięki Kevinowi za oszczędność ~ 29 bajtów

Jeszcze raz dziękuję Kevinowi za kolejne 6 bajtów

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

Postępował zgodnie z tym samym wzorem, co Galen wymyślił dla swojej odpowiedzi J.

Wypróbuj online!

Siatkówka , 102 bajty

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

Wypróbuj online! Link zawiera przypadki testowe. Zwraca liczbę sposobów, w jakie cyfry mogą być przenoszone, aby osiągnąć rosnącą sekwencję, która wynosi 2 dla prostej zamiany, ponieważ w takim przypadku jedną cyfrę można przesunąć obok drugiej. Wyjaśnienie:

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

Sparuj cyfry.

\d
*

Konwertuj na unary.

(_*),\1
_

Weź różnicę, ale dodaj 1, ponieważ praca z zerem w Retina jest trudna ™.

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

Wymień wszystkie sekwencje cyfr uzyskane po przesunięciu dokładnie jednej cyfry.

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

Sprawdź kolejne cyfry.

Perl 5 , -F 87 84 83 bajtów

Liczenie w starym stylu: 86 bajtów ( +3dla -F)

Podaj cyfry jako 2 linie na STDIN, ostatniej linii bez końcowego nowego wiersza.

Drukuje łańcuch różnicowy do 2 razy dla wartości true, nic dla wartości false

Długi A0123456789sznurek jest naprawdę denerwujący.

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

Wypróbuj online!

Jestem pewien, że to się 79liczy:

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

Awaria dla prawidłowej pary, więc otrzymujesz niezerowy kod wyjścia. Nie robi nic, jeśli nie jest parą i wychodzi z kodem wyjścia 0. Wiem, że zwracanie wyniku za pomocą kodu wyjścia jest dozwolone, ale czy są one odpowiednio prawdziwe i fałszywe, czy w rzeczywistości odwrócone (bo powłoka 0jest prawdziwa)?

Rubin , 124 113 99 95 bajtów

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

Wypróbuj online!

Pyt , 20 18 bajtów

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

Wypróbuj online!

Wyjaśnienie:

       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

Dodaj ++ , 105 bajtów

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

Wypróbuj online!

Definiuje funkcję lambda, która przyjmuje dwie listy cyfr jako dane wejściowe. Zwraca dodatnią liczbę całkowitą podzielną przez 24 ¹ dla par DJMcMego, 0 w przeciwnym razie.

_{1: Jeśli jest to zbyt restrykcyjne, wyświetla również dodatnią liczbę całkowitą dla par DJMcMego, a 0 w przeciwnym razie}

Jak to działa

Tutaj przeprowadzamy 4 kontrole, aby ustalić, czy dane wejściowe są prawidłowe. Części kodu, które wykonują te kontrole, to

BcB_€|B]dBkbUBSVcGbU£>sVcGB]V

Tutaj bierzemy listę różnic cyfr bezwzględnych, a następnie policzymy liczbę nakładających się par, które są sortowane w kolejności malejącej. Każda para DJMcMego daje wynik 1 , ale nie są one unikalne pod tym względem. Przechowujemy również bezwzględne różnice cyfr na wejściach, aby później zapisać bajty. Ta tablica będzie przez cały czas określana jako A.

BKB#BKBcB_0º>b]

Następnie bierzemy posortowane różnice między A i A , zanim stwierdzimy, że przynajmniej jedna z tych różnic jest ujemna.

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

Po trzecie, należy sprawdzić, czy para [1, 2] zawarty jest w przednich przyrostach . To sprawdza, czy co najmniej jedna pozycja A jest sortowana, co jest kryterium dla par DJMcMego.

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

Jako naszej ostatniej kontroli, możemy stwierdzić, że drugi element A nigdy nie jest 0 . Aby para X i Y była parą DJMcMego, możemy założyć, że ich A jest zawsze unikatowe, ponieważ tablicy z duplikatami nigdy nie można utworzyć kolejno, zamieniając jedną wartość z inną.

Na koniec sprawdzamy, czy pierwsze trzy z tych testów zwróciły 1 , a czwarty zwrócił wartość x taką, że x ≠ 0

Krok krok po kroku przez kod jest następujący

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 bajtów

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

Wypróbuj online!

@JayCe z absurdalnym 22-bajtowym zapisaniem!

Oto koń roboczy adist, który daje „uogólnioną odległość edycji Levenshteina” między dwoma łańcuchami. Domyślnie odległość to liczba minimalnej liczby wstawek, usunięć i podstawień wymaganych do przekształcenia jednego łańcucha w inny. Ale adistpozwala na ważenie rzeczy tak, jak lubisz - więc ważę każdą substytucję, aby dodać 9 do odległości, a nie 1. To skutecznie zmusza algorytm do wyszukiwania tylko wstawień i usunięć.

Ten kod akceptuje wektory liczb całkowitych, oblicza bezwzględne różnice elementarne i tłumaczy wynik na 1, wywołując go w.

Następnie obliczana jest niestandardowa ważona odległość Levenshteina między wwklejonymi razem, aby utworzyć ciąg znaków i ciąg "1234..."(właściwie utf-8 "\001\002\003\004...", ale adistto nie obchodzi.) Z taką samą liczbą znaków jak w.

Jedynym sposobem, w jaki ciąg może mieć dokładnie jedną cyfrę na miejscu, jest wykonanie jednego usunięcia i jednego wstawienia, co daje odległość 2.

JavaScript, 137 136 135 134 132 123 bajtów

Pobiera dane wejściowe jako dwie tablice cyfr w składni curry, wyjścia 0dla truei dowolnej innej liczby dla 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

Przypadki testowe

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 bajtów

Dziękuję Panu Xcoderowi za 116->84cięcie, ale stwierdziłem, że przeoczyłem kryteria „kolejnej liczby”, więc w tym celu dodano 26 bajtów :(

Potem jeszcze -1 podziękowań, panie Xcoder i -13 podziękowań

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)

Wypróbuj online!

Ten poniżej naprawia 25634 - 11111problem, ale z podwójną długością ( 211 206 145 142B) ... Gra w golfa ...

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)

Wypróbuj online!

I gratulacje dla nowych moderatorów :)

Wyjaśnienie:

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

Generuje listę bezwzględnych różnic cyfr.

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

Oblicza przesunięcie z właściwej pozycji.

sum(r)==0

Jeśli sekwencja nie jest ciągła, wówczas suma przesunięcia „zwykle” nie będzie wynosić 0. Ale nawet jeśli jest równa 0, następne będą ją blokować.

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

Tylko 0 lub 1 element będzie miał przesunięcie bezwzględne większe niż 1 (ten z niewłaściwą pozycją, a 0 jest w przypadku jak 1,2,3,5,4)

any(r)

Blokuje przypadek, gdy wszystkie liczby znajdują się we właściwych pozycjach

Haskell , 182 163 162 132 bajty

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

Pobiera dane wejściowe jako listę cyfr. Funkcja pomocnicza, pktóra daje wszystkie możliwe sposoby podziału listy na dwie części, służy do wyjmowania elementu i ponownego wstawiania go w inne miejsce.

Wypróbuj online!