Comme la plupart d'entre vous le savent probablement, les mémoires matérielles (adressables en octets) peuvent être divisées en deux catégories - petit-boutien et gros-boutiste . Dans les mémoires little-endian, les octets sont numérotés en commençant par 0 à la petite extrémité (la moins significative) et dans les mémoires big-endian dans l'autre sens.

Fait amusant : ces termes sont basés sur le livre de Jonathan Swift , Gulliver's Travels, dans lequel le roi lilliputien a ordonné à ses citoyens de casser leurs œufs sur le petit bout (donc les petits-bouts) et les rebelles cassaient le leur sur le grand bout.

Comment fonctionne l'échange

Supposons que nous ayons un entier non signé (32 bits) 12648430en mémoire, dans une machine big-endian qui pourrait ressembler à ceci:

  addr: 0  1  2  3
memory: 00 C0 FF EE

En inversant l'ordre des octets, nous obtenons l'entier hexadécimal 0xEEFFC000qui est 4009738240en décimal.

Ta tâche

Écrivez un programme / fonction qui reçoit un entier 32 bits non signé en décimal et sort l'entier résultant lors de l'échange de l'endianité comme décrit ci-dessus.

Règles

• L'entrée sera toujours dans la plage 0de4294967295
• La sortie peut être imprimée sur STDOUT (les sauts de ligne / espaces sont très bien) ou retournés
• L'entrée et la sortie sont en décimal
• Le comportement sur une entrée non valide n'est pas défini

Cas de test

0 -> 0
1 -> 16777216
42 -> 704643072
128 -> 2147483648
12648430 -> 4009738240
16885952 -> 3232235777
704643072 -> 42
3735928559 -> 4022250974
4009738240 -> 12648430
4026531839 -> 4294967279
4294967295 -> 4294967295

langage machine x86_32, 3 octets

endian_swap:        # to be called with PASCAL REGISTER calling convention
0f c8    bswap eax
c3       ret

C'est un peu une triche. La convention d'appel Pascal registre (voir Wikipedia ) est un peu comme __fastcall, sauf qu'elle passe le premier paramètre dans eax, et eax contient également la valeur de retour. Il s'agit également d'un nettoyage de l'appel, mais comme nous n'utilisons la pile pour rien d'autre que le pointeur de retour, nous n'avons rien à faire. Cela nous permet d'éviter un mov ou un xchg et d'utiliser directement bswap.

x86_64 langage machine Linux, 5 4 octets

0:       0f cf                   bswap  %edi
2:       97                      xchg   %eax,%edi
3:       c3                      retq 

Merci à @peter ferrie pour -1.

Essayez-le en ligne!

C (gcc), 20, 29 17 octets

La suggestion de @ hvd.

__builtin_bswap32

Essayez-le en ligne!

Ancienne réponse;

#include<byteswap.h>
bswap_32

inclure doit être importé.

Japt , 10 14 octets

sG ùT8 ò w ¬nG

Essayez-le

Explication

Convertir un entier d'entrée en une chaîne de base-16 ( sG), utiliser 0pour remplir le début à la longueur 8 ( ùT8), diviser en un tableau de 2 chaînes de caractères ( ò), inverser ( w), rejoindre à une chaîne ( ¬) et reconvertir en base- 10 ( nG).

Gelée , 10 octets

⁴4*+b⁹ḊṚḅ⁹

Essayez-le en ligne!

Python 2 , 44 octets

f=lambda x,i=3:x and(x%256)<<8*i|f(x>>8,i-1)

Essayez-le en ligne!

APL + WIN 14 octets

256⊥⌽(4⍴256)⊤⎕

Explication

⎕ prompt for screen input
(4⍴256)⊤ 4 byte representation in base 256
⌽ reverse bytes
256⊥ bytes from base 256 to integer

C # , 70 68 octets

Ce n'est probablement pas optimal.

68:

Func<uint,uint>f=n=>((n=n>>16|n<<16)&0xFF00FF00)>>8|(n&0xFF00FF)<<8;

70:

uint e(uint n){n=n>>16|n<<16;return(n&0xFF00FF00)>>8|(n&0xFF00FF)<<8;}

Essayez-le en ligne!

Wolfram Language (Mathematica) , 24 octets

IntegerReverse[#,256,4]&

Essayez-le en ligne!

Inverse l'entrée interprétée comme un entier en base 256 avec 4 chiffres.

05AB1E , 12 10 octets

3F₁‰R`})₁β

Essayez-le en ligne! Explication:

  ₁         Integer constant 256
   ‰        [Div, Mod]
    R       Reverse
     `      Flatten to stack
3F    }     Repeat 3 times
       )    Collect results
        ₁β  Convert from base 256

JavaScript (ES6), 45 43 octets

