หมายเหตุ: ในช่วงครึ่งแรกของความท้าทายนี้มาจากความท้าทายก่อนหน้านี้มาร์ตินพลิก, เห็นภาพบิตทอผ้า

ความชั่วร้ายของการเขียนโปรแกรมภาษาลึกลับมีการดำเนินการที่น่าสนใจเกี่ยวกับค่าไบต์ซึ่งเรียกว่า "การทอผ้า"

มันคือการเปลี่ยนรูปแบบของบิตที่แปดของไบต์ (ไม่สำคัญว่าเราจะเริ่มนับจากจุดสิ้นสุดเมื่อรูปแบบสมมาตร):

• บิต 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รวม ที่อาจนำมาในฐานใด ๆ แต่จะต้องสอดคล้องและคุณต้องระบุหากฐานที่คุณเลือกไม่ได้ฐานสิบ

คุณไม่สามารถป้อนข้อมูลของคุณเป็นศูนย์ได้

เอาท์พุต

คุณควรส่งออกผลลัพธ์ของการทอผ้าบิตในฐานใด ๆ ซึ่งจะต้องสอดคล้องและระบุถ้าไม่ฐานสิบ

คุณอาจ zero-pad เอาท์พุทของคุณ

ที่เกี่ยวข้อง: เห็นภาพการทอผ้าบิต

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

นี้เพื่อให้ความรู้สึกเหมือนการโกง

CJam, 15 12 ไบต์

ขอบคุณ FryAmTheEggman สำหรับการบันทึก 3 ไบต์

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

อินพุตเป็นทศนิยม เอาท์พุทเป็นศูนย์ไบนารีเบาะ

ลองออนไลน์!

คำอธิบาย

&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 ของ Martin ลองที่นี่

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

ใช้ permute builtin 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 ตัวและแทรก a0ในตำแหน่งนั้น

ตอนนี้สำหรับการเปลี่ยนแปลงจริง ทางออกที่ตรงไปตรงมาคือ:

(.)(.)(.)(.)(.)(.)(.)(.)
$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

มันเป็นขั้นตอนการรับเข้าและส่งคืนผลลัพธ์ผ่านการลงทะเบียนอัล

ถอดชิ้นส่วน

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

ชำรุด

ค่อนข้างเหมือนกันกับคำตอบที่มีอยู่มากมาย: bit-shift บิตทั้งหมดเข้าที่โดยใช้<<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]ที่เราไม่จำเป็นต้องทำตามปกติเราใส่แค็ปซูลสตริงนั้นไว้ใน parens แล้วทำดัชนีเข้าไป[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)

รับอินพุตเป็นสตริงของค่าไบนารี เบาะเอาท์พุท บันทึกได้ 4 ไบต์ด้วย @Luis Mendo

คำอธิบาย:

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

ยืมเคล็ดลับการเปลี่ยนแปลงจากคำตอบ CJam ของ MartinEnder

ลองออนไลน์

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 แล้ว%สลับและ@หมุนเพื่อให้ได้ลำดับที่ถูกต้อง

อินพุตในฐานสิบเอาต์พุตในฐานสอง

vi, 27 ไบต์

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

ในกรณีที่<ESC>แสดงให้เห็นถึงตัวหนี I / O เป็นแบบไบนารี่เอาท์พุทเป็นแบบเสริม 24 ไบต์เป็นกลุ่ม:

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

จริงแล้ว 27 ไบต์

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

ลองออนไลน์!

โปรแกรมนี้ทำอินพุตและเอาต์พุตเป็นสตริงไบนารี (เอาต์พุตคือ zero-padded ถึง 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 ไบต์

อินพุตถูกใช้ในฐาน -2 เป็นสตริงเอาต์พุตยังเป็นฐาน -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``)