Ya no es demasiado importante, pero de vez en cuando alguien necesita saberlo.

Aquí hay un simple golf: sin tener en cuenta la opinión del usuario, ¡dígame si la computadora en la que se ejecuta el código está en un sistema operativo de 64 bits o en un sistema operativo de 32 bits!

Si el código se ejecuta en un sistema operativo de 32 bits, imprima "32", si el código se ejecuta en un sistema operativo de 64 bits, envíe "64". Importante: Imprima cualquier otra cadena no vacía de caracteres alfanuméricos si no tiene 32 o 64 bits.

Tenga en cuenta que un programa de 32 bits que se ejecuta en una computadora con un sistema operativo de 64 bits debe generar "64". Puede suponer que los usuarios utilizarán software de 64 bits siempre que sea posible.

Para ser elegible para la entrada, su código debe poder ejecutarse en Windows 4.10 o sistemas Windows más nuevos compatibles con Microsoft, y al menos una versión de Linux de su elección (siempre que esa versión sea gratuita). Se pueden instalar modificaciones de compatibilidad, siempre y cuando el programa todavía devuelva el valor correcto.

Se aplican las reglas habituales de código de golf .

Nota: Si su respuesta solo pretende imprimir 32 o 64, pero no el caso alternativo, lo aceptaré, pero no es una respuesta competitiva.

^{¡Intentaré publicar algunos resultados de ejecutar estos códigos en diferentes sistemas operativos más adelante!}

Conjunto x86 (políglota), 13 bytes

Bytecode:

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

Define una función que devuelve 32 si se interpreta como 32 bits, 64 si es de 64 bits y 32767 si es de 16 bits.

Quería hacer un políglota que se ejecutara en Windows y Linux, pero esto es mucho más difícil de lo que pensaba. Como es, no estoy seguro de que haya alguna forma de imprimir un valor en Windows que no sea de 16 bits sin vinculación.

Explicación

Este código usa dos tell para determinar la arquitectura en la que se está ejecutando. La primera es la instrucción 0x48, en 16 y 32 bits, esto es dec %eax, pero en 64 bits, es un prefijo de tamaño de instrucción. El segundo indicador es la misma instrucción, sin embargo, cuando lo ejecutamos en el valor 0x8000, el bit más significativo se voltea solo si el tamaño del registro es de 16 bits, configurando el indicador de desbordamiento y permitiéndonos usarlo jo.

En 16 bits, este código se interpreta de la siguiente manera:

   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, este código se interpreta de la siguiente manera:

   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, este código se interpreta de la siguiente manera:

   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

código de máquina x86, 12 bytes

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

Sin golf:

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

Esta función funciona en Linux cuando se usa en ELF32, siguiendo i386 SysV ABI, así como en Windows / Wine cuando se usa en PE32, después de la stdcallconvención de llamada.

Mathematica, 17 bytes

$SystemWordLength

Cargadores de arranque

¿Sabía que GRUB e IPXE tienen lenguajes de programación completos de Turing accesibles en tiempo de ejecución? La familia de cargadores de arranque Syslinux no, pero pueden hacer esto.

IPXE, 36 bytes

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

la primera línea es necesaria si el script se ejecuta de forma remota, pero no si se escribe directamente en la línea de comando.

GRUB, 42 bytes

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

Syslinux, 186 bytes

