เป็นที่สุดของคุณอาจจะรู้ (ไบต์แอดเดรส) ความทรงจำฮาร์ดแวร์สามารถแบ่งออกเป็นสองประเภท - น้อย endianและbig- ในความทรงจำเล็ก ๆ น้อย ๆ bytes จะถูกกำหนดหมายเลขเริ่มต้นด้วย 0 ที่จุดสิ้นสุด (สำคัญน้อยที่สุด) และในทางกลับกันขนาดใหญ่

ข้อเท็จจริงที่สนุกสนาน : ข้อตกลงนี้มีพื้นฐานมาจากหนังสือGulliver's Travels ของJonathan Swiftที่ซึ่งกษัตริย์ Lilliputian สั่งให้ประชาชนของเขาทำลายไข่ของพวกเขาในตอนจบเล็ก ๆ

การแลกเปลี่ยนทำงานอย่างไร

สมมติว่าเรามีจำนวนเต็มไม่ได้ลงนาม (32 บิต) 12648430ในหน่วยความจำในเครื่องขนาดใหญ่ที่อาจมีลักษณะดังนี้:

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

โดยการกลับคำสั่ง byte เราได้รับจำนวนเต็มฐานสิบหก0xEEFFC000ซึ่งเป็น4009738240ทศนิยม

งานของคุณ

เขียนโปรแกรม / ฟังก์ชั่นที่ได้รับจำนวนเต็ม 32 บิตที่ไม่ได้ลงนามเป็นทศนิยมและส่งออกจำนวนเต็มผลลัพธ์เมื่อสลับ endianness ตามที่อธิบายไว้ข้างต้น

กฎระเบียบ

• ข้อมูลที่ป้อนจะอยู่ในช่วง0ถึง4294967295
• สามารถพิมพ์เอาต์พุตไปที่ STDOUT (ลากขึ้นบรรทัดใหม่ / เว้นช่องว่างได้) หรือส่งคืน
• อินพุตและเอาต์พุตเป็นทศนิยม
• พฤติกรรมของอินพุตที่ไม่ถูกต้องนั้นไม่มีการกำหนด

กรณีทดสอบ

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

x86_32 ภาษาเครื่อง 3 ไบต์

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

นี่คือการโกงเล็กน้อย แบบแผนการเรียกใช้การลงทะเบียน Pascal (ดูWikipedia ) เป็นบิตเช่น __ fastcall ยกเว้นว่าจะผ่านพารามิเตอร์แรกใน eax และ eax ยังมีค่าส่งคืน นอกจากนี้ยังเป็นการทำความสะอาดแบบ callee ด้วย แต่เนื่องจากเราไม่ได้ใช้สแต็คสำหรับสิ่งอื่นใดนอกจากตัวชี้คืนเราจึงไม่จำเป็นต้องทำอะไรเลย สิ่งนี้ทำให้เราสามารถหลีกเลี่ยง mov หรือ xchg และใช้ bswap โดยตรง

x86_64 ภาษาเครื่อง Linux, 5 4 ไบต์

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

ขอบคุณ@peter ferrieสำหรับ -1

ลองออนไลน์!

C (gcc) 20, 29 17 ไบต์

คำแนะนำของ @ hvd

__builtin_bswap32

ลองออนไลน์!

คำตอบเก่า ๆ

#include<byteswap.h>
bswap_32

ควรรวมการนำเข้า

Japt , 10 14 ไบต์

sG ùT8 ò w ¬nG

ลองมัน

คำอธิบาย

แปลงจำนวนเต็มอินพุตให้เป็นสตริงฐาน -16 ( sG) ใช้0เพื่อแพ็ตเริ่มต้นจนถึงความยาว 8 ( ùT8) แบ่งเป็นอาร์เรย์ของสตริงอักขระ 2 ตัว ( ò) ย้อนกลับ ( w) กลับเข้าสู่สตริง ( ¬) และแปลงกลับเป็นเบส - 10 ( nG)

เยลลี่ 10 ไบต์

⁴4*+b⁹ḊṚḅ⁹

ลองออนไลน์!

Python 2 , 44 ไบต์

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

ลองออนไลน์!

APL + ชนะ 14 ไบต์

256⊥⌽(4⍴256)⊤⎕

คำอธิบาย

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

C # , 70 68 ไบต์

นี่อาจไม่เหมาะสม

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

ลองออนไลน์!

ภาษา Wolfram (Mathematica)ขนาด 24 ไบต์

