Não é mais tão importante, mas, ocasionalmente, alguém precisa saber.

Aqui está um exemplo simples: não tendo nenhuma entrada do usuário, diga-me se o computador no qual o código é executado está em um sistema operacional de 64 bits ou em um sistema operacional de 32 bits!

Se o código for executado em um sistema operacional de 32 bits, imprima "32"; se o código for executado em um sistema operacional de 64 bits, produza "64". Importante: imprima qualquer outra sequência não vazia de caracteres alfanuméricos se não tiver 32 ou 64 bits.

Observe que um programa de 32 bits em execução em um computador com sistema operacional de 64 bits deve gerar "64". Você pode assumir que os usuários usarão software de 64 bits sempre que possível.

Para se qualificar para a entrada, seu código deve ser capaz de executar nos sistemas Windows 4.10 ou mais recentes suportados pela Microsoft e pelo menos um tipo de Linux de sua escolha (desde que esse tipo seja gratuito). Mods de compatibilidade podem ser instalados, desde que o programa ainda retorne o valor correto.

Aplicam-se as regras usuais de código-golfe .

Nota: Se a sua resposta tiver apenas a intenção de imprimir 32 ou 64, mas não o caso alt, aceitarei, mas não é uma resposta concorrente.

^{Vou tentar publicar alguns resultados da execução desses códigos em diferentes sistemas operacionais mais tarde!}

Montagem x86 (poliglota), 13 bytes

Bytecode:

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

Define uma função que retorna 32 se interpretada como 32 bits, 64 se 64 bits e 32767 se 16 bits.

Eu queria criar um poliglota que rodasse no Windows e Linux, mas isso é muito mais difícil do que eu pensava. Como é, não tenho certeza de que exista alguma maneira de imprimir um valor no Windows que não seja de 16 bits sem vincular.

Explicação

Este código usa duas instruções para determinar a arquitetura em que está sendo executado. A primeira é a instrução 0x48 - em 16 e 32 bits dec %eax, mas em 64 bits, é um prefixo do tamanho da instrução. A segunda indicação é a mesma instrução, no entanto, quando a executamos no valor 0x8000, o bit mais significativo é invertido apenas se o tamanho do registro for 16 bits, configurando o sinalizador de estouro e nos permitindo usar jo.

Em 16 bits, esse código é interpretado da seguinte maneira:

   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 */

Em 32 bits, esse código é interpretado da seguinte maneira:

   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

Em 64 bits, esse código é interpretado da seguinte maneira:

   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

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

Esta função funciona no Linux quando usado no ELF32, seguindo o i386 SysV ABI, bem como no Windows / Wine quando usado no PE32, seguindo a stdcallconvenção de chamada.

Mathematica, 17 bytes

$SystemWordLength

Carregadores de inicialização

Você sabia que o GRUB e o IPXE possuem linguagens de programação completas de Turing acessíveis em tempo de execução? A família Syslinux de gerenciadores de inicialização não, mas eles podem fazer isso.

IPXE, 36 bytes

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

a primeira linha é necessária se o script for executado remotamente, mas não se digitado diretamente na linha de comando.

GRUB, 42 bytes

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

Syslinux, 186 bytes

São necessários três arquivos, o primeiro é o 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

e t.cfg

menu title 32

ans s.cfg

menu title 64

Para este, a parte mais difícil é que o syslinux não possui recursos simples de exibição de texto; portanto, o menu é abusado.

Julia 14 13 bytes

n->8sizeof(1)

Explicar:

• Função Anon, recebendo qualquer coisa (inclusive nothing) retornando um número inteiro 32 ou 64
• Literais inteiros são do tipo Intque, dependendo de 32 ou 64 bits, é um Int32ou um Int64( 1pode ser qualquer dígito)
• colocar um número antes de uma chamada de função fazer uma multiplicação de justaposição
• Esta é basicamente uma versão minificada do códigoSys.WORD_SIZE usada na resposta de rahnema1

