Il y a deux nouveaux shérifs en ville - Identifier les paires DJMcMego!

60

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

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

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

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

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

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

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

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

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

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

Cas de test

a, b -> Output

31716, 45941 -> Truthy
12354, 11111 -> Truthy
56798, 22222 -> Truthy
23564, 11111 -> Truthy
1759,  2435  -> Truthy
12345, 11111 -> Falsy
3333,  2101  -> Falsy
22354, 22222 -> Falsy
31717, 45941 -> Falsy
14325, 11111 -> Falsy
89789, 78865 -> Falsy
14954, 61713 -> Falsy
25631, 11114 -> Falsy

Ou, dans un autre format .

M. Xcoder
la source
Pouvons-nous produire la vérité pour les paires non-DJMcMego et la fausseté pour les paires DJMcMego? De plus, les valeurs de vérité et de fausseté doivent-elles être cohérentes?
Dylnan
6
@Blacksilver Je pense l'avoir battu : P
DJMcMayhem
2
@ Mr.Xcoder "L'échange des valeurs de vérité / fausseté est autorisé par défaut" Est-ce réellement une chose?
Martin Ender
2
@ Mr.Xcoder Bien sûr, de nombreux défis le permettent, mais dire "c'est autorisé par défaut" implique pour moi qu'il existe un méta-post à ce sujet quelque part.
Martin Ender
1
Peut-être ajouter 25631, 11114comme exemple. Les différences sont 14523ce qui confond plusieurs des programmes actuels
Ton Hospel

Réponses:

7

05AB1E , 18 octets

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

Essayez-le en ligne!

Emigna
la source
Vous devriez probablement ajouter une note qui 1est le seul numéro de vérité dans 05AB1E; Si M. Xcoder ne m'avait pas informé de ce fait, j'aurais mis en doute la validité de cette solution. Pourriez-vous ajouter une explication également lorsque vous avez le temps?
Shaggy
@Shaggy Vous pouvez jeter un coup d'œil à l'explication de ma solution dans l'intervalle: elle n'est pas aussi efficace que celle d'Enigma, mais nous utilisons principalement les mêmes fonctions.
Kaldo
@Shaggy: Je n'ai pas eu le temps d'ajouter une explication quand j'ai posté ça, mais c'est fait maintenant :)
Emigna
Cela échoue pour le nouveau cas de test, 14325, 11111 (falsy).
Dennis
@Dennis: Merci, cela devrait être résolu pour le moment (au prix de trop d'octets). Devra essayer de jouer au golf plus tard.
Emigna
7

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

  • Merci à Stan Strum pour l’insertion d’un golf d’un octet.
  • Sauvegardé quatre octets en jonglant avec certaines initialisations de variables.
  • Sauvegardé un octet en jouant for(...;l++)b*=B[l]==-~B[l-1];au golf for(...;b*=B[l]==-~B[~-l++]);(reposant probablement sur un comportement indéfini, car il faut d'abord évaluer B[l]suivi de -~B[~-l++]).
  • Enregistré trois cinq octets.
  • Sauvé quinze vingt-six octets grâce à ceilingcat .
j,k,l,L,r,b;f(char*A,char*B){for(j=r=0;k=A[L=j];)A[j++]=-~abs(A[j]-B[j]);for(;k-L;k++)for(j=~0;L-++j;r|=!b)if(k-j)for(bcopy(B-~l,strcpy(B,A)+l,strlen(A+l)),bcopy(B+j,B-~j,L+~j),B[j]=A[k],l=b=0;B[++l];b|=B[l]+~B[~-l]);A=r;}

Essayez-le en ligne!

Explication (version de 248 octets)

j,k,l,L,r,b;                            // global variables
f(char*A,char*B){                       // function takes two strings
 for(j=r=0;A[j];L=j)                    // loop through A, compute array length L
  A[j++]=-~abs(A[j]-B[j]);              // set every entry in A to the absolute
                                        // difference of A and B at that position
                                        /* Test out all possible movements of        *
                                         * characters and see if any one             *
                                         * results in a sorted list => DJMcMego pair */
 for(j=0;j-L;j++)                       // loop through array
  for(k=~0;L-++k;r|=!b)                 // loop through array
   if(j-k){                             // j is not equal to k
    for(l=0;A[l];B[l++]=A[l]);          // copy A to B
    for(l=j;A[l];B[~-l]=B[++l]);        // shift part of B
    for(l=L;l-k;B[-~l]=B[--l]);         // shift part of B
    B[k]=A[j];                          // insert character at correct position
    for(l=b=0;B[++l];b|=B[l]+~B[~-l]);} // test if B is sorted
 A=r;}                                  // return if there was a DJMcMego pair found

Essayez-le en ligne!

Jonathan Frech
la source
Pour les boucles qui ne courent qu'une fois, vous pouvez sauter j=0comme dans le 41e personnage
Stan Strum
@StanStrum Je suis à peu près certain que vous comptez alors sur jla valeur, 0ce qui n'est pas nécessairement le cas après plusieurs appels. Une fonction, cependant, devrait être souvent appelable de manière arbitraire et toujours résoudre le problème ( méta-poste pertinent ).
Jonathan Frech
@StanStrum Vous pouvez cependant définir jzéro avant la boucle et ainsi sauvegarder un octet.
Jonathan Frech
Vous pouvez raser un octet avec f(char*A,char*B){-> f(A,B)char*A,*B;{.
LambdaBeta
@LambdaBeta Ces deux extraits sont de même longueur.
Jonathan Frech
4

JavaScript (ES6), 130 octets

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

a=>b=>a.some((_,i)=>a.some((_,j)=>i-j&&!(A=a.map((v,i)=>Math.abs(v-b[i]))).some(v=>v-A[~k--]-1,A.splice(i,0,A.splice(j,1)[k=0]))))

Essayez-le en ligne!

Arnauld
la source
4

SWI-Prolog, 157 octets

Pas très court, mais le problème semblait particulièrement bien adapté aux prédicats déclaratifs, aux liaisons variables et à la récursivité, c'est-à-dire Prolog :)

n(T,Y):-s(T,Q,I,J),s(Y,W,I,J),m(Q,W).
s(T,Q,I,J):-nth0(I,T,X,R),nth0(J,Q,X,R),I\=J.
m([A,B|T],[C,D|Y]):-1 is abs(B-D)-abs(A-C),m([B|T],[D|Y]).
m([_],[_]).

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

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

s(T,Q,I,J)    % switch (yet unbounded) index I and J in list T, store in Q
s(Y,W,I,J)    % switch (now bounded) I and J in list Y
m(Q,W)        % check new lists
s(T,Q,I,J) :- nth0(I,T,X,R) % X (unbounded) is the I-th (unbounded) element 
                            % of list T with rest R (=prefix+postfix) 
nth0(J,Q,X,R) % the same X is the J-th element in list Q with the same rest R
I\=J          % I and J are unequal
m([A,B|T],[C,D|Y]) :-  % consider first two elements of both lists
1 is abs(B-D)-abs(A-C) % check if differences are consecutive                          
m([B|T],[D|Y])         % recursion starting with the second element
m([_],[_]).            % stop recursion at last element in the list
Marijn
la source
4

J , 27 octets

−8 octets grâce à FrownyFrog

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

Essayez-le en ligne!

Solution initiale:

J , 35 octets

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

Essayez-le en ligne!

Explication

Prend des listes de chiffres en entrée

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

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

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

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

Galen Ivanov
la source
Echoue pour 25634 11111(comme beaucoup d'autres soumissions)
Ton Hospel le
@ Ton Hospel - Oui, vous avez raison. Je vais vérifier comment ça se passe.
Galen Ivanov
Je ne l'ai pas réparé, j'ai juste joué au golf.
FrownyFrog
@FrownyFrog Merci! J'ai oublié ce problème.
Galen Ivanov
4

Gelée , 14 octets

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

Essayez-le en ligne!

Comment ça fonctionne

ạµṢ_JEċ@Œ¿-Ƥ%L  Main link. Arguments: A, B (digit arrays)

ạ               Take the elementwise absolute difference. Call the result R.
 µ              New chain. Argument: R
  Ṣ             Sort R.
    J           Indices; yield [1, ..., len(R)].
   _            Take the elementwise difference.
     E          Test if all differences are equal.
                The result is 1 if R consists of consecutive digits, 0 otherwise.
          -Ƥ    For all outfixes of R, generated by dropping one of its elements:
        Œ¿        Get its permutation index (1 if sorted, higher if not).
      ċ@        Count the number of times the Boolean from the left appears in the
                array to the right. If the Boolean is 1, the count represents the
                number of ways a single digit can be deleted to yield a sorted
                array. The count has to be positive for a DJMcMego pair, but less
                than the length of R, since R may not be sorted.
            %L  Take the result modulo len(R), mapping len(R) to 0.
Dennis
la source
3

Japt , 18 octets

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

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

íaV
ä> x*Un än × É

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


Explication

                   :Implicit input of digit arrays U and V               :[3,1,7,1,6],[4,5,9,4,1]
í V                :Interleave V with U                                  :[[3,4],[1,5],[7,9],[1,4],[6,1]]
 a                 :Get the absolute difference of each pair             :[1,4,2,3,5]
\n                 :Assign that new array to variable U
ä>                 :Is each element greater than the next?               :[false,true,false,false]
     Un            :Sort U                                               :[1,2,3,4,5]
        än         :Get the deltas                                       :[1,1,1,1]
           ×       :Reduce by multiplication                             :1
    *              :Multiply each element in the boolean array by that   :[0,1,0,0]
   x               :Reduce by addition                                   :1
             É     :Subtract 1                                           :0

Et, pour parcourir ce processus sur quelques autres cas de test:

---------------------------------------------------------------
| U   | [2,3,5,6,4] | [1,2,3,4,5] | [3,1,7,1,7] | [1,4,9,5,4] |
| V   | [1,1,1,1,1] | [1,1,1,1,1] | [4,5,9,4,1] | [6,1,7,1,3] |
|-----|-------------|-------------|-------------|-------------|
| íaV | [1,2,4,5,3] | [0,1,2,3,4] | [1,4,2,3,6] | [5,3,2,4,1] |
|-----|-------------|-------------|-------------|-------------|
| ä>  | [F,F,F,T]   | [F,F,F,F]   | [F,T,F,F]   | [T,T,F,T]   |
|-----|-------------|-------------|-------------|-------------|
| Un  | [1,2,3,4,5] | [0,1,2,3,4] | [1,2,3,4,6] | [1,2,3,4,5] |
| än  | [1,1,1,1]   | [1,1,1,1]   | [1,1,1,2]   | [1,1,1,1]   |
| ×   | 1           | 1           | 2           | 1           |
|-----|-------------|-------------|-------------|-------------|
| *   | [0,0,0,1]   | [0,0,0,0]   | [0,2,0,0]   | [1,1,0,1]   |
| x   | 1           | 0           | 2           | 3           |
| É   | 0           | -1          | 1           | 2           |
---------------------------------------------------------------
Hirsute
la source
2
Échec 25634 11111(comme beaucoup d'autres soumissions)
Ton Hospel
2

Perl, 121 118 octets

($a,$b)=map[split//],@ARGV;
$s+=$l>$_,$l=$_ for@c=map abs($$a[$i]-$$b[$i++]),@$a;
@c=sort@c;
say$s==1&&$c[-1]-$c[0]==$#$a

Test à Bash:

function golf {
   perl -E'($a,$b)=map[split//],@ARGV;$s+=$l>$_,$l=$_ for@c=map abs($$a[$i]-$$b[$i++]),@$a;@c=sort@c;say$s==1&&$c[-1]-$c[0]==$#$a' $1 $2
}
golf 31716 45941       #says 1, true
golf 12354 11111       #says 1, true
golf 56798 22222       #says 1, true
golf 46798 22222       #says nothing, false
golf 22354 22222       #says nothing, false
golf 1759 2435         #says 1, true
golf 12345 11111       #says nothing, false
golf 89789 78865       #says nothing, false
golf 14954 61713       #says nothing, false
Kjetil S.
la source
Échec 25634 11111(comme beaucoup d'autres soumissions)
Ton Hospel
2

Java 8 , 245 227 223 194 188 octets

Merci à Kevin pour avoir économisé environ 29 octets

Merci encore à Kevin pour 6 autres octets

 z->{int l=z.length/2,c[]=new int[l],i=0,j=0;for(;i<l;)c[i]=Math.abs(z[i]-z[i+++l]);java.util.Arrays.sort(z=c.clone());for(i=0;i<l-1;j+=z[i]-z[i-1]!=1?1:0)j+=c[i]-c[++i]>0?1:0;return j==1;}

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

Essayez-le en ligne!

DevelopingDeveloper
la source
1
Vous pouvez jouer au golf un peu plus comme ceci ( 194 octets ): 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;}j'ai combiné le intet int[]au début; utilisé l=z.length/2une fois et réutilisé lau lieu de 4 fois; changé le if(...)j++à j+=...?1:0afin qu'ils puissent être placés à l'intérieur des boucles et que les crochets et le deuxième point-virgule puissent être supprimés; supprimé le i++et faites ++directement sur le dernier ide la boucle; etc.
Kevin Cruijssen
1
188 octets : z->{int l=z.length/2,c[]=new int[l],i=0,j=0;for(;i<l;)c[i]=Math.abs(z[i]-z[i+++l]);java.util.Arrays.sort(z=c.clone());for(i=0;i<l-1;j+=z[i]-z[i-1]!=1?1:0)j+=c[i]-c[++i]>0?1:0;return j==1;}. Supprimez d[]et réutilisez les informations dont zvous n’avez plus besoin; Changé j+=c[i]-c[i+1]?1:0;et j+=d[i+1]-d[i++]!=1?1:0à j+=c[i]-c[++i]?1:0;et j+=z[i]-z[i-1]?1:0. +1 de moi, cependant. Bonne réponse! :)
Kevin Cruijssen
1
Merci @ Kevin, chaque fois que tu as commenté, je n'avais trouvé qu'une ou deux des nombreuses façons dont tu avais déjà joué au golf: P Tu es beaucoup plus rapide que moi! Merci beaucoup pour l'aide!
DevelopingDeveloper
2
Hehe :) Tout vient avec l'expérience, je suppose. Je joue déjà à Java depuis près de deux ans maintenant. Plus vous le faites, plus vous voyez facilement ce genre de choses. Et même mes réponses ont été écrites par OlivierGrégoire, Nevay et quelques autres tout le temps. Oh, vous les avez probablement déjà vues, mais il est intéressant de lire des astuces pour le golf en Java et des astuces pour le golf en <toutes les langues> .
Kevin Cruijssen
2
Echoue pour 25634 11111(comme beaucoup d'autres soumissions)
Ton Hospel le
2

Rétine , 102 octets

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

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

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

Associez les chiffres.

\d
*

Convertir en unaire.

(_*),\1
_

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

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

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

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

Recherchez des chiffres consécutifs.

Neil
la source
2

Perl 5 , -F 87 84 83 octets

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

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

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

La longue A0123456789ficelle est vraiment énervante.

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

Essayez-le en ligne!

Je suis habitué si cela 79compte comme valide:

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

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

Ton Hospel
la source
2

Ruby , 124 113 99 95 octets

->l,b,d=-1{m=l.map!{|i|(i-b[d+=1]).abs}.sort;l.any?{|*i|m-i==l-i}&&m!=l&&/#{m*''}/=~[*0..9]*''}

Essayez-le en ligne!

Asone Tuhid
la source
Échec 25634 11111(comme beaucoup d'autres soumissions)
Ton Hospel
@TonHospel a réglé le problème, merci
Asone Tuhid Le
Rebond impressionnant. Avoir un +1:-)
Ton Hospel
1

Pyt , 20 18 octets

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

Essayez-le en ligne!

Explication:

       Implicitly get the first number
ą      Convert to list of digits
←      Get the second number
ą      Convert to list of digits
-Å     Take the absolute value of the differences of the lists element-wise
Đ      Duplicate the list of differences
ʁ>     Reduce by greater than
Ʃ1=    Is the sum of that array equal to 1
⇹      Swap the top two items on the stack
ş      Sort the top of the stack ascending
₋      Reduce by subtraction (from the right)
Π1=    Is the product of the array equal to 1
∧      bitwise-AND (in this case, also logical AND) the top two items on the stack
       Implicit print
mudkip201
la source
2
Echoue pour 25634 11111(comme beaucoup d'autres soumissions)
Ton Hospel le
1

Ajouter ++ , 105 octets

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

Essayez-le en ligne!

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

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

Comment ça fonctionne

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

BcB_€|B]dBkbUBSVcGbU£>sVcGB]V

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

BKB#BKBcB_0º>b]

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

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

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

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

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

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

Une marche à suivre du code est la suivante

D,w,		; Define a function w;
		;   This takes an array of integers
		;   Returns whether the pair [1, 2] appears in the absolute forward differences
		;
	@	; Take one argument
	~,	; Splat that argument to the stack
		;   Example argument:		[1 4 2 3 5]
		;
	Ñ_	; Increments;		STACK = [3 -2 1 2]
	€|	; Magnitudes;		STACK = [3 2 1 2]
	BSVcGbU	; Overlapping pairs;	STACK = [[3 2] [2 1] [1 2]]
	1b]2b]+	; Push [1 2];		STACK = [[3 2] [2 1] [1 2] [1 2]]
	º=	; Any equal [1 2];	STACK = [1]

; ============= ;

D,k,		; Define a function k;
		;   This function takes an array of integers
		;   Returns whether the second element is 0;
		;
	@,	; Take one argument and push to the stack
		;   Example argument:		[[1 4 2 3 5]]
		;
	BP	; Behead;		STACK = [[4 2 3 5]] 
	B*	; Product;		STACK = [120]
		;
		; In DJMcMego pairs, A may begin with a 0
		; For example, 12354 and 11111, so we need to remove the first element
		; Taking the product yields 0 if any element is 0
		; However, in order to be a DJMcMego pair, two digits at the same index
		;   cannot be the same, otherwise their digit-wise difference will be 0

; ============= ;

L,		; Define a lambda function
		;
		; This lambda function takes two arrays of digits as input
		; Returns an integer to determine if those digits represent a DJMcMego pair
		;
		; A lambda function is shorter to define than a normal function
		; However, when called inside functions with the ] command,
		;   they consume the entire stack as arguments, meaning that using functions
		;   allows us to preserve important values
		;
		; Example arguments:		[[3 1 7 1 6] [4 5 9 4 1]]
		;
		; First check:
		;
	BcB_	; Digit differences;	STACK = [-1 -4 -2 -3 5]
	€|	; Magnitudes;		STACK = [1 4 2 3 5]
	B]dBkbU	; Save a copy, A	STACK = [1 4 2 3 5]			A: [1 4 2 3 5]
	BSVcGbU	; Overlapping pairs;	STACK = [[1 4] [4 2] [2 3] [3 5]]
	£>	; Sorted descendingly?	STACK = [0 1 0 0]
	sVcG	; How many?		STACK = [1]
	B]V	; Save a copy;		STACK = []				Register: [1]
		;
		; Second check:
		;
	BK	; Retrieve A;		STACK = [[1 4 2 3 5]]
	B#	; Sort;			STACK = [[1 2 3 4 5]]
	BK	; Retrieve A;		STACK = [[1 2 3 4 5] [1 4 2 3 5]]
	BcB_	; Element differences;	STACK = [0 -2 1 1 0]
	0º>b]	; Any negatives;	STACk = [[1]]
		;
		; Third and fourth checks:
		;
	G	; Retrieve register;	STACK = [[1] [1]]
	BK	; Retreive A;		STACK = [[1] [1] [1 4 2 3 5]]
	{w}b]	; Run w;		STACK = [[1] [1] [1]]
	++	; Concatenate;		STACK = [[1 1 1]]
	b*1=	; Product = 1;		STACK = [1]
	BK{k}	; Run k;		STACK = [1 120]
	*	; Multiply;		STACK = [120]

		; To force output as 1 and 0 values,
		;   append a ? to the end, to output the sign (forces boolean conversion)

la source
1

R , 110 106 84 octets

function(x,y,z=abs(x-y),w=z-min(z)+1)adist(p(1:max(w)),p(w),c("s"=9))==2
p=intToUtf8

Essayez-le en ligne!

@JayCe avec une sauvegarde ridicule de 22 octets!

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

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

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

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

ngm
la source
Cela échoue pour le nouveau cas de test, 14325, 11111 (falsy).
Dennis
Je pense que cela paste0peut être juste pastepuisqu'il n'y a qu'une entrée.
Giuseppe
p=intToUtf8 ?
JayCe
Je pensais avoir un golf remplaçant w=z-min(z)+1)adist(p(1:max(w))par w=z-min(z))adist(p(0:max(w))mais ça ne marche pas car intToUtf8(\000)c'est nul.
JayCe
C'est une solution intéressante qui mérite plus de votes positifs. Je pense que prédire les votes positifs dans Codegolf est la prochaine frontière pour l'IA :)
JayCe
0

JavaScript, 137 136 135 134 132 123 123 octets

Prend les entrées sous forme de deux tableaux de chiffres dans la syntaxe de curry, les sorties 0pour trueet tout autre nombre pour false.

a=>b=>(c=a.map((x,y)=>(x-=b[y])<0?-x:x)).map(x=>t+=x>c[++j]&(d=[...c].sort()).slice(i=0,-1).every(x=>d[++i]-x&1),t=j=0)|t^1

Cas de test

f=
a=>b=>(c=a.map((x,y)=>(x-=b[y])<0?-x:x)).map(x=>t+=x>c[++j]&(d=[...c].sort()).slice(i=0,-1).every(x=>d[++i]-x&1),t=j=0)|t^1
o.innerText=`${l=`-`.repeat(21)}\n|   #1  |   #2  | f |${m=`\n|${`|`.padStart(8,`-`).repeat(2)}---|\n`}${[[31716,45941],[12354,11111],[56798,22222],[23564,11111],[1759,2435],[12345,11111],[3333,2101],[22354,22222],[31717,45941],[89789,78865],[14954,61713]].map(([x,y])=>`| ${JSON.stringify(x).padEnd(6)}| ${JSON.stringify(y).padEnd(6)}| ${f([...``+x])([...``+y])} |`).join(m)}\n`+l
<pre id=o></pre>

Hirsute
la source
1
[...u].sort(y=0)est invalide javascript, l'argument pour le tri doit être une fonction
edc65
@ edc65, c'est depuis longtemps édité. Invalide que cela puisse être, cependant, cela a fonctionné! ;)
Shaggy
2
"Echoue pour 25634 11111(comme beaucoup d'autres soumissions)" - Ton Hospel
Asone Tuhid le
0

Python 2 , 116 119 106 octets

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

Après cela, -1 merci de plus M. Xcoder, et -13 Merci ovs

def m(a,b):l=[abs(x-y)for x,y in zip(a,b)];print sum(e>f for e,f in zip(l,l[1:]))==1==len(l)-max(l)+min(l)

Essayez-le en ligne!

Celui ci-dessous corrige le 25634 - 11111problème mais avec double longueur ( 211 206 145 142B) ... Golf ...

def m(a,b):l=[abs(x-y)for x,y in zip(a,b)];r=[l[i]-i-min(l)for i in range(len(l))];print(sum(r)==0)&(len([x for x in r if abs(x)>1])<2)&any(r)

Essayez-le en ligne!

Et félicitations aux nouveaux modérateurs :)

Explication:

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

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

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

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

sum(r)==0

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

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

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

any(r)

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

Shieru Asakoto
la source
Il semble échouer pour m([3,3,3,3],[2,1,0,1])(retourne True) Tio
Asone Tuhid
@AsoneTuhid J'ai résolu le problème en fonction de son parcours car lorsque j'ai soumis la réponse et qu'il a joué au golf, j'ai oublié ce cas.
Shieru Asakoto
2
Echoue pour 25634 11111(comme beaucoup d'autres soumissions)
Ton Hospel le
@TonHospel Oh, c'est délicat. Je pense aux méthodes pour y remédier, mais il semble que cela va ajouter un tas d'octets à la réponse
Shieru Asakoto
0

Haskell , 182 163 162 132 octets

(#)=zipWith(-)
a&b|s<-abs<$>a#b=or[all(==1)$tail a#a|(x,h:y)<-p s,(q,r)<-p$x++y,a<-[q++h:r],a/=s]
p l=[splitAt k l|k<-[0..length l]]

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

Essayez-le en ligne!

Angs
la source