Nota: la primera mitad de este desafío proviene del desafío anterior de Martin Ender, Visualize Bit Weaving .

El lenguaje de programación esotérico evil tiene una operación interesante sobre los valores de bytes que llama "tejido".

Es esencialmente una permutación de los ocho bits del byte (no importa desde qué extremo comencemos a contar, ya que el patrón es simétrico):

• El bit 0 se mueve al bit 2
• El bit 1 se mueve al bit 0
• El bit 2 se mueve al bit 4
• El bit 3 se mueve al bit 1
• El bit 4 se mueve al bit 6
• El bit 5 se mueve al bit 3
• El bit 6 se mueve al bit 7
• El bit 7 se mueve al bit 5

Por conveniencia, aquí hay otras tres representaciones de la permutación. Como un ciclo:

(02467531)

Como mapeo:

57361402 -> 76543210 -> 64725031

Y como una lista de pares de mapeo:

[[0,2], [1,0], [2,4], [3,1], [4,6], [5,3], [6,7], [7,5]]

Después de los 8tejidos, el byte se restablece esencialmente.

Por ejemplo, tejer el número 10011101(que está 157en la base 10) producirá 01110110(que está 118en la base 10).

Entrada

Solo hay 256entradas válidas, es decir, todos los enteros entre 0e 255inclusive. Puede tomarse en cualquier base, pero debe ser coherente y debe especificarlo si la base que elige no es la base diez.

No puede poner a cero sus entradas.

Salida

Debe generar el resultado del tejido de bits, en cualquier base, que también debe ser coherente y especificado si no es la base diez.

Puede poner a cero sus salidas.

Relacionado: Visualice el tejido de bits

Python 2.7, 44 -> 36 bytes

lambda x:x/4&42|x*2&128|x*4&84|x/2&1

Mal, 3 personajes

rew

Pruébalo en línea!

La entrada está en la base 256 (por ejemplo, ASCII), por ejemplo, para ingresar el dígito 63, ingrese ASCII 63, que es ?.

Explicación:

r          #Read a character
 e         #Weave it
  w        #Display it

Esto por lo que se siente como hacer trampa.

CJam, 15 12 bytes

Gracias a FryAmTheEggman por guardar 3 bytes.

l8Te[m!6532=

Entrada en base 2. Salida también en base 2, acolchada a 8 bits con ceros.

Pruébalo aquí.

Explicación

l      e# Read the input.
8Te[   e# Left-pad it to 8 elements with zeros.
m!     e# Generate all permutations (with duplicates, i.e. treating equal elements
       e# in different positions distinctly).
6532=  e# Select the 6533rd, which happens to permute the elements like [1 3 0 5 2 7 4 6].

MATL , 14 bytes

&8B[2K1B3D5C])

La entrada está en decimal. La salida es binaria con relleno cero.

Pruébalo en línea!

Explicación

&8B         % Take input number implicitly. Convert to binary array with 8 digits
[2K1B3D5C]  % Push array [2 4 1 6 3 8 5 7]
)           % Index first array with second array. Implicitly display

Jalea, 11 bytes

+⁹BḊŒ!6533ị

Traducción de la respuesta de Martin CJam. Pruébalo aquí.

+⁹BḊ          Translate (x+256) to binary and chop off the MSB.
              This essentially zero-pads the list to 8 bits.
    Œ!        Generate all permutations of this list.
      6533ị   Index the 6533rd one.

JavaScript (ES6), 30 bytes

f=n=>n*4&84|n*2&128|n/2&1|n/4&42

J, 12 bytes

