Nota: la prima metà di questa sfida proviene dalla precedente sfida di Martin Ender, Visualize Bit Weaving .

Il malefico linguaggio di programmazione esoterico ha un'interessante operazione sui valori di byte che chiama "tessitura".

È essenzialmente una permutazione degli otto bit del byte (non importa da quale fine iniziamo il conteggio, poiché il modello è simmetrico):

• Il bit 0 viene spostato nel bit 2
• Il bit 1 viene spostato sul bit 0
• Il bit 2 viene spostato sul bit 4
• Il bit 3 viene spostato sul bit 1
• Il bit 4 viene spostato sul bit 6
• Il bit 5 viene spostato sul bit 3
• Il bit 6 viene spostato sul bit 7
• Il bit 7 viene spostato sul bit 5

Per comodità, ecco altre tre rappresentazioni della permutazione. Come un ciclo:

(02467531)

Come mappatura:

57361402 -> 76543210 -> 64725031

E come un elenco di coppie della mappatura:

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

Dopo i 8weavings, il byte viene sostanzialmente resettato.

Ad esempio, la tessitura del numero 10011101(che è 157nella base 10) produrrà 01110110(che è 118nella base 10).

Ingresso

Vi sono solo 256input validi, vale a dire tutti i numeri interi compresi 0e 255compresi. Questo può essere preso in qualsiasi base, ma deve essere coerente e devi specificarlo se la base scelta non è la base dieci.

Si può non pari a zero-pad ingressi.

Produzione

Dovresti produrre il risultato della tessitura dei bit, in qualsiasi base, che deve anche essere coerente e specificato se non in base dieci.

È possibile azzerare le uscite.

Correlati: Visualizza la tessitura dei bit

Python 2.7, 44 -> 36 byte

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

Male, 3 personaggi

rew

Provalo online!

L'ingresso è in base 256, (ad es. ASCII), ad es. Per inserire la cifra 63, inserire ASCII 63 che è ?.

Spiegazione:

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

Questo modo si sente come barare.

CJam, 15 12 byte

Grazie a FryAmTheEggman per aver salvato 3 byte.

l8Te[m!6532=

Input in base 2. Output anche in base 2, imbottito a 8 bit con zeri.

Provalo qui.

Spiegazione

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

L'input è in decimale. L'output è binario con riempimento zero.

Provalo online!

Spiegazione

&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

Gelatina, 11 byte

+⁹BḊŒ!6533ị

Traduzione della risposta CJam di Martin. Provalo qui.

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

Utilizza il permute incorporato A.con indice di permutazione 6532che corrisponde all'operazione di tessitura dei bit.

uso

L'input è un elenco di cifre binarie. L'output è un elenco con zero cifre di 8 cifre binarie.

   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

Spiegazione

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

Ingresso e uscita in base 2, uscita con imbottitura a sinistra.

Provalo online!

Spiegazione

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

Questo ha appena lasciato il pad sull'input con zeri. Il +indica che questa fase viene ripetuta finché la corda smette di cambiare. Corrisponde all'inizio della stringa purché contenga meno di 8 caratteri e inserisce a 0in quella posizione.

Ora per la permutazione effettiva. La soluzione diretta è questa:

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

Tuttavia è dolorosamente lungo e ridondante. Ho trovato una diversa formulazione della permutazione che è molto più facile da implementare in Retina ( Xrappresenta uno scambio di bit adiacenti):

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

Ora è molto più facile da implementare:

(.)(.)
$2$1

Questo semplicemente abbina due personaggi e li scambia. Poiché le partite non si sovrappongono, questo scambia tutte e quattro le coppie.

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

Ora vogliamo fare di nuovo la stessa cosa, ma vogliamo saltare il primo personaggio. Il modo più semplice per farlo è richiedere che la corrispondenza non inizi con un limite di parole \B.

codice macchina x86, 20 byte

In esadecimale:

89C22455C1E002D0E0D1E880E2AAC0EA0211D0C3

È una procedura che accetta input e restituisce risultati tramite il registro AL

Smontaggio

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 (macro non sicura), 39 byte

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

C (funzione), 41 byte

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

C (programma completo), 59 byte

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

(ritorna tramite il codice di uscita, quindi invocare con echo "157" | ./weave;echo $?)

C (programma completo conforme agli standard), 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 (programma completo conforme agli standard senza avvisi del compilatore), 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 (programma completo conforme agli standard senza avvisi del compilatore in grado di leggere da argomenti o stdin e include controllo errori / intervallo), 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)));}

Abbattersi

Più o meno lo stesso di molte risposte esistenti: sposta i bit in posizione usando <<2( *4), <<1( *2), >>1( /2) e>>2 ( /4), quindi| tutto insieme.

Il resto non è altro che sapori diversi di piastra della caldaia.

Mathematica, 34 byte

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

Funzione anonima. Prende un elenco di cifre binarie e genera un elenco imbottito di 8 cifre binarie.

PowerShell v2 +, 34 byte

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

Traduzione della risposta di @ LegionMammal978 . Programma completo. Accetta input tramite argomento della riga di comando come numero binario, output come array binario, con riempimento zero.

La "{0:D8}"-fporzione utilizza stringhe di formato numerico standard per anteporre 0all'input $args. Poiché l' -foperatore supporta l'utilizzo di un array come input e abbiamo esplicitamente dichiarato di utilizzare il primo elemento {0:, non è necessario fare il solito $args[0]. Incapsuliamo quella stringa in parentesi, quindi ci indicizziamo [1,3,0,5,2,7,4,6]con la tessitura. L'array risultante viene lasciato sulla pipeline e l'output è implicito.

Esempi

(il valore predefinito .ToString()per un array ha il separatore come `n, quindi ecco perché l'output è newline separato qui)

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)

Accetta input come stringa di valori binari. Uscita imbottita. 4 byte salvati grazie a @Luis Mendo.

Spiegazione:

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

Provalo online!

Questo richiede input e output in binario. Gran parte del conteggio dei byte deriva dal riempimento con 0. Se il riempimento fosse consentito, potremmo semplicemente fare:

òxplò2|@q

Grazie alla soluzione di Martin per il metodo di scambio di caratteri, ad esempio:

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

Spiegazione:

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

Spiegazione

ž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

L'ingresso è nella base 10. L'
uscita è nella base 2.

Prende in prestito il trucco di permutazione dalla risposta CJam di MartinEnder

Provalo online

Pyth, 19 personaggi

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

Ingresso e uscita sono base 2.

Lontano da un esperto di Pyth, ma dal momento che nessun altro ha risposto con esso, ho provato.

Spiegazione:

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 byte

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

Ingresso e uscita in base 2. L'uscita è imbottita.

Provalo online!

UGL , 50 byte

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

Provalo online!

Rip-mod ripetutamente di 2, quindi %scambiare e @rotolare per farli nel giusto ordine.

Input in base-dieci, output in base-due.

vi, 27 byte

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

Dove <ESC>rappresenta il personaggio Escape. L'I / O è binario, l'output è imbottito. 24 byte in vim:

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

In realtà, 27 byte

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

Provalo online!

Questo programma fa input e output come una stringa binaria (l'output è a zero bit a 8 bit).

Spiegazione:

'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 byte

L'input è preso in base-2 come stringa, anche l'output è base-2 come stringa

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