Như hầu hết các bạn có thể biết, bộ nhớ phần cứng (địa chỉ byte) có thể được chia thành hai loại - endian nhỏ và big endian . Trong các ký ức endian nhỏ, các byte được đánh số bắt đầu bằng 0 ở đầu nhỏ (ít quan trọng nhất) và ở các đầu cuối lớn theo cách khác.

Sự thật thú vị : Những thuật ngữ này dựa trên cuốn sách Gulliver's Travels của Jonathan Swift , nơi vua Lilliputian đã ra lệnh cho công dân của mình phá vỡ trứng của họ ở đầu nhỏ (vì vậy những người cuối cùng nhỏ bé) và phiến quân sẽ phá vỡ chúng ở đầu lớn.

Cách hoán đổi hoạt động

Giả sử chúng ta có một số nguyên không dấu (32 bit) 12648430trong bộ nhớ, trong một máy cuối lớn có thể trông như sau:

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

Bằng cách đảo ngược các byte đặt hàng chúng tôi nhận được số nguyên hệ thập lục phân 0xEEFFC000mà là 4009738240trong hệ thập phân.

Nhiệm vụ của bạn

Viết chương trình / hàm nhận số nguyên 32 bit không dấu trong số thập phân và xuất ra số nguyên kết quả khi hoán đổi độ bền như mô tả ở trên.

Quy tắc

• Đầu vào sẽ luôn nằm trong phạm vi 0để4294967295
• Đầu ra có thể được in thành STDOUT (theo dõi dòng mới / dấu cách là tốt) hoặc trả lại
• Đầu vào và đầu ra là số thập phân
• Hành vi trên đầu vào không hợp lệ là không xác định

Các trường hợp thử nghiệm

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

ngôn ngữ máy x86_32, 3 byte

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

Đây là một chút gian lận. Quy ước gọi đăng ký Pascal (xem Wikipedia ) hơi giống với __fastcall, ngoại trừ nó vượt qua tham số đầu tiên trong eax và eax cũng chứa giá trị trả về. Đó cũng là công việc dọn dẹp, nhưng vì chúng tôi không sử dụng ngăn xếp cho bất cứ thứ gì ngoài con trỏ trở lại, chúng tôi không cần phải làm gì cả. Điều này cho phép chúng tôi tránh một Mov hoặc xchg và chỉ cần sử dụng bswap trực tiếp.

x86_64 ngôn ngữ máy Linux, 5 4 byte

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

Cảm ơn @peter ferrie cho -1.

Hãy thử trực tuyến!

C (gcc), 20, 29 17 byte

@ đề nghị của hvd.

__builtin_bswap32

Hãy thử trực tuyến!

Câu trả lời cũ;

#include<byteswap.h>
bswap_32

bao gồm nên nhập khẩu.

Japt , 10 14 byte

sG ùT8 ò w ¬nG

Thử nó

Giải trình

Chuyển đổi số nguyên đầu vào thành chuỗi cơ sở-16 ( sG), sử dụng 0để đệm bắt đầu với độ dài 8 ( ùT8), tách thành một mảng gồm 2 chuỗi ký tự ( ò), đảo ngược ( w), nối lại thành chuỗi ( ¬) và chuyển đổi trở lại cơ sở- 10 ( nG).

Thạch , 10 byte

⁴4*+b⁹ḊṚḅ⁹

Hãy thử trực tuyến!

Python 2 , 44 byte

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

Hãy thử trực tuyến!

APL + THẮNG 14 byte

256⊥⌽(4⍴256)⊤⎕

Giải trình

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

C # , 70 68 byte

Điều này có lẽ không tối ưu.

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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 24 byte

