Tauschen Sie die Endianness

20

Wie die meisten von Ihnen wahrscheinlich wissen, können (byteadressierbare) Hardwarespeicher in zwei Kategorien unterteilt werden - Little Endian und Big Endian . In Little-Endian-Speichern werden die Bytes beginnend mit 0 am kleinen (niedrigstwertigen) Ende und in Big-Endian-Speichern umgekehrt nummeriert.

Wissenswertes : Diese Begriffe basieren auf Jonathan Swifts Buch Gullivers Reisen, in dem der lilliputanische König seinen Bürgern befahl, ihre Eier am kleinen Ende zu zerbrechen (also die Little Endians) und die Rebellen am großen Ende.

So funktioniert Tauschen

Angenommen, wir haben eine vorzeichenlose Ganzzahl (32 Bit) 12648430im Speicher in einer Big-Endian-Maschine, die wie folgt aussehen könnte:

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

Durch Invertieren der Bytereihenfolge erhalten wir die hexadezimale Ganzzahl, 0xEEFFC000die 4009738240dezimal ist.

Deine Aufgabe

Schreiben Sie ein Programm / eine Funktion, die eine 32-Bit-Ganzzahl ohne Vorzeichen als Dezimalzahl empfängt und die sich ergebende Ganzzahl beim Tauschen der Endianze wie oben beschrieben ausgibt.

Regeln

  • Die Eingabe wird immer im Bereich von 0bis liegen4294967295
  • Die Ausgabe kann auf STDOUT gedruckt (nachgestellte Zeilenumbrüche / Leerzeichen sind in Ordnung) oder zurückgegeben werden
  • Eingabe und Ausgabe erfolgen dezimal
  • Verhalten bei ungültiger Eingabe bleibt undefiniert

Testfälle

0 -> 0
1 -> 16777216
42 -> 704643072
128 -> 2147483648
12648430 -> 4009738240
16885952 -> 3232235777
704643072 -> 42
3735928559 -> 4022250974
4009738240 -> 12648430
4026531839 -> 4294967279
4294967295 -> 4294967295
code-golf  number  integer  hexadecimal 
— ბიმო
quelle
Bedeutet "Eingabe und Ausgabe sind dezimal" für eine Funktionsantwort, dass entweder eine Folge von Ziffernzeichen oder ein Array von Ziffernwerten erforderlich ist? Oder kann eine Funktionsantwort die natürliche Ganzzahldarstellung ihrer Sprache verwenden, die in den meisten Fällen absolut nichts mit "Dezimal" zu tun hat?
— Aschepler
1
@aschepler Der ganzzahlige Wert der Sprache, z. 42wird dezimal angegeben, ist aber technisch gesehen beispielsweise in C binär. Sie können natürlich eingeben 0x2a, was ich verhindern wollte, ist die Eingabe als Zeichenfolge "2a"oder dergleichen.
— 25.
Verwandte (da diese Herausforderung nur sicherstellt, dass zuerst 32 Bit
— aufgefüllt werden

Antworten:

25

x86_32-Maschinensprache, 3 Byte

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

Das ist ein kleiner Betrug. Die Aufrufkonvention für Pascal-Register (siehe Wikipedia ) ist ein bisschen wie __fastcall, außer dass sie den ersten Parameter in eax übergibt und eax auch den Rückgabewert enthält. Es ist auch eine Aufräumaktion, aber da wir den Stack nur für den Rückgabezeiger verwenden, müssen wir nichts tun. Dies ermöglicht es uns, ein mov oder xchg zu vermeiden und einfach bswap direkt zu verwenden.

— Polynom
quelle
bswap
— Vielleicht
@ceilingcat Sehr wahr, obwohl ich mir sicher bin, dass dies aufgrund von Compiler- oder Toolchain-Einschränkungen implizit bei vielen anderen Lösungen der Fall ist!
— Polynom
10

x86_64 Maschinensprache Linux, 5 4 Bytes

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

Danke an @peter ferrie für -1.

Probieren Sie es online!

— Ceilingcat
quelle
Das ist kein dezimaler Rückgabewert. Ich denke nicht, dass das zählt. Außerdem können Sie xchg edi, eax für 4 Bytes.
— Peter Ferrie
@peterferrie Wow, ich habe gerade auf Ihrer Website nach PE-Headern gesucht.
— Ceilingcat
6

Japt , 10 14 Bytes

sG ùT8 ò w ¬nG

Versuch es

Erläuterung

Wandle eine ganze Zahl in eine Zeichenfolge zur Basis 16 ( sG) um 0, fülle den Anfang mit einer Länge von 8 ( ùT8) auf, teile ihn in ein Array mit 2 Zeichenfolgen ( ò) auf, kehre ( w) um, verbinde ihn wieder mit einer Zeichenfolge ( ¬) und wandle ihn zurück in eine Zeichenfolge zur Basis 16 ( ). 10 ( nG).

— Zottelig
quelle
Sie wissen, was eine nützliche Funktion sein könnte, ist, dass Sie mehr Funktionen wie ydiese haben, wenn Sie einer Funktion eine Funktion zuweisen, ihre normale Transformation anwenden, die Funktion ausführen und dann die Transformation invertieren. In diesem Fall würde es meiner Meinung nach sG_ò w ¬für 8 Bytes gekürzt werden können . Oder wenn òes auch so wäre, könnte es sogar sG_ò2_wfür 7 sein ...
— ETHproductions
@ETHproductions Ich unterstütze es; Das Under- &.Adverb in J macht das und es ist manchmal sehr hilfreich beim Golfen. Das Codieren in allen Inversionen kann jedoch mühsam sein.
— Cole
@ETHproductions: je mehr "überladen", desto besser :) Ich schrieb dies beim Ziehen von Pints ​​und hatte ursprünglich sG_òw..., konnte für das Leben von mir nicht herausfinden, warum es nicht funktionieren würde! Ich habe meine Fehler irgendwann gemerkt!
— Shaggy
Scheint nicht für Eingaben unter 2 << 24 ... zu funktionieren
— Neil
Danke, @Neil; wird später behoben. Sieht so aus, als würde es mich 4 Bytes kosten.
— Shaggy
5