f=(n,p=0,t=4)=>t?f(n>>>8,p*256+n%256,t-1):p

05AB1E , 9 octets

žJ+₁в¦R₁β

Essayez-le en ligne!

-1 merci à Neil .

Port de ma réponse Jelly.

MATL , 12 10 octets

7Y%1Z%P7Z%

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

        % Implicitly input a number, read as a double
7Y%     % Cast to uint32
1Z%     % Convert to uint8 without changing underlying data. The result is 
        % an array of four uint8 numbers, each corresponding to a byte of
        % the original number's representation 
P       % Flip array
7Z%     % Convert back to uint32 without changing underlying data. The array
        % of four uint8 numbers is interpreted as one uint32 number.
        % Implicitly display

JavaScript (ES6), 51 45 octets

6 octets enregistrés avec l'aide de @ Neil

n=>(n>>>24|n>>8&65280|(n&65280)<<8|n<<24)>>>0

Cas de test

let f=

n=>(n>>>24|n>>8&65280|(n&65280)<<8|n<<24)>>>0

console.log(f(0         )) // -> 0
console.log(f(1         )) // -> 16777216
console.log(f(42        )) // -> 704643072
console.log(f(128       )) // -> 2147483648
console.log(f(16885952  )) // -> 3232235777
console.log(f(704643072 )) // -> 42
console.log(f(3735928559)) // -> 4022250974
console.log(f(4009738240)) // -> 12648430
console.log(f(4026531839)) // -> 4294967279
console.log(f(4294967295)) // -> 4294967295

J, 16 octets

