Примітка: перша половина цього виклику виходить з попереднього виклику Мартіна Ендера - Visualize Bit Weaving .

Езотерична мова програмування зла має цікаву операцію над значеннями байтів, які вона називає "плетінням".

По суті це перестановка восьми біт байта (не має значення, з якого кінця ми почнемо рахувати, оскільки шаблон є симетричним):

• Біт 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

Це так схоже на обман.

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. Спробуйте тут.

+⁹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 символів, і вставляється a 0в цьому положенні.

Тепер про фактичну перестановку. Безпосереднім рішенням є таке:

(.)(.)(.)(.)(.)(.)(.)(.)
$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), потім |все разом.

Решта - це не що інше, як різні смаки котла-плити.

Математика, 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

Матлаб, 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

Завдяки рішенню Мартіна за метод заміни символів, наприклад:

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

Спробуйте в Інтернеті

Піта, 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

Спробуйте в Інтернеті!

Неодноразово дів-мод на 2, а потім %поміняйте місцями та @прокручуйте, щоб отримати їх у потрібному порядку.

Вхід в базі-десять, вихід в базовому-два.

vi, 27 байт

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

Де <ESC>зображено символ Escape. Введення / виведення є двійковим, вихід - прокладеним. 24 байт in vim:

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 байт

Введення приймається в базі-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``)