6532 A._8&{.

Utiliza el permute incorporado A. con el índice de permutación6532 que corresponde a la operación de tejido de bits.

Uso

La entrada es una lista de dígitos binarios. La salida es una lista con relleno de cero de 8 dígitos binarios.

   f =: 6532 A._8&{.
   f 1 0 0 1 1 1 0 1
0 1 1 1 0 1 1 0
   f 1 1 1 0 1 1 0
1 1 0 1 1 0 0 1

Explicación

6532 A._8&{.  Input: s
       _8&{.  Takes the list 8 values from the list, filling with zeros at the front
              if the length(s) is less than 8
6532          The permutation index for bit-weaving
     A.       permute the list of digits by that index and return

Retina , 39 bytes

+`^(?!.{8})
0
(.)(.)
$2$1
\B(.)(.)
$2$1

Entrada y salida en la base 2, la salida se rellena a la izquierda.

Pruébalo en línea!

Explicación

+`^(?!.{8})
0

Esto simplemente rellena la entrada con ceros. los+ indica que esta etapa se repite hasta que la cadena deja de cambiar. Coincide con el comienzo de la cadena siempre que contenga menos de 8 caracteres e inserte un 0en esa posición.

Ahora para la permutación real. La solución directa es esta:

(.)(.)(.)(.)(.)(.)(.)(.)
$2$4$1$6$3$8$5$7

Sin embargo, eso es dolorosamente largo y redundante. Encontré una formulación diferente de la permutación que es mucho más fácil de implementar en Retina ( Xrepresenta un intercambio de bits adyacentes):

1 2 3 4 5 6 7 8
 X   X   X   X
2 1 4 3 6 5 8 7
   X   X   X
2 4 1 6 3 8 5 7

Ahora eso es mucho más fácil de implementar:

(.)(.)
$2$1

Esto simplemente coincide con dos personajes y los intercambia. Como las coincidencias no se superponen, esto intercambia los cuatro pares.

\B(.)(.)
$2$1

Ahora queremos volver a hacer lo mismo, pero queremos omitir el primer personaje. La forma más fácil de hacerlo es exigir que la coincidencia no comience en un límite de palabra con \B.

código de máquina x86, 20 bytes

En hexadecimal:

89C22455C1E002D0E0D1E880E2AAC0EA0211D0C3

Es un procedimiento que toma datos y devuelve resultados a través del registro AL

Desmontaje

89 c2                   mov    edx,eax
24 55                   and    al,0x55  ;Clear odd bits
c1 e0 02                shl    eax,0x2  ;Shift left, bit 6 goes to AH...
d0 e0                   shl    al,1     ;...and doesn't affected by this shift
d1 e8                   shr    eax,1    ;Shift bits to their's target positions
80 e2 aa                and    dl,0xaa  ;Clear even bits
c0 ea 02                shr    dl,0x2   ;Shift right, bit 1 goes to CF
11 d0                   adc    eax,edx  ;EAX=EAX+EDX+CF
c3                      ret

C (macro insegura), 39 bytes

#define w(v)v*4&84|v*2&128|v/2&1|v/4&42

C (función), 41 bytes

w(v){return v*4&84|v*2&128|v/2&1|v/4&42;}

C (programa completo), 59 bytes

main(v){scanf("%d",&v);return v*4&84|v*2&128|v/2&1|v/4&42;}

(regresa a través del código de salida, así que invoque con echo "157" | ./weave;echo $?)

C (programa completo compatible con los estándares), 86 bytes

#include<stdio.h>
int main(){int v;scanf("%d",&v);return v*4&84|v*2&128|v/2&1|v/4&42;}

C (programa completo compatible con los estándares sin advertencias del compilador), 95 bytes

#include<stdio.h>
int main(){int v;scanf("%d",&v);return (v*4&84)|(v*2&128)|(v/2&1)|(v/4&42);}

C (programa completo compatible con los estándares sin advertencias del compilador que puede leer argumentos o stdin e incluye verificación de error / rango), 262 bytes

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
int main(int v,char**p){v=v<2?isatty(0)&&puts("Value?"),scanf("%d",&v)?v:-1:strtol(p[1],p,10);exit(*p==p[1]||v&255^v?fprintf(stderr,"Invalid value\n"):!printf("%d\n",(v*4&84)|(v*2&128)|(v/2&1)|(v/4&42)));}

Descompostura

Más o menos lo mismo que muchas respuestas existentes: desplazar todos los bits en su lugar utilizando <<2( *4), <<1( *2), >>1( /2) y >>2( /4), luego |todo junto.

El resto no es más que diferentes sabores de caldera.

Mathematica, 34 bytes

PadLeft[#,8][[{2,4,1,6,3,8,5,7}]]&

Función anónima. Toma una lista de dígitos binarios y genera una lista acolchada de 8 dígitos binarios.

PowerShell v2 +, 34 bytes

("{0:D8}"-f$args)[1,3,0,5,2,7,4,6]

Traducción de la respuesta de @ LegionMammal978 . Programa completo Toma la entrada a través del argumento de la línea de comandos como un número binario, emite como una matriz binaria, con relleno de cero.

La "{0:D8}"-fparte utiliza cadenas de formato numérico estándar para anteponer 0a la entrada $args. Dado que el -foperador admite tomar una matriz como entrada, y hemos dicho explícitamente que use el primer elemento {0:, no necesitamos hacer lo habitual $args[0]. Encapsulamos esa cadena en parens, luego la indexamos[1,3,0,5,2,7,4,6] con el tejido. La matriz resultante se deja en la tubería y la salida es implícita.

Ejemplos

(el valor predeterminado .ToString()para una matriz tiene el separador como `n, por eso la salida está separada por una nueva línea aquí)

PS C:\Tools\Scripts\golfing> .\golf-bit-weaving.ps1 10011101
0
1
1
1
0
1
1
0

PS C:\Tools\Scripts\golfing> .\golf-bit-weaving.ps1 1111
0
0
0
1
0
1
1
1

Matlab, 49 48 44 bytes

s=sprintf('%08s',input(''));s('24163857'-48)

Toma la entrada como una cadena de valores binarios. Salida acolchada. 4 bytes guardados gracias a @Luis Mendo.

Explicación:

input('')             -- takes input
s=sprintf('%08s',...) -- pads with zeros to obtain 8 digits
s('24163857'-48)      -- takes positions [2 4 1 6 3 8 5 7] from s (48 is code for '0')

V , 17 bytes

8é0$7hd|òxplò2|@q

Pruébalo en línea!

Esto toma entrada y salida en binario. La mayor parte del recuento de bytes proviene de rellenarlo con ceros. Si se permitiera rellenar la entrada, podríamos hacer:

òxplò2|@q

Gracias a la solución de Martin para el método de intercambio de caracteres, por ejemplo:

1 2 3 4 5 6 7 8
 X   X   X   X
2 1 4 3 6 5 8 7
   X   X   X
2 4 1 6 3 8 5 7

Explicación:

8é0                 "Insert 8 '0' characters
   $                "Move to the end of the current line
    7h              "Move 7 characters back
      d|            "Delete until the first character
        ò   ò       "Recursively:
         xp         "Swap 2 characters
           l        "And move to the right
             2|     "Move to the second column
               @q   "And repeat our last recursive command.

05AB1E, 14 12 bytes

žz+b¦œ6532èJ

Explicación

žz+b¦           # convert to binary padded with 0's to 8 digits
     œ6532è     # get the 6532th permutation of the binary number
           J    # join and implicitly print

La entrada está en la base 10.
salida está en la base 2.

Toma prestado el truco de permutación de la respuesta CJam de MartinEnder

Pruébalo en línea

Pyth, 19 caracteres

s[@z1.it%2tzP%2z@z6

Entrada y salida son base 2.

Lejos de ser un experto en Pyth, pero como nadie más ha respondido con él, lo intenté.

Explicación:

s[                # combine the 3 parts to a collection and then join them
  @z1             # bit 1 goes to bit 0
  .i              # interleave the next two collections
    t%2tz         # bits 3,5,7; t is used before z to offset the index by 1
    P%2z          # bits 0,2,4
  @z6             # bit 6 goes to bit 7

Laberinto , 27 26 bytes

_1@
&,)}}}=}}=}}=}!{!!{{!"

Entrada y salida en la base 2. La salida está acolchada.

Pruébalo en línea!

UGL , 50 bytes

cuuRir/r/r/r/r/r/r/%@@%@@%@@%@@@%@@%@@%@@@oooooooo

Pruébalo en línea!

Repetidamente div-mod por 2, y luego %intercambia y @rueda para obtenerlos en el orden correcto.

Entrada en base diez, salida en base dos.

vi, 27 bytes

8I0<ESC>$7hc0lxp<ESC>l"qd0xp3@q03@q

Donde <ESC>representa el personaje de Escape. I / O está en binario, la salida está rellenada 24 bytes en vim:

8I0<ESC>$7hd0xpqqlxpq2@q03@q

En realidad, 27 bytes

'08*+7~@tñiWi┐W13052746k♂└Σ

Pruébalo en línea!

Este programa ingresa y emite como una cadena binaria (la salida se rellena con ceros hasta 8 bits).

Explicación:

'08*+7~@tñiWi┐W13052746k♂└Σ
'08*+                        prepend 8 zeroes
     7~@t                    last 8 characters (a[:~7])
         ñi                  enumerate, flatten
           Wi┐W              for each (i, v) pair: push v to register i
               13052746k     push [1,3,0,5,2,7,4,6] (the permutation order, zero-indexed)
                        ♂└   for each value: push the value in that register
                          Σ  concatenate the strings

JavaScript, 98 bytes

La entrada se toma en base-2 como una cadena, la salida también es en base-2 como una cadena

n=>(n.length<8?n="0".repeat(8-n.length)+n:0,a="13052746",t=n,n.split``.map((e,i)=>t[a[i]]).join``)