APL + WIN 14 Bytes

256⊥⌽(4⍴256)⊤⎕

Erläuterung

⎕ prompt for screen input
(4⍴256)⊤ 4 byte representation in base 256
⌽ reverse bytes
256⊥ bytes from base 256 to integer
— Graham
quelle
1
Würde 256⊥⌽⎕⊤⍨4⍴256für -1 Byte arbeiten?
— Erik der Outgolfer
Der Operator ⍨ ist in APL + WIN nicht verfügbar, daher lautet die Antwort "Nein", könnte aber für Dyalog APL
— Graham,
5

C # , 70 68 Bytes

Dies ist wahrscheinlich nicht 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;}

Probieren Sie es online!

— Polynom
quelle
Sie können die Zuweisung in den returnAusdruck verschieben und dann die Member-Syntax mit Ausdruck verwenden: uint e(uint n)=>((n=n>>16|n<<16)&0xFF00FF00)>>8|(n&0xFF00FF)<<8;für 64 Bytes.
— HDV
@hvd Dies wird für mich nicht als gültige Ausdruckssyntax angezeigt. Ich war jedoch in der Lage, den Umlagerungstrick zu verwenden, um 2 Bytes weg zu rasieren.
— Polynom
Ich habe aus meinem Kommentar kopiert und in Ihren TIO-Link eingefügt, um sicherzustellen, dass es keine Tippfehler oder ähnliches gibt, und genau so, wie es in meinem Kommentar ist, funktioniert es: TIO-Link
— DVD
Mir ist aufgefallen, dass 0xFF00FF00 die Ergänzung zu 0xFF00FF ist, und ich frage mich, ob Sie dies nutzen können. Das Deklarieren einer Variablen
— erfordert jedoch
Oh! Gut, um die Konstanten tatsächlich zu überprüfen: Sie können sie 0xFF00FFzweimal verwenden, indem >>Sie sie vorher &eingeben, und Sie können sie dann 0xFF00FFauf ~0u/257: uint e(uint n)=>((n=n>>16|n<<16)>>8&~0u/257)|(n&~0u/257)<<8;für 60 verkürzen . TIO link
— hvd
4

