Ce n'est plus très important, mais il faut parfois que quelqu'un sache.

Voici un golf simple: Si vous ne faites aucune saisie, dites-moi si l'ordinateur sur lequel le code est exécuté utilise un système d'exploitation 64 bits ou un système d'exploitation 32 bits!

Si le code est exécuté sur un système d'exploitation 32 bits, imprimez "32", si le code est exécuté sur un système d'exploitation 64 bits, indiquez "64". Important: Imprimez toute autre chaîne de caractères alphanumériques non vide si elle n’est ni 32 ni 64 bits.

Veuillez noter qu'un programme 32 bits s'exécutant sur un ordinateur avec un système d'exploitation 64 bits doit générer "64". Vous pouvez supposer que les utilisateurs utiliseront un logiciel 64 bits autant que possible.

Pour pouvoir entrer, votre code doit pouvoir être exécuté sur les systèmes Windows pris en charge par Windows 4.10 ou une version plus récente de Microsoft, et sur au moins une version de Linux de votre choix (tant que cette version est gratuite). Des mods de compatibilité peuvent être installés, tant que le programme retourne toujours la bonne valeur.

Les règles habituelles de code-golf s'appliquent.

Remarque: si votre réponse vise uniquement à imprimer 32 ou 64, mais pas le cas alt, je l'accepterai, mais ce n'est pas une réponse en concurrence.

^{Je vais essayer de poster quelques résultats de l'exécution de ces codes sur différents systèmes d'exploitation plus tard!}

Assemblage x86 (polyglotte), 13 octets

Bytecode:

31 c0 b4 80 48 70 05 04 40 83 e0 60 c3

Définit une fonction qui renvoie 32 si interprété comme 32 bits, 64 si 64 bits et 32767 si 16 bits.

Je voulais créer un polyglotte fonctionnant sous Windows et Linux, mais c'est beaucoup plus difficile que je ne le pensais. En l'état actuel des choses, je ne suis même pas sûr qu'il soit possible d'imprimer une valeur sous Windows non 16 bits sans liaison.

Explication

Ce code utilise deux instructions pour déterminer l'architecture sur laquelle il s'exécute. La première est l'instruction 0x48, c'est-à-dire sur 16 et 32 ​​bits dec %eax, mais sur 64 bits, il s'agit d'un préfixe de taille d'instruction. Le second tell est la même instruction, cependant, lorsque nous l'exécutons sur la valeur 0x8000, le bit le plus significatif est inversé uniquement si la taille du registre est de 16 bits, en définissant l'indicateur de dépassement de capacité et en permettant son utilisation jo.

En 16 bits, ce code est interprété comme suit:

   0:   31 c0                   xor    %ax,%ax    /* 0x0000 */
   2:   b4 80                   mov    $0x80,%ah  /* 0x8000 */
   4:   48                      dec    %ax        /* 0x7fff */
   5:   70 05                   jo c              /* taken  */
   7:   04 40                   add    $0x40,%al
   9:   83 e0 60                and    $0x60,%ax
   c:   c3                      ret               /* 0x7fff */

En 32 bits, ce code est interprété comme suit:

   0:   31 c0                   xor    %eax,%eax   /* 0x00000000 */
   2:   b4 80                   mov    $0x80,%ah   /* 0x00008000 */
   4:   48                      dec    %eax        /* 0x00007fff */
   5:   70 05                   jo c               /* not taken  */
   7:   04 40                   add    $0x40,%al   /* 0x00007f3f */
   9:   83 e0 60                and    $0x60,%eax  /* 0x00000020 */
   c:   c3                      ret

En 64 bits, ce code est interprété comme suit:

   0:   31 c0                   xor    %eax,%eax   /* 0x00000000 */
   2:   b4 80                   mov    $0x80,%ah   /* 0x00008000 */
   4:   48 70 05                rex.W jo c         /* not taken  */
   7:   04 40                   add    $0x40,%al   /* 0x00008040 */
   9:   83 e0 60                and    $0x60,%eax  /* 0x00000040 */
   c:   c3                      ret

