Scrivere un programma o una funzione che emetta un Lif eseguito su una piccola architettura endian o un Bif eseguito su una grande architettura endian. Uscita in minuscolo lo bè anche accettabile.

Non ci sono input.

Il punteggio è il golf del codice, quindi vince il codice con il minor numero di byte.

Modifica: come da commenti qui sotto, sto chiarendo che la voce deve essere in grado di funzionare su entrambe le architetture.

Credo che ci sia una sola risposta che questo influisca e che la risposta abbia chiaramente indicato che è così.

Python, 33 byte

import sys
exit(sys.byteorder[0])

sys.byteorderè o 'little'o 'big'(e per quelli di voi che leggeranno questa frase senza guardare il codice, [0]significa prendere il primo carattere).

C, 26 byte

a=66<<24|76;f(){puts(&a);}

Presuppone caratteri a 32 bit inte ASCII. Testato su amd64 (little-endian) e mips (big-endian).

GCC, 23 byte

00000000: 613d 2742 0000 4c27 3b66 2829 7b70 7574  a='B..L';f(){put
00000010: 7328 2661 293b 7d                        s(&a);}

Suggerito da feersum. Il valore delle costanti multi-carattere dipende dall'implementazione, ma questo sembra funzionare in GCC. Testato sulle stesse architetture.

MATLAB / Octave, 24 byte

[~,~,e]=computer;disp(e)

La computerfunzione fornisce informazioni sul computer su cui è in esecuzione. La terza uscita è endianness: Lo rispettivamente Bper little o big endian.

Provalo su Ideone .

JavaScript ES6, 50 byte

_=>"BL"[new Int8Array(Int16Array.of(1).buffer)[0]]

Non so chi abbia deciso che fosse una buona idea per gli oggetti TypedArray esporre l'endianità nativa dell'interprete, ma eccoci qui.

C, 36 35 byte

1 byte grazie a @algmyr e @owacoder.

main(a){printf(*(char*)&a?"L":"B");}
main(a){putchar(66+10**(char*)&a);}
main(a){putchar("BL"[*(char*)&a]);}

• Versione 1: Ideone it!
• Versione 2: Ideone esso!
• Versione 3: Ideone esso!

Crediti qui .

Non testato dal momento che non ho una macchina big-endian.

Mathematica, 22

{B,L}[[$ByteOrdering]]

Questo probabilmente infrange alcune regole sul non usare una funzione integrata, ma non sono davvero interessato a rbergare un'alternativa.

C, 27

Un byte in più, ma eccolo qui:

f(){putchar(htons(19522));}

Codice macchina PowerPC - 20 byte

PowerPC è bi-endian (l'endianness può essere impostato all'avvio), quindi questo codice dovrebbe essere conforme alla richiesta di sfida di poter eseguire sia su macchine BE che LE. Questa è una funzione che restituisce ¹ 'L' o 'B'dipende dall'endianness attualmente impostato.

Come funzione, AFAICT è conforme all'ABI PowerPC SVR4 (utilizzato da Linux su ppc32), all'ABI PowerOpen (utilizzato ad esempio da AIX) e all'ABI OS X. In particolare, si basa solo sul fatto che GPR 0 è un registro di lavoro volatile e GPR 3 viene utilizzato per restituire valori "piccoli".

00000000 <get_endian>:
   0:   7c 00 00 a6     mfmsr   r0
   4:   54 03 0f fe     rlwinm  r3,r0,1,31,31
   8:   1c 63 00 0a     mulli   r3,r3,10
   c:   38 63 00 42     addi    r3,r3,66
  10:   4e 80 00 20     blr

Ora, va così:

• l' MSR viene letto nel registro GP 0; l'MSR contiene al bit 31 le impostazioni di endianness (0 = big endian; 1 = little endian);
• rlwinmestratti appena un po: prende il valore in GPR0, r Otates l EFT da 1 posto (in modo che ora si trova in posizione 0) e m chiede con 1 (la maschera generata da coloro 31,31 ² ); il risultato viene inserito nel registro GP 3;
• moltiplica il risultato per 10 e somma 66 ( 'B') (10 è la differenza tra 'L'e 'B')
• infine, torna al chiamante

Appunti

1. sì, la domanda richiede di stampare , ma non è chiaro come dovrei stampare roba nell'assemblaggio che dovrebbe funzionare senza modifiche su diversi sistemi operativi. =)

2. per chi fosse interessato, consultare la documentazione di rlwinm ; non sapendo quasi nulla di PowerPC, ho trovato questo tipo di istruzioni estremamente interessanti.

   Aggiornamento 2018 : Raymond Chen pubblica una serie sull'architettura PowerPC, qui puoi trovare il suo fantastico post su rlwinm& amici.

Java 8, 96, 64 52 byte

()->(""+java.nio.ByteOrder.nativeOrder()).charAt(0);

Un golf basato su questa risposta SO . Tutto il merito va a @LeakyNun e @AlanTuning. Java mantiene la striscia libera.

96 byte:

 char e(){return java.nio.ByteOrder.nativeOrder().equals(java.nio.ByteOrder.BIG_ENDIAN)?'b':'l';}