05AB1E , 12 10 Bytes

3F₁‰R`})₁β

Probieren Sie es online! Erläuterung:

  ₁         Integer constant 256
   ‰        [Div, Mod]
    R       Reverse
     `      Flatten to stack
3F    }     Repeat 3 times
       )    Collect results
        ₁β  Convert from base 256
— Neil
quelle
1
Dies scheint keine gültige Lösung zu sein. Das "Auffüllen", das Sie tun, wiederholt tatsächlich die Liste der Bytes mit der Länge 4.
— Erik the Outgolfer
@EriktheOutgolfer Bah, ich wünschte, die Dokumentation würde tatsächlich sagen, dass ...
— Neil
3

JavaScript (ES6), 45 43 Byte

f=(n,p=0,t=4)=>t?f(n>>>8,p*256+n%256,t-1):p
— ETHproductions
quelle
1
Beginnend mit t=0speichert 2 Bytes:f=(n,p=t=0)=>t++<4?f(n>>>8,p*256+n%256):p
— Arnauld
3

MATL , 12 10 Bytes

7Y%1Z%P7Z%

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

        % 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
— Luis Mendo
quelle
2

JavaScript (ES6), 51 bis 45 Byte

6 Bytes mit Hilfe von @ Neil gespeichert

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

Testfälle

Code-Snippet anzeigen

— Arnauld
quelle
Schön, das beste was ich mit Rekursion bekommen konnte war f=(n,p=0,t=4)=>t?f(n/256|0,p*256+n%256,t-1):p.
— ETHproductions
@ETHproductions ... das ist kürzer?
— Erik der Outgolfer 25.11.17 um 17:57
1
@ETHproductions Das ist definitiv kürzer. Du solltest es posten.
— Arnauld
46 Bytes:n=>(n>>>24|n>>8&65280|n<<8&16711680|n<<24)>>>0
— Neil
1
@hvd Keine Sorge. Sie können es entweder als alternative Version hinzufügen oder die vorhandene Version vollständig ersetzen. Wie du willst!
— Arnauld
2

J, 16 Bytes

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

Probieren Sie es online!

Arbeit an der Verkürzung des rechten Ausdrucks. Ich glaube, ich kann ein paar Bytes sparen, wenn ich das mit einer Beta-J-Version mache. Ich schwöre, ich habe hier gesehen, dass Sie einen Zug mit einem Substantiv in einer neuen Beta-Version beenden können ...

Erläuterung

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

In 4-stellige Basis 256 konvertieren, die Ziffern umkehren und dann zurück in Dezimalzahlen konvertieren. Führen Sie grundsätzlich den im OP bereitgestellten Algorithmus aus. Dies ist möglicherweise das einzige Mal, bei dem es hilfreich ist, dass bei der gemischten Basiskonvertierung von J die Anzahl der Stellen angegeben werden muss, obwohl dies 2 Byte weniger wäre, wenn ich den Zug mit einem Substantiv beenden könnte ( (#:~4#256)stattdessen).

— cole
quelle
2

Excel VBA, 103 92 Bytes

Anonyme VBE-Direktfensterfunktion, die Eingaben aus dem Bereich [A1]in hexadezimal umwandelt, Bytes umkehrt und an das VBE-Direktfenster ausgibt

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)]
— Taylor Scott
quelle
Kann ich das irgendwo testen? Könnten Sie bitte einen Online-Dolmetscher hinzufügen?
— 25.
2
@BruceForte Nein, leider gibt es keine Online-Interpreter für eine der VBA-Varianten. Wenn Sie jedoch eine Kopie von Excel auf Ihrem Computer haben, können Sie auf die VBE zugreifen, indem Sie Alt + F11 und dann das Direktfenster durch Drücken von Strg drücken + G. Für diese anonyme Funktion würden Sie dann Ihre Eingabe in Zelle A1 und den obigen Code in das unmittelbare Fenster einfügen und die Eingabetaste drücken
— Taylor Scott
Oh - und manchmal ist VBA ein bisschen funky (und die Mac-Version ist zwangsläufig schlechter als die Windows-Version), so dass dies und, sofern nicht anders angegeben, alle VBA-Lösungen die Standard-32-Bit-Windows-Version annehmen
— Taylor Scott
2

