Ecrivez un programme ou une fonction générant un Lif si exécuté sur une architecture little endian ou un Bsi exécuté sur une architecture big endian. La sortie en minuscule lou best également acceptable.

Il n'y a pas d'entrée.

Scoring est un code de golf, donc le code avec le moins d'octets gagne.

Edit: Selon les commentaires ci-dessous, je précise que l'entrée doit pouvoir être exécutée sur l'une ou l'autre architecture.

Je crois qu’il n’ya qu’une réponse à cela et cette réponse a clairement indiqué que c’était le cas.

Python, 33 octets

import sys
exit(sys.byteorder[0])

sys.byteorderest soit 'little'ou 'big'(et pour ceux d’entre vous qui liront cette phrase sans regarder le code, cela [0]signifie prendre le premier caractère).

C, 26 octets

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

Suppose des caractères 32 bits intet ASCII. Testé sur amd64 (little-endian) et mips (big-endian).

GCC, 23 octets

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

Proposé par feersum. La valeur des constantes à plusieurs caractères dépend de la mise en œuvre, mais cela semble fonctionner dans GCC. Testé sur les mêmes architectures.

MATLAB / Octave, 24 octets

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

La computerfonction donne des informations sur l'ordinateur sur lequel il tourne. Le troisième résultat est endianness: Lou Bpour le petit ou le grand endian respectivement.

Essayez-le sur Ideone .

JavaScript ES6, 50 octets

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

Je ne sais pas qui a décidé que c’était une bonne idée que les objets TypedArray exposent l’ endianité native de l’interprète, mais nous y sommes.

C, 36 35 octets

1 octet grâce à @algmyr et @owacoder.

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

• Version 1: Ideone it!
• Version 2: Ideone it!
• Version 3: Ideone it!

Crédits ici .

Non testé car je n'ai pas de machine big-endian.

Mathematica, 22

{B,L}[[$ByteOrdering]]

Cela déroge probablement à la règle de ne pas utiliser de fonction intégrée, mais je ne suis pas vraiment intéressé par l'option Rube Goldberging.

C, 27

Un octet de plus, mais le voici quand même:

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

Code machine PowerPC - 20 octets

PowerPC étant bi-endian (l’endianness peut être configuré au démarrage), ce code doit donc être conforme à la demande de challenge de pouvoir s’exécuter sur des machines BE et LE. Cette fonction renvoie ¹ 'L' ou 'B'dépend de l’endianité actuellement définie.

En tant que fonction, AFAICT est conforme à l’ABI SVPC PowerPC (utilisé par Linux sur ppc32), à l’ABI PowerOpen (utilisée par exemple par AIX) et à l’ABI OS X. En particulier, il se base simplement sur le fait que GPR 0 est un registre de travail volatil et que GPR 3 est utilisé pour renvoyer des "petites" valeurs.

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

Maintenant, ça se passe comme ça:

• le MSR est lu dans le registre GP 0; le MSR contient au bit 31 les paramètres de finalité (0 = grand endian; 1 = petit endian);
• rlwinmextraits juste un peu: il prend la valeur en GPR0, r Otates l auche par 1 place (donc qui est maintenant en position 0) et m demande avec 1 (le masque généré par ceux 31,31 ² ); le résultat est placé dans le registre GP 3;
• multiplier le résultat par 10 et additionner 66 ( 'B') (10 étant la différence entre 'L'et 'B')
• enfin, retournez à l'appelant

Remarques

1. Oui, la question demande à imprimer , mais on ne sait pas exactement comment imprimer des éléments d'un assemblage censé fonctionner sans modification sous différents systèmes d'exploitation. =)

2. pour les personnes intéressées, voir la documentation rlwinm ; ne connaissant pratiquement rien de PowerPC, j’ai trouvé ce genre d’instructions extrêmement intéressant.

   Mise à jour 2018 : Raymond Chen publie une série sur l'architecture PowerPC. Vous trouverez ici son article sur à propos de rlwinm& friends.

Java 8, 96, 64 52 octets

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

Un golf basé sur cette réponse SO . Tout le mérite revient à @LeakyNun et à @AlanTuning. Java garde la strie perdante.

96 octets:

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

64 octets:

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

Untested b / c Je n'ai pas accès à une machine big-endian.

Perl, 38 36 octets

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

Fonctionne en plaçant un nombre dans l'ordre des octets par défaut du système et en le comparant à un nombre emballé dans un ordre d'octets little-endian.

(G) Forth, 24 octets

here $4200004C , c@ emit

Suppose que les cellules ont 32 bits (et que votre interprète Forth supporte les préfixes de base de Gforth ). Il stocke simplement le nombre 0x4200004C en mémoire, puis affiche l'octet au bas de la liste.

C, 34 octets

Cela suppose le codage de caractères ASCII

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

Appel sans argument.

Explication:

Sur appel, asera 1. *(char*)aaccède au premier octet de a, qui sur les plates-formes little-endian sera 1, sur les plates-formes big-endian sera 0.

Sur les plates-formes big-endian, ce code passera donc 66 + 10 * 0 = 66 à putchar. 66 est le code ASCII pour B. Sur les plates-formes little-endian, il passera 66 + 10 * 1 = 76, ce qui correspond au code ASCII L.

C #, 60 52 octets

C # est étonnamment compétitif dans celui-ci.

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

Crédits à Groo pour la syntaxe C # 6.

60 octets:

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

Julia, 24 19 octets

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

C'est une fonction anonyme qui ne prend aucune entrée et retourne un Char. Pour l'appeler, assignez-le à une variable. Il suppose que les entiers sont 64 bits.

La ntohfonction convertit l’endianité de la valeur qui lui est transmise de l’ordre des octets du réseau (big endian) en celle utilisée par l’ordinateur hôte. Sur les machines Big Endian, ntohc’est la fonction d’identité car il n’ya pas de conversion à faire. Sur les machines little endian, les octets sont permutés, donc ntoh(5) == 360287970189639680. Ce qui est aussi, peut-être plus lisiblement, égal à: 0000010100000000000000000000000000000000000000000000000000000000en binaire.

Si nous décalons légèrement le résultat de ntoh(5)55, nous aurons 0 sur les machines Big Endian et 10 sur les machines Little Endian. En ajoutant cela à la constante de caractère 'B', nous aurons 'B'ou 'L'pour les grandes ou les petites machines endianes, respectivement.

5 octets sauvés grâce à FryAmTheEggman et Dennis!

PHP 5.6, 41 31 octets (merci à isertusernamehere)

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

PHP 7, 41 octets

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

Idée volée à: https://stackoverflow.com/a/24785578/2496717

Common Lisp, 27 octets

Testé sur SBCL et ECL. Pour une approche portable, il faut utiliser des fonctionnalités triviales .

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

La #+notation est une condition de lecture , qui lit le formulaire suivant uniquement si l'expression conditionnelle est évaluée à true. Ici, la condition est le #+big-endiantexte entier, ce qui signifie que le test est satisfait si le :big-endianmot - clé appartient à la *FEATURES*liste (liste contenant notamment des informations spécifiques à la plate-forme). L'expression suivante est 'B, qui est lue ou ignorée en fonction du résultat du test. Si votre plate-forme est big-endian et que vous écrivez le formulaire ci-dessus dans le REPL, c'est exactement comme si vous aviez écrit ce qui suit:

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

^{(NB. CL-USER>Est l'invite)}

Le corps d'une fonction est implicite PROGN, ce qui signifie que seule l'évaluation de la dernière expression est renvoyée. Ainsi , le symbole de retour ci - dessus en fait B. Cependant, si la condition de temps de lecture est définie sur false, le formulaire se lit comme si vous aviez écrit:

CL-USER>(lambda()'L)

... qui retourne simplement le symbole L.

ARMv6 et versions ultérieures: code machine 20 octets

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 testé, car je n'ai pas de machine appropriée à portée de main. Le bit 9 du CPSR donne l’endianité actuelle de la charge / du magasin.

Perl 5, 21 + 1 = 22 octets

Courez avec perl -E.

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

Testé sur amd64 (little-endian) et mips (big-endian).

R, 28 23 octets

substr(.Platform$endian,1,1)

.Platform$endianretourne bigsi exécuté sur big endian et littlesi peu. Ici, en utilisant substr, il retourne la première lettre de la sortie, donc soit bou l.

Comme endianc'est le seul objet commençant par un eobjet contenu, .Platformnous pouvons le réduire grâce à une correspondance partielle avec le code de 23 octets suivant:

substr(.Platform$e,1,1)

Clojure, 46 44 octets

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

C’est une fonction qui utilise le langage Java intégré pour obtenir l’endianité de la machine. Ensuite, obtenez la représentation sous forme de chaîne qui sera soit "LITTLE_ENDIAN"ou "BIG_ENDIAN", prenez le premier caractère de la chaîne choisie et renvoyez-le.

2 octets sauvés grâce à @ cliffroot .

Rubis, 3130 caractères.

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

Hmm, ça doit être un meilleur moyen. Comptez 5 caractères en moins si le caractère n'a pas besoin d'être imprimé, car je pense que d'autres solutions omettent l'impression. c'est-à-dire supprimer la partie "met" si vous ne voulez rien imprimer.

Bash (et autres shells Unix), 32 (33) octets

Première et deuxième tentative:

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

Merci à Dennis, version plus courte:

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

L' echoutilitaire génère une nouvelle ligne, avec une valeur hexadécimale 0Aet aucune autre sortie. Car <<<ac'est 61 0A.

L' odutilitaire, par défaut, interprète l'entrée en mots de deux octets, complétée de zéros si le nombre d'octets est impair, et convertit en octal. Il en résulte que la sortie de l'écho est interprétée comme 0A 00convertie 005000en big-endian ou 000012en little-endian. 61 0Adevient 005141en little-endian et 060412en big-endian. La sortie complète de od comprend également l' adresse et des données de taille qui signifie que nous ne pouvons pas utiliser 0, 1ou 2pour le test.

La commande est bien définie pour exposer l'endianité du système. De la norme :

L'ordre d'octet utilisé lors de l'interprétation des valeurs numériques est défini par l'implémentation, mais doit correspondre à l'ordre dans lequel une constante du type correspondant est stockée en mémoire sur le système.

Notes de compatibilité

Je ne suis pas certain que la mise echo|oden place de guillemets arrières sans guillemets [ce qui donne un argument de trois mots case] soit prise en charge sur tous les systèmes. Je ne suis pas certain que tous les systèmes prennent en charge les scripts shell sans fin de ligne. Je suis en grande partie certain, mais pas à 100%, du comportement d’od en ajoutant l’octet de remplissage sur les systèmes big-endian. Si nécessaire, echo apeut être utilisé pour les versions portables. Tous les scripts fonctionnent en bash, ksh et zsh, tandis que les scripts portables fonctionnent en tiret.

PHP, 16 octets

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

Cela utilise deux astuces non utilisées dans les deux réponses PHP existantes:

1. La valeur transmise à pack () ou unpack () peut être n'importe quoi, pas seulement 0 ou 1.
2. L'opérateur binaire XOR ( ^) au niveau des bits fonctionne sur les chaînes et le résultat est uniquement aussi long que la chaîne la plus courte, évitant ainsi le recours à un opérateur d'indexation de chaîne ou ternaire.

Noeud, 42 octets

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

Pro: il y a un construit. Contre: les noms de propriété sont très longs

PowerShell, 44 octets

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

Caractère 66 est B, et est ensuite numéro 10 caractères 76, L. Une valeur booléenne "true" devient 1lors de la conversion en nombre. BitConverterest une classe .NET standard.

Raquette, 35 à 28 octets

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

'Bou 'Lrespectivement. Faites-moi savoir si ce n'est pas assez spécifique :)

PHP, 22 octets

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

Haskell (utilisant des types numériques avec une taille limitée de GHC), 75 octets

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

(pas testé sur une architecture big-endian, mais il semble que cela devrait fonctionner!)

K, 15 octets

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

Explication;

    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 octets

iconv -tucs2<<<䉌|head -c1

䉌( U + 424C ) est codé sous la forme de trois octets UTF-8: E4 89 8C.

On suppose que iconvla fonction de glibc est utilisée et que les paramètres régionaux UTF-8 sont utilisés.