Nota: a primeira metade deste desafio vem do desafio anterior de Martin Ender, Visualize Bit Weaving .

A linguagem de programação esotérica evil possui uma operação interessante sobre valores de bytes que chama de "tecelagem".

É essencialmente uma permutação dos oito bits do byte (não importa de que extremidade começamos a contar, pois o padrão é simétrico):

• O bit 0 é movido para o bit 2
• O bit 1 é movido para o bit 0
• O bit 2 é movido para o bit 4
• O bit 3 é movido para o bit 1
• O bit 4 é movido para o bit 6
• O bit 5 é movido para o bit 3
• O bit 6 é movido para o bit 7
• O bit 7 é movido para o bit 5

Por conveniência, aqui estão outras três representações da permutação. Como um ciclo:

(02467531)

Como um mapeamento:

57361402 -> 76543210 -> 64725031

E como uma lista de pares do mapeamento:

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

Após a 8tecelagem, o byte é redefinido essencialmente.

Por exemplo, tecer o número 10011101(que está 157na base 10) produzirá 01110110(que está 118na base 10).

Entrada

Existem apenas 256entradas válidas, ou seja, todos os números inteiros entre 0e 255inclusive. Isso pode ser considerado em qualquer base, mas deve ser consistente e você deve especificar se a base escolhida não for a base dez.

Você não pode zerar suas entradas.

Resultado

Você deve produzir o resultado da tecelagem de bits, em qualquer base, que também deve ser consistente e especificada, se não a base dez.

Você pode zerar suas saídas.

Relacionados: Visualize Bit Weaving

Python 2.7, 44 -> 36 bytes

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

Mal, 3 caracteres

rew

Experimente online!

A entrada está na base 256 (por exemplo, ASCII), por exemplo, para inserir o dígito 63, digite ASCII 63 que é ?.

Explicação:

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

Este modo se sente como fazer batota.

CJam, 15 12 bytes

Obrigado a FryAmTheEggman por salvar 3 bytes.

l8Te[m!6532=

Entrada na base 2. Saída também na base 2, preenchida com 8 bits com zeros.

Teste aqui.

Explicação

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

A entrada está em decimal. A saída é binária com preenchimento zero.

Experimente online!

Explicação

&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

Gelatina, 11 bytes

+⁹BḊŒ!6533ị

Tradução da resposta CJam de Martin. Experimente aqui.

+⁹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&{.

Usa o permuto embutido A.com índice de permutação 6532que corresponde à operação de tecelagem de bits.

Uso

Entrada é uma lista de dígitos binários. Saída é uma lista preenchida com zero de 8 dígitos binários.

   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

Explicação

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 e saída na base 2, a saída é preenchida à esquerda.

Experimente online!

Explicação

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

Isso apenas pressiona a entrada com zeros. A +indica que nesta fase é repetido até que a corda pára de mudar. Corresponde ao início da string, desde que haja menos de 8 caracteres, e insere um0 nessa posição.

Agora, para a permutação real. A solução direta é esta:

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

No entanto, é dolorosamente longo e redundante. Encontrei uma formulação diferente da permutação que é muito mais fácil de implementar na Retina ( Xrepresenta uma troca de bits adjacentes):

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

Agora isso é muito mais fácil de implementar:

(.)(.)
$2$1

Simplesmente combina dois caracteres e os troca. Como as correspondências não se sobrepõem, isso troca todos os quatro pares.

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

Agora queremos fazer a mesma coisa novamente, mas queremos pular o primeiro caractere. A maneira mais fácil de fazer isso é exigir que a correspondência não comece no limite de uma palavra \B.

código de máquina x86, 20 bytes

Em hexadecimal:

89C22455C1E002D0E0D1E880E2AAC0EA0211D0C3

É um procedimento que recebe entrada e retorna resultado via registro AL

Desmontagem

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 não segura), 39 bytes

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

C (função), 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;}

(retorna via código de saída, chame com echo "157" | ./weave;echo $?)

C (programa completo compatível com os padrões), 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 compatível com os padrões, sem avisos do 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 compatível com os padrões, sem avisos do compilador, que pode ler argumentos ou stdin e inclui verificação de erro / intervalo), 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)));}

Demolir

Praticamente o mesmo que muitas respostas existentes: mude todos os bits no lugar usando <<2( *4), <<1( *2), >>1( /2) e >>2( /4), depois |todos juntos.

O resto nada mais é do que sabores diferentes de caldeira.

Mathematica, 34 bytes

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

Função anônima. Pega uma lista de dígitos binários e gera uma lista preenchida de 8 dígitos binários.

PowerShell v2 +, 34 bytes

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

Tradução da resposta de @ LegionMammal978 . Programa completo. Recebe a entrada via argumento da linha de comando como um número binário, gera como uma matriz binária, preenchida com zero.

A "{0:D8}"-fparte usa cadeias de formato numérico padrão para preceder 0a entrada $args. Como o -foperador suporta a tomada de uma matriz como entrada, dissemos explicitamente para usar o primeiro elemento{0: , não precisamos fazer o habitual $args[0]. Encapsulamos essa string em parens e depois indexamos nela[1,3,0,5,2,7,4,6] com a tecelagem. A matriz resultante é deixada no pipeline e a saída é implícita.

Exemplos

(o padrão .ToString()para uma matriz tem o separador como `n, é por isso que a saída é nova linha separada aqui)

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)

Recebe a entrada como uma sequência de valores binários. Saída acolchoada. 4 bytes salvos graças ao @Luis Mendo.

Explicação:

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

Experimente online!

Isso leva entrada e saída em binário. A maior parte da contagem de bytes vem do preenchimento com zeros. Se o preenchimento da entrada fosse permitido, poderíamos simplesmente:

òxplò2|@q

Graças à solução de Martin pelo método de troca de caracteres, por exemplo:

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

Explicação:

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

Explicação

ž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

A entrada está na base 10.
saída está na base 2.

Empresta o truque de permutação de permutação da resposta CJam de MartinEnder

Experimente online

Pitão, 19 caracteres

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

Entrada e saída são a base 2.

Longe de ser um especialista em Pyth, mas como ninguém mais respondeu com isso, eu tentei.

Explicação:

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

Labirinto , 27 26 bytes

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

Entrada e saída na base 2. A saída é preenchida.

Experimente online!

UGL , 50 bytes

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

Experimente online!

Div-mod repetidamente por 2 e, em seguida, %troque e @role para obtê-los na ordem certa.

Entrada na base dez, saída na base dois.

vi, 27 bytes

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

Onde <ESC>representa o caractere de escape. A E / S está em binário, a saída é preenchida. 24 bytes no vim:

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

Na verdade, 27 bytes

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

Experimente online!

Este programa faz entrada e saída como uma sequência binária (a saída é preenchida com zero a 8 bits).

Explicação:

'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

A entrada é obtida na base-2 como uma string, a saída também é na base-2 como uma string

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