Lưu ý: nửa đầu của thử thách này đến từ thử thách trước đó của Martin Ender, Visualize Bit Weaving .

Cái ác ngôn ngữ lập trình bí truyền có một hoạt động thú vị trên các giá trị byte mà nó gọi là "dệt".

Nó thực chất là một hoán vị của tám bit của byte (không quan trọng chúng ta bắt đầu đếm từ đâu, vì mẫu này là đối xứng):

• Bit 0 được chuyển sang bit 2
• Bit 1 được chuyển sang bit 0
• Bit 2 được chuyển sang bit 4
• Bit 3 được chuyển sang bit 1
• Bit 4 được chuyển sang bit 6
• Bit 5 được chuyển sang bit 3
• Bit 6 được chuyển sang bit 7
• Bit 7 được chuyển sang bit 5

Để thuận tiện, đây là ba đại diện khác của hoán vị. Như một chu kỳ:

(02467531)

Như một ánh xạ:

57361402 -> 76543210 -> 64725031

Và như một danh sách các cặp ánh xạ:

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

Sau khi 8dệt, byte về cơ bản được thiết lập lại.

Ví dụ, dệt số 10011101(nằm 157trong cơ sở 10) sẽ tạo ra 01110110(nằm 118trong cơ sở 10).

Đầu vào

Chỉ 256có đầu vào hợp lệ, cụ thể là tất cả các số nguyên giữa 0và 255bao gồm. Điều đó có thể được thực hiện trong bất kỳ cơ sở nào, nhưng nó phải nhất quán và bạn phải chỉ định nó nếu cơ sở bạn chọn không phải là cơ sở mười.

Bạn có thể không pad-pad đầu vào của bạn.

Đầu ra

Bạn nên xuất kết quả của bit dệt, trong bất kỳ cơ sở nào, cũng phải nhất quán và được chỉ định nếu không phải là cơ sở mười.

Bạn có thể không đệm các đầu ra của bạn.

Liên quan: Trực quan hóa Bit Dệt

Python 2.7, 44 -> 36 byte

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

Ác, 3 nhân vật

rew

Hãy thử trực tuyến!

Đầu vào nằm trong cơ sở 256, (ví dụ ASCII), ví dụ để nhập chữ số 63, nhập ASCII 63 ?.

Giải trình:

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

Đây nên cảm thấy như gian lận.

CJam, 15 12 byte

Cảm ơn FryAmTheEggman vì đã lưu 3 byte.

l8Te[m!6532=

Đầu vào trong cơ sở 2. Đầu ra cũng ở cơ sở 2, được đệm thành 8 bit có số không.

Kiểm tra nó ở đây.

Giải trình

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 byte

&8B[2K1B3D5C])

Đầu vào là số thập phân. Đầu ra là nhị phân không đệm.

Hãy thử trực tuyến!

Giải trình

&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

Thạch, 11 byte

+⁹BḊŒ!6533ị

Bản dịch câu trả lời CJam của Martin. Hãy thử nó ở đây.

+⁹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 byte

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

J, 12 byte

6532 A._8&{.

Sử dụng hàm dựng sẵn A.với chỉ số hoán vị 6532tương ứng với hoạt động dệt bit.

Sử dụng

Đầu vào là một danh sách các chữ số nhị phân. Đầu ra là một danh sách không đệm gồm 8 chữ số nhị phân.

   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

Giải trình

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

Võng mạc , 39 byte

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

Đầu vào và đầu ra trong cơ sở 2, đầu ra được đệm trái.

Hãy thử trực tuyến!

Giải trình

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

Điều này chỉ là phần đệm bên trái đầu vào với số không. Dấu +hiệu cho thấy giai đoạn này được lặp lại cho đến khi chuỗi ngừng thay đổi. Nó khớp với phần đầu của chuỗi miễn là có ít hơn 8 ký tự trong đó và chèn một ký tự 0vào vị trí đó.

Bây giờ cho hoán vị thực tế. Giải pháp đơn giản là đây:

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

Tuy nhiên, điều đó thật dài và dư thừa. Tôi đã tìm thấy một công thức khác của hoán vị dễ thực hiện hơn trong Retina ( Xđại diện cho một hoán đổi của các bit liền kề):

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

Bây giờ điều đó dễ thực hiện hơn nhiều:

(.)(.)
$2$1

Điều này chỉ đơn giản là phù hợp với hai nhân vật và hoán đổi chúng. Vì các trận đấu không trùng nhau, điều này hoán đổi cả bốn cặp.

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

Bây giờ chúng tôi muốn làm điều tương tự một lần nữa, nhưng chúng tôi muốn bỏ qua nhân vật đầu tiên. Cách dễ nhất để làm như vậy là yêu cầu trận đấu không bắt đầu ở ranh giới từ với \B.

mã máy x86, 20 byte

Trong hex:

89C22455C1E002D0E0D1E880E2AAC0EA0211D0C3

Đây là một thủ tục lấy kết quả đầu vào và trả về thông qua thanh ghi AL

Tháo gỡ

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 không an toàn), 39 byte

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

