Escriba un programa o función que genere un Lif ejecutado en una pequeña arquitectura endian o un Bif ejecutado en una gran arquitectura endian. Salida en minúscula lo btambién es aceptable.

No hay entrada

La puntuación es el código de golf, por lo que gana el código con la menor cantidad de bytes.

Editar: según los comentarios a continuación, aclaro que la entrada debe poder ejecutarse en cualquier arquitectura.

Creo que solo hay una respuesta a la que esto afecta, y esa respuesta ha indicado claramente que este es el caso.

Python, 33 bytes

import sys
exit(sys.byteorder[0])

sys.byteorderes uno 'little'o 'big'(y para aquellos de ustedes que leerán esta oración sin mirar el código, [0]significa tomar el primer carácter).

C, 26 bytes

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

Asume caracteres de 32 bits inty ASCII. Probado en amd64 (little-endian) y mips (big-endian).

CCG, 23 bytes

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

Sugerido por feersum. El valor de las constantes de varios caracteres depende de la implementación, pero parece funcionar en GCC. Probado en las mismas arquitecturas.

MATLAB / Octave, 24 bytes

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

La computerfunción proporciona información sobre, bueno, la computadora en la que se está ejecutando. El tercer resultado es endianness: Lo Bpara little-o big-endian respectivamente.

Pruébalo en Ideone .

JavaScript ES6, 50 bytes

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

No sé quién decidió que era una buena idea para los objetos TypedArray exponer la resistencia nativa del intérprete, pero aquí estamos.

C, 36 35 bytes

1 byte gracias a @algmyr y @owacoder.

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

• Versión 1: Ideone it!
• Versión 2: Ideone it!
• Versión 3: Ideone it!

Créditos aquí .

Sin probar ya que no tengo una máquina big endian.

Mathematica, 22

{B,L}[[$ByteOrdering]]

Esto probablemente rompe alguna regla sobre no usar una función incorporada, pero no estoy realmente interesado en buscar una alternativa.

C, 27

Un byte más, pero aquí está de todos modos:

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

Código de máquina PowerPC: 20 bytes

PowerPC es bi-endian (la endianness se puede configurar al inicio), por lo que este código debe cumplir con la solicitud de desafío de poder ejecutar tanto en máquinas BE como LE. Esta es una función que devuelve ¹ 'L' o 'B'depende de la endianness configurada actualmente.

Como función, AFAICT conforma el SVR4 PowerPC ABI (usado por Linux en ppc32), el PowerOpen ABI (usado por ejemplo por AIX) y el OS X ABI. En particular, se basa solo en el hecho de que GPR 0 es un registro de cero volátil, y GPR 3 se utiliza para devolver valores "pequeños".

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

Ahora, va así:

• el MSR se lee en el registro GP 0; el MSR contiene en el bit 31 la configuración de endianness (0 = big endian; 1 = little endian);
• rlwinmextractos sólo un poco: se toma el valor en GPR0, r Otates l eft por 1 lugar (de modo que ahora está en la posición 0) y m pide con 1 (la máscara generada por los 31,31 ² ); el resultado se coloca en el registro GP 3;
• multiplica el resultado por 10 y suma 66 ( 'B') (10 es la diferencia entre 'L'y 'B')
• finalmente, regrese a la persona que llama

Notas

1. sí, la pregunta pide imprimir , pero no está claro cómo debo imprimir cosas en el ensamblaje que se espera que se ejecute sin modificaciones en diferentes sistemas operativos. =)

2. Para aquellos interesados, consulte la documentación de rlwinm ; Sin saber nada sobre PowerPC, este tipo de instrucciones me pareció extremadamente interesante.

   Actualización 2018 : Raymond Chen está publicando una serie sobre la arquitectura PowerPC, puede encontrar aquí su gran publicación sobre rlwinm& amigos.

Java 8, 96, 64 52 bytes

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

Un golf basado en esta respuesta SO . Todo el crédito va a @LeakyNun y @AlanTuning. Java mantiene la racha perdedora.

