W mieście są dwaj nowi szeryfowie - Identyfikacja par DJMcMego!

59

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):459413171645941

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

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 1(31716,45941)435123451

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

  • 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 , 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 .

Pan Xcoder
źródło
Czy możemy wygenerować wartość true dla par niebędących DJMcMego i fałsz dla par DJMcMego? Czy też wartości prawdy / fałszu muszą być spójne?
dylnan
6
@Blacksilver Chyba go go
pobiłem
2
@ Mr.Xcoder „Zamiana wartości prawda / fałsz jest domyślnie dozwolona” Czy to w rzeczywistości coś?
Martin Ender
2
@ Mr.Xcoder Oczywiście, wiele wyzwań na to pozwala, ale powiedzenie „domyślnie dozwolone” sugeruje mi, że gdzieś jest o tym meta post.
Martin Ender
1
Może dodaj 25631, 11114jako przykład. Różnice wprowadzają w błąd 14523kilka obecnych programów
Ton Hospel

Odpowiedzi:

7

05AB1E , 18 bajtów

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

Wypróbuj online!

Emigna
źródło
Prawdopodobnie powinieneś dodać notatkę, która 1jest jedyną prawdziwą liczbą w 05AB1E; Gdyby pan Xcoder nie poinformował mnie o tym fakcie, zakwestionowałbym ważność tego rozwiązania. Czy możesz również dodać wyjaśnienie, gdy masz czas?
Kudłaty
@Shaggy Możesz w międzyczasie rzucić okiem na wyjaśnienie mojego rozwiązania: nie jest ono tak wydajne jak Enigma, ale głównie używamy tych samych funkcji.
Kaldo
@Shaggy: Nie miałem czasu, aby dodać wyjaśnienie, kiedy to opublikowałem, buty już gotowe :)
Emigna
Nie udaje się to w przypadku nowego przypadku testowego, 14325, 11111 (fałsz).
Dennis
@Dennis: Dzięki, należy na razie naprawić (kosztem zbyt wielu bajtów). Będę musiał spróbować zagrać w golfa później.
Emigna,
7

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!

Jonathan Frech
źródło
W przypadku pętli, które działają tylko 1 raz, możesz pominąć j=0jak w 41 znaku
Stan Strum
@StanStrum Jestem całkiem pewien, że polegasz na jwartości, 0która niekoniecznie ma miejsce po kilku rozmowach. Funkcja powinna jednak być dowolnie często wywoływana i nadal rozwiązywać wyzwanie ( odpowiedni meta post ).
Jonathan Frech
@StanStrum Można jednak zdefiniować jjako zero przed pętlą, a tym samym zaoszczędzić bajt.
Jonathan Frech
Możesz ogolić bajt za pomocą f(char*A,char*B){-> f(A,B)char*A,*B;{.
LambdaBeta
@LambdaBeta Te dwa fragmenty mają równą długość.
Jonathan Frech,
4

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!

Arnauld
źródło
4

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
Marijn
źródło
4

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

Galen Iwanow
źródło
Nie powiedzie się 25634 11111(podobnie jak wiele innych zgłoszeń)
Ton Hospel
@ Ton Hospel - Tak, masz rację. Sprawdzę, jak to naprawić.
Galen Iwanow
Nie naprawiłem tego, po prostu grałem w golfa.
FrownyFrog,
@FrownyFrog Dziękujemy! Zapomniałem tego problemu.
Galen Iwanow
4

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.
Dennis
źródło
3

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           |
---------------------------------------------------------------
Kudłaty
źródło
2
Nie powiedzie się 25634 11111(podobnie jak wiele innych zgłoszeń)
Ton Hospel
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
Kjetil S.
źródło
Nie powiedzie się 25634 11111(podobnie jak wiele innych zgłoszeń)
Ton Hospel
2

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!

DevelopingDeveloper
źródło
1
Możesz zagrać w golfa jeszcze kilka rzeczy ( 194 bajtów ): z->{int l=z.length/2,c[]=new int[l],i=0,j=0,d[];for(;i<l;)c[i]=Math.abs(z[i]-z[i+++l]);java.util.Arrays.sort(d=c.clone());for(i=0;i<l-1;j+=d[i+1]-d[i++]!=1?1:0)j+=c[i]-c[i+1]>0?1:0;return j==1;}połączyłem inti int[]na początku; użyte l=z.length/2raz i ponownie użyć lzamiast 4 razy; zmieniono na, if(...)j++aby j+=...?1:0można je było umieścić w pętlach, a nawiasy i drugi średnik można usunąć; usunięto i++i wykonaj ++bezpośrednio na ostatniej iw pętli; itd.
Kevin Cruijssen
1
188 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;}. Usunięto d[]i ponownie wykorzystano zniepotrzebne dane wejściowe ; Zmieniono j+=c[i]-c[i+1]?1:0;i j+=d[i+1]-d[i++]!=1?1:0na j+=c[i]-c[++i]?1:0;i j+=z[i]-z[i-1]?1:0. +1 ode mnie. Niezła odpowiedź! :)
Kevin Cruijssen
1
Dzięki @Kevin, Za każdym razem, gdy skomentowałeś, znalazłem tylko jeden lub dwa z wielu sposobów, w jakie już grałeś w golfa: P Jesteś znacznie szybszy ode mnie! Dziękuję bardzo za pomoc!
DevelopingDeveloper
2
Hehe :) To chyba wszystko z doświadczeniem. Już od prawie dwóch lat gram w golfa w Javie. Im częściej to robisz, tym łatwiej widzisz tego rodzaju rzeczy. I nawet moje odpowiedzi są ciągle ignorowane przez Oliviera Grégoire'a, Nevay'a i innych. Och, prawdopodobnie już je widziałeś, ale Porady dotyczące gry w golfa w Javie i Porady dotyczące gry w golfa w <wszystkich językach> są dość interesujące do przeczytania.
Kevin Cruijssen
1
Nie powiedzie się 25634 11111(podobnie jak wiele innych zgłoszeń)
Ton Hospel
2

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.

Neil
źródło
2

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

Ton Hospel
źródło
2

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!

Asone Tuhid
źródło
Nie powiedzie się 25634 11111(podobnie jak wiele innych zgłoszeń)
Ton Hospel
@TonHospel naprawił to, dzięki
Asone Tuhid
Niesamowite odbicie. Miej +1:-)
Ton Hospel
1

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
mudkip201
źródło
1
Nie powiedzie się 25634 11111(podobnie jak wiele innych zgłoszeń)
Ton Hospel
1

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 1 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ódło
1

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.

ngm
źródło
Nie udaje się to w przypadku nowego przypadku testowego, 14325, 11111 (fałsz).
Dennis
Myślę, że paste0może tak być, pasteponieważ jest tylko jeden wkład.
Giuseppe
p=intToUtf8 ?
JayCe
Myślałam, że golf wymianie w=z-min(z)+1)adist(p(1:max(w))z w=z-min(z))adist(p(0:max(w))ale to nie działa, ponieważ intToUtf8(\000)jest NULL.
JayCe
To ciekawe rozwiązanie, które zasługuje na więcej entuzjastów ... Myślę, że przewidywanie entuzjastów w Codegolf to kolejna granica dla AI :)
JayCe
0

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>

Kudłaty
źródło
1
[...u].sort(y=0)jest niepoprawny javascript, argumentem dla sortowania musi być funkcja
edc65
@ edc65, to już dawno zostało zredagowane. Choć może to być nieprawidłowe, zadziałało! ;)
Kudłaty
1
„Nie powiedzie się 25634 11111(podobnie jak wiele innych zgłoszeń)” - Ton Hospel
Asone Tuhid
0

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

Shieru Asakoto
źródło
Wydaje się, że zawodzi m([3,3,3,3],[2,1,0,1])(zwraca True) Tio
Asone Tuhid
@AsoneTuhid Naprawiłem problem w oparciu o jego golfa, ponieważ kiedy przesłałem odpowiedź, a on grał moją odpowiedź, zapomniałem o tym przypadku.
Shieru Asakoto
1
Nie powiedzie się 25634 11111(podobnie jak wiele innych zgłoszeń)
Ton Hospel
@TonHospel Och, to trudne. Zastanawiam się, jak to naprawić, ale wydaje się, że doda sporo odpowiedzi do odpowiedzi
Shieru Asakoto
0

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!

Angs
źródło