注意：此挑战的前半部分来自Martin Ender的先前挑战， Visualize Bit Weaving。

深奥的编程语言 Evil对字节值进行了有趣的操作，称之为“编织”。

本质上是字节的八位的排列（因为模式是对称的，所以我们从哪一端开始计数并不重要）：

• 位0移至位2
• 位1移至位0
• 位2移到位4
• 位3移至位1
• 位4移至位6
• 位5移至位3
• 位6移至位7
• 位7移至位5

为方便起见，这是置换的其他三种表示形式。作为一个周期：

(02467531)

作为映射：

57361402 -> 76543210 -> 64725031

并作为映射对的列表：

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

后 8织品，字节基本复位。

例如，编织数字10011101（157以10 为底）将产生01110110（118以10底）。

输入值

只有256有效输入，即0和之间的所有整数255。可以采用任何基数，但是必须保持一致，并且如果选择的基数不是十进制，则必须指定它。

你可能不会对输入进行零填充。

输出量

您应该以任何基数输出位编织的结果，该结果还必须一致，并且如果不是十进制，则必须指定。

您可以将输出零填充。

相关：可视化位编织

Python 2.7版，44 - > 36个字节

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

邪恶，3个字符

rew

在线尝试！

输入以256为基数（例如ASCII），例如要输入数字63，请输入ASCII 63 ?。

说明：

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

这所以感觉就像作弊。

果酱，15岁 12个字节

感谢FryAmTheEggman节省了3个字节。

l8Te[m!6532=

以2为底的输入。也以2为底的输出。填充为0的8位。

在这里测试。

说明

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字节

&8B[2K1B3D5C])

输入为十进制。输出为零填充二进制。

在线尝试！

说明

&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

果冻，11个字节

+⁹BḊŒ!6533ị

马丁CJam答案的翻译。在这里尝试。

+⁹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个字节

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

J，12个字节

6532 A._8&{.

使用内置的置换 A.带有置换索引的，置换索引6532对应于位编织操作。

用法

输入是二进制数字列表。输出是8位二进制数字的零填充列表。

   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

说明

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

视网膜，39字节

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

输入和输出以2为底，输出为左填充。

在线尝试！

说明

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

这只是将输入用零填充。该+指示重复这一阶段，直到串停止变化。只要字符串少于8个字符，它就与字符串的开头匹配，并0在该位置插入a 。

现在进行实际排列。简单的解决方案是这样的：

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

然而，这是痛苦的漫长而多余的。我发现了不同的排列方式，在Retina中更容易实现（X代表相邻位的交换）：

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

现在，实现起来更加容易：

(.)(.)
$2$1

这仅匹配两个字符并交换它们。由于匹配不重叠，因此会交换所有四对。

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

现在我们想再次做同样的事情，但是我们想跳过第一个字符。最简单的方法是要求匹配不以开头\B。

x86机器码，20字节

十六进制：

89C22455C1E002D0E0D1E880E2AAC0EA0211D0C3

这是一个通过AL寄存器获取输入并返回结果的过程

拆卸

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（不安全的宏），39个字节

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

C（函数），41字节

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

C（完整程序），59个字节

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

（通过退出代码返回，因此请使用调用echo "157" | ./weave;echo $?）

C（符合标准的完整程序），86字节

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

C（符合标准的完整程序，没有编译器警告），95字节

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

C（标准兼容的完整程序，没有编译器警告，可以从参数或stdin读取，并且包括错误/范围检查），262个字节

#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)));}

分解

与许多现有答案几乎相同：通过使用<<2（*4），<<1（*2），>>1（/2）和>>2（/4）将所有位移位到适当位置，然后将|它们全部合并在一起。

剩下的不过是不同口味的样板。

Mathematica，34个字节

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

匿名函数。获取一个二进制数字列表，并输出一个填充的8个二进制数字列表。

PowerShell v2 +，34个字节

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

@ LegionMammal978的答案的翻译。完整程序。通过命令行参数将输入作为二进制数，将输出作为二进制数组（零填充）。

该"{0:D8}"-f部分使用标准数字格式字符串加0在输入前面$args。由于-f运算符支持将数组作为输入，并且我们已经明确表示要使用第一个元素{0:，因此我们无需执行通常的$args[0]。我们将该字符串封装在括号中，然后索引到其中[1,3,0,5,2,7,4,6]进行编织。结果数组留在管道上，并且输出是隐式的。

例子

（.ToString()数组的默认分隔符为`n，因此这就是输出在此处换行的原因）

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字节

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

将输入作为二进制值的字符串。输出已填充。@Luis Mendo节省了4个字节。

说明：

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个字节

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

在线尝试！

这将以二进制形式输入和输出。大部分字节计数来自将其填充为0。如果允许填充输入，我们可以这样做：

òxplò2|@q

感谢Martin对于交换字符方法的解决方案，例如：

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

说明：

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字节

žz+b¦œ6532èJ

说明

ž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

输入以10为底。
输出以2为底。

从MartinEnder的CJam答案中借​​用排列技巧

在线尝试

Pyth，19个字符

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

输入和输出为基数2。

距离Pyth专家还很远，但是由于没有其他人对此做出回答，所以我给了它一个机会。

说明：

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

迷宫，27 26字节

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

输入和输出以2为底。填充输出。

在线尝试！

UGL，50字节

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

在线尝试！

重复div-mod 2，然后%交换并@滚动以使其顺序正确。

输入以10为底，输出以2为底。

vi，27个字节

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

其中<ESC>代表转义字符。I / O为二进制，填充输出。Vim中的24个字节：

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

其实是27个位元组

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

在线尝试！

该程序将输入和输出作为二进制字符串（输出用零填充到8位）。

说明：

'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字节

输入以base-2作为字符串，输出也以base-2作为字符串

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