64 byte:

char e(){return(""+java.nio.ByteOrder.nativeOrder()).charAt(0);}

B / c non testato Non ho accesso a una macchina big-endian.

Perl, 38 36 byte

say+(pack"L",1 eq pack"V",1)?"L":"B"

Funziona impacchettando un numero nell'ordine byte predefinito del sistema e confrontandolo con un numero impacchettato nell'ordine byte little-endian.

(G) Avanti, 24 byte

here $4200004C , c@ emit

Suppone che le celle siano a 32 bit (e che l'interprete Forth supporti i prefissi di base di Gforth ). Memorizza semplicemente il numero 0x4200004C in memoria e quindi visualizza il byte nella parte bassa.

C, 34 byte

Ciò presuppone la codifica dei caratteri ASCII

main(a){putchar(66+10**(char*)a);}

Chiama senza discussione.

Spiegazione:

A chiamata, asarà 1. *(char*)aaccede al primo byte di a, che su piattaforme little-endian sarà 1, su piattaforme big-endian sarà 0.

Su piattaforme big-endian, questo codice passerà quindi da 66 + 10 * 0 = 66 a putchar. 66 è il codice ASCII per B. Su piattaforme little-endian, passerà 66 + 10 * 1 = 76, che è il codice ASCII per L.

C #, 60 52 byte

C # è sorprendentemente competitivo in questo.

char e=>System.BitConverter.IsLittleEndian?'L':'B';

Ringraziamenti a Groo per la sintassi di C # 6.

60 byte:

char e(){return System.BitConverter.IsLittleEndian?'L':'B';}

Julia, 24 19 byte

()->ntoh(5)>>55+'B'

Questa è una funzione anonima che non accetta input e restituisce a Char. Per chiamarlo, assegnarlo a una variabile. Presuppone che i numeri interi siano a 64 bit.

La ntohfunzione converte l'endianità del valore passato dall'ordine dei byte di rete (big endian) a quello utilizzato dal computer host. Su macchine big endian, ntohè la funzione identità poiché non è necessario eseguire alcuna conversione. Su macchine little endian, i byte vengono scambiati, quindi ntoh(5) == 360287970189639680. Che è anche, forse più leggibile, uguale a: 0000010100000000000000000000000000000000000000000000000000000000in binario.

Se spostiamo leggermente il risultato di ntoh(5)55, otterremo 0 su macchine big endian e 10 su macchine little endian. Aggiungendolo alla costante del personaggio 'B', otterremo 'B'o 'L'per macchine endian grandi o piccole, rispettivamente.

5 byte salvati grazie a FryAmTheEggman e Dennis!

PHP 5.6, 41 31 byte (da qui a isertusernamehere)

<?=unpack(S,"\x01\x00")[1]-1?B:L;

PHP 7, 41 byte

echo unpack('S',"\x01\x00")[1]-1?'B':'L';

Idea rubata da: https://stackoverflow.com/a/24785578/2496717

Lisp comune, 27 byte

Testato su SBCL ed ECL. Per un approccio portatile, si dovrebbero usare funzionalità banali .

(lambda()'L #+big-endian'B)

La #+notazione è una condizione del tempo di lettura , che legge il modulo successivo solo se l'espressione condizionale restituisce true. Qui la condizione è l'intero #+big-endiantesto, il che significa che il test è soddisfatto se la :big-endianparola chiave appartiene *FEATURES*all'elenco (un elenco che contiene tra l'altro informazioni specifiche della piattaforma). L'espressione seguente è 'B, che viene letta o ignorata in base all'esito del test. Se la tua piattaforma è big-endian e scrivi il modulo sopra nella REPL, è esattamente come se avessi scritto quanto segue:

CL-USER>(lambda()'L 'B)

^{(NB CL-USER>è il prompt)}

Il corpo di una funzione è implicito PROGN, nel senso che viene restituita solo la valutazione dell'ultima espressione. Così il simbolo rendimenti superiori in realtà B. Se tuttavia la condizione del tempo di lettura è falsa, il modulo si legge come se si scrivesse:

CL-USER>(lambda()'L)

... che semplicemente restituisce un simbolo L.

ARMv6 e versioni successive: 20 byte di codice macchina

0xE10F1000 : MRS   r0,CPSR        ; read current status register
0xE3110C02 : TST   r0,#1<<9       ; set Z flag if bit 9 set
0x03A0004C : MOVEQ r0,#'L'        ; return 'L' if Z clear
0x13A00042 : MOVNE r0,#'B'        ; return 'B' if Z set
0xEBxxxxxx : BL    putchar        ; print it (relative branch)

Non testato, poiché non ho una macchina adatta a portata di mano. Il bit 9 del CPSR fornisce l'attuale endianness di carico / archivio.

Perl 5, 21 + 1 = 22 byte

Corri con perl -E.

say ord pack(S,1)?L:B

Testato su amd64 (little-endian) e mips (big-endian).

R, 28 23 byte

substr(.Platform$endian,1,1)

.Platform$endianritorna bigse eseguito su big endian e littlese su little. Qui, usando substr, restituisce la prima lettera dell'output, quindi o bo l.

Poiché endianè l'unico oggetto che inizia con un eoggetto contenuto, .Platformpossiamo ridurlo grazie alla corrispondenza parziale al seguente codice di 23 byte:

substr(.Platform$e,1,1)

Clojure, 46 44 byte

#(nth(str(java.nio.ByteOrder/nativeOrder))0)

Questa è una funzione che utilizza il builtin Java per ottenere l'endianness della macchina. Quindi ottenere la rappresentazione di stringa che sarà o "LITTLE_ENDIAN"o "BIG_ENDIAN"e prendere il primo carattere di qualsiasi stringa scelta e restituirla.

Salvato 2 byte grazie a @ cliffroot .

Rubino, 3130 caratteri.

puts [1].pack("s")>"\01"??L:?B

Hmm, deve essere un modo migliore. Conta 5 caratteri in meno se il carattere non deve essere emesso poiché penso che altre soluzioni omettano la stampa. vale a dire rimuovere la parte "put" se non si desidera stampare nulla.

Bash (e altre shell unix), 32 (33) byte

Primo e secondo tentativo:

case `echo|od` in *5*)echo B;;*)echo L;;esac # portable
[[ `echo|od` =~ 5 ]]&&echo B||echo L         # non-portable

