注：この課題の前半は、Martin Enderの前の課題であるVisualize Bit Weavingから来ています。

難解なプログラミング言語の悪には、「織り」と呼ばれるバイト値に対する興味深い操作があります。

基本的には、バイトの8ビットの順列です（パターンが対称であるため、どちらの端からカウントを開始してもかまいません）。

• ビット0はビット2に移動します
• ビット1はビット0に移動します
• ビット2はビット4に移動します
• ビット3はビット1に移動します
• ビット4はビット6に移動します
• ビット5はビット3に移動します
• ビット6はビット7に移動します
• ビット7はビット5に移動します

便宜上、置換のその他の3つの表現を示します。サイクルとして：

(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包括的に。これはどのベースでも使用できますが、一貫している必要があり、選択したベースがベース10でない場合は指定する必要があります。

入力をゼロで埋めることはできません。

出力

ビットウィービングの結果を任意のベースで出力する必要がありますが、これもベース10でない場合は一貫性があり、指定する必要があります。

出力をゼロで埋めることができます。

関連：ビットウィービングの視覚化

パイソン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

これは不正行為のように感じます。

CJam、15 12バイト

3バイトを節約してくれたFryAmTheEggmanに感謝します。

l8Te[m!6532=

基数2の入力。基数2にも出力。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])

入力は10進数です。出力はゼロが埋め込まれたバイナリです。

オンラインでお試しください！

説明

&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ị

Martinの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を備えたpermuteビルトインを使用します。

使用法

入力は2進数のリストです。出力は、8桁の2桁のゼロが埋め込まれたリストです。

   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

これは単に2つの文字に一致し、それらを交換します。一致は重複しないため、4つのペアすべてがスワップされます。

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

ここで再び同じことを行いたいが、最初の文字をスキップしたい。そうするための最も簡単な方法は、マッチがすることを要求することではありませんとワード境界で開始します\B。

x86マシンコード、20バイト

16進数で：

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}]]&

無名関数。2進数のリストを取得し、8桁の2進数の埋め込みリストを出力します。

PowerShell v2 +、34バイト

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

@ LegionMammal978の回答の翻訳。完全なプログラム。コマンドライン引数を介して入力を2進数として受け取り、ゼロで埋められたバイナリ配列として出力します。

この"{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

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