|.&.((4#256)#:])

Essayez-le en ligne!

Travailler à raccourcir l'expression de droite. Je pense que je peux raser quelques octets en faisant cela avec une version beta J. Je jure que j'ai vu ici que vous pouvez terminer un train avec un nom dans une nouvelle version bêta ...

Explication

|.&.((4#256)#:])
    ((4#256)#:])  Convert to 4 two-byte blocks
            #:      Debase to
      4#256         4 digits base 256
  &.              Apply right function, left function, then inverse of right
|.                Reverse digits

Convertissez en 4 chiffres base 256, inversez les chiffres, puis reconvertissez en décimal. Fondamentalement, exécutez l'algorithme fourni dans l'OP. C'est peut-être la seule fois où il est utile que la conversion de base mixte de J vous oblige à spécifier le nombre de chiffres, bien que ce serait 2 octets de moins si je pouvais terminer le train dans un nom (à la (#:~4#256)place).

Excel VBA, ₁₀₃ 92 octets

Fonction de fenêtre immédiate VBE anonyme qui prend les entrées de la plage [A1]convertit en hexadécimal, inverse les octets et sort dans la fenêtre immédiate VBE

h=[Right(Rept(0,8)&Dec2Hex(A1),8)]:For i=0To 3:s=s+Mid(h,7-2*i,2):Next:[B1]=s:?[Hex2Dec(B1)]

Assemblage PPC (32 bits), 8 octets

endian_swap:    # WORD endian_swap(WORD)
7c 60 1c 2c     LWBRX 3,0,3
4e 80 00 20     BLR

Comment cela fonctionne:

• La convention d'appel PPC place le premier paramètre de mot 32 bits dans SP + 24 et les ombres qui s'adressent dans GPR3.
• LWBRX prend la charge GPR3 ​​(troisième opérande) et l'étend à zéro (deuxième opérande) dans EA, puis lit 4 octets dans l'ordre inverse et le stocke dans GPR3 ​​(premier opérande).
• GPR3 détient la valeur de retour.
• BLR revient de la fonction (branche à l'adresse dans le registre LR)

Malheureusement, il n'y a pas d'émulateurs d'assemblage PPC en ligne que je puisse trouver pour démontrer. Pardon!

Befunge, 62 61 ou 49 octets

0&0v!p22:/3g22/*:*82\+%*:*82+<
@.$_:28*:*%00p\28*:**00g28*:*^

Essayez-le en ligne!

Il s'agit de Befunge standard sur l'interpréteur de référence, et nous devons donc tenir compte du fait que les cellules de mémoire sont signées sur 8 bits et corriger tout débordement signé possible.

Sur les implémentations avec des cellules de mémoire non signées (par exemple PyFunge), ou lorsque la plage est supérieure à 8 bits (par exemple FBBI), nous pouvons nous en passer sans ces vérifications, en économisant 12 octets.

0&0v!p22:/3g22/*:*82\+g<
@.$_:28*:*%00p\28*:**00^

Essayez FBBI en ligne!
Essayez PyFunge en ligne!

Bien que notez que PyFunge a une entrée entière de traitement des bogues, donc lors des tests sur TIO, vous devez suivre le nombre dans le champ de saisie avec un espace ou un saut de ligne.

Octave , 10 octets

@swapbytes

Essayez-le en ligne!

C'est peut-être la première fois qu'Octave obtient exactement le même score que son dérivé du golf, MATL. Bien sûr, dans ce cas, c'est Octave qui a le intégré, plutôt que MATL, ce qui le rend beaucoup plus facile.

Définit un handle vers le intégré swapbytes, qui prend n'importe quel type de données, échange l'endianité et génère le résultat. Dans ce cas, l'entrée est un entier non signé 32 bits.

C #,  44  36 octets

n=>n>>24|n>>8&65280|n&65280<<8|n<<24

Essayez-le en ligne!

Cela était à l'origine basé sur la réponse C # de Polynomial , qui m'a suggéré de publier une nouvelle réponse avec mes améliorations, mais l'approche adoptée dans la réponse JavaScript d'Arnauld s'est avérée encore plus courte en C #.

R , 86 octets

Je pensais qu'il y avait déjà une réponse (ou deux) dans R pour cette question, mais je devais me tromper ou ils avaient les mêmes problèmes que moi avec R ne faisant pas de signature. Ce problème a supprimé tous les éléments intégrés qui auraient pu aider. J'ai essayé la conversion de base 256, mais cela a fini par être trop long, mais je pense qu'il y a encore de la place pour quelqu'un de plus intelligent que moi pour le faire. Ensuite, je me suis retrouvé avec ce qui suit, une conversion en base 2 échangeant l'ordre dans une fonction récursive.

f=function(x,y=0,i=31)'if'(i+1,f(x-(2^i*z),y+(2^((3-i%/%8)*8+i%%8)*(z=2^i<=x)),i-1),y)

Essayez-le en ligne!

f=function(x,y=0,i=31)       # set up the function and initial values
  'if'(i+1,                  # test for i >= 0
    f(                       # recursively call the function
      x-(2^i*z),             # remove 2^i from x when 2^i <= x
      y+(2^                  # add to y 2 to the power of
        ((3-i%/%8)*8+i%%8)   # calc to swap the order of the bytes
        *(z=2^i<=x)),        # when 2^i <= x
      i-1),                  # decrement i
   y)                        # return y

R , 41 octets

function(n)n%/%256^(0:3)%%256%*%256^(3:0)

Essayez-le en ligne!

Vérifiez tous les cas de test!

Utilise une conversion en base 256 comme MickyT l'a suggéré ici . R n'a pas d'entiers 32 bits non signés, pas plus qu'il n'a d'entiers 64 bits. Cela nous empêche d'utiliser des opérations au niveau du bit mais cette approche (et probablement celle de MickyT) est probablement encore plus courte car les opérateurs au niveau du bit de R sont assez verbeux.

Utilise le numéro 4 de cette astuce , en tenant compte du fait que nous n'obtenons jamais un nombre aussi grand que 256^4.

n%/%256^(0:3)%%256extrait les octets et %*%, le produit matriciel, est le produit scalaire dans cette situation, avec 256^(3:0)effet de l'ordre inversé des octets. %*%renverra un 1x1 matrixcontenant la valeur endian-inversée.

CP-1610Assemblage , 6 DECLEs = 8 octets

Ce code est destiné à être exécuté sur une Intellivision .

Un opcode CP-1610 est codé avec une valeur de 10 bits, connue sous le nom de «DECLE». Cette fonction est longue de 6 DECLEs, commençant à 480C $ et se terminant à 4811 $.

Le CP-1610 possède des registres 16 bits, nous utilisons donc deux d'entre eux (R0 et R1) pour stocker une valeur 32 bits.

                               ROMW  10           ; use 10-bit ROM

                               ORG   $4800        ; start program at address $4800

                               ;; example call
4800  0001                     SDBD               ; load 0xDEAD into R0
4801  02B8 00AD 00DE           MVII  #$DEAD, R0
4804  0001                     SDBD               ; load 0xBEEF into R1
4805  02B9 00EF 00BE           MVII  #$BEEF, R1

4808  0004 0148 000C           CALL  swap32       ; call our function

480B  0017                     DECR  PC           ; loop forever

                               ;; swap32 function
                       swap32  PROC

480C  0040                     SWAP  R0           ; 16-bit SWAP of R0
480D  0041                     SWAP  R1           ; 16-bit SWAP of R1

480E  01C1                     XORR  R0, R1       ; exchange R0 and R1
480F  01C8                     XORR  R1, R0       ; using 3 consecutive eXclusive OR
4810  01C1                     XORR  R0, R1

4811  00AF                     JR    R5           ; return

                               ENDP

Dump d'exécution

 R0   R1   R2   R3   R4   R5   R6   R7    CPU flags  instruction
 ------------------------------------------------------------------
 0000 4800 0000 0000 01FE 1041 02F1 4800  ------iq   SDBD
 0000 4800 0000 0000 01FE 1041 02F1 4801  -----D-q   MVII #$DEAD,R0
 DEAD 4800 0000 0000 01FE 1041 02F1 4804  ------iq   SDBD
 DEAD 4800 0000 0000 01FE 1041 02F1 4805  -----D-q   MVII #$BEEF,R1
[DEAD BEEF]0000 0000 01FE 1041 02F1 4808  ------iq   JSR  R5,$480C

 DEAD BEEF 0000 0000 01FE 480B 02F1 480C  ------iq   SWAP R0
 ADDE BEEF 0000 0000 01FE 480B 02F1 480D  S------q   SWAP R1
 ADDE EFBE 0000 0000 01FE 480B 02F1 480E  S------q   XORR R0,R1
 ADDE 4260 0000 0000 01FE 480B 02F1 480F  ------iq   XORR R1,R0
 EFBE 4260 0000 0000 01FE 480B 02F1 4810  S-----iq   XORR R0,R1
[EFBE ADDE]0000 0000 01FE 480B 02F1 4811  S-----iq   MOVR R5,R7

 EFBE ADDE 0000 0000 01FE 480B 02F1 480B  ------iq   DECR R7

C # (.NET Core) , 72 + 31 = 103 octets

m=>BitConverter.ToUInt32(BitConverter.GetBytes(m).Reverse().ToArray(),0)

Essayez-le en ligne!

+31 pour using System;using System.Linq;

J'espérais utiliser Array.Reverse ligne, mais ce n'était pas le cas (voir alternative ci-dessous).

C # (.NET Core) , 87 + 13 = 100 octets

m=>{var a=BitConverter.GetBytes(m);Array.Reverse(a);return BitConverter.ToUInt32(a,0);}

Essayez-le en ligne!

+13 pour using System;

Cette solution prend soin de @JeppeStigNielsen; supprimer la restriction d'avoir tout en ligne enregistré 3 octets.

REXX , 42 octets

say c2d(left(reverse(d2c(arg(1))),4,'0'x))

Essayez-le en ligne!

Non golfé:

n=arg(1) -- take n as argument
n=d2c(n) -- convert from decimal to character (bytes)
n=reverse(n) -- reverse characters
n=left(n,4,'0'x) -- extend to four bytes, padding with zeros
n=c2d(n) -- convert from bytes to decimal again
say n -- output result

Swift, 28 octets

{(n:UInt32)in n.byteSwapped}

Langage machine ARM Linux, 8 octets

0:       e6bf0f30       rev     r0, r0
4:       e12fff1e       bx      lr

Pour essayer vous-même, compilez et exécutez ce qui suit sur un appareil Raspberry Pi ou Android exécutant GNUroot

#include<stdio.h>
#define f(x) ((unsigned int(*)(unsigned int))"0\xf\xbf\xe6\x1e\xff/\xe1")(x)
int main(){
  printf( "%u %u\n", 0, f(0) );
  printf( "%u %u\n", 1, f(1) );
  printf( "%u %u\n", 42, f(42) );
  printf( "%u %u\n", 128, f(128) );
  printf( "%u %u\n", 16885952, f(16885952) );
  printf( "%u %u\n", 704643072, f(704643072) );
  printf( "%u %u\n", 3735928559U, f(3735928559U) );
  printf( "%u %u\n", 4009738240U, f(4009738240U) );
  printf( "%u %u\n", 4026531839U, f(4026531839U) );
  printf( "%u %u\n", 4294967295U, f(4294967295U) );
}

Perl 5 , 27 octets

say hex unpack H8,pack I,<>

Essayez-le en ligne!

Perl 5 -p , 21 octets

$_=unpack V,pack N,$_

Essayez-le en ligne!

K4 , 18 octets

Solution:

0b/:,/8#|12 8#0b\:

Exemples:

q)\
  0b/:,/8#|12 8#0b\:0
0
  0b/:,/8#|12 8#0b\:1
16777216
  0b/:,/8#|12 8#0b\:42
704643072
  0b/:,/8#|12 8#0b\:4294967295
4294967295
  0b/:,/8#|12 8#0b\:4026531839
4294967279

Explication:

Il n'y a pas d'entiers non signés, donc la saisie est longue.

Convertir en tableau booléen (64 bits), remodeler, inverser, prendre les 8 premiers octets, reconvertir en long.

0b/:,/8#|12 8#0b\: / the solution
              0b\: / convert to bits
         12 8#     / reshape into 12x8 grid (wraps)
        |          / reverse
      8#           / take first 8
    ,/             / flatten
0b/:               / convert to long

Prime:

Version 19 octets en oK que vous pouvez essayer en ligne!

2/,/8#|12 8#(64#2)\