Grazie a Dennis, versione più corta:

od<<<a|grep -q 5&&echo L||echo B  # non-portable
echo|od|grep -q 5&&echo B||echo L # portable

L' echoutilità genera una nuova riga, con valore esadecimale 0Ae nessun altro output. Perché <<<alo è 61 0A.

L' odutilità, per impostazione predefinita, interpreta l'input come parole a due byte, a zero se il numero di byte è dispari e converte in ottale. Ciò comporta l'interpretazione dell'output dell'eco 0A 00, che viene convertito in 005000big-endian o 000012in little-endian. 61 0Adiventa 005141in little-endian e 060412in big-endian. L'uscita piena di od comprende anche indirizzi e dimensione dei dati che significa che non possiamo usare 0, 1o 2per il test.

Il comando è ben definito per esporre l'endianità del sistema. Dallo standard :

L'ordine dei byte utilizzato durante l'interpretazione dei valori numerici è definito dall'implementazione, ma deve corrispondere all'ordine in cui una costante del tipo corrispondente è memorizzata nel sistema.

Note sulla compatibilità

Non sono sicuro che inserendo echo|odbackquotes senza virgolette doppie [che si traduce in un argomento di tre parole in case] sia supportato su tutti i sistemi. Non sono sicuro se tutti i sistemi supportano gli script di shell senza una nuova riga finale. Sono per lo più sicuro, ma non del 100%, del comportamento di od con l'aggiunta del byte di riempimento sui sistemi big-endian. Se necessario, echo apuò essere utilizzato per le versioni portatili. Tutti gli script funzionano in bash, ksh e zsh e quelli portatili funzionano in dash.

PHP, 16 byte

<?=pack(S,14)^B;

Questo utilizza due trucchi non utilizzati nelle due risposte PHP esistenti:

1. Il valore passato a pack () o unpack () può essere qualsiasi cosa, non solo 0 o 1.
2. L'operatore XOR bit a bit ( ^) lavora su stringhe e il risultato è lungo solo quanto la stringa più corta, evitando la necessità di un indicizzatore di stringa o di un operatore ternario.

Nodo, 42 byte

n=>require('os').endianness()[0]

Pro: c'è un builtin. Contro: i nomi delle proprietà sono molto lunghi

PowerShell, 44 byte

[char](66+10*[BitConverter]::IsLittleEndian)

Il personaggio 66 è B , e successivamente 10 caratteri è il numero 76, L. Un valore booleano "true" diventa 1quando viene cast su un numero. BitConverterè una classe .NET standard.

Racchetta, 35 28 byte

(if(system-big-endian?)'B'L)

'Bo 'Lrispettivamente. Fammi sapere se questo non è abbastanza specifico :)

PHP, 22 byte

<?=ord(pack(S,1))?L:B;

Haskell (utilizzando tipi numerici con dimensioni limitate solo per GHC), 75 byte

import Unsafe.Coerce
import GHC.Int
f="BL"!!fromEnum(unsafeCoerce 1::Int8)

(non testato su un'architettura big-endian, ma sembra che dovrebbe funzionare!)

K, 15 byte

    ("bl")@*6h$-8!`
    ,"l"

Spiegazione;

    From right to left;
    -8!`       /serialises the back tick and returns (0x010000000a000000f500)
    6h$-8!`    /This casts the result to `int which is type 6h(could have used `int$-8!`) - the result is (1 0 0 0 10 0 0 0 245 0i)
    *6h$-8!`   /* means first, we take the first item which is 1. Since it will be either 1 or 0, we can use it to index (@) into the two element list on the left i.e. ("bl")1 returns "l" and ("bl")0 returns b

Bash, 27 byte

iconv -tucs2<<<䉌|head -c1

䉌( U + 424C ) è codificato come tre byte UTF-8:E4 89 8C .

Si presume che iconvutilizzi la funzione di glibc e che venga utilizzata una locale UTF-8.