Es ist nicht mehr so ​​wichtig, aber gelegentlich muss es jemand wissen.

Hier ist ein einfaches Beispiel: Sagen Sie mir ohne Benutzereingabe, ob der Computer, auf dem der Code ausgeführt wird, ein 64-Bit-Betriebssystem oder ein 32-Bit-Betriebssystem ist!

Wenn der Code auf einem 32-Bit-Betriebssystem ausgeführt wird, geben Sie "32" aus. Wenn der Code auf einem 64-Bit-Betriebssystem ausgeführt wird, geben Sie "64" aus. Wichtig: Drucken Sie eine beliebige andere nicht leere Zeichenfolge aus alphanumerischen Zeichen, wenn es sich nicht um 32- oder 64-Bit handelt.

Bitte beachten Sie, dass ein 32-Bit-Programm, das auf einem Computer mit einem 64-Bit-Betriebssystem ausgeführt wird, "64" ausgeben sollte. Sie können davon ausgehen, dass Benutzer nach Möglichkeit 64-Bit-Software verwenden.

Um zur Teilnahme berechtigt zu sein, muss Ihr Code auf Windows 4.10 oder neueren von Microsoft unterstützten Windows-Systemen und mindestens einer Linux-Version Ihrer Wahl ausgeführt werden können (sofern diese Version kostenlos ist). Kompatibilitätsmods können installiert werden, solange das Programm noch den richtigen Wert zurückgibt.

Es gelten die üblichen Code-Golf- Regeln.

Hinweis: Wenn Ihre Antwort nur zum Ausdrucken von 32 oder 64 gedacht ist, nicht jedoch für den Alternativfall, akzeptiere ich sie, aber es handelt sich nicht um eine konkurrierende Antwort.

^{Ich werde später versuchen, einige Ergebnisse der Ausführung dieser Codes auf verschiedenen Betriebssystemen zu veröffentlichen!}

x86-Assembly (mehrsprachig), 13 Byte

Bytecode:

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

Definiert eine Funktion, die 32 zurückgibt, wenn sie als 32-Bit, 64, wenn 64-Bit und 32767, wenn 16-Bit interpretiert wird.

Ich wollte einen Polyglot machen, der unter Windows und Linux lief, aber das ist viel schwieriger als ich dachte. Da ich nicht sicher bin, ob es überhaupt eine Möglichkeit gibt, einen Wert unter Nicht-16-Bit-Windows ohne Verknüpfung zu drucken.

Erläuterung

Dieser Code verwendet zwei Tells, um die Architektur zu bestimmen, auf der er ausgeführt wird. Der erste ist der Befehl 0x48 - bei 16 und 32 Bit ist dies der Fall dec %eax, bei 64 Bit handelt es sich jedoch um ein Präfix der Befehlsgröße . Der zweite Befehl ist derselbe. Wenn wir ihn jedoch auf dem Wert 0x8000 ausführen, wird das höchstwertige Bit nur dann umgedreht, wenn die Registergröße 16 Bit beträgt, wodurch das Überlaufflag gesetzt und die Verwendung zugelassen wird jo.

In 16 Bits wird dieser Code wie folgt interpretiert:

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

In 32 Bit wird dieser Code wie folgt interpretiert:

   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

In 64 Bit wird dieser Code wie folgt interpretiert:

   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

x86-Maschinencode, 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

Diese Funktion funktioniert unter Linux unter ELF32 nach i386 SysV ABI sowie unter Windows / Wine unter PE32 nach stdcallAufruf der Konvention.

Mathematica, 17 Bytes

$SystemWordLength

Bootloader

Wussten Sie, dass sowohl bei GRUB als auch bei IPXE die vollständigen Programmiersprachen von Turing zur Laufzeit verfügbar sind? Die Syslinux-Familie von Bootloadern kann dies jedoch nicht.

IPXE, 36 Byte

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

Die erste Zeile wird benötigt, wenn das Skript remote ausgeführt wird, jedoch nicht, wenn es direkt in der Befehlszeile eingegeben wird.

GRUB, 42 Bytes

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

Syslinux, 186 Bytes

Das braucht drei Dateien, die erste ist syslinux.cfg (oder isolinux.cfg usw.).

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

und t.cfg

menu title 32

ans an cfg

menu title 64

In diesem Fall ist der schwierige Teil, dass Syslinux keine einfachen Textanzeigefunktionen hat, sodass das Menü missbraucht wird.

Julia 14 13 Bytes

n->8sizeof(1)

Erklären:

• Anon-Funktion, die alles (einschließlich nothing) annimmt, was eine Ganzzahl von 32 oder 64 zurückgibt
• Ganzzahlige Literale sind vom Typ Int, je nachdem, ob es sich bei 32-Bit- oder 64-Bit- Literalen um ein Int32oder ein Bit handelt Int64(das 1kann eine beliebige Ziffer sein).
• Das Platzieren einer Nummer vor einem Funktionsaufruf führt eine Nebeneinander-Multiplikation durch
• Dies ist im Grunde eine verkleinerte Version des Codes fürSys.WORD_SIZE , der in der Antwort von rahnema1 verwendet wird

Eine andere lustige Antwort ist ()->"$(Int)"[4:5], aber ich kann den Countdown für diese nicht abrufen.

-1 danke an @Roman Gräf

julia, 20 17 16 bytes

n->Sys.WORD_SIZE

* Dank @LyndonWhite wurden 3 Bytes gespeichert * Dank @ RomanGräf wurde ein Byte gespeichert

Bisherige Antworten:

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

Probieren Sie es online!

JavaScript (Node.js), 24 Byte

_=>process.arch.slice(1)

Dies ist eine Funktion und kehrt '32', '64'oder wenn weder 'rm'.

C 33 31 29 23 Bytes

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

Vielen Dank an die Kommentatoren @ceilingcat und @Dennis für die Golftipps!

PowerShell, 16 Byte

8*[IntPtr]::Size

Ruft die Zeigergröße in Byte ab und multipliziert sie mit 8, um Bits zu erhalten.

Python 2, 52, 48, 42, 41 Bytes

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

Danke an totalhuman!

Java 8, 45 Bytes

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

Perl 6 , 17 Bytes

say $*KERNEL.bits

Versuch es

Es gibt eine Verwandte, $?BITSdie die Anzahl der Bits enthält, die ein Native intin der Laufzeit hat.

say $?BITS

Versuch es

Windows CMD, 56 52 Bytes (danke Bob!)

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

Immer noch überraschend lang - bis jetzt am längsten!

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

Eigentlich gibt es hier mehr als 2 Fälle. Untersuchen wir sie

• Das einfachste: IsWow64Processexistiert nicht: Wir arbeiten mit einem 32-Bit-Betriebssystem

Für die nächsten beiden Fälle müssen wir wissen, dass unsere Binärdatei eine 32-Bit-ausführbare Datei sein wird. Und diese Beschreibung dessen, was in den out- Parameter von ausgegeben wirdIsWow64Process

Ein Zeiger auf einen Wert, der auf TRUE gesetzt ist, wenn der Prozess unter WOW64 ausgeführt wird. Wenn der Prozess unter 32-Bit-Windows ausgeführt wird, wird der Wert auf FALSE festgelegt. Wenn es sich bei dem Prozess um eine 64-Bit-Anwendung handelt, die unter 64-Bit-Windows ausgeführt wird, wird der Wert ebenfalls auf FALSE festgelegt.

Das lässt uns mit zwei zusätzlichen Fällen:

• IsWow64Process existiert und ergibt WAHR -> Wir sind auf einer 64-Bit-Maschine
• IsWow64Process existiert und ergibt FALSE -> Wir sind auf einer 32-Bit-Maschine

Wir sind nicht besorgt über den Teil, in dem eine 64-Bit-Anwendung auf einem 64-Bit-Windows FALSE ergibt. Wie wir wissen dass unsere Anwendung 32-Bit ist

Oh, und es gibt noch einen weiteren Fall, der von dieser Herausforderung nicht abgedeckt wird und auf jeden Fall selten sein sollte:

• IsWow64Process ist vorhanden, schlägt jedoch fehl: Wir verwenden standardmäßig einen 32-Bit-Computer.

Dies sollte die meisten Windows NT-Betriebssysteme abdecken. Habe nur auf Win10 64-Bit, Win7 64-Bit, Win 8.1 32-Bit und WinXP SP1 32-Bit getestet

Ursprüngliche Antwort:

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

Um sicherzugehen, müssen wir nur 2 Fälle unterscheiden

• IsWow64Process existiert nicht in kernel32.dll => Wir sind auf einer 32-Bit-Maschine.

• IsWow64Process existiert => Wir sind auf einer 64-Bit-Maschine.

Der tatsächliche Wert von IsWow64Process ist für diese Herausforderung unerheblich, da die Binärdatei auf jeden Fall 32 Bit sein soll.

Im Gegensatz zu den meisten Antworten hängt dies nicht davon ab, dass die Binärdatei selbst auf dem Computer kompiliert wird, auf dem sie ausgeführt wird.

Wenn ich eine kürzere Funktion kennen würde, die nur auf 64-Bit- und nicht auf 32-Bit-Computern verfügbar ist, könnte ich die Antwort verkürzen.

C #, 60-50 Bytes

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

Danke @TheLethalCoder

Ruby, 22 Bytes

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

["any string"].pack("p")Gibt eine Zeichenfolge zurück, deren Bytes dem Zeiger entsprechen, auf den gezeigt "any string"wird. Bei einem 64-Bit-Betriebssystem sind es 8 Zeichen, bei einem 32-Bit-Betriebssystem 4 Zeichen.

R, 16 Bytes

.Machine[[18]]*8

Gibt die Zeigergröße zurück.

Perl, 18 15 18 Bytes

say length pack p8

x86-Maschinencode, 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

Wenn es als ausführbare 64-Bit-Datei kompiliert wird, gibt es 64 Zoll zurück eax . Wenn es als 32-Bit kompiliert wird, gibt es 32 zurück - unabhängig vom Betriebssystem.

Diese Antwort basiert auf den Regeln:

Sie können davon ausgehen, dass Benutzer nach Möglichkeit 64-Bit-Software verwenden.

PHP, 18 Bytes

<?=PHP_INT_SIZE*8;

Damit werden alle Fälle von 32-, 64- und anderen Bit-CPUs korrekt behandelt. Vorausgesetzt, PHP_INT_SIZE ist korrekt, wird die genaue Größe der CPU angezeigt, unabhängig davon, auf welcher CPU PHP ausgeführt wird!

Wenn PHP läuft

32-Bit-Betriebssystem PHP_INT_SIZE == 4,

64-Bit-Betriebssystem PHP_INT_SIZE == 8,

16-Bit-Betriebssystem PHP_INT_SIZE == 2 (theoretisch)

8-Bit-Betriebssystem PHP_INT_SIZE == 1 (wieder theoretisch)

128-Bit-Betriebssystem PHP_INT_SIZE == 16 (noch nicht erreicht, aber möglich)

C # (29 Bytes)

Console.Write(IntPtr.Size*8);

Power Shell, 17 52 Bytes

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

Gibt 64 zurück, wenn eine der folgenden Bedingungen erfüllt ist:

• Auf Ihrem aktuellen Laufwerk befindet sich ein Verzeichnis mit einem Dateinamen, der auf "close paren" endet Program Files (x86).
• archgibt einen String zurück, der mit 4(ASCII 52) endet , wie x86_64im Gegensatz zu z i686.

Der Try-Catch soll den Fehler umgehen, den Sie erhalten, wenn gci nichts zurückgibt und Sie keinen Bogen haben . Ich habe bisher keinen kürzeren Weg gefunden. GCI wird verwendet , über ls weil auf Linux, ls einen sichtbaren Fehler produzieren.

Diese Version sollte erkennen, ob das Betriebssystem 64-Bit ist und nicht nur PowerShell. Es wurde getestet, um unter Windows und Linux zu funktionieren. Für Mac - Unterstützung, ersetzen archmit uname -m.

Vorherige Nur-Windows-Version: -!(ls \*`))*32+64

Swift 4 REPL / Playground, 12 Bytes

Int.bitWidth

Intist wortgroß und verhält sich entweder wie Int32oder Int64abhängig vom System.

Ruby, 10 Bytes

p 0.size*8

Ruby kann zwar Ganzzahlen beliebiger Länge verwenden, speichert jedoch intern die Werte, die in ein Maschinenwort passen, als Fixnum. Die Methode liefert Fixnum#sizeimmer die Länge eines Maschinenwortes in Bytes.

Die FixnumKlasse wurde in Ruby 2.4.0 entfernt, ihre Funktionalität wurde in die Klasse aufgenommen Integer. Der Code steht.

Shell, 26 Bytes

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

Bash, 25 17 Bytes

getconf LONG_BIT

Vielen Dank an Dennis für die Golfhilfe.

C, 22 Bytes

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

Dies ist eine auf der Zeigergröße basierende Antwort, die eine native Binärdatei voraussetzt. Das 0ist gegossen an int**(Adresse 0x0). Dann addieren wir 8 zu 0, was in C den Zeiger um vorrückt sizeof(int*)*8. 4 Bytes * 8 Bits = 32, 8 Bytes * 8 Bits = 64. Also bekommen wir (int**)0x20und0x40 die werden dann implizit als ganze Zahlen umgewandelt, indem sie von einem implizit zurückgegeben werdenint zurückgegebenen Funktion zurückgegeben werden.

C, eigenständig, 34 Bytes

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

C, Spaß mit Unicode, 30 Code-Punkte, 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, danke an JonathanAllan!
Bis auf 59 von @Clearer

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

Probieren Sie es online!

Mein erstes Mal Code-Golfen :)
Sollte die richtige Version ausgeben, auch wenn 32Bit-Python auf 64bit-OS läuft.
Vorausgesetzt es platform.machine()gibt i*86oder x86für 32Bit-OS. Ich habe keine, um dies zu überprüfen. Die Ausgabe erfolgt, 0wenn das Betriebssystem nicht im 64/32-
Bit- Modus ist