Hinweis: Die erste Hälfte dieser Herausforderung stammt von Martin Enders vorheriger Herausforderung, Visualize Bit Weaving .

Die esoterische Programmiersprache evil hat eine interessante Operation für Bytewerte, die sie "Weben" nennt.

Es ist im Wesentlichen eine Permutation der acht Bits des Bytes (es spielt keine Rolle, von welchem ​​Ende aus wir zu zählen beginnen, da das Muster symmetrisch ist):

• Bit 0 wird nach Bit 2 verschoben
• Bit 1 wird nach Bit 0 verschoben
• Bit 2 wird nach Bit 4 verschoben
• Bit 3 wird nach Bit 1 verschoben
• Bit 4 wird nach Bit 6 verschoben
• Bit 5 wird nach Bit 3 verschoben
• Bit 6 wird nach Bit 7 verschoben
• Bit 7 wird nach Bit 5 verschoben

Der Einfachheit halber sind hier drei weitere Darstellungen der Permutation. Als Zyklus:

(02467531)

Als Zuordnung:

57361402 -> 76543210 -> 64725031

Und als Liste von Paaren des Mappings:

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

Nach dem 8Weben wird das Byte im Wesentlichen zurückgesetzt.

Zum Beispiel wird das Weben der Zahl 10011101(die sich 157in der Basis 10 befindet) ergeben 01110110(die sich 118in der Basis 10 befindet).

Eingang

Es gibt nur 256gültige Eingaben, nämlich alle ganzen Zahlen zwischen 0und255 einschließlich. Dies kann in jeder Basis angenommen werden, muss aber konsistent sein und Sie müssen es angeben, wenn die von Ihnen gewählte Basis nicht die Basis zehn ist.

Sie dürfen Ihre Eingaben nicht auf Null setzen.

Ausgabe

Sie sollten das Ergebnis des Bitwebens in einer beliebigen Basis ausgeben, die auch konsistent sein und angegeben werden muss, wenn nicht die Basis zehn.

Sie können Ihre Ausgänge auf null setzen.

Siehe auch: Visualize Bit Weaving

Python 2.7, 44 -> 36 Bytes

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

Böse, 3 Zeichen

rew

Probieren Sie es online!

Die Eingabe erfolgt in der Basis 256 (z. B. ASCII). Um z. B. die Ziffer 63 einzugeben, geben Sie ASCII 63 ein ? .

Erläuterung:

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

Das fühlt sich so an, als würde man betrügen.

CJam, 15 12 Bytes

Vielen Dank an FryAmTheEggman für die Einsparung von 3 Bytes.

l8Te[m!6532=

Eingabe in Basis 2. Ausgabe auch in Basis 2, mit Nullen auf 8 Bit aufgefüllt.

Teste es hier.

Erläuterung

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 Bytes

&8B[2K1B3D5C])

Die Eingabe erfolgt dezimal. Die Ausgabe ist binär mit Nullen aufgefüllt.

Probieren Sie es online!

Erläuterung

&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 Bytes

+⁹BḊŒ!6533ị

Übersetzung von Martins CJam-Antwort. Probieren Sie es hier aus.

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

6532 A._8&{.

Verwendet das eingebaute Permut A.mit dem Permutationsindex, 6532der der Bitweboperation entspricht.

Verwendung

Die Eingabe ist eine Liste von Binärziffern. Die Ausgabe ist eine mit Nullen aufgefüllte Liste mit 8 Binärziffern.

   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

Erläuterung

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 Bytes

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

Eingabe und Ausgabe in Basis 2, Ausgabe wird links aufgefüllt.

Probieren Sie es online!

Erläuterung

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

Dies füllt die Eingabe nur links mit Nullen auf. Das +zeigt an, dass diese Phase wiederholt wird, bis sich die Zeichenfolge nicht mehr ändert. Es stimmt mit dem Anfang der Zeichenfolge überein, solange weniger als 8 Zeichen enthalten sind, und fügt ein0 an dieser Position ein ein.

Nun zur eigentlichen Permutation. Die einfache Lösung lautet wie folgt:

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

Das ist jedoch schmerzhaft lang und überflüssig. Ich habe eine andere Formulierung der Permutation gefunden, die in Retina viel einfacher zu implementieren ist ( Xrepräsentiert einen Austausch benachbarter Bits):

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

Das ist jetzt viel einfacher zu implementieren:

(.)(.)
$2$1

Dies vergleicht einfach zwei Zeichen und tauscht sie aus. Da sich Übereinstimmungen nicht überlappen, werden alle vier Paare getauscht.

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

Jetzt wollen wir dasselbe noch einmal machen, aber wir wollen das erste Zeichen überspringen. Am einfachsten ist es, wenn Sie festlegen, dass die Übereinstimmung nicht an einer Wortgrenze mit beginnt \B.

x86-Maschinencode, 20 Byte

In hex:

89C22455C1E002D0E0D1E880E2AAC0EA0211D0C3

Es ist eine Prozedur, die Eingaben vornimmt und Ergebnisse über das AL-Register zurückgibt

Demontage

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 (unsicheres Makro), 39 Bytes

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

C (Funktion), 41 Bytes

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

C (volles Programm), 59 Bytes

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

(Rückgabe über Exit-Code, also mit aufrufen echo "157" | ./weave;echo $?)

C (normenkonformes Vollprogramm), 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 (normenkonformes Vollprogramm ohne Compiler-Warnungen), 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 (normenkonformes Vollprogramm ohne Compiler-Warnungen, die aus Argumenten oder stdin gelesen werden können und Fehler- / Bereichsprüfung enthalten), 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)));}

