Remarque: la première moitié de ce défi provient du précédent défi de Martin Ender, Visualize Bit Weaving .

Le langage de programmation ésotérique mal a une opération intéressante sur les valeurs d'octets qu'il appelle "tissage".

Il s'agit essentiellement d'une permutation des huit bits de l'octet (peu importe de quelle extrémité nous commençons à compter, car le motif est symétrique):

• Le bit 0 est déplacé vers le bit 2
• Le bit 1 est déplacé vers le bit 0
• Le bit 2 est déplacé vers le bit 4
• Le bit 3 est déplacé vers le bit 1
• Le bit 4 est déplacé vers le bit 6
• Le bit 5 est déplacé vers le bit 3
• Le bit 6 est déplacé vers le bit 7
• Le bit 7 est déplacé vers le bit 5

Pour plus de commodité, voici trois autres représentations de la permutation. En cycle:

(02467531)

En tant que cartographie:

57361402 -> 76543210 -> 64725031

Et comme une liste de paires de la cartographie:

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

Après 8 tissages, l'octet est essentiellement réinitialisé.

Par exemple, le tissage du nombre 10011101(qui est 157en base 10) produira 01110110(qui est 118en base 10).

Contribution

Il n'y a que des 256entrées valides, à savoir tous les entiers compris entre 0et 255inclus. Cela peut être pris dans n'importe quelle base, mais il doit être cohérent et vous devez le spécifier si la base que vous choisissez n'est pas la base dix.

Vous ne pouvez pas mettre à zéro vos entrées.

Production

Vous devez sortir le résultat du tissage des bits, dans n'importe quelle base, qui doit également être cohérent et spécifié sinon en base dix.

Vous pouvez mettre à zéro vos sorties.

Connexe: Visualize Bit Weaving

Python 2.7, 44 -> 36 octets

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

Mal, 3 personnages

rew

Essayez-le en ligne!

L'entrée est en base 256, (par exemple ASCII), par exemple pour entrer le chiffre 63, entrez ASCII 63 qui est ?.

Explication:

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

Cette façon se sent comme de la tricherie.

CJam, 15 12 octets

Merci à FryAmTheEggman pour avoir économisé 3 octets.

l8Te[m!6532=

Entrée en base 2. Sortie également en base 2, complétée à 8 bits avec des zéros.

Testez-le ici.

Explication

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 octets

&8B[2K1B3D5C])

L'entrée est en décimal. La sortie est un binaire à remplissage nul.

Essayez-le en ligne!

Explication

&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

Gelée, 11 octets

+⁹BḊŒ!6533ị

Traduction de la réponse CJam de Martin. Essayez-le ici.

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

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

J, 12 octets

6532 A._8&{.

Utilise la permutation intégrée A.avec un indice de permutation 6532qui correspond à l'opération de tissage de bits.

Usage

L'entrée est une liste de chiffres binaires. La sortie est une liste à 8 chiffres binaires complétée par zéro.

   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

Explication

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

Rétine , 39 octets

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

Entrée et sortie en base 2, la sortie est remplie à gauche.

Essayez-le en ligne!

Explication

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

Cela vient de remplir l'entrée avec des zéros. le+ indique que cette étape est répétée jusqu'à ce que la chaîne cesse de changer. Il correspond au début de la chaîne tant qu'il contient moins de 8 caractères et insère un 0dans cette position.

Maintenant pour la permutation réelle. La solution simple est la suivante:

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

Cependant, c'est douloureusement long et redondant. J'ai trouvé une formulation différente de la permutation qui est beaucoup plus facile à implémenter dans la rétine ( Xreprésente un échange de bits adjacents):

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

Maintenant, c'est beaucoup plus facile à mettre en œuvre:

(.)(.)
$2$1

Cela correspond simplement à deux caractères et les échange. Comme les correspondances ne se chevauchent pas, cela permute les quatre paires.

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

Maintenant, nous voulons refaire la même chose, mais nous voulons sauter le premier caractère. La manière la plus simple de le faire est d'exiger que la correspondance ne commence pas à la limite d'un mot avec \B.

code machine x86, 20 octets

En hex:

89C22455C1E002D0E0D1E880E2AAC0EA0211D0C3

C'est une procédure prenant l'entrée et renvoyant le résultat via le registre AL

Démontage

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 sécurisée), 39 octets

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

