Une convolution binaire est décrite par un nombre Met est appliquée à un nombre N. Pour chaque bit dans la représentation binaire de M, si le bit est défini ( 1), le bit correspondant dans la sortie est donné en XORant les deux bits adjacents au bit correspondant dans N(enroulant autour si nécessaire). Si le bit n'est pas défini ( 0), le bit correspondant dans la sortie est donné par le bit correspondant dans N.

Un exemple travaillé (avec des valeurs 8 bits):

1. Laissez N = 150, M = 59. Leurs représentations binaires sont (respectivement) 10010110et 00111011.
2. Sur la base de Mla représentation binaire de, les bits 0, 1, 3, 4 et 5 sont convolus.
   1. Le résultat pour le bit 0 est donné par XORing bits 1 et 7 (puisque nous bouclons), ce qui donne 1.
   2. Le résultat pour le bit 1 est donné par XORing bits 0 et 2, ce qui donne 0.
   3. Le résultat pour le bit 2 est donné par le bit 2 d'origine, ce qui donne 1.
   4. Le résultat pour le bit 3 est donné par les bits XORing 2 et 4, ce qui donne 0.
   5. Le résultat pour le bit 4 est donné par les bits XORing 3 et 5, ce qui donne 0.
   6. Le résultat pour le bit 5 est donné par les bits XORing 4 et 6, ce qui donne 1.
   7. Les résultats pour les bits 6 et 7 sont donnés par les bits d'origine 6 et 7, ce qui donne 0et 1.
3. La sortie est donc 10100110( 166).

Le défi

Étant donné Net M, affichez le résultat de l'exécution de la convolution binaire décrite par Msur N. L'entrée et la sortie peuvent être dans n'importe quel format pratique, cohérent et sans ambiguïté. Net Msera toujours dans la plage (inclusive) [0, 255](entiers non signés 8 bits), et leurs représentations binaires doivent être remplies à 8 bits pour effectuer la convolution binaire.

Cas de test

150 59 -> 166
242 209 -> 178
1 17 -> 0
189 139 -> 181
215 104 -> 215
79 214 -> 25
190 207 -> 50
61 139 -> 180
140 110 -> 206
252 115 -> 143
83 76 -> 31
244 25 -> 245
24 124 -> 60
180 41 -> 181
105 239 -> 102
215 125 -> 198
49 183 -> 178
183 158 -> 181
158 55 -> 186
215 117 -> 198
255 12 -> 243

JavaScript (ES6), 31 octets

(n,m)=>n^m&(n^(n*=257)>>1^n>>7)

Python 2, 35 octets

lambda m,n:n^m&(n^n*257/2^n*2^n>>7)

J, 34 octets

2#.[:({"_1],._1&|.~:1&|.)/(8#2)#:]

Approche directe qui applique le processus défini dans le défi. Prend l'entrée comme un tableau [n, m].

Formulaires sept smileys, [:, :(, :1, (8, 8#, #:et :].

Usage

   f =: 2#.[:({"_1],._1&|.~:1&|.)/(8#2)#:]
   f 150 59
171
   f 59 150
166
   f 209 242
178
   f 17 1
0
   f 139 189
181

code machine x64, 17 octets

88CD88C8D0C9D0C530E930C120D130C8C3

Démonté:

0:  88 cd                   mov    ch,cl
2:  88 c8                   mov    al,cl
4:  d0 c9                   ror    cl,1
6:  d0 c5                   rol    ch,1
8:  30 e9                   xor    cl,ch
a:  30 c1                   xor    cl,al
c:  20 d1                   and    cl,dl
e:  30 c8                   xor    al,cl
10: c3                      ret

Convient pour la convention d'appel Win64 (arguments dans rcx, rdx).

Haskell, 66 octets

import Data.Bits
n%m=n.&.(255-m)+(rotate n 1`xor`rotate n(-1)).&.m

Fonctionne comme prévu lorsqu'il est appelé avec des Word8données. Remplacez (255-m)par complement m(+5 octets) pour faire fonctionner la fonction avec n'importe quel type de données intégral non signé.