Jak zapewne większość z was wie, pamięć sprzętową (adresowalną bajtowo) można podzielić na dwie kategorie - little-endian i big-endian . W pamięciach little-endian bajty są ponumerowane zaczynając od 0 na małym (najmniej znaczącym) końcu, a w big-endian na odwrót.

Ciekawostka : Warunki te oparte są na książce Jonathana Swifta Podróż Guliwera, w której król Lilliputian nakazał swoim obywatelom rozbić jaja na małym końcu (a więc na małych endianach), a rebelianci rozbili ich na wielkim końcu.

Jak działa zamiana

Załóżmy, że mamy 12648430w pamięci liczbę całkowitą bez znaku (32-bitową) w maszynie typu big-endian, która może wyglądać następująco:

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

Odwracając kolejność bajtów, otrzymujemy liczbę szesnastkową, 0xEEFFC000która jest 4009738240dziesiętna.

Twoje zadanie

Napisz program / funkcję, która odbiera 32-bitową liczbę całkowitą bez znaku w systemie dziesiętnym i wyświetla wynikową liczbę całkowitą podczas zamiany endianizmu, jak opisano powyżej.

Zasady

• Dane wejściowe zawsze będą w zakresie 0do4294967295
• Dane wyjściowe można wydrukować do STDOUT (końcowe znaki nowej linii / spacje są w porządku) lub zwrócić
• Dane wejściowe i wyjściowe są dziesiętne
• Zachowanie w przypadku nieprawidłowych danych wejściowych pozostaje niezdefiniowane

Przypadki testowe

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

język maszynowy x86_32, 3 bajty

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

To trochę oszustwo. Konwencja wywoływania rejestru Pascal (patrz Wikipedia ) jest trochę podobna do __fastcall, z tym wyjątkiem, że przekazuje pierwszy parametr w eax, a eax zawiera również wartość zwracaną. Jest to również czyszczenie callee, ale ponieważ nie używamy stosu do niczego innego niż wskaźnik powrotu, nie musimy nic robić. To pozwala nam uniknąć mov lub xchg i po prostu użyć bswap bezpośrednio.

x86_64 język maszynowy Linux, 5 4 bajtów

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

Dzięki @peter ferrie za -1.

Wypróbuj online!

C (gcc), 20, 29 17 bajtów

sugestia @ hvd.

__builtin_bswap32

Wypróbuj online!

Stara odpowiedź;

#include<byteswap.h>
bswap_32

należy dołączyć.

Japt , 10 14 bajtów

sG ùT8 ò w ¬nG

Spróbuj

Wyjaśnienie

Konwertuj wejściową liczbę całkowitą na ciąg 16 ( sG), użyj, 0aby wstawić początek na długość 8 ( ùT8), podziel na tablicę 2 ciągów znaków ( ò), reverse ( w), połącz ponownie w ciąg ( ¬) i przekonwertuj z powrotem na base- 10 ( nG).

Galaretka , 10 bajtów

⁴4*+b⁹ḊṚḅ⁹

Wypróbuj online!

Python 2 , 44 bajty

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

Wypróbuj online!

APL + WIN 14 bajtów

256⊥⌽(4⍴256)⊤⎕

Wyjaśnienie

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

C # , 70 68 bajtów

To prawdopodobnie nie jest optymalne.

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

Wypróbuj online!

Wolfram Language (Mathematica) , 24 bajty

