Catatan: bagian pertama dari tantangan ini berasal dari tantangan Martin Ender sebelumnya, Visualisasi Bit Weaving .

Kejahatan bahasa pemrograman esoterik memiliki operasi yang menarik pada nilai byte yang disebutnya "tenun".

Ini pada dasarnya adalah permutasi dari delapan bit byte (tidak masalah dari mana kita mulai menghitung, karena polanya simetris):

• Bit 0 dipindahkan ke bit 2
• Bit 1 dipindahkan ke bit 0
• Bit 2 dipindahkan ke bit 4
• Bit 3 dipindahkan ke bit 1
• Bit 4 dipindahkan ke bit 6
• Bit 5 dipindahkan ke bit 3
• Bit 6 dipindahkan ke bit 7
• Bit 7 dipindahkan ke bit 5

Untuk kenyamanan, berikut adalah tiga representasi permutasi lainnya. Sebagai sebuah siklus:

(02467531)

Sebagai pemetaan:

57361402 -> 76543210 -> 64725031

Dan sebagai daftar pasangan pemetaan:

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

Setelah 8tenun, byte pada dasarnya direset.

Misalnya, menenun nomor 10011101(yang ada 157di basis 10) akan menghasilkan 01110110(yang ada 118di basis 10).

Memasukkan

Hanya ada 256input yang valid, yaitu semua bilangan bulat di antara 0dan 255inklusif. Itu dapat diambil dalam basis apa pun, tetapi harus konsisten dan Anda harus menentukannya jika basis yang Anda pilih bukan basis sepuluh.

Anda tidak boleh memasukkan input dengan benar.

Keluaran

Anda harus menampilkan hasil dari bit weaving, dalam basis apa pun, yang juga harus konsisten dan ditentukan jika bukan basis sepuluh.

Anda dapat mem-pad-out output Anda.

Terkait: Visualisasikan Bit Weaving

Python 2.7, 44 -> 36 byte

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

Evil, 3 karakter

rew

Cobalah online!

Input dalam basis 256, (misalnya ASCII), misalnya untuk memasukkan digit 63, masukkan ASCII 63 yang ?.

Penjelasan:

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

Ini jadi terasa seperti kecurangan.

CJam, 15 12 byte

Terima kasih kepada FryAmTheEggman karena telah menghemat 3 byte.

l8Te[m!6532=

Input pada basis 2. Output juga pada basis 2, diisi hingga 8 bit dengan nol.

Uji di sini.

Penjelasan

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

Input dalam desimal. Output adalah biner nol-empuk.

Cobalah online!

Penjelasan

&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

Jelly, 11 byte

+⁹BḊŒ!6533ị

Terjemahan dari jawaban CJam Martin. Coba di sini.

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

Menggunakan permutasi bawaan A.dengan indeks permutasi 6532yang sesuai dengan operasi penenaman bit.

Pemakaian

Input adalah daftar digit biner. Output adalah daftar nol-digit 8 digit biner.

   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

Penjelasan

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 byte

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

Input dan output dalam basis 2, output dibiarkan berlapis.

Cobalah online!

Penjelasan

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

Ini hanya menyisakan input dengan nol. Itu+ menunjukkan bahwa tahap ini diulang sampai string berhenti berubah. Ini cocok dengan awal string selama ada kurang dari 8 karakter di dalamnya, dan sisipkan a0 di posisi itu.

Sekarang untuk permutasi yang sebenarnya. Solusi lurus ke depan adalah ini:

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

Namun itu sangat panjang dan berlebihan. Saya menemukan formulasi permutasi yang berbeda yang jauh lebih mudah untuk diterapkan di Retina ( Xmewakili pertukaran bit yang berdekatan):

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

Nah, itu jauh lebih mudah untuk diterapkan:

(.)(.)
$2$1

Ini hanya cocok dengan dua karakter dan menukar mereka. Karena pertandingan tidak tumpang tindih, ini menukar keempat pasangan.

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

Sekarang kami ingin melakukan hal yang sama lagi, tetapi kami ingin melewatkan karakter pertama. Cara termudah untuk melakukannya adalah dengan meminta agar kecocokan tidak dimulai pada batas kata \B.

kode mesin x86, 20 byte

Dalam hex:

89C22455C1E002D0E0D1E880E2AAC0EA0211D0C3

Ini adalah prosedur mengambil input dan mengembalikan hasil melalui register AL

Membongkar

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 (makro tidak aman), 39 byte

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

C (fungsi), 41 byte

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

C (program penuh), 59 byte

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

(kembali melalui kode keluar, jadi panggil dengan echo "157" | ./weave;echo $? )

C (program lengkap standar-compliant), 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 (program lengkap standar-compliant tanpa peringatan kompiler), 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 (program penuh standar-compliant tanpa peringatan kompiler yang dapat membaca dari argumen atau stdin dan termasuk pengecekan error / range), 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)));}