Esto toma tres archivos, el primero es syslinux.cfg (o 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

y t.cfg

menu title 32

ans s.cfg

menu title 64

Para este, la parte difícil es que syslinux no tiene capacidades simples de visualización de texto, por lo que se abusa del menú.

Julia 14 13 bytes

n->8sizeof(1)

Explique:

• Función Anon, tomar cualquier cosa (incluido nothing) devolver un número entero 32 o 64
• Los literales enteros son de tipo Intque, dependiendo de si 32 bits o 64 bits, es un Int32o un Int64( 1podría ser cualquier dígito)
• colocar un número antes de una llamada de función hace una multiplicación de yuxtaposición
• Esta es básicamente una versión reducida del código paraSys.WORD_SIZE , utilizada en la respuesta de rahnema1

Otra respuesta divertida es ()->"$(Int)"[4:5], pero no puedo contar la cuenta atrás de esa.

-1 gracias a @Roman Gräf

julia, 20 17 16 bytes

n->Sys.WORD_SIZE

* Gracias a @LyndonWhite guardó 3 bytes * Gracias a @ RomanGräf guardó un byte

Respuestas anteriores:

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

Pruébalo en línea!

JavaScript (Node.js), 24 bytes

_=>process.arch.slice(1)

Esta es una función y regresa '32', '64'o si ninguno 'rm'.

C, 33 31 29 23 bytes

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

¡Gracias a los comentaristas @ceilingcat y @Dennis por los consejos de golf!

PowerShell, 16 bytes

8*[IntPtr]::Size

Obtiene el tamaño del puntero en bytes, se multiplica por 8 para obtener bits.

Python 2, 52, 48, 42 41 bytes

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

Gracias a totalmente humano!

Java 8, 45 bytes

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

Perl 6 , 17 bytes

say $*KERNEL.bits

Intentalo

Hay un relacionado $?BITSque contiene el número de bits que tiene un nativo inten el tiempo de ejecución.

say $?BITS

Intentalo

Windows CMD, 56 52 bytes (¡gracias Bob!)

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

Todavía sorprendentemente largo, ¡el más largo hasta ahora!

C, Win32 API, 103 183 bytes

#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 realidad hay más de 2 casos aquí. Vamos a examinarlos

• Lo más fácil: IsWow64Processno existe: estamos en un sistema operativo de 32 bits

Para los próximos dos casos, necesitamos saber que nuestro binario será un ejecutable de 32 bits. Y esta descripción de lo que estará fuera del parámetro out deIsWow64Process

Un puntero a un valor que se establece en TRUE si el proceso se ejecuta en WOW64. Si el proceso se ejecuta en Windows de 32 bits, el valor se establece en FALSO. Si el proceso es una aplicación de 64 bits que se ejecuta en Windows de 64 bits, el valor también se establece en FALSO.

Eso nos deja con dos casos adicionales:

• IsWow64Process existe, y produce VERDADERO -> Estamos en una máquina de 64 bits
• IsWow64Process existe, y produce FALSO -> Estamos en una máquina de 32 bits

No nos preocupa la parte en que una aplicación de 64 bits en un Windows de 64 bits produce FALSO. Como sabemos que nuestra aplicación es de 32 bits

Ah, y hay un caso adicional que no está cubierto por este desafío y que debería ser raro de todos modos:

• IsWow64Process existe, pero falla: el valor predeterminado es la máquina de 32 bits.

Esto debería cubrir la mayoría de los sistemas operativos Windows NT. Solo he probado en Win10 de 64 bits, Win 7 de 64 bits, Win 8.1 de 32 bits y WinXP SP1 de 32 bits

Respuesta original:

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

Para estar seguros, necesitamos distinguir solo 2 casos

• IsWow64Process no existe en kernel32.dll => Estamos en una máquina de 32 bits.

• IsWow64Process existe => Estamos en una máquina de 64 bits.

El valor real proporcionado por IsWow64Processes irrelevante para este desafío, ya que queremos que el binario sea de 32 bits en cualquier caso.

A diferencia de la mayoría de las respuestas, esto no depende de que el binario se compile en la máquina en la que se ejecuta.

Si conociera una función más corta que está presente solo en máquinas de 64 bits y no en máquinas de 32 bits, podría acortar la respuesta.

C #, 60 50 bytes

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

Gracias @TheLethalCoder

Ruby, 22 bytes

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

["any string"].pack("p")devuelve una cadena cuyos bytes corresponden al puntero que apunta hacia "any string", y tiene 8 caracteres si el sistema operativo es de 64 bits, o 4 caracteres si el sistema operativo es de 32 bits.

R, 16 bytes

.Machine[[18]]*8

Devuelve el tamaño del puntero.

Perl, 18 15 18 bytes

say length pack p8

código de máquina x86, 8 bytes

31 C0 B0 40 48 24 60 C3

Sin golf:

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 se compila como un ejecutable de 64 bits, devuelve 64 in eax, y si se compila como 32 bits, devuelve 32, independientemente del sistema operativo.

Esta respuesta se basa en las reglas que dicen:

Puede suponer que los usuarios utilizarán software de 64 bits siempre que sea posible.

PHP, 18 bytes

<?=PHP_INT_SIZE*8;

Esto maneja correctamente todos los casos de 32, 64 y otras CPU de bits siempre que PHP_INT_SIZE sea correcto, ¡mostrará el tamaño preciso de la CPU sin importar en qué CPU se esté ejecutando PHP!

Si PHP se está ejecutando en

SO de 32 bits PHP_INT_SIZE == 4,

SO de 64 bits PHP_INT_SIZE == 8,

Sistema operativo de 16 bits PHP_INT_SIZE == 2 (teóricamente)

Sistema operativo de 8 bits PHP_INT_SIZE == 1 (nuevamente teóricamente)

Sistema operativo de 128 bits PHP_INT_SIZE == 16 (Todavía no se ha logrado pero es posible)

C # (29 bytes)

Console.Write(IntPtr.Size*8);

Potencia Shell, 17 52 bytes

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

Devuelve 64 si alguno de los siguientes es verdadero:

• Tiene un directorio en su unidad actual con un nombre de archivo que termina en un par cercano, la idea es detectar Program Files (x86).
• archdevuelve una cadena que termina en 4(ASCII 52), al igual que x86_64, a diferencia de, por ejemplo i686.

El intento de captura está destinado a eludir el error que obtienes si gci no devuelve nada y no tienes un arco . No he encontrado una forma más corta de hacerlo hasta ahora. gci se usa sobre ls porque en Linux, ls producirá un error visible.

Esta versión debería detectar si el sistema operativo es de 64 bits en lugar de solo PowerShell, y se ha probado que funciona en Windows y Linux. Para soporte de Mac, reemplace archcon uname -m.

Versión anterior solo para Windows: -!(ls \*`))*32+64

Swift 4 REPL / Playground, 12 bytes

Int.bitWidth

Inttiene el tamaño de una palabra, actúa como Int32o Int64dependiendo del sistema.

Rubí, 10 bytes

p 0.size*8

Si bien Ruby puede usar enteros de cualquier longitud, internamente almacena los valores que se ajustan a una palabra de máquina como Fixnum. El método Fixnum#sizesiempre devuelve la longitud en bytes de una palabra de máquina.

La Fixnumclase se eliminó en Ruby 2.4.0, su funcionalidad se incluyó en la clase Integer. El código se mantiene.

Shell, 26 bytes

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

Bash, 25 17 bytes

getconf LONG_BIT

Gracias a Dennis por la ayuda en el golf.

C, 22 bytes

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

Esta es una respuesta basada en el tamaño del puntero que asume un binario nativo. El 0se envía a int**(dirección 0x0). Luego agregamos 8 a 0, que, en C avanza, el puntero por sizeof(int*)*8. 4 bytes * 8 bits = 32, 8 bytes * 8 bits = 64. Entonces obtenemos (int**)0x20y 0x40que luego se intconvierten implícitamente como enteros al devolverlos de una función de retorno implícito .

C, independiente, 34 bytes

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

C, divertido con Unicode, 30 puntos de código, 34 bytes (UTF-8)

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

Java, 50 bytes

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

PHP, 29 bytes

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

https://3v4l.org/Y6JXv

Python 3 , 77 84 71 59 bytes

-13 bytes, gracias a @JonathanAllan!
Hasta 59 por @Clearer

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

Pruébalo en línea!

Mi primer código de golf:
debería mostrar la versión correcta incluso cuando se ejecuta 32Bit-Python en 64bit-OS.
Suponiendo que platform.machine()da i*86o x86para 32Bit-OS. No tengo uno disponible para verificar esto. La salida es 0cuando el sistema operativo no está en 64 / 32Bit
Edit: se agregó una declaración de impresión, por lo que tiene 7 bytes más