code machine x86, 12 octets

8c c8 83 f8 23 b0 20 75 02 00 c0 c3

Ungolfed:

getKernelBitness:
    mov eax,cs
    cmp eax,0x23 ; 32 bit process on 64 bit kernel has this selector in CS
    mov al,32
    jne kernelIs32Bit
    add al,al    ; return value in eax
kernelIs32Bit:
    ret

Cette fonction fonctionne sous Linux lorsqu'elle est utilisée dans ELF32, après ABI i386 SysV, ainsi que sous Windows / Wine lorsqu'elle est utilisée dans PE32, conformément stdcallà la convention d'appel.

Mathematica, 17 octets

$SystemWordLength

Chargeurs de démarrage

Saviez-vous que GRUB et IPXE disposent tous les langages de programmation complets de Turing accessibles au moment de l'exécution? Les chargeurs de démarrage de la famille Syslinux ne le font pas mais ils peuvent le faire.

IPXE, 36 octets

#!ipxe
cpuid --ext 29 && echo 64 || echo 32

la première ligne est nécessaire si le script est exécuté à distance, mais pas si elle est tapée directement sur la ligne de commande.

GRUB, 42 octets

if cpuid -l ; then
echo 64
else
echo 32
fi

Syslinux, 186 octets

Cela prend trois fichiers, le premier est syslinux.cfg (ou isolinux.cfg, etc.).

label a
  kernel ifcpu64.c32
  append s -- t

label s
  kernel menu.c32
  append s.cfg

label t
  kernel menu.c32
  append t.cfg

default a
prompt 0
timeout 0

et t.cfg

menu title 32

ans s.cfg

menu title 64

Pour ce qui est de l’essentiel, c’est que syslinux n’a aucune possibilité d’affichage de texte, ce qui rend le menu abusif.

Julia 14 13 octets

n->8sizeof(1)

Explique:

• Anon fonction, prenant n'importe quoi (incluant nothing) retournant un entier 32, ou 64
• Les littéraux entiers sont de type Intqui, selon qu’il s’agisse de 32 bits ou de 64 bits, est un Int32ou un Int64(le 1chiffre peut être n’importe quel chiffre)
• placer un nombre avant un appel de fonction effectue une multiplication de juxtaposition
• Ceci est essentiellement une version abrégée du codeSys.WORD_SIZE utilisé dans la réponse de rahnema1

Une autre réponse amusante est ()->"$(Int)"[4:5], mais je ne peux pas obtenir le compte à rebours sur celui-là.

-1 grâce à @Roman Gräf

julia, 20 17 16 octets

n->Sys.WORD_SIZE

* Merci à @LyndonWhite enregistré 3 octets * Merci à @ RomanGräf enregistré un octet

Réponses précédentes:

()->Sys.WORD_SIZE
print(Sys.WORD_SIZE)

Essayez-le en ligne!

JavaScript (Node.js), 24 octets

_=>process.arch.slice(1)

Ceci est une fonction et retourne '32', '64'ou si ni 'rm'.

C, 33 31 29 23 octets

f(){return sizeof&f*8;}

Merci aux commentateurs @ceilingcat et @Dennis pour leurs astuces de golf!

PowerShell, 16 octets

8*[IntPtr]::Size

Obtient la taille du pointeur en octets, multiplie par 8 pour obtenir des bits.

Python 2, 52, 48, 42 41 octets

from struct import*;print calcsize("P")*8

Merci à totalement humain!

Java 8, 45 octets

()->System.getProperty("sun.arch.data.model")

Perl 6 , 17 octets

say $*KERNEL.bits

L'essayer

Il y a un lien $?BITSqui contient le nombre de bits qu'un natif inta dans le runtime.

say $?BITS

L'essayer

Windows CMD, 56 52 octets (merci Bob!)

if EXIST "%ProgramFiles(x86)%" (echo 64)else echo 32

Encore étonnamment long - le plus long jusqu'à présent!

C, API Win32, 103 183 octets