C (hàm), 41 byte

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

C (chương trình đầy đủ), 59 byte

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

(trả về qua mã thoát, vì vậy gọi với echo "157" | ./weave;echo $?)

C (chương trình đầy đủ tuân thủ tiêu chuẩn), 86 byte

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

C (chương trình đầy đủ tuân thủ tiêu chuẩn không có cảnh báo về trình biên dịch), 95 byte

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

C (chương trình đầy đủ tuân thủ tiêu chuẩn không có cảnh báo trình biên dịch có thể đọc từ đối số hoặc stdin và bao gồm kiểm tra lỗi / phạm vi), 262 byte

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

Phá vỡ

Khá giống với rất nhiều câu trả lời hiện có: bit-shift tất cả các bit vào vị trí bằng cách sử dụng <<2( *4), <<1( *2), >>1( /2) và >>2( /4), sau |đó tất cả cùng nhau.

Phần còn lại không có gì ngoài những hương vị khác nhau của nồi hơi.

Toán học, 34 byte

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

Chức năng ẩn danh. Lấy danh sách các chữ số nhị phân và đưa ra danh sách đệm gồm 8 chữ số nhị phân.

PowerShell v2 +, 34 byte

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

Bản dịch câu trả lời của @ LegionMammal978 . Chương trình đầy đủ. Đưa đầu vào thông qua đối số dòng lệnh dưới dạng số nhị phân, đầu ra dưới dạng mảng nhị phân, không đệm.

Các "{0:D8}"-fphần sử dụng chuỗi định dạng số tiêu chuẩn để thêm vào trước 0vào đầu vào $args. Vì -ftoán tử hỗ trợ lấy một mảng làm đầu vào và chúng tôi đã nói rõ ràng là sử dụng phần tử đầu tiên{0: , chúng tôi không cần phải làm như bình thường $args[0]. Chúng tôi gói gọn chuỗi đó trong parens, sau đó lập chỉ mục cho nó [1,3,0,5,2,7,4,6]bằng cách dệt. Mảng kết quả được để lại trên đường ống và đầu ra là ẩn.

Ví dụ

(mặc định .ToString()cho một mảng có dấu phân cách là `n, vì vậy đó là lý do tại sao đầu ra là dòng mới được phân tách ở đây)

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 byte

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

Lấy đầu vào là chuỗi các giá trị nhị phân. Đầu ra đệm. 4 byte được lưu nhờ @Luis Mendo.

Giải trình:

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 byte

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

Hãy thử trực tuyến!

Điều này có đầu vào và đầu ra trong nhị phân. Hầu hết số byte đến từ việc đệm nó bằng 0. Nếu đệm đầu vào được cho phép, chúng ta có thể làm:

òxplò2|@q

Nhờ giải pháp của Martin cho phương pháp hoán đổi ký tự, ví dụ:

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

Giải trình:

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 byte

žz+b¦œ6532èJ

Giải trình

ž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

Đầu vào là trong cơ sở 10.
Đầu ra là trong cơ sở 2.

Mượn mẹo hoán vị từ câu trả lời CJam của MartinEnder

Dùng thử trực tuyến

Pyth, 19 ký tự

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

Đầu vào và đầu ra là cơ sở 2.

Khác xa với một chuyên gia Pyth, nhưng vì chưa có ai trả lời với nó nên tôi đã cho nó một phát súng.

Giải trình:

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

Mê cung , 27 26 byte

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

Đầu vào và đầu ra trong cơ sở 2. Đầu ra được đệm.

Hãy thử trực tuyến!

UGL , 50 byte

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

Hãy thử trực tuyến!

Lặp đi lặp lại div-mod bằng 2, sau đó %trao đổi và@ cuộn để có được chúng theo đúng thứ tự.

Đầu vào trong cơ sở mười, đầu ra trong cơ sở hai.

vi, 27 byte

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

Nơi <ESC>đại diện cho nhân vật Escape. I / O ở dạng nhị phân, đầu ra được đệm. 24 byte trong vim:

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

Trên thực tế, 27 byte

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

Hãy thử trực tuyến!

Chương trình này thực hiện đầu vào và đầu ra dưới dạng một chuỗi nhị phân (đầu ra được đệm bằng 0 đến 8 bit).

Giải trình:

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

Đầu vào được lấy trong cơ sở-2 dưới dạng chuỗi, đầu ra cũng là cơ sở-2 dưới dạng chuỗi

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