IntegerReverse[#,256,4]&

Hãy thử trực tuyến!

Đảo ngược đầu vào được hiểu là một số nguyên trong cơ sở 256 với 4 chữ số.

05AB1E , 12 10 byte

3F₁‰R`})₁β

Hãy thử trực tuyến! Giải trình:

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

JavaScript (ES6), 45 43 byte

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

05AB1E , 9 byte

žJ+₁в¦R₁β

Hãy thử trực tuyến!

-1 cảm ơn Neil .

Cổng trả lời Jelly của tôi.

MATL , 12 10 byte

7Y%1Z%P7Z%

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

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

Đã lưu 6 byte với sự giúp đỡ của @ Neil

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

Các trường hợp thử nghiệm

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 byte

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

Hãy thử trực tuyến!

Làm việc trên rút ngắn biểu thức bên tay phải. Tôi nghĩ rằng tôi có thể cạo một vài byte bằng cách làm cho nó hoạt động với phiên bản beta J. Tôi thề tôi đã thấy ở đây rằng bạn có thể kết thúc một chuyến tàu với một danh từ trong phiên bản beta mới ...

Giải trình

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

Chuyển đổi thành 4 chữ số cơ sở 256, đảo ngược các chữ số, sau đó chuyển đổi thành số thập phân. Về cơ bản, thực hiện thuật toán được cung cấp trong OP. Đây có lẽ là lần duy nhất hữu ích khi chuyển đổi cơ sở hỗn hợp của J yêu cầu bạn chỉ định số chữ số, mặc dù nó sẽ ít hơn 2 byte nếu tôi có thể kết thúc chuyến tàu trong một danh từ ( (#:~4#256)thay vào đó).

VBA Excel, ₁₀₃ 92 byte

Hàm cửa sổ tức thời VBE ẩn danh nhận đầu vào từ phạm vi [A1]chuyển thành hex, đảo ngược byte và xuất ra cửa sổ ngay lập tức 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)]

Hội đồng PPC (32-bit), 8 byte

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

Cách thức hoạt động:

• Quy ước gọi PPC đặt tham số từ 32 bit đầu tiên vào SP + 24 và đổ bóng địa chỉ vào GPR3.
• LWBRX nhận tải GPR3 ​​(toán hạng thứ ba) và không mở rộng nó (toán hạng thứ hai) vào EA, sau đó đọc 4 byte theo thứ tự ngược lại và lưu trữ vào GPR3 ​​(toán hạng đầu tiên).
• GPR3 giữ giá trị trả về.
• BLR trả về từ hàm (các nhánh đến địa chỉ trong thanh ghi LR)

Thật không may, không có bất kỳ trình giả lập lắp ráp PPC trực tuyến nào mà tôi có thể tìm thấy để chứng minh. Lấy làm tiếc!

Befunge, 62 61 hoặc 49 byte

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

Hãy thử trực tuyến!

Điều này đang sử dụng Befunge tiêu chuẩn trên trình thông dịch tham chiếu và do đó chúng ta cần tính đến thực tế là các ô nhớ được ký 8 bit và sửa lỗi cho lỗi tràn ký có thể.

Khi triển khai với các ô nhớ không dấu (ví dụ PyFunge) hoặc trong đó phạm vi lớn hơn 8 bit (ví dụ FBBI), chúng ta có thể thoát khỏi mà không cần kiểm tra, tiết kiệm 12 byte.

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

Hãy thử FBBI trực tuyến!
Hãy thử PyFunge trực tuyến!

Mặc dù lưu ý rằng PyFunge có đầu vào số nguyên xử lý lỗi, vì vậy khi kiểm tra trên TIO, bạn cần theo dõi số trong trường đầu vào với dấu cách hoặc dấu cách.

Octave , 10 byte

@swapbytes

Hãy thử trực tuyến!

Đây có thể là lần đầu tiên Octave có cùng số điểm với dẫn xuất golf, MATL. Tất nhiên, trong trường hợp này, đó là Octave có tích hợp, thay vì MATL, làm cho nó dễ dàng hơn nhiều.

Xác định một tay cầm để tích hợp swapbytes, lấy bất kỳ loại dữ liệu nào, hoán đổi độ bền và đưa ra kết quả. Trong trường hợp này, đầu vào là số nguyên không dấu 32 bit.

C #,  44  36 byte

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

Hãy thử trực tuyến!

Điều này ban đầu dựa trên câu trả lời C # của Polynomial , người đề nghị tôi đăng câu trả lời mới với những cải tiến của mình trên đó, nhưng cách tiếp cận trong câu trả lời JavaScript của Arnauld hóa ra còn ngắn hơn trong C #.

R , 86 byte

Tôi nghĩ rằng đã có câu trả lời (hoặc hai) cho R cho câu hỏi này, nhưng tôi chắc chắn đã nhầm lẫn hoặc họ có những vấn đề tương tự mà tôi gặp phải với R không thực hiện ints đã ký. Vấn đề đó đã lấy ra bất kỳ nội dung nào có thể giúp được. Tôi đã thử chuyển đổi cơ sở 256, nhưng cuối cùng nó vẫn dài, nhưng tôi nghĩ vẫn còn chỗ cho một người thông minh hơn tôi để làm điều đó. Sau đó, tôi đã kết thúc với phần sau đây là chuyển đổi cơ sở 2 hoán đổi thứ tự trong hàm đệ quy.

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)

Hãy thử trực tuyến!

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 byte

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

Hãy thử trực tuyến!

Xác nhận tất cả các trường hợp thử nghiệm!

Sử dụng chuyển đổi cơ sở 256 như MickyT đề xuất ở đây . R không có số nguyên 32 bit không dấu, cũng không có số nguyên 64 bit. Điều này ngăn chúng tôi sử dụng các thao tác bitwise nhưng cách tiếp cận này (và có thể là của MickyT) có thể vẫn còn ngắn hơn vì các toán tử bitwise của R khá dài dòng.

Sử dụng số 4 của mẹo này , có tính đến việc chúng tôi không bao giờ nhận được số lượng lớn như256^4 .

n%/%256^(0:3)%%256trích xuất các byte và %*%, sản phẩm ma trận, là sản phẩm dấu chấm trong tình huống này, với 256^(3:0)hiệu ứng thứ tự đảo ngược của byte. %*%sẽ trả về 1x1 matrixchứa giá trị đảo ngược về cuối.

Lắp ráp CP-1610 , 6 DECLE = 8 byte

Mã này được dự định để chạy trên Intellivision .

Opcode CP-1610 được mã hóa với giá trị 10 bit, được gọi là 'DECLE'. Chức năng này dài 6 DECLE, bắt đầu từ $ 480C và kết thúc ở mức $ 4811.

CP-1610 có các thanh ghi 16 bit, vì vậy chúng tôi đang sử dụng hai trong số chúng (R0 và R1) để lưu trữ giá trị 32 bit.

                               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

Đổ rác

 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 byte

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

Hãy thử trực tuyến!

+31 cho using System;using System.Linq;

Tôi đã hy vọng sử dụng Array.Reversenội tuyến, nhưng nó đã không được (xem thay thế bên dưới).

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

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

Hãy thử trực tuyến!

+13 cho using System;

Giải pháp này chăm sóc @JeppeStigNielsen; loại bỏ hạn chế có tất cả mọi thứ lưu trong 3 byte.

REXX , 42 byte

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

Hãy thử trực tuyến!

Ung dung:

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 byte

{(n:UInt32)in n.byteSwapped}

Ngôn ngữ máy ARM Linux, 8 byte

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

Để tự mình thử, hãy biên dịch và chạy phần sau trên thiết bị Raspberry Pi hoặc Android chạy 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 byte

say hex unpack H8,pack I,<>

Hãy thử trực tuyến!

Perl 5 -p , 21 byte

$_=unpack V,pack N,$_

Hãy thử trực tuyến!

K4 , 18 byte

Dung dịch:

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

Ví dụ:

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

Giải trình:

Không có ints không dấu, vì vậy mất đầu vào là một thời gian dài.

Chuyển đổi thành mảng boolean (64 bit), định hình lại, đảo ngược, lấy 8 byte đầu tiên, chuyển đổi trở lại dài.

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

Tiền thưởng:

Phiên bản 19 byte trong oK mà bạn có thể thử trực tuyến!

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