IntegerReverse[#,256,4]&

ลองออนไลน์!

ย้อนกลับอินพุตที่ตีความว่าเป็นจำนวนเต็มในฐาน 256 ที่มีตัวเลข 4 หลัก

05AB1E , 12 10 ไบต์

3F₁‰R`})₁β

ลองออนไลน์! คำอธิบาย:

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

JavaScript (ES6), 45 43 ไบต์

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

05AB1E , 9 ไบต์

žJ+₁в¦R₁β

ลองออนไลน์!

-1 ต้องขอบคุณนีลนีล

พอร์ตคำตอบของเยลลี่ของฉัน

MATL , 12 10 ไบต์

7Y%1Z%P7Z%

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมดตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย

        % 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 ไบต์

บันทึก 6 ไบต์ด้วยความช่วยเหลือของ @ Neil

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

กรณีทดสอบ

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 ไบต์

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

ลองออนไลน์!

ทำงานเพื่อย่อนิพจน์ทางขวาให้สั้นลง ฉันคิดว่าฉันสามารถโกนทิ้งได้สองสามไบต์ด้วยการทำให้งานนี้เป็นรุ่นเบต้า J ฉันสาบานที่ฉันเห็นที่นี่ว่าคุณสามารถจบการรถไฟด้วยคำนามในรุ่นเบต้าใหม่ ...

คำอธิบาย

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

แปลงเป็นตัวเลข 4 หลัก 256 แปลงกลับตัวเลขแล้วแปลงกลับเป็นทศนิยม โดยทั่วไปให้ทำอัลกอริทึมที่ให้ไว้ใน OP นี่อาจเป็นครั้งเดียวที่มีประโยชน์ที่การแปลงฐานแบบผสมของ J ต้องการให้คุณระบุจำนวนหลักแม้ว่ามันจะน้อยกว่า 2 ไบต์ถ้าฉันสามารถจบขบวนรถไฟด้วยคำนาม ( (#:~4#256)แทน)

Excel VBA, ₁₀₃ 92 ไบต์

ฟังก์ชั่นหน้าต่างแบบไม่ระบุชื่อ VBE ทันทีที่รับอินพุตจากช่วง[A1]แปลงเป็นฐานสิบหกย้อนกลับไบต์และส่งออกไปยังหน้าต่างทันที 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)]

PPC Assembly (32- บิต), 8 ไบต์

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

มันทำงานอย่างไร:

• การประชุม PPC ที่เรียกว่าใส่พารามิเตอร์คำ 32- บิตแรกลงใน SP + 24 และเงาที่อยู่ใน GPR3
• LWBRXรับภาระ GPR3 ​​(ตัวถูกดำเนินการตัวที่สาม) และ zero-extend (ตัวถูกดำเนินการตัวที่สอง) ลงใน EA จากนั้นอ่าน 4 ไบต์ในลำดับย้อนกลับและเก็บไว้ใน GPR3 ​​(ตัวถูกดำเนินการครั้งแรก)
• GPR3 เก็บค่าส่งคืน
• BLR ส่งคืนจากฟังก์ชัน (สาขาไปยังที่อยู่ในการลงทะเบียน LR)

น่าเสียดายที่ไม่มีอีมูเลเตอร์ PPC แบบออนไลน์ที่ฉันสามารถแสดงให้เห็นได้ ขออภัย!

Befunge, 62 61 หรือ 49 ไบต์

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

ลองออนไลน์!

นี่คือการใช้ Befunge มาตรฐานกับล่ามอ้างอิงและเราจำเป็นต้องพิจารณาว่าเซลล์หน่วยความจำมีการลงนามแบบ 8 บิตและถูกต้องสำหรับการล้นที่มีการลงชื่อ

ในการใช้งานกับเซลล์หน่วยความจำที่ไม่ได้ลงนาม (เช่น PyFunge) หรือช่วงที่มีค่ามากกว่า 8 บิต (เช่น FBBI) เราสามารถออกไปได้โดยไม่ต้องมีการตรวจสอบเหล่านั้นประหยัด 12 ไบต์

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

ลอง FBBI ออนไลน์!
ลอง PyFunge ออนไลน์!

แม้ว่าโปรดทราบว่า PyFunge มีการป้อนข้อมูลเป็นจำนวนเต็มในการประมวลผลบั๊กดังนั้นเมื่อทำการทดสอบกับ TIO คุณจะต้องติดตามตัวเลขในช่องป้อนข้อมูลด้วยช่องว่างหรือตัวแบ่งบรรทัด

เสียงคู่แปดฟ 10 ไบต์

@swapbytes

ลองออนไลน์!

นี่อาจเป็นครั้งแรกที่ Octave มีคะแนนเท่ากันกับ MATLAB แน่นอนในกรณีนี้มันเป็นอ็อกเทฟที่มีในตัวมากกว่า MATL ทำให้ง่ายขึ้นมาก

กำหนดหมายเลขอ้างอิงให้กับบิวด์อินswapbytesซึ่งใช้ชนิดข้อมูลใด ๆ สับเปลี่ยน endianness และแสดงผลลัพธ์ ในกรณีนี้อินพุตเป็นจำนวนเต็มที่ไม่ได้ลงชื่อ 32 บิต

ค#,  44  36 ไบต์

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

ลองออนไลน์!

เดิมนี้ใช้คำตอบ C # ของ Polynomialซึ่งแนะนำให้ฉันโพสต์คำตอบใหม่ด้วยการปรับปรุงของฉัน แต่วิธีการที่ใช้ในคำตอบ JavaScript ของ Arnauldกลายเป็นสั้นกว่าใน C #

R , 86 ไบต์

ฉันคิดว่ามีคำตอบ (หรือสอง) ใน R สำหรับคำถามนี้ แต่ฉันต้องเข้าใจผิดหรือพวกเขามีปัญหาแบบเดียวกับที่ฉันมีกับ R ที่ไม่ได้ลงนามใน ints ปัญหานั้นได้สร้างตัวอาคารที่สามารถช่วยได้ ฉันลองใช้การแปลงฐาน 256 แต่มันจบลงด้วยความยาว แต่ฉันคิดว่ายังมีห้องสำหรับคนที่ฉลาดกว่าฉันที่จะทำเช่นนั้น จากนั้นฉันก็ลงเอยด้วยสิ่งต่อไปนี้ซึ่งมันเป็นการแปลงเบส 2 ที่เปลี่ยนลำดับในฟังก์ชั่นวนซ้ำ

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)

ลองออนไลน์!

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 ไบต์

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

ลองออนไลน์!

ตรวจสอบกรณีทดสอบทั้งหมด!

ใช้การแปลงฐาน 256 ตามที่ MickyT แนะนำที่นี่ที่นี่R ไม่มีจำนวนเต็ม 32 บิตที่ไม่ได้ลงชื่อและไม่มีจำนวนเต็ม 64 บิต สิ่งนี้ทำให้เราไม่สามารถใช้การดำเนินงานระดับบิตได้ แต่วิธีนี้ (และอาจเป็นไปได้ว่า MickyT) อาจยังสั้นกว่าเนื่องจากตัวดำเนินการระดับบิตของ R นั้นค่อนข้างละเอียด

ใช้หมายเลข 4 ของเคล็ดลับนี้โดยคำนึงว่าเราไม่เคยได้รับตัวเลขที่มีขนาดใหญ่เท่า256^4คำนึงถึงว่าเราไม่เคยได้รับเป็นจำนวนมากมีขนาดใหญ่เป็น

n%/%256^(0:3)%%256แยกไบต์และ%*%ผลิตภัณฑ์เมทริกซ์เป็นผลิตภัณฑ์ดอทในสถานการณ์นี้โดยมี256^(3:0)ผลต่อลำดับที่กลับเป็นไบต์ %*%จะส่งคืน 1x1 matrixที่มีค่า endian-reverse

ชุดประกอบCP-1610 , 6 DECLEs = 8 ไบต์

รหัสนี้มีวัตถุประสงค์เพื่อให้ทำงานบนIntellivision Intellivision

CP-1610 opcode ถูกเข้ารหัสด้วยค่า 10 บิตหรือที่เรียกว่า 'DECLE' ฟังก์ชันนี้มีความยาว 6 DECLE เริ่มต้นที่ $ 480C และสิ้นสุดที่ $ 4811

CP-1610 มีการลงทะเบียน 16 บิตดังนั้นเราจึงใช้สองรายการ (R0 และ R1) เพื่อจัดเก็บค่า 32- บิต

                               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

การถ่ายโอนข้อมูลการดำเนินการ

 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 ไบต์

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

ลองออนไลน์!

+31 สำหรับ using System;using System.Linq;

ฉันหวังว่าจะใช้Array.Reverseอินไลน์ แต่ก็ไม่เป็นเช่นนั้น (ดูทางเลือกด้านล่าง)

C # (. NET Core) , 87 + 13 = 100 ไบต์

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

ลองออนไลน์!

+13 สำหรับ using System;

โซลูชันนี้ดูแล @JeppeStigNielsen; ลบข้อ จำกัด ของการมีทุกอย่างที่บันทึกไว้แบบอินไลน์ 3 ไบต์

REXX , 42 ไบต์

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

ลองออนไลน์!

Ungolfed:

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 ไบต์

{(n:UInt32)in n.byteSwapped}

ARM ภาษาเครื่อง Linux, 8 ไบต์

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

ในการลองด้วยตัวเองให้รวบรวมและเรียกใช้สิ่งต่อไปนี้บนอุปกรณ์ Raspberry Pi หรือ Android ที่ใช้ 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 ไบต์

say hex unpack H8,pack I,<>

ลองออนไลน์!

Perl 5 -p , 21 ไบต์

$_=unpack V,pack N,$_

ลองออนไลน์!

K4 , 18 ไบต์

วิธีการแก้:

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

ตัวอย่าง:

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

คำอธิบาย:

ไม่มี ints ที่ไม่ได้ลงชื่อดังนั้นใช้อินพุตเป็นเวลานาน

แปลงเป็นบูลีนอาร์เรย์ (64 บิต) ปรับรูปร่างย้อนกลับใช้เวลา 8 ไบต์แรกแปลงกลับเป็นยาว

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

โบนัส:

เวอร์ชัน19 ไบต์ในOKซึ่งคุณสามารถลองออนไลน์ได้!

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