Outra resposta divertida é ()->"$(Int)"[4:5], mas não consigo contar a contagem.

-1 graças a @Roman Gräf

julia, 20 17 16 bytes

n->Sys.WORD_SIZE

* Graças a @LyndonWhite salvou 3 bytes * Graças a @ RomanGräf salvou um byte

Respostas anteriores:

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

Experimente online!

JavaScript (Node.js), 24 bytes

_=>process.arch.slice(1)

Esta é uma função e retorna '32', '64'ou, se nenhuma 'rm'.

C, 33 31 29 23 bytes

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

Obrigado aos comentadores @ceilingcat e @Dennis pelas dicas de golfe!

PowerShell, 16 bytes

8*[IntPtr]::Size

Obtém o tamanho do ponteiro em bytes, multiplica por 8 para obter bits.

Python 2, 52, 48, 42 41 bytes

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

Graças a totalmente humano!

Java 8, 45 bytes

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

Perl 6 , 17 bytes

say $*KERNEL.bits

Tente

Existe um relacionado $?BITSque contém o número de bits que um nativo intpossui no tempo de execução.

say $?BITS

Tente

Windows CMD, 56 52 bytes (obrigado Bob!)

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

Ainda surpreendentemente demorado - o mais longo até agora!

C, API Win32, 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;}

Na verdade, existem mais de 2 casos aqui. Vamos examiná-los

• O mais fácil: IsWow64Processnão existe: estamos em um sistema operacional de 32 bits

Para os próximos dois casos, precisamos ter o conhecimento de que nosso binário será um executável de 32 bits. E essa descrição do que será exibido no parâmetro out deIsWow64Process

Um ponteiro para um valor definido como TRUE se o processo estiver sendo executado no WOW64. Se o processo estiver sendo executado no Windows de 32 bits, o valor será definido como FALSE. Se o processo for um aplicativo de 64 bits em execução no Windows de 64 bits, o valor também será definido como FALSE.

Isso nos deixa com dois casos adicionais:

• IsWow64Process existe e gera VERDADEIRO -> Estamos em uma máquina de 64 bits
• IsWow64Process existe e gera FALSE -> Estamos em uma máquina de 32 bits

Não nos preocupamos com a parte em que um aplicativo de 64 bits no Windows de 64 bits gera FALSE. Como sabemos que nosso aplicativo é de 32 bits

Ah, e há um caso adicional que não é coberto por esse desafio e deve ser raro de qualquer maneira:

• IsWow64Process existe, mas falha: O padrão é a máquina de 32 bits.

Isso deve abranger a maioria dos sistemas operacionais Windows NT. Foram testados apenas no Win10 de 64 bits, no Win 7 de 64 bits, no Win 8.1 de 32 bits e no WinXP SP1 de 32 bits

Resposta original:

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

Para ter certeza, precisamos distinguir apenas 2 casos

• IsWow64Process não existe no kernel32.dll => Estamos em uma máquina de 32 bits.

• IsWow64Process existe => Estamos em uma máquina de 64 bits.

O valor real fornecido por IsWow64Processé irrelevante para esse desafio, pois queremos que o binário seja de 32 bits em qualquer caso.

Ao contrário da maioria das respostas, isso não depende do próprio binário sendo compilado na máquina em que é executado.

Se eu conhecesse uma função mais curta que está presente apenas em máquinas de 64 bits e não de 32 bits, poderia reduzir a resposta.

C #, 60 50 bytes

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

Obrigado @TheLethalCoder

Ruby, 22 bytes

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

["any string"].pack("p")retorna uma cadeia de caracteres cujos bytes correspondem ao ponteiro apontado para "any string"e possui 8 caracteres se o sistema operacional for de 64 bits ou 4 caracteres se o sistema operacional for de 32 bits.

R, 16 bytes