Nervenzusammenbruch

So ziemlich das Gleiche wie bei vielen vorhandenen Antworten: Verschieben Sie alle Bits mit <<2( *4), <<1( *2), >>1( /2) und >>2( /4) an die richtige Stelle| alles zusammen.

Der Rest ist nichts anderes als verschiedene Geschmacksrichtungen der Kesselplatte.

Mathematica, 34 Bytes

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

Anonyme Funktion. Nimmt eine Liste von Binärziffern und gibt eine gepolsterte Liste von 8 Binärziffern aus.

PowerShell v2 +, 34 Byte

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

Übersetzung der Antwort von @ LegionMammal978 . Volles Programm. Übernimmt die Eingabe über das Befehlszeilenargument als Binärzahl, gibt sie als binäres Array aus und wird mit Nullen aufgefüllt.

Der "{0:D8}"-fTeil verwendet Zeichenfolgen im numerischen Standardformat , 0um der Eingabe voran zu stellen $args. Da der -fOperator die Verwendung eines Arrays als Eingabe unterstützt und wir ausdrücklich die Verwendung des ersten Elements angegeben haben {0:, müssen wir nicht das Übliche tun $args[0]. Wir kapseln diesen String in Parens und indizieren ihn dann[1,3,0,5,2,7,4,6] mit dem Weben. Das resultierende Array verbleibt in der Pipeline und die Ausgabe ist implizit.

Beispiele

(Die Standardeinstellung .ToString()für ein Array hat das Trennzeichen als `n. Deshalb wird die Ausgabe hier durch Zeilenumbrüche getrennt.)

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 Bytes

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

Übernimmt die Eingabe als Zeichenfolge von Binärwerten. Ausgabe gepolstert. 4 Bytes gespart dank @Luis Mendo.

Erläuterung:

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 Bytes

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

Probieren Sie es online!

Dies nimmt die Ein- und Ausgabe in Binärform vor. Der größte Teil der Byteanzahl stammt aus dem Auffüllen mit Nullen. Wenn das Auffüllen der Eingabe erlaubt wäre, könnten wir einfach Folgendes tun:

òxplò2|@q

Dank Martins Lösung für das Austauschen von Zeichen, zB:

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

Erläuterung:

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 Bytes

žz+b¦œ6532èJ

Erläuterung

ž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

Die Eingabe erfolgt in Basis 10.
Ausgabe erfolgt in Basis 2.

Leiht den Permutationstrick aus MartinEnders CJam-Antwort

Probieren Sie es online aus

Pyth, 19 Zeichen

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

Eingang und Ausgang sind Basis 2.

Weit entfernt von einem Pyth-Experten, aber da noch niemand anders geantwortet hat, habe ich es ausprobiert.

Erläuterung:

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

Labyrinth , 27 26 Bytes

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

Ein- und Ausgabe in Basis 2. Die Ausgabe ist gepolstert.

Probieren Sie es online!

UGL , 50 Bytes

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

Probieren Sie es online!

Div-Mod wiederholt durch 2, und dann %tauschen und @rollen, um sie in der richtigen Reihenfolge zu erhalten.

Eingabe in Basis zehn, Ausgabe in Basis zwei.

vi, 27 Bytes

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

Wo <ESC>steht das Escape-Zeichen? E / A ist binär, Ausgang ist gepolstert. 24 Bytes in vim:

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

Eigentlich 27 Bytes

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

Probieren Sie es online!

Dieses Programm führt die Ein- und Ausgabe als Binärzeichenfolge durch (die Ausgabe ist auf 8 Bit aufgefüllt).

Erläuterung:

'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

Die Eingabe erfolgt in der Basis 2 als Zeichenfolge, die Ausgabe erfolgt ebenfalls in der Basis 2 als Zeichenfolge

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