Uwaga: pierwsza połowa tego wyzwania pochodzi z poprzedniego wyzwania Martina Endera, Visualize Bit Weaving .

Ezoteryczny język programowania zło ma interesującą operację na wartościach bajtów, które nazywa „tkaniem”.

Zasadniczo jest to permutacja ośmiu bitów bajtu (nie ma znaczenia, od którego końca zaczniemy liczyć, ponieważ wzór jest symetryczny):

• Bit 0 jest przenoszony na bit 2
• Bit 1 jest przenoszony na bit 0
• Bit 2 jest przenoszony na bit 4
• Bit 3 jest przenoszony na bit 1
• Bit 4 jest przenoszony na bit 6
• Bit 5 jest przenoszony na bit 3
• Bit 6 jest przenoszony na bit 7
• Bit 7 jest przenoszony na bit 5

Dla wygody oto trzy inne przedstawienia permutacji. Jako cykl:

(02467531)

Jako mapowanie:

57361402 -> 76543210 -> 64725031

I jako lista par mapowania:

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

Po 8utkaniu bajt jest zasadniczo resetowany.

Na przykład, wyplatanie liczby 10011101(która jest 157w bazie 10) da 01110110(która jest 118w bazie 10).

Wejście

Dostępne są tylko 256prawidłowe dane wejściowe, a mianowicie wszystkie liczby całkowite między 0i 255włącznie. Można to wziąć w dowolnej bazie, ale musi być spójna i musisz ją określić, jeśli wybrana baza nie jest dziesiątą.

Ty może nie zero-pad swoje wejścia.

Wynik

Powinieneś wyprowadzić wynik tkania bitów w dowolnej bazie, która również musi być spójna i określona, ​​jeśli nie jest to baza dziesięć.

Państwo może zero-pad swoich wyjść.

Powiązane: Wizualizacja tkania bitów

Python 2.7, 44 -> 36 bajtów

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

Zło, 3 postacie

rew

Wypróbuj online!

Dane wejściowe są w bazie 256, (np. ASCII), np. Aby wprowadzić cyfrę 63, wprowadź ASCII 63, która jest ?.

Wyjaśnienie:

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

To tak, jakby oszukiwać.

CJam, 15 12 bajtów

Dzięki FryAmTheEggman za oszczędność 3 bajtów.

l8Te[m!6532=

Wejście w bazie 2. Wyjście również w bazie 2, wypełnione do 8 bitów zerami.

Sprawdź to tutaj.

Wyjaśnienie

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 bajtów

&8B[2K1B3D5C])

Dane wejściowe są dziesiętne. Dane wyjściowe są binarne z zerowaniem.

Wypróbuj online!

Wyjaśnienie

&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

Galaretka, 11 bajtów

+⁹BḊŒ!6533ị

Tłumaczenie odpowiedzi Martina na CJam. Wypróbuj tutaj.

+⁹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 bajtów

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

J, 12 bajtów