IntegerReverse[#,256,4]&

Wypróbuj online!

Odwraca wejście interpretowane jako liczba całkowita w podstawie 256 z 4 cyframi.

05AB1E , 12 10 bajtów

3F₁‰R`})₁β

Wypróbuj online! Wyjaśnienie:

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

JavaScript (ES6), 45 43 bajtów

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

05AB1E , 9 bajtów

žJ+₁в¦R₁β

Wypróbuj online!

-1 dzięki Neilowi .

Port mojej galaretki odpowiedzi.

MATL , 12 10 bajtów

7Y%1Z%P7Z%

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie

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

Zapisano 6 bajtów z pomocą @ Neila

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

Przypadki testowe

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

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

Wypróbuj online!

Praca nad skróceniem ekspresji prawej ręki. Myślę, że mogę zmniejszyć liczbę bajtów, wprowadzając tę ​​wersję w wersji beta J. Przysięgam, widziałem tutaj, że możesz zakończyć pociąg rzeczownikiem w nowej wersji beta ...

Wyjaśnienie

|.&.((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

Konwertuj na 4 cyfry, podstawa 256, odwróć cyfry, a następnie przekonwertuj z powrotem na dziesiętne. Zasadniczo wykonaj algorytm podany w OP. Być może jest to jeden raz, kiedy pomocne jest, aby mieszana konwersja bazy J wymagała określenia liczby cyfr, chociaż byłoby to o 2 mniej bajtów, gdybym mógł zakończyć pociąg rzeczownikiem ( (#:~4#256)zamiast tego).

Excel VBA, ₁₀₃ 92 bajtów

Anonimowa funkcja bezpośredniego okna VBE, która pobiera dane wejściowe z zakresu [A1]do postaci szesnastkowej, odwraca bajty i wysyła dane do bezpośredniego okna 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)]

Zestaw PPC (32-bit), 8 bajtów

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

Jak to działa:

• Konwencja wywoływania PPC umieszcza pierwszy 32-bitowy parametr słowa w SP + 24, a cienie zwracają się do GPR3.
• LWBRX pobiera ładunek GPR3 ​​(trzeci operand) i zeruje go (drugi operand) do EA, a następnie odczytuje 4 bajty w odwrotnej kolejności i przechowuje go w GPR3 ​​(pierwszy operand).
• GPR3 przechowuje wartość zwracaną.
• BLR powraca z funkcji (rozgałęzia się na adres w rejestrze LR)

Niestety nie ma żadnych emulatorów asemblera PPC w Internecie, które mógłbym wykazać. Przepraszam!

Befunge, 62 61 lub 49 bajtów

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

Wypróbuj online!

Korzysta to ze standardowego Befunge na interpretatorze referencyjnym, dlatego musimy wziąć pod uwagę fakt, że komórki pamięci są podpisane 8-bitowo i poprawić ewentualne przepełnienie podpisu.

W implementacjach z niepodpisanymi komórkami pamięci (np. PyFunge) lub gdy zasięg jest większy niż 8 bitów (np. FBBI), możemy uciec bez tych kontroli, oszczędzając 12 bajtów.

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

Wypróbuj FBBI online!
Wypróbuj PyFunge online!

Chociaż zauważ, że PyFunge ma błąd przetwarzania liczb całkowitych, więc podczas testowania na TIO musisz podążać za liczbą w polu wprowadzania ze spacją lub łamaniem linii.

Oktawa , 10 bajtów

@swapbytes

Wypróbuj online!

To może być pierwszy raz, gdy Octave ma dokładnie taki sam wynik jak jego golfowa pochodna, MATL. Oczywiście w tym przypadku to Octave ma wbudowane, a nie MATL, co znacznie ułatwia.

Definiuje uchwyt do wbudowanego swapbytes, który przyjmuje dowolny typ danych, zamienia endianness i wyświetla wynik. W tym przypadku wejściem jest 32-bitowa liczba całkowita bez znaku.

DO#,  44  36 bajtów

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

Wypróbuj online!

Pierwotnie było to oparte na odpowiedzi C # firmy Polynomial , która zasugerowała opublikowanie nowej odpowiedzi z moimi ulepszeniami, ale podejście zastosowane w odpowiedzi JavaScript Arnaulda okazało się jeszcze krótsze w języku C #.

R , 86 bajtów

Myślałem, że w R jest już odpowiedź (lub dwie) na to pytanie, ale musiałem się pomylić lub mieli te same problemy, które miałem z R, że nie robiłem podpisanych int. Ten problem usunął wszystkie wbudowane elementy, które mogłyby pomóc. Próbowałem konwersji 256 bazowej, ale zakończyło się to zbyt długo, ale myślę, że jest jeszcze miejsce dla kogoś mądrzejszego ode mnie. Potem skończyło się na tym, że konwersja base 2 zamienia kolejność w funkcji rekurencyjnej.

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)

Wypróbuj online!

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

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

Wypróbuj online!

Sprawdź wszystkie przypadki testowe!

Używa base-256 konwersję jako MickyT sugerowanej tutaj . R nie ma 32-bitowych liczb całkowitych bez znaku ani 64-bitowych liczb całkowitych. To uniemożliwia nam korzystanie z operacji bitowych, ale to podejście (i prawdopodobnie MickyT) jest prawdopodobnie jeszcze krótsze, ponieważ operatory bitowe R są dość gadatliwe.

Wykorzystuje numer 4 tej wskazówki , biorąc pod uwagę, że nigdy nie otrzymamy liczby tak dużej jak 256^4.

n%/%256^(0:3)%%256wyodrębnia bajty, a %*%iloczyn macierzowy jest iloczynem kropkowym w tej sytuacji, z 256^(3:0)zachowaniem odwróconej kolejności bajtów. %*%zwróci 1x1 matrixzawierający wartość odwróconą przez endian.

Zespół CP-1610 , 6 DECLE = 8 bajtów

Ten kod jest przeznaczony do uruchamiania na Intellivision .

Kod operacji CP-1610 jest kodowany za pomocą 10-bitowej wartości, zwanej „DECLE”. Ta funkcja ma 6 DECLE długości, zaczynając od 480 $ C, a kończąc na 4811 $.

CP-1610 ma rejestry 16-bitowe, więc używamy dwóch z nich (R0 i R1) do przechowywania wartości 32-bitowej.

                               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

Zrzut wykonania

 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 bajty

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

Wypróbuj online!

+31 za using System;using System.Linq;

Miałem nadzieję użyć Array.Reverseinline, ale tak nie było (patrz alternatywa poniżej).

C # (.NET Core) , 87 + 13 = 100 bajtów

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

Wypróbuj online!

+13 dla using System;

To rozwiązanie obsługuje @JeppeStigNielsen; usunięcie ograniczenia polegającego na tym, że wszystko w linii zostało zapisane 3 bajty.

REXX , 42 bajty

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

Wypróbuj online!

Nie golfowany:

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

Szybki, 28 bajtów

{(n:UInt32)in n.byteSwapped}

Język maszynowy ARM Linux, 8 bajtów

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

Aby wypróbować to samodzielnie, skompiluj i uruchom poniższe na urządzeniu Raspberry Pi lub Android z systemem 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 bajtów

say hex unpack H8,pack I,<>

Wypróbuj online!

Perl 5 -p , 21 bajtów

$_=unpack V,pack N,$_

Wypróbuj online!

K4 , 18 bajtów

Rozwiązanie:

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

Przykłady:

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

Wyjaśnienie:

Nie ma żadnych znaków całkowitych bez znaku, więc dane wejściowe są tak długie.

Konwertuj na tablicę boolowską (64 bity), przekształcaj, odwracaj, bierz pierwsze 8 bajtów, konwertuj z powrotem na długie.

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

Premia:

Wersja 19-bajtowa w OK, którą możesz wypróbować online!

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