.Machine[[18]]*8

Retorna o tamanho do ponteiro.

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

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

Se compilado como um executável de 64 bits, ele retornará 64 pol eaxe, se compilado como 32 bits, retornará 32 - independentemente do sistema operacional.

Esta resposta se baseia nas regras que dizem:

Você pode assumir que os usuários usarão software de 64 bits sempre que possível.

PHP, 18 bytes

<?=PHP_INT_SIZE*8;

Isso lida corretamente com todos os casos de CPUs de 32, 64 e outros bits, desde que PHP_INT_SIZE esteja correto, mostrando o tamanho preciso da CPU, independentemente da CPU em que a PHP esteja sendo executada!

Se o PHP estiver sendo executado em

SO PHP_INT_SIZE == 4 de 32 bits,

SO de 64 bits PHP_INT_SIZE == 8,

SO de 16 bits PHP_INT_SIZE == 2 (teoricamente)

SO de 8 bits PHP_INT_SIZE == 1 (novamente teoricamente)

SO de 128 bits PHP_INT_SIZE == 16 (Ainda não foi alcançado, mas é possível)

C # (29 bytes)

Console.Write(IntPtr.Size*8);

PowerShell, 17 52 bytes

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

Retorna 64 se um dos seguintes for verdadeiro:

• Você tem um diretório em sua unidade atual com um nome de arquivo que termina em uma parêntese, a idéia é detectar Program Files (x86).
• archretorna uma string terminada em 4(ASCII 52), como x86_64, ao contrário de por exemplo i686.

O try-catch visa contornar o erro que você obtém se gci não retornar nada e você não tiver um arco . Eu não encontrei uma maneira mais curta de fazê-lo até agora. gci é usado sobre ls porque no Linux, ls produzirá um erro visível.

Esta versão deve detectar se o sistema operacional é de 64 bits e não apenas o PowerShell, e foi testado para funcionar no Windows e Linux. Para suporte ao Mac, substitua archpor uname -m.

Versão anterior apenas para Windows: -!(ls \*`))*32+64

Swift 4 REPL / Parque infantil, 12 bytes

Int.bitWidth

Inttem tamanho de palavra, agindo como um Int32ou Int64dependendo do sistema.

Ruby, 10 bytes

p 0.size*8

Enquanto Ruby pode usar números inteiros de qualquer tamanho, internamente ele armazena os valores que cabem em uma palavra de máquina como Fixnum. O método Fixnum#sizesempre retorna o comprimento em bytes de uma palavra de máquina.

A Fixnumclasse foi removida no Ruby 2.4.0, sua funcionalidade foi incluída na classe Integer. O código permanece.

Shell, 26 bytes

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

Bash, 25 17 bytes

getconf LONG_BIT

Agradecimentos a Dennis pela ajuda no golfe.

C, 22 bytes

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

Esta é uma resposta baseada no tamanho do ponteiro que assume um binário nativo. O 0é convertido para int**(endereço 0x0). Em seguida, adicionamos 8 a 0, que, em C, avança, o ponteiro por sizeof(int*)*8. 4 bytes * 8 bits = 32, 8 bytes * 8 bits = 64. Então, obtemos (int**)0x20e 0x40que são convertidos implicitamente como números inteiros, retornando-os de uma intfunção de retorno implícito .

C, autônomo, 34 bytes

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

C, divertido com Unicode, 30 pontos 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, graças a @ Jonathanon Allan!
Até 59 por @Clearer

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

Experimente online!

Meu primeiro código de golfe :)
Deve produzir a versão correta, mesmo ao executar 32Bit-Python no sistema operacional de 64 bits.
Supondo que você platform.machine()fornece i*86ou x86para 32Bit-OS. Não tenho um disponível para verificar isso. A saída ocorre 0quando o SO não está no 64 / 32Bit
Edit: Adicionada instrução de impressão, por isso possui 7 bytes a mais