PPC-Assembly (32-Bit), 8 Byte

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

Wie das funktioniert:

  • Die PPC-Aufrufkonvention fügt den ersten 32-Bit-Wortparameter in SP + 24 ein und fügt diese Adresse in GPR3 ​​ein.
  • LWBRX nimmt das Laden von GPR3 ​​(dritter Operand) und erweitert es (zweiter Operand) in EA auf Null, liest dann 4 Bytes in umgekehrter Reihenfolge und speichert es in GPR3 ​​(erster Operand).
  • GPR3 enthält den Rückgabewert.
  • BLR kehrt von der Funktion zurück (verzweigt zur Adresse im LR-Register)

Leider gibt es keine Online-Emulatoren für PPC-Assemblys, die ich demonstrieren könnte. Es tut uns leid!

— Polynom
quelle
2

Befunge, 62 61 oder 49 Bytes

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

Probieren Sie es online!

Hierbei wird der Standard Befunge für den Referenzinterpreter verwendet. Daher müssen wir die Tatsache berücksichtigen, dass die Speicherzellen mit 8-Bit-Vorzeichen versehen sind und einen möglichen vorzeichenbehafteten Überlauf korrigieren.

Bei Implementierungen mit vorzeichenlosen Speicherzellen (z. B. PyFunge) oder wenn der Bereich größer als 8 Bit ist (z. B. FBBI), können wir ohne diese Überprüfungen davonkommen und 12 Byte einsparen.

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

Versuchen Sie FBBI online!
Versuchen Sie PyFunge online!

Beachten Sie, dass PyFunge eine Ganzzahleingabe für die Fehlerverarbeitung hat. Wenn Sie also mit TIO testen, müssen Sie der Zahl im Eingabefeld ein Leerzeichen oder einen Zeilenumbruch folgen.

— James Holderness
quelle
2

Oktave , 10 Bytes

@swapbytes

Probieren Sie es online!

Dies könnte das erste Mal sein, dass Octave genau die gleiche Punktzahl wie sein Golf-Derivat MATL hat. Natürlich ist in diesem Fall Octave anstelle von MATL eingebaut, was es viel einfacher macht.

Definiert ein Handle für das integrierte Element swapbytes, das einen beliebigen Datentyp annimmt, die Endianness austauscht und das Ergebnis ausgibt. In diesem Fall ist die Eingabe eine 32-Bit-Ganzzahl ohne Vorzeichen.

— Sanchises
quelle
2

R , 86 Bytes

Ich dachte, es gibt bereits eine (oder zwei) Antworten auf diese Frage in R, aber ich muss mich geirrt haben, oder sie hatten dieselben Probleme, die ich hatte, wenn R keine signierten Eingaben machte. Dieses Problem hat alle Buildins beseitigt, die hätten helfen können. Ich habe die 256-Basis-Konvertierung ausprobiert, aber sie hat sich als zu lang erwiesen, aber ich denke, es gibt immer noch Raum für jemanden, der klüger ist als ich. Dann kam ich zu dem Ergebnis, dass es sich um eine Basis 2-Konvertierung handelte, die die Reihenfolge in eine rekursive Funktion umtauschte.

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)

Probieren Sie es 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
— MickyT
quelle
Sie hatten Recht damit, dass die Basis 256 kürzer ist!
— Giuseppe
@ Giuseppe, du wirst einen Hut aufsetzen, nicht
— wahr
2

R , 41 Bytes

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

Probieren Sie es online!

Überprüfen Sie alle Testfälle!