Kerusakan

Hampir sama dengan banyak jawaban yang ada: bit-shift semua bit ke tempatnya dengan menggunakan <<2( *4), <<1( *2), >>1( /2) dan >>2( /4), lalu| semuanya bersamaan.

Sisanya tidak lain hanyalah rasa berbeda dari pelat ketel.

Mathematica, 34 byte

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

Fungsi anonim. Mengambil daftar digit biner, dan menampilkan daftar empuk 8 digit biner.

PowerShell v2 +, 34 byte

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

Terjemahan dari jawaban @ LegionMammal978 . Program lengkap. Mengambil input melalui argumen baris perintah sebagai angka biner, output sebagai array biner, nol-empuk.

The "{0:D8}"-fporsi menggunakan standar format numerik string untuk tambahkan 0ke input $args. Karena -foperator mendukung pengambilan array sebagai input, dan kami telah secara eksplisit mengatakan untuk menggunakan elemen pertama{0: , kami tidak perlu melakukan hal yang biasa $args[0]. Kami merangkum string itu dalam parens, lalu mengindeksnya[1,3,0,5,2,7,4,6] dengan tenun. Array yang dihasilkan ditinggalkan di pipeline dan output implisit.

Contohnya

(default .ToString()untuk array memiliki separator sebagai `n, jadi itu sebabnya output dipisahkan baris baru di sini)

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)

Mengambil input sebagai string nilai biner. Output empuk. 4 byte disimpan berkat @Luis Mendo.

Penjelasan:

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

Cobalah online!

Ini membutuhkan input dan output dalam biner. Sebagian besar jumlah byte berasal dari padding dengan 0's. Jika mengisi input diizinkan, kami bisa melakukan:

òxplò2|@q

Berkat solusi Martin untuk metode bertukar karakter, misalnya:

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

Penjelasan:

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

Penjelasan

ž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

Input ada di basis 10.
Output di basis 2.

Pinjam trik permutasi dari jawaban CJam MartinEnder

Cobalah online

Pyth, 19 karakter

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

Input dan output adalah basis 2.

Jauh dari ahli Pyth, tetapi karena tidak ada orang lain yang menjawabnya, saya mencobanya.

Penjelasan:

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

Labirin , 27 26 byte

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

Input dan output pada basis 2. Output diisi.

Cobalah online!

UGL , 50 byte

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

Cobalah online!

Div-mod berulang kali dengan 2, lalu %swap dan@ roll untuk mendapatkannya dalam urutan yang benar.

Input dalam basis-sepuluh, output dalam basis-dua.

vi, 27 byte

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

Dimana <ESC>mewakili karakter Escape. I / O dalam biner, output diisi. 24 byte dalam vim:

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

Sebenarnya, 27 byte

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

Cobalah online!

Program ini melakukan input dan output sebagai string biner (output bernilai nol hingga 8 bit).

Penjelasan:

'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

Input diambil dalam basis-2 sebagai string, output juga basis-2 sebagai 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``)