Non è più troppo importante, ma a volte qualcuno deve saperlo.

Ecco un semplice golf: Non prendere input da parte dell'utente, dimmi se il computer su cui viene eseguito il codice si trova su un sistema operativo a 64 bit o su un sistema operativo a 32 bit!

Se il codice viene eseguito su un sistema operativo a 32 bit, stampare "32", se il codice viene eseguito su un sistema operativo a 64 bit, produrre "64". Importante: stampare qualsiasi altra stringa non vuota di caratteri alfanumerici se non è a 32 o 64 bit.

Si noti che un programma a 32 bit in esecuzione su un computer con un sistema operativo a 64 bit dovrebbe generare "64". Puoi presumere che gli utenti useranno software a 64 bit ogni volta che sarà possibile.

Per essere idoneo per l'ingresso, il tuo codice deve essere in grado di funzionare su Windows 4.10 o su sistemi Windows supportati da Microsoft più recenti e almeno un sapore di Linux di tua scelta (purché tale sapore sia gratuito). Le mod di compatibilità possono essere installate, purché il programma restituisca ancora il valore corretto.

Si applicano le solite regole del code-golf .

Nota: se la tua risposta è destinata solo a stampare 32 o 64, ma non il caso alt, lo accetterò, ma non è una risposta concorrente.

^{Proverò a pubblicare alcuni risultati dell'esecuzione di questi codici su diversi sistemi operativi in ​​seguito!}

x86 Assembly (poliglotta), 13 byte

bytecode:

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

Definisce una funzione che restituisce 32 se interpretata come 32-bit, 64 se 64-bit e 32767 se 16-bit.

Volevo realizzare un poliglotta che funzionasse su Windows e Linux, ma è molto più difficile di quanto pensassi. Dato che non sono sicuro che esista un modo per stampare un valore su Windows non a 16 bit senza collegamento.

Spiegazione

Questo codice utilizza due tell per determinare l'architettura su cui è in esecuzione. Il primo è l'istruzione 0x48: su 16 e 32 bit, questo è dec %eax, ma su 64 bit, è un prefisso della dimensione dell'istruzione. Il secondo tell è la stessa istruzione, tuttavia, quando lo eseguiamo sul valore 0x8000, il bit più significativo viene invertito solo se la dimensione del registro è di 16 bit, impostando il flag di overflow e permettendoci di usarlo jo.

A 16 bit, questo codice viene interpretato come segue:

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

A 32 bit, questo codice viene interpretato come segue:

   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

A 64 bit, questo codice viene interpretato come segue:

   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

codice macchina x86, 12 byte

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

Questa funzione è attiva in Linux se utilizzata in ELF32, seguendo l'iI6 SysV ABI, così come in Windows / Wine se utilizzata in PE32, seguendo la stdcallconvenzione di chiamata.

Mathematica, 17 byte

$SystemWordLength

Caricatori di avvio

Sapevi che GRUB e IPXE hanno entrambi i linguaggi di programmazione completi Turing accessibili in fase di esecuzione? La famiglia di boot loader Syslinux non lo fa, ma può farlo.

IPXE, 36 byte

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

la prima riga è necessaria se lo script viene eseguito in remoto, ma non se digitato direttamente nella riga di comando.

GRUB, 42 byte

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

Syslinux, 186 byte

Questo richiede tre file il primo è syslinux.cfg (o isolinux.cfg, ecc.).

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

Per questo la parte difficile è che syslinux non ha alcuna semplice capacità di visualizzazione del testo, quindi il menu è abusato.

Julia 14 13 byte

n->8sizeof(1)

Spiegare:

• Una funzione anon, che accetta qualsiasi cosa (incluso nothing) restituendo un numero intero 32 o 64
• I letterali interi sono di tipo Intche, a seconda che sia a 32 bit o 64 bit, è un Int32o un Int64( 1potrebbe essere qualsiasi cifra)
• posizionando un numero prima di una chiamata di funzione si verifica una moltiplicazione di giustapposizione
• Questa è fondamentalmente una versione minimizzata del codice perSys.WORD_SIZE , usata nella risposta di rahnema1

Un'altra risposta divertente è ()->"$(Int)"[4:5], ma non riesco a fare il conto alla rovescia su quella.

-1 grazie a @Roman Gräf

julia, 20 17 16 byte

n->Sys.WORD_SIZE

* Grazie a @LyndonWhite salvato 3 byte * Grazie a @ RomanGräf ha salvato un byte

Risposte precedenti:

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

Provalo online!

JavaScript (Node.js), 24 byte

_=>process.arch.slice(1)

Questa è una funzione e ritorna '32', '64'o, se nessuna 'rm'.

C, 33 31 29 23 byte

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

Grazie ai commentatori @ceilingcat e @Dennis per i suggerimenti sul golf!

PowerShell, 16 byte

8*[IntPtr]::Size

Ottiene la dimensione del puntatore in byte, moltiplica per 8 per ottenere bit.

Python 2, 52, 48, 42 41 byte

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

Grazie a totalmente umano!

Java 8, 45 byte

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

Perl 6 , 17 byte

say $*KERNEL.bits

Provalo

C'è un correlato $?BITSche contiene il numero di bit che un nativo intha nel runtime.

say $?BITS

Provalo

Windows CMD, 56 52 byte (grazie Bob!)

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

Ancora sorprendentemente lungo - il più lungo finora!

C, API Win32, 103 183 byte

#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;}

In realtà ci sono più di 2 casi qui. Esaminiamoli

• Il più semplice: IsWow64Processnon esiste: siamo su un sistema operativo a 32 bit

Per i prossimi due casi abbiamo bisogno di sapere che il nostro binario sarà un eseguibile a 32 bit. E questa descrizione di ciò che sarà fuori nel parametro out diIsWow64Process

Un puntatore a un valore impostato su TRUE se il processo è in esecuzione su WOW64. Se il processo è in esecuzione su Windows a 32 bit, il valore è impostato su FALSE. Se il processo è un'applicazione a 64 bit in esecuzione su Windows a 64 bit, il valore è impostato anche su FALSE.

Questo ci lascia con due casi aggiuntivi:

• IsWow64Process esiste e produce VERO -> Siamo su una macchina a 64 bit
• IsWow64Process esiste e produce FALSO -> Siamo su una macchina a 32 bit

Non ci preoccupiamo della parte in cui un'applicazione a 64 bit su una Windows a 64 bit produce FALSO. Come sappiamo che la nostra applicazione è a 32 bit

Oh, e c'è un altro caso che non è coperto da questa sfida e dovrebbe essere comunque raro:

• IsWow64Process esiste, ma non riesce: per impostazione predefinita si utilizza una macchina a 32 bit.

Questo dovrebbe coprire la maggior parte dei sistemi operativi Windows NT. Hanno testato solo su Win10 64-Bit, Win 7 64-Bit, Win 8.1 32-Bit e WinXP SP1 32-Bit

Risposta originale:

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

Per essere sicuri, dobbiamo distinguere solo 2 casi

• IsWow64Process non esiste in kernel32.dll => Siamo su una macchina a 32 bit.

• IsWow64Process esiste => Siamo su una macchina a 64 bit.

Il valore effettivo fornito da IsWow64Processè irrilevante per questa sfida, poiché vogliamo che il binario sia a 32 bit in ogni caso.

Diversamente dalla maggior parte delle risposte, ciò non dipende dal fatto che il binario stesso sia compilato sulla macchina su cui è eseguito.

Se conoscessi una funzione più breve presente solo su macchine a 64 bit e non a 32 bit, potrei accorciare la risposta.

C #, 60 50 byte

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

Grazie @TheLethalCoder

Rubino, 22 byte

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

["any string"].pack("p")restituisce una stringa i cui byte corrispondono al puntatore che puntava verso "any string", ed è di 8 caratteri se il sistema operativo è a 64 bit o 4 caratteri se il sistema operativo è a 32 bit.

R, 16 byte

.Machine[[18]]*8

Restituisce la dimensione del puntatore.

Perl, 18 15 18 byte

say length pack p8

codice macchina x86, 8 byte

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 compilato come eseguibile a 64 bit, restituisce 64 pollici eaxe, se compilato come 32 bit, restituisce 32, indipendentemente dal sistema operativo.

Questa risposta si basa sulle regole che dicono:

Puoi presumere che gli utenti useranno software a 64 bit ogni volta che sarà possibile.

PHP, 18 byte

<?=PHP_INT_SIZE*8;

Questo gestisce correttamente tutti i casi di CPU a 32, 64 e altri bit a condizione che PHP_INT_SIZE sia corretto, mostrerà la dimensione precisa della CPU indipendentemente da quale CPU PHP è in esecuzione!

Se PHP è in esecuzione

Sistema operativo a 32 bit PHP_INT_SIZE == 4,

Sistema operativo a 64 bit PHP_INT_SIZE == 8,

Sistema operativo a 16 bit PHP_INT_SIZE == 2 (teoricamente)

Sistema operativo a 8 bit PHP_INT_SIZE == 1 (di nuovo teoricamente)

Sistema operativo a 128 bit PHP_INT_SIZE == 16 (Non ancora raggiunto ma possibile)

C # (29 byte)

Console.Write(IntPtr.Size*8);

PowerShell, 17 52 byte

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

Restituisce 64 se si verifica una delle seguenti condizioni:

• Si dispone di una directory sull'unità corrente con un nome file che termina in una parentesi chiusa, l'idea è quella di rilevare Program Files (x86).
• archrestituisce una stringa che termina con 4(ASCII 52), come x86_64, al contrario di es i686.

Il try-catch ha lo scopo di aggirare l'errore che si ottiene se gci non restituisce nulla e non si ha un arco . Non ho trovato un modo più breve per farlo finora. GCI viene utilizzato su ls perché su Linux, ls produrrà un errore di visibile.

Questa versione dovrebbe rilevare se il sistema operativo è a 64 bit anziché solo PowerShell ed è testato per funzionare su Windows e Linux. Per il supporto Mac, sostituirlo archcon uname -m.

Versione precedente solo per Windows: -!(ls \*`))*32+64

Swift 4 REPL / Playground, 12 byte

Int.bitWidth

Intha le dimensioni di una parola, agisce come uno Int32o Int64dipende dal sistema.

Rubino, 10 byte

p 0.size*8

Mentre Ruby può usare numeri interi di qualsiasi lunghezza, internamente memorizza i valori che si adattano a una parola macchina come Fixnum. Il metodo Fixnum#sizerestituisce sempre la lunghezza in byte di una parola macchina.

La Fixnumclasse è stata rimossa in Ruby 2.4.0, la sua funzionalità è stata inclusa nella classe Integer. Il codice è valido.

Shell, 26 byte

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

Bash, 25 17 byte

getconf LONG_BIT

Grazie a Dennis per l'aiuto nel golf.

C, 22 byte

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

Questa è una risposta basata sulla dimensione del puntatore che assume un file binario nativo. Il 0il cast int**(indirizzo 0x0). Quindi aggiungiamo 8 a 0, che, in C avanza, il puntatore di sizeof(int*)*8. 4 byte * 8 bit = 32, 8 byte * 8 bit = 64. Quindi otteniamo (int**)0x20e 0x40che vengono quindi implicitamente espressi come numeri interi restituendoli da una intfunzione di ritorno implicito .

C, autonomo, 34 byte

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

C, divertente con Unicode, 30 punti di codice, 34 byte (UTF-8)

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

Java, 50 byte

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

PHP, 29 byte

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

https://3v4l.org/Y6JXv

Python 3 , 77 84 71 59 byte

-13 byte, grazie a @JonathanAllan!
Fino a 59 di @Clearer

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

Provalo online!

Il mio pugno time-golfing :)
Dovrebbe produrre la versione corretta anche quando si esegue 32Bit-Python su 64 bit-OS.
Supponendo platform.machine()dà i*86o x86per 32 bit-OS. Non ne ho uno disponibile per verificare questo. L'output è 0quando il sistema operativo non è in 64/32 bit
Modifica: aggiunta istruzione di stampa, quindi ha ottenuto 7 byte in più