C (fonction), 41 octets

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

C (programme complet), 59 octets

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

(retourne via le code de sortie, donc appelez avec echo "157" | ./weave;echo $? )

C (programme complet conforme aux normes), 86 octets

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

C (programme complet conforme aux normes sans avertissements du compilateur), 95 octets

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

C (programme complet conforme aux normes sans avertissement du compilateur qui peut lire à partir des arguments ou stdin et inclut la vérification des erreurs / plage), 262 octets

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

Panne

À peu près la même chose que beaucoup de réponses existantes: décaler tous les bits en place en utilisant <<2( *4), <<1( *2), >>1( /2) et >>2( /4), puis| tout cela ensemble.

Le reste n'est que des saveurs différentes de chaudronnerie.

Mathematica, 34 octets

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

Fonction anonyme. Prend une liste de chiffres binaires et génère une liste remplie de 8 chiffres binaires.

PowerShell v2 +, 34 octets

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

Traduction de la réponse de @ LegionMammal978 . Programme complet. Prend l'entrée via l'argument de ligne de commande sous forme de nombre binaire, les sorties sous forme de tableau binaire, avec un zéro.

La "{0:D8}"-fpartie utilise des chaînes de format numérique standard pour ajouter 0à l'entrée $args. Puisque l' -fopérateur prend en charge la prise d'un tableau en entrée, et que nous avons explicitement dit d'utiliser le premier élément {0:, nous n'avons pas besoin de faire l'habituel $args[0]. Nous encapsulons cette chaîne en parens, puis l'indexons [1,3,0,5,2,7,4,6]avec le tissage. Le tableau résultant est laissé sur le pipeline et la sortie est implicite.

Exemples

(la valeur .ToString()par défaut pour un tableau a le séparateur comme `n, c'est pourquoi la sortie est séparée par des sauts de ligne)

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 octets

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

Prend l'entrée sous forme de chaîne de valeurs binaires. Sortie rembourrée. 4 octets enregistrés grâce à @Luis Mendo.

Explication:

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 octets

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

Essayez-le en ligne!

Cela prend l'entrée et la sortie en binaire. La plupart du nombre d'octets provient du remplissage avec des 0. Si le remplissage de l'entrée était autorisé, nous pourrions simplement faire:

òxplò2|@q

Merci à la solution de Martin pour la méthode d'échange de caractères, par exemple:

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

Explication:

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 octets

žz+b¦œ6532èJ

Explication

ž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'entrée est en base 10. La
sortie est en base 2.

Emprunte l'astuce de permutation de la réponse CJam de MartinEnder

Essayez-le en ligne

Pyth, 19 caractères

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

L'entrée et la sortie sont en base 2.

Loin d'un expert en Pyth, mais comme personne d'autre n'a encore répondu, je lui ai donné un coup de feu.

Explication:

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

Labyrinthe , 27 26 octets

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

Entrée et sortie en base 2. La sortie est rembourrée.

Essayez-le en ligne!

UGL , 50 octets

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

Essayez-le en ligne!

Div-mod à plusieurs reprises par 2, puis %échangez et @roulez pour les mettre dans le bon ordre.

Entrée en base dix, sortie en base deux.

vi, 27 octets

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

Où <ESC>représente le caractère d'échappement. Les E / S sont en binaire, la sortie est complétée. 24 octets dans vim:

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

En fait, 27 octets

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

Essayez-le en ligne!

Ce programme fait l'entrée et la sortie sous forme de chaîne binaire (la sortie est complétée par zéro à 8 bits).

Explication:

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

L'entrée est prise en base-2 sous forme de chaîne, la sortie est également en base-2 sous forme de chaîne

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