96 bytes:

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

64 bytes:

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

No probado b / c No tengo acceso a una máquina big endian.

Perl, 38 36 bytes

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

Funciona empacando un número en el orden de bytes predeterminado del sistema y comparándolo con un número empaquetado en orden de bytes little endian.

(G) Adelante, 24 bytes

here $4200004C , c@ emit

Asume que las celdas son de 32 bits (y que su intérprete de Forth admite los prefijos base de Gforth ). Simplemente almacena el número 0x4200004C en la memoria y luego muestra el byte en el extremo inferior.

C, 34 bytes

Esto supone la codificación de caracteres ASCII

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

Llama sin discusión.

Explicación:

En llamada, aserá 1. *(char*)aaccede al primer byte de a, que en plataformas little endian será 1, en plataformas big endian será 0.

En plataformas big-endian, este código pasará 66 + 10 * 0 = 66 a putchar. 66 es el código ASCII para B. En plataformas little endian, pasará 66 + 10 * 1 = 76, que es el código ASCII L.

C #, 60 52 bytes

C # es sorprendentemente competitivo en este caso.

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

Créditos a Groo para la sintaxis C # 6.

60 bytes:

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

Julia, 24 19 bytes

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

Esta es una función anónima que no toma entrada y devuelve a Char. Para llamarlo, asígnelo a una variable. Se supone que los enteros son de 64 bits.

La ntohfunción convierte la endianidad del valor que se le pasa del orden de bytes de la red (big endian) a la utilizada por la computadora host. En las máquinas Big Endian, ntohes la función de identidad ya que no hay conversión que hacer. En pequeñas máquinas endian, los bytes se intercambian, entonces ntoh(5) == 360287970189639680. Que también es, quizás más legible, igual a: 0000010100000000000000000000000000000000000000000000000000000000en binario.

Si desplazamos un poco a la derecha el resultado de ntoh(5)55, obtendremos 0 en máquinas endian grandes y 10 en máquinas endian pequeñas. Agregando eso a la constante de caracteres 'B', obtendremos 'B'o 'L'para máquinas endian grandes o pequeñas, respectivamente.

¡Ahorró 5 bytes gracias a FryAmTheEggman y Dennis!

PHP 5.6, 41 31 bytes (thx a isertusernamehere)

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

PHP 7, 41 bytes

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

Idea robada de: https://stackoverflow.com/a/24785578/2496717

Lisp común, 27 bytes

Probado en SBCL y ECL. Para un enfoque portátil, uno debe usar funciones triviales .

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

La #+notación es una condición de tiempo de lectura , que lee la siguiente forma solo si la expresión condicional se evalúa como verdadera. Aquí la condición es el #+big-endiantexto completo, lo que significa que la prueba se cumple si la :big-endianpalabra clave pertenece a la *FEATURES*lista (una lista que contiene, entre otras cosas, información específica de la plataforma). La siguiente expresión es 'B, que se lee o se omite de acuerdo con el resultado de la prueba. Si su plataforma es big-endian y escribe el formulario anterior en el REPL, es exactamente como si hubiera escrito lo siguiente:

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

^{(NB. CL-USER>Es el aviso)}

El cuerpo de una función es implícito PROGN, lo que significa que solo se devuelve la evaluación de la última expresión. Así el símbolo rendimientos superiores realidad B. Sin embargo, si la condición de tiempo de lectura se evalúa como falsa, el formulario se lee como si usted hubiera escrito:

CL-USER>(lambda()'L)

... que simplemente devuelve el símbolo L.

ARMv6 y posterior: código de máquina de 20 bytes

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)

No probado, ya que no tengo una máquina adecuada a mano. El bit 9 del CPSR proporciona la capacidad de carga / almacenamiento actual.

Perl 5, 21 + 1 = 22 bytes

Corre con perl -E.

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

Probado en amd64 (little-endian) y mips (big-endian).

R, 28 23 bytes

substr(.Platform$endian,1,1)

.Platform$endianregresa bigsi se ejecuta en big endian y si se ejecuta littleen pequeño. Aquí, usando substr, devuelve la primera letra de la salida, entonces bo l.

Como endianes el único objeto que comienza con un eobjeto contenido .Platform, podemos reducirlo gracias a la coincidencia parcial con el siguiente código de 23 bytes:

substr(.Platform$e,1,1)

Clojure, 46 44 bytes

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

Esta es una función que utiliza la función Java incorporada para obtener la resistencia de la máquina. Luego obtenga la representación de cadena que será o "LITTLE_ENDIAN"o "BIG_ENDIAN"y tome el primer carácter de la cadena elegida y devuélvala.

Guardado 2 bytes gracias a @ cliffroot .

Rubí, 3130 caracteres

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

Hmm, debe ser una mejor manera. Cuente 5 caracteres menos si el carácter no necesita ser emitido, ya que creo que otras soluciones omiten la impresión. es decir, elimine la parte "pone" si no desea imprimir nada.

Bash (y otros shells de Unix), 32 (33) bytes

Primer y segundo intento:

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

Gracias a Dennis, versión más corta:

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

La echoutilidad genera una nueva línea, con valor hexadecimal 0A, y ninguna otra salida. Pues <<<alo es 61 0A.

La odutilidad, por defecto, interpreta la entrada como palabras de dos bytes, rellena con ceros si el número de bytes es impar, y convierte a octal. Esto hace que la salida del eco se interprete como 0A 00, que se convierte en 005000big-endian o 000012en little-endian. 61 0Ase convierte 005141en little-endian y 060412en big-endian. La salida completa de OD también incluye la dirección y tamaño de los datos que significa que no podemos utilizar 0, 1o 2para la prueba.

El comando está bien definido para exponer la resistencia del sistema. De la norma :

El orden de bytes utilizado al interpretar los valores numéricos está definido por la implementación, pero debe corresponder al orden en el que se almacena una constante del tipo correspondiente en la memoria del sistema.

Notas de compatibilidad

No estoy seguro si poner echo|odcomillas traseras sin comillas dobles alrededor de ellas [lo que da como resultado un argumento de tres palabras para case] es compatible con todos los sistemas. No estoy seguro de si todos los sistemas admiten scripts de shell sin nueva línea de terminación. Estoy casi seguro, pero no el 100% del comportamiento de od al agregar el byte de relleno en los sistemas big-endian. Si es necesario, echo ase puede usar para las versiones portátiles. Todos los scripts funcionan en bash, ksh y zsh, y los portátiles funcionan en el tablero.

PHP, 16 bytes

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

Esto usa dos trucos que no se usan en las dos respuestas PHP existentes:

1. El valor pasado a pack () o unpack () puede ser cualquier cosa, no solo 0 o 1.
2. El operador XOR bit a bit ( ^) funciona en cadenas, y el resultado es tan largo como la cadena más corta, evitando la necesidad de una indexación de cadena o un operador ternario.

Nodo, 42 bytes

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

Pro: hay un incorporado. Con: los nombres de propiedad son muy largos

PowerShell, 44 bytes

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

Carácter 66 es B, y 10 caracteres más tarde es el número 76, L. Un valor booleano de "verdadero" se convierte 1cuando se convierte en un número. BitConverteres una clase estándar de .NET.

Raqueta, 35 28 bytes

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

'Bo 'Lrespectivamente. Avísame si esto no es lo suficientemente específico :)

PHP, 22 bytes

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

Haskell (utilizando tipos numéricos de tamaño restringido solo para GHC), 75 bytes

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

(no probado en una arquitectura big endian, ¡pero parece que debería funcionar!)

K, 15 bytes

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

Explicación;

    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 bytes

iconv -tucs2<<<䉌|head -c1

䉌( U + 424C ) se codifica como tres UTF-8 bytes: E4 89 8C.

Se supone que iconvusa la función de glibc y que se usa un entorno local UTF-8.