6532 A._8&{.

Używa wbudowanej A.permutacji z indeksem permutacji, 6532który odpowiada operacji tkania bitów.

Stosowanie

Dane wejściowe to lista cyfr binarnych. Dane wyjściowe to wyściełana zerami lista 8 cyfr binarnych.

   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

Wyjaśnienie

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

Siatkówka , 39 bajtów

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

Wejście i wyjście w bazie 2, wyjście jest lewe.

Wypróbuj online!

Wyjaśnienie

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

To tylko uzupełnia wejście zerami. +Wskazuje, że etap ten jest powtarzany aż łańcuch zatrzyma się zmienia. Dopasowuje początek łańcucha, o ile zawiera mniej niż 8 znaków, i wstawia znak 0w tej pozycji.

Teraz rzeczywista permutacja. Proste rozwiązanie jest następujące:

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

Jest to jednak boleśnie długie i zbędne. Znalazłem inne sformułowanie permutacji, które jest znacznie łatwiejsze do wdrożenia w Retina ( Xreprezentuje zamianę sąsiednich bitów):

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

Teraz jest to znacznie łatwiejsze do wdrożenia:

(.)(.)
$2$1

To po prostu dopasowuje dwie postacie i zamienia je. Ponieważ mecze się nie pokrywają, zamienia wszystkie cztery pary.

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

Teraz chcemy zrobić to samo ponownie, ale chcemy pominąć pierwszą postać. Najłatwiejszym sposobem jest wymaganie, aby dopasowanie nie zaczynało się od granicy słowa z \B.

kod maszynowy x86, 20 bajtów

W hex:

89C22455C1E002D0E0D1E880E2AAC0EA0211D0C3

Jest to procedura przyjmująca dane wejściowe i zwracające wyniki za pośrednictwem rejestru AL

Demontaż

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 (niebezpieczne makro), 39 bajtów

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

C (funkcja), 41 bajtów

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

C (pełny program), 59 bajtów

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

(zwraca przez kod wyjścia, więc wywołaj za pomocą echo "157" | ./weave;echo $?)

C (pełny program zgodny ze standardami), 86 bajtów

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

C (pełny program zgodny ze standardami bez ostrzeżeń kompilatora), 95 bajtów

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

C (zgodny z normami pełny program bez ostrzeżeń kompilatora, który może odczytać z argumentów lub standardowego wejścia i obejmuje sprawdzenie błędów / zakresu), 262 bajty

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

Awaria

Prawie to samo co wiele istniejących odpowiedzi: przesuń bit wszystkie bity na miejsce za pomocą <<2( *4), <<1( *2), >>1( /2) i >>2( /4), a następnie |wszystko razem.

Reszta to nic innego jak różne smaki płyty kotłowej.

Mathematica, 34 bajty

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

Funkcja anonimowa. Pobiera listę cyfr binarnych i wyświetla wypełnioną listę 8 cyfr binarnych.

PowerShell v2 +, 34 bajty

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

Tłumaczenie @ LegionMammal978 za odpowiedź . Pełny program Pobiera dane wejściowe za pomocą argumentu wiersza poleceń jako liczbę binarną, dane wyjściowe jako tablicę binarną, uzupełnione zerami.

Ta "{0:D8}"-fczęść używa standardowych ciągów formatu numerycznego, aby dodać 0dane wejściowe $args. Ponieważ -foperator obsługuje przyjmowanie tablicy jako danych wejściowych i wyraźnie powiedzieliśmy, że należy użyć pierwszego elementu {0:, nie musimy robić tego, co zwykle $args[0]. Hermetyzujemy ten ciąg w parens, a następnie indeksujemy do niego[1,3,0,5,2,7,4,6] za pomocą tkania. Powstała tablica pozostaje w potoku, a dane wyjściowe są niejawne.

Przykłady

(wartość domyślna .ToString()dla tablicy ma separator jako `n, więc dlatego dane wyjściowe są tutaj oddzielane znakiem nowej linii)

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 bajtów

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

Pobiera dane wejściowe jako ciąg wartości binarnych. Wyjście wyściełane. 4 bajty zapisane dzięki @Luis Mendo.

Wyjaśnienie:

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 bajtów

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

Wypróbuj online!

To pobiera dane wejściowe i wyjściowe w postaci binarnej. Większość bajtów pochodzi z dopełniania jej zerami. Gdyby dopełnienie wejścia było dozwolone, moglibyśmy po prostu:

òxplò2|@q

Dzięki rozwiązaniu Martina dla metody zamiany znaków, np .:

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

Wyjaśnienie:

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 bajtów

žz+b¦œ6532èJ

Wyjaśnienie

ž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

Dane wejściowe są w bazie 10.
Wyjście jest w bazie 2.

Pożycza sztuczkę permutacyjną z odpowiedzi CJam MartinEndera

Wypróbuj online

Pyth, 19 znaków

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

Wejście i wyjście są podstawą 2.

Daleko od eksperta w Pyth, ale ponieważ nikt jeszcze nie odpowiedział na to pytanie, dałem mu szansę.

Wyjaśnienie:

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

Labirynt , 27 26 bajtów

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

Wejście i wyjście w bazie 2. Wyjście jest wyściełane.

Wypróbuj online!

UGL , 50 bajtów

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

Wypróbuj online!

Kilkakrotnie div-mod przez 2, a następnie %zamień i @rzuć, aby uzyskać je we właściwej kolejności.

Wejście w bazie dziesięć, wyjście w bazie dwa.

vi, 27 bajtów

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

Gdzie <ESC>reprezentuje postać Escape. Wejścia / wyjścia są binarne, dane wyjściowe są wypełnione. 24 bajty w vimie:

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

Właściwie 27 bajtów

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

Wypróbuj online!

Ten program wprowadza i wyprowadza dane jako ciąg binarny (dane wyjściowe są uzupełnione zerami do 8 bitów).

Wyjaśnienie:

'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 bajtów

Dane wejściowe są traktowane jako base-2 jako ciąg, dane wyjściowe są również base-2 jako ciąg

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