Verwendet eine Basis-256 Konvertierung als MickyT vorgeschlagen hier . R hat weder vorzeichenlose 32-Bit-Ganzzahlen noch 64-Bit-Ganzzahlen. Dies hindert uns daran, bitweise Operationen zu verwenden, aber dieser Ansatz (und wahrscheinlich MickyTs) ist wahrscheinlich immer noch kürzer, da die bitweisen Operatoren von R ziemlich ausführlich sind.

Verwendet Nummer 4 dieses Tipps , wobei zu berücksichtigen ist, dass wir niemals eine Nummer erhalten, die so groß ist wie 256^4.

n%/%256^(0:3)%%256extrahiert die Bytes, und %*%das Matrixprodukt ist in dieser Situation das Skalarprodukt, wobei 256^(3:0)die umgekehrte Reihenfolge der Bytes bewirkt wird. %*%Gibt ein 1x1 zurück, matrixdas den Endian-umgekehrten Wert enthält.

— Giuseppe
quelle
1

CP-1610- Baugruppe, 6 DECLEs = 8 Byte

Dieser Code soll auf einer Intellivision ausgeführt werden .

Ein CP-1610-Opcode wird mit einem 10-Bit-Wert codiert, der als "DECLE" bezeichnet wird. Diese Funktion ist 6 DECLE lang und beginnt bei $ 480C und endet bei $ 4811.

Der CP-1610 verfügt über 16-Bit-Register, daher verwenden wir zwei davon (R0 und R1), um einen 32-Bit-Wert zu speichern.

                               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

Execution Dump

 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
— Arnauld
quelle
Warum sind das 7,5 Bytes? Ich denke, es sollte 8 Bytes sein.
— Erik der Outgolfer
@EriktheOutgolfer Fair genug. Entsprechend aktualisiert.
— Arnauld
@EriktheOutgolfer Weil 60 Bits 7,5 Bytes entsprechen?
— Jeppe Stig Nielsen
@JeppeStigNielsen Das stimmt, aber eine Datei kann niemals 7,5 Byte lang sein, sie wird vor oder nach dem Auffüllen mit Nullen aufgefüllt.
— Erik der Outgolfer
@EriktheOutgolfer Technisch könnte dies wirklich in einem 10-Bit-ROM gespeichert werden. Hier ist ein Beispiel Datenblatt. (Heute verwenden wir 16-Bit-ROM für Intellivision-Homebrew-Spiele, aber früher waren Speicherchips so teuer, dass die Verwendung von 10-Bit eine echte Geldersparnis war.)
— Arnauld
1

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

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

Probieren Sie es online!

+31 für using System;using System.Linq;

Ich hatte gehofft, Array.ReverseInline zu verwenden , aber es sollte nicht sein (siehe Alternative unten).

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

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

Probieren Sie es online!

+13 für using System;

Diese Lösung pflegen von @JeppeStigNielsen; Aufhebung der Einschränkung, dass alles inline gespeichert werden soll (3 Byte).

— Ayb4btu
quelle
Da Sie sparen können using System.Linq;, ist die Verwendung immer noch billiger x=>{var a=BitConverter.GetBytes(x);Array.Reverse(a);return BitConverter.ToUInt32(a,0);}.
— Jeppe Stig Nielsen
1

REXX , 42 Bytes

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

Probieren Sie es online!

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
— idrougge
quelle
1

ARM Maschinensprache Linux, 8 Bytes

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

Um dies selbst zu versuchen, kompilieren Sie Folgendes und führen Sie es auf einem Raspberry Pi oder Android-Gerät aus, auf dem GNUroot ausgeführt wird

#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) );
}
— Ceilingcat
quelle
1

K4 , 18 Bytes

Lösung:

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

Beispiele:

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

Erläuterung:

Es gibt keine vorzeichenlosen Eingaben, daher dauert die Eingabe so lange.

In ein boolesches Array (64 Bit) konvertieren, umformen, umkehren, die ersten 8 Byte belegen und zurück in Long konvertieren.

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

Bonus:

19-Byte- Version in OK, die Sie online testen können !

2/,/8#|12 8#(64#2)\
— Streetster
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.