Es gibt zwei neue Sheriffs in der Stadt - DJMcMego-Paare identifizieren!

59

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

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

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

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

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

Mr. Xcoder
quelle
Können wir Wahrheit für Nicht-DJMcMego-Paare und Falsch für DJMcMego-Paare ausgeben? Müssen die Wahrheits- / Falschheitswerte auch konsistent sein?
Dylnan
6
@Blacksilver Ich glaube, ich habe ihn geschlagen : P
DJMcMayhem
2
@ Mr.Xcoder "Tauschen der Wahrheits- / Falschheitswerte ist standardmäßig erlaubt" Ist das eigentlich eine Sache?
Martin Ender
2
@ Mr.Xcoder Sicher, viele Herausforderungen erlauben es, aber wenn ich sage "Es ist standardmäßig erlaubt", impliziere ich, dass es irgendwo einen Meta-Post darüber gibt.
Martin Ender
1
Vielleicht 25631, 11114als Beispiel hinzufügen . Die Unterschiede sind, 14523die einige der aktuellen Programme
verwirren

Antworten:

7

05AB1E , 18 Bytes

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

Probieren Sie es online!

Emigna
quelle
Sie sollten wahrscheinlich eine Notiz hinzufügen, die 1die einzige wahrheitsgemäße Zahl in 05AB1E ist. Hätte Herr Xcoder mich nicht darüber informiert, hätte ich die Gültigkeit dieser Lösung in Frage gestellt. Können Sie auch eine Erklärung hinzufügen, wenn Sie Zeit haben?
Shaggy
@Shaggy In der Zwischenzeit können Sie sich die Erklärung meiner Lösung ansehen: Sie ist nicht so effizient wie die von Enigma, aber wir verwenden meist dieselben Funktionen.
Kaldo
@ Shaggy: Ich hatte keine Zeit, eine Erklärung hinzuzufügen, als ich das gepostet habe, aber jetzt ist es soweit :)
Emigna
Dies schlägt für den neuen Testfall 14325, 11111 (falsch) fehl.
Dennis
@Dennis: Danke, sollte erstmal behoben werden (auf Kosten von zu vielen Bytes). Muss versuchen, dies später zu spielen.
Emigna
7

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!

Jonathan Frech
quelle
Für Schleifen, die nur 1 Mal ausgeführt werden, können Sie j=0wie im 41. Zeichen
Stan Strum
@StanStrum Ich bin mir ziemlich sicher, dass Sie sich dann auf jden Wert verlassen , der 0nach mehreren Aufrufen nicht unbedingt der Fall ist. Eine Funktion sollte jedoch beliebig oft aufrufbar sein und trotzdem die Herausforderung lösen ( relevanter Metapost ).
Jonathan Frech
@StanStrum Sie können jedoch jvor der Schleife den Wert Null definieren und so ein Byte speichern.
Jonathan Frech
Sie können ein Byte mit f(char*A,char*B){-> rasieren f(A,B)char*A,*B;{.
LambdaBeta
@LambdaBeta Diese beiden Schnipsel sind gleich lang.
Jonathan Frech
4

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!

Arnauld
quelle
4

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
Marijn
quelle
4

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

Galen Ivanov
quelle
Scheitert 25634 11111(wie bei vielen anderen Einsendungen)
Ton Hospel
@ Ton Hospel - Ja, du hast recht. Ich werde nachsehen, wie ich das Problem beheben kann.
Galen Ivanov
Ich habe es nicht behoben, nur Golf gespielt.
FrownyFrog
@FrownyFrog Vielen Dank! Ich habe dieses Problem vergessen.
Galen Ivanov
4

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.
Dennis
quelle
3

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           |
---------------------------------------------------------------
Zottelig
quelle
2
Scheitert 25634 11111(wie bei vielen anderen Einsendungen)
Ton Hospel
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
Kjetil S.
quelle
Scheitert 25634 11111(wie bei vielen anderen Einsendungen)
Ton Hospel
2

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!

Entwicklungsentwickler
quelle
1
Sie können noch ein paar Dinge wie dieses ( 194 Bytes ) spielen: 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;}Ich habe das intund int[]am Anfang kombiniert ; verwendet l=z.length/2einmal und wiederverwenden lstatt 4 - mal; geändert if(...)j++in, j+=...?1:0so dass sie in die Schlaufen eingefügt werden können und die Klammern und das zweite Semikolon entfernt werden können; entferne das i++und mache ++direkt am letzten iin der Schleife; etc.
Kevin Cruijssen
1
188 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;}. Die nicht mehr benötigten d[]Eingaben wurden entfernt und wiederverwendet z. Geändert j+=c[i]-c[i+1]?1:0;und j+=d[i+1]-d[i++]!=1?1:0zu j+=c[i]-c[++i]?1:0;und j+=z[i]-z[i-1]?1:0. +1 von mir. Gute Antwort! :)
Kevin Cruijssen
1
Vielen Dank @ Kevin, jedes Mal, wenn Sie einen Kommentar abgeben, habe ich nur einen oder zwei der vielen Wege gefunden, auf denen Sie bereits Golf gespielt haben: P Sie sind viel schneller als ich! Vielen Dank für die Hilfe!
DevelopingDeveloper
2
Hehe :) Es kommt alles mit Erfahrung, denke ich. Ich spiele bereits seit fast zwei Jahren auf Java. Je mehr Sie es tun, desto leichter sehen Sie diese Art von Dingen. Und selbst meine Antworten werden von OlivierGrégoire, Nevay und einigen anderen immer wieder auf den Prüfstand gestellt. Oh, Sie haben sie wahrscheinlich schon gesehen, aber Tipps zum Golfen in Java und Tipps zum Golfen in <allen Sprachen> sind ziemlich interessant zu lesen.
Kevin Cruijssen
1
Scheitert 25634 11111(wie bei vielen anderen Einsendungen)
Ton Hospel
2

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.

Neil
quelle
2

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

Tonne Hospel
quelle
2

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!

Asone Tuhid
quelle
Scheitert 25634 11111(wie bei vielen anderen Einsendungen)
Ton Hospel
@TonHospel behoben, danke
Asone Tuhid
Genialer Rebound. Have a +1:-)
Ton Hospel
1

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
mudkip201
quelle
1
Scheitert 25634 11111(wie bei vielen anderen Einsendungen)
Ton Hospel
1

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

quelle
1

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.

ngm
quelle
Dies schlägt für den neuen Testfall 14325, 11111 (falsch) fehl.
Dennis
Ich denke das paste0kann nur sein, pasteda es nur einen Eingang gibt.
Giuseppe
p=intToUtf8 ?
JayCe
Ich dachte , ich hätte einen Golf ersetzt w=z-min(z)+1)adist(p(1:max(w))mit , w=z-min(z))adist(p(0:max(w))aber es funktioniert nicht , da intToUtf8(\000)NULL ist.
JayCe
Dies ist eine interessante Lösung, die mehr Gegenstimmen verdient ... Ich denke, die Vorhersage der Gegenstimmen in Codegolf ist die nächste Grenze für AI :)
JayCe
0

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>

Zottelig
quelle
1
[...u].sort(y=0)ist ungültiges Javascript, das Argument für die Sortierung muss eine Funktion sein
edc65
@ edc65, das ist längst rausgeschnitten. Ungültig, wie es auch sein mag, es hat funktioniert! ;)
Shaggy
1
"Scheitert 25634 11111(wie bei vielen anderen Einsendungen)" - Ton Hospel
Asone Tuhid
0

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

Shieru Asakoto
quelle
Es scheint zu scheitern für m([3,3,3,3],[2,1,0,1])(kehrt zurück True) Tio
Asone Tuhid
@AsoneTuhid Ich habe das Problem aufgrund seines Golfspiels behoben, da ich diesen Fall vergessen habe, als ich die Antwort abgab und er meine Antwort abgab.
Shieru Asakoto
1
Scheitert 25634 11111(wie bei vielen anderen Einsendungen)
Ton Hospel
@TonHospel Oh, das ist schwierig. Ich denke über Methoden nach, um das
Problem
0

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!

Angs
quelle