#include <windows.h>
typedef int(WINAPI*F)(HANDLE,int*);b;main(){F f=GetProcAddress(GetModuleHandle("kernel32"),"IsWow64Process");return(f!=0&&f(GetCurrentProcess(),&b)&&!b)?32:64;}

En réalité, il y a plus de 2 cas ici. Examinons-les

• Le plus simple: IsWow64Processn'existe pas: nous sommes sur un système d'exploitation 32 bits

Pour les deux prochains cas, nous devons savoir que notre binaire sera un exécutable de 32 bits. Et cette description de ce qui sera dans le paramètre out deIsWow64Process

Un pointeur sur une valeur définie sur TRUE si le processus s'exécute sous WOW64. Si le processus s'exécute sous Windows 32 bits, la valeur est définie sur FALSE. Si le processus est une application 64 bits s'exécutant sous Windows 64 bits, la valeur est également définie sur FALSE.

Cela nous laisse avec deux cas supplémentaires:

• IsWow64Process existe et donne VRAI -> Nous sommes sur une machine 64 bits
• IsWow64Process existe, et donne FAUX -> Nous sommes sur une machine 32 bits

Nous ne nous inquiétons pas de la partie où une application 64 bits sous Windows 64 bits donne FAUX. Comme nous savons que notre application est 32 bits

Oh, et il y a un cas supplémentaire qui n'est pas couvert par ce défi et devrait être rare de toute façon:

• IsWow64Process existe, mais il échoue: nous utilisons par défaut une machine 32 bits.

Cela devrait couvrir la plupart des systèmes d'exploitation Windows NT. N'avoir testé que sur Win10 64 bits, Win 7 64 bits, Win 8.1 32 bits et WinXP SP1 32 bits

Réponse originale:

#include<windows.h>
main(){return GetProcAddress(GetModuleHandle("Kernel32"),"IsWow64Process")?64:32;}

Pour être sûr, nous n'avons besoin de distinguer que 2 cas

• IsWow64Process n'existe pas dans kernel32.dll => Nous sommes sur une machine 32 bits.

• IsWow64Process existe => Nous sommes sur une machine 64 bits.

La valeur réelle fournie par IsWow64Processest sans importance pour ce défi, car nous voulons que le binaire soit 32 bits dans tous les cas.

Contrairement à la plupart des réponses, cela ne repose pas sur le binaire lui-même compilé sur la machine sur laquelle il est exécuté.

Si je connaissais une fonction plus courte, présente uniquement sur les machines 64 bits et non 32 bits, je pourrais raccourcir la réponse.

C #, 60 50 octets

_=>System.Environment.Is64BitOperatingSystem?64:32

Merci @TheLethalCoder

Ruby, 22 octets

p [?a].pack(?p).size*8

["any string"].pack("p")renvoie une chaîne dont les octets correspondent au pointeur pointé vers "any string", et est composée de 8 caractères si le système d'exploitation est 64 bits ou de 4 caractères si le système d'exploitation est 32 bits.

R, 16 octets

.Machine[[18]]*8

Retourne la taille du pointeur.

Perl, 18 15 18 octets

say length pack p8

code machine x86, 8 octets

31 C0 B0 40 48 24 60 C3

Ungolfed:

31 c0    xor eax,eax
b0 40    mov al, 0x40
48       dec al — in 32-bit mode; "REX.W" in 64-bit mode (ignored)
24 60    and al, 0x60
c3       ret

Si compilé en tant qu'exécutable 64 bits, il renvoie 64 po eaxet s'il est compilé en 32 bits, puis 32 - quel que soit le système d'exploitation.

Cette réponse s'appuie sur les règles disant:

Vous pouvez supposer que les utilisateurs utiliseront un logiciel 64 bits autant que possible.

PHP, 18 octets

<?=PHP_INT_SIZE*8;

Ceci gère correctement tous les cas de processeurs 32, 64 et autres bits, à condition que PHP_INT_SIZE soit correct, il montrera la taille précise du processeur, quel que soit le processeur utilisé par PHP!

Si PHP est en cours d'exécution sur

Système d'exploitation 32 bits PHP_INT_SIZE == 4,

Système d'exploitation 64 bits PHP_INT_SIZE == 8,

Système d'exploitation 16 bits PHP_INT_SIZE == 2 (en théorie)

Système d'exploitation 8 bits PHP_INT_SIZE == 1 (encore théoriquement)

Système d'exploitation 128 bits PHP_INT_SIZE == 16 (Pas encore atteint, mais possible)

C # (29 octets)

Console.Write(IntPtr.Size*8);

PowerShell, 17 52 octets

try{32+32*((gci \*`))-or(arch)[-1]-eq52)}catch{32}

Renvoie 64 si l'une des conditions suivantes est vraie:

• Vous avez un répertoire sur votre lecteur actuel avec un nom de fichier se terminant par une parenthèse étroite, l’idée étant de détecter Program Files (x86).
• archretourne une chaîne se terminant par 4(ASCII 52), comme x86_64, par opposition à eg i686.

Le try-catch est destiné à contourner l'erreur que vous obtenez si gci ne renvoie rien et que vous n'avez pas d' arche . Je n'ai pas trouvé de moyen plus court de le faire jusqu'à présent. gci est utilisé sur ls car sous Linux, ls produira une erreur visible.

Cette version doit détecter si le système d'exploitation est 64 bits plutôt que simplement PowerShell et si son fonctionnement sous Windows et Linux a été testé. Pour le support Mac, remplacez archpar uname -m.

Version précédente uniquement pour Windows: -!(ls \*`))*32+64

Swift 4 REPL / Playground, 12 octets

Int.bitWidth

Intest la taille des mots, agissant comme l'un Int32ou l' autre ou Int64selon le système.

Ruby, 10 octets

p 0.size*8

Bien que Ruby puisse utiliser des nombres entiers de toutes les longueurs, il stocke en interne les valeurs qui entrent dans un mot machine en tant que Fixnum. La méthode Fixnum#sizeretourne toujours la longueur en octets d'un mot machine.

La Fixnumclasse a été supprimée dans Ruby 2.4.0, ses fonctionnalités ont été incluses dans la classe Integer. Le code est valide.

Shell, 26 octets

uname -m|awk \$0=/_/?64:32

Bash, 25 17 octets

getconf LONG_BIT

Merci à Dennis pour son aide au golf.

C, 22 octets

f(){return(int**)0+8;}

Ceci est une réponse basée sur la taille du pointeur qui suppose un binaire natif. Le 0est jeté sur int**(adresse0x0 ). Ensuite, nous ajoutons 8 à 0, qui, dans C, avance le pointeur de sizeof(int*)*8. 4 octets * 8 bits = 32, 8 octets * 8 bits = 64. Nous obtenons donc (int**)0x20et 0x40qui sont ensuite implicitement convertis en entiers en les renvoyant de manière impliciteint convertis en qu'entiers fonction de restitution .

C, autonome, 34 octets

main(){printf("%d\n",(int**)0+8);} 

C, amusant avec Unicode, 30 points de code, 34 octets (UTF-8)

main(){puts((int**)U" ㈳㐶"+1);}

Java, 50 octets

int b(){return com.sun.jna.Native.POINTER_SIZE*8;}

PHP, 29 octets

<?=@php_uname(m)[-1]-4?32:64;

https://3v4l.org/Y6JXv

Python 3 , 77 84 71 59 octets

-13 octets, grâce à @JonathanAllan!
Jusqu'à 59 par @Clearer

from platform import*;print({'4':64,'6':32}[machine()[-1]])

Essayez-le en ligne!

Mon premier jeu de code temporel :)
Devrait produire la version correcte même lors de l'exécution de 32Bit-Python sur un système d'exploitation 64 bits.
En supposant que platform.machine()donne i*86ou x86pour 32Bit-OS. Je n'en ai pas pour vérifier cela. La sortie est 0lorsque le système d'exploitation n'est pas en 64 / 32Bit
Édition: instruction d'impression ajoutée, donc 7 octets plus