Una convoluzione binaria è descritta da un numero Me viene applicata a un numero N. Per ogni bit nella rappresentazione binaria di M, se il bit è impostato ( 1), il bit corrispondente nell'output è dato da XORing i due bit adiacenti al bit corrispondente in N(avvolgimento quando necessario). Se il bit non è impostato ( 0), il bit corrispondente nell'uscita è dato dal bit corrispondente in N.

Un esempio funzionante (con valori a 8 bit):

1. Let N = 150, M = 59. Le loro rappresentazioni binarie sono (rispettivamente) 10010110e 00111011.
2. Sulla base Mdella rappresentazione binaria, i bit 0, 1, 3, 4 e 5 sono contorti.
   1. Il risultato per il bit 0 è dato dai bit 1 e 7 di XORing (dal momento che ci avvolge), cedendo 1.
   2. Il risultato per il bit 1 è dato dai bit XORing 0 e 2, che danno 0.
   3. Il risultato per il bit 2 è dato dal bit originale 2, cedendo 1.
   4. Il risultato per il bit 3 è dato da XORing bit 2 e 4, cedendo 0.
   5. Il risultato per il bit 4 è dato da XORing bit 3 e 5, cedendo 0.
   6. Il risultato per il bit 5 è dato dai bit XORing 4 e 6, che danno 1.
   7. I risultati per i bit 6 e 7 sono dati dai bit originali 6 e 7, che producono 0e 1.
3. L'output è quindi 10100110( 166).

La sfida

Dato Ne Mprodotto il risultato dell'esecuzione della convoluzione binaria descritta da Mupon N. L'input e l'output possono essere in qualsiasi formato conveniente, coerente e inequivocabile. Ne Msaranno sempre nell'intervallo (inclusivo) [0, 255](numeri interi senza segno a 8 bit) e le loro rappresentazioni binarie dovrebbero essere riempite a 8 bit per eseguire la convoluzione binaria.

Casi 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 byte

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

Python 2, 35 byte

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

J, 34 byte

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

Approccio diretto che applica il processo definito nella sfida. Accetta input come un array [n, m].

Forme smileys sette, [:, :(, :1, (8, 8#, #:, e :].

uso

   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

codice macchina x64, 17 byte

88CD88C8D0C9D0C530E930C120D130C8C3

Disassembled:

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

Adatto per la convenzione di chiamata Win64 (argomenti in rcx, rdx).

Haskell, 66 byte

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

Funziona come previsto quando chiamato con i Word8dati. Sostituisci (255-m)con complement m(+5 byte) per far funzionare la funzione con qualsiasi tipo di dati integrale senza segno.