มันไม่สำคัญเกินไปอีกต่อไป แต่บางครั้งบางคนจำเป็นต้องรู้

นี่คือสนามกอล์ฟที่เรียบง่าย: ไม่ต้องป้อนข้อมูลจากผู้ใช้บอกฉันว่าคอมพิวเตอร์ที่รันโค้ดอยู่บนระบบปฏิบัติการ 64 บิตหรือระบบปฏิบัติการ 32 บิต!

หากโค้ดรันบนระบบปฏิบัติการ 32 บิตให้พิมพ์ "32" หากโค้ดนั้นรันบนระบบปฏิบัติการ 64 บิตเอาต์พุต "64" สำคัญ: พิมพ์สตริงอื่น ๆ ที่ไม่ใช่อักขระว่างของตัวอักษรและตัวเลขหากไม่ใช่ 32 หรือ 64 บิต

โปรดทราบว่าโปรแกรม 32 บิตที่ทำงานบนคอมพิวเตอร์ที่มีระบบปฏิบัติการ 64 บิตควรจะแสดงผลลัพธ์เป็น "64" คุณสามารถสันนิษฐานได้ว่าผู้ใช้จะใช้ซอฟต์แวร์ 64 บิตทุกครั้งที่ทำได้

เพื่อให้มีสิทธิ์ในการเข้ารหัสของคุณจะต้องสามารถทำงานบนWindows 4.10 หรือใหม่กว่า Microsoft ที่รองรับระบบ Windows และ Linux อย่างน้อยหนึ่งรสชาติที่คุณเลือก (ตราบใดที่รสชาตินั้นไม่ฟรี) สามารถติดตั้ง Mod Compatibility ได้ตราบใดที่โปรแกรมยังคงส่งคืนค่าที่ถูกต้อง

มีการใช้กฎของสนามกอล์ฟตามปกติ

หมายเหตุ: หากคำตอบของคุณมีไว้สำหรับพิมพ์ 32 หรือ 64 เท่านั้นไม่ใช่คำตอบ alt ฉันจะยอมรับ แต่ไม่ใช่คำตอบที่แข่งขันกัน

^{ฉันจะลองและโพสต์ผลการเรียกใช้รหัสเหล่านี้ในระบบปฏิบัติการที่แตกต่างกันในภายหลัง!}

x86 แอสเซมบลี (หลายภาษา), 13 ไบต์

bytecode:

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

กำหนดฟังก์ชั่นที่ส่งกลับ 32 ถ้าตีความว่าเป็น 32- บิต, 64 ถ้า 64- บิตและ 32767 ถ้า 16- บิต

ฉันต้องการสร้างรูปหลายภาษาที่ทำงานบน Windows และ Linux แต่มันยากกว่าที่ฉันคิด เนื่องจากฉันไม่แน่ใจว่าจะมีวิธีการพิมพ์ค่าบน Windows ที่ไม่ใช่แบบ 16 บิตโดยไม่ต้องลิงก์

คำอธิบาย

รหัสนี้ใช้สองบอกเพื่อกำหนดสถาปัตยกรรมมันกำลังทำงานอยู่ อย่างแรกคือคำสั่ง 0x48— บน 16 และ 32 บิตนี่คือdec %eaxแต่ใน 64 บิตมันเป็นคำนำหน้าขนาดคำสั่ง บอกที่สองคือการเรียนการสอนเหมือนกัน แต่เมื่อเราดำเนินการได้ใน 0x8000 ค่าบิตที่สำคัญที่สุดคือการพลิกเท่านั้นถ้าขนาดลงทะเบียนเป็น 16 joบิตการตั้งธงล้นและแจ้งให้เราใช้

ใน 16 บิตรหัสนี้ถูกตีความดังต่อไปนี้:

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

ใน 32 บิตรหัสนี้ถูกตีความดังต่อไปนี้:

   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

ใน 64 บิตรหัสนี้ถูกตีความดังต่อไปนี้:

   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, 12 ไบต์

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

ฟังก์ชั่นนี้ทำงานใน Linux เมื่อใช้ใน ELF32, i386 SysV ABI ต่อไปนี้, เช่นเดียวกับใน Windows / Wine เมื่อใช้ใน PE32, ตามstdcallแบบแผนการโทร

Mathematica ขนาด 17 ไบต์

$SystemWordLength

Boot Loaders

คุณรู้หรือไม่ว่า GRUB และ IPXE ทั้งสองมีทัวริงภาษาโปรแกรมที่สมบูรณ์สามารถเข้าถึงได้ในเวลาทำงาน? ตระกูลบูตโหลดเดอร์ของ Syslinux ทำไม่ได้ แต่พวกเขาสามารถทำได้

IPXE, 36 ไบต์

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

จำเป็นต้องใช้บรรทัดแรกหากสคริปต์รันจากระยะไกล แต่ไม่ใช่ถ้าพิมพ์โดยตรงที่บรรทัดคำสั่ง

GRUB, 42 ไบต์

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

Syslinux, 186 ไบต์

ขั้นตอนนี้ใช้เวลาสามไฟล์ไฟล์แรกคือ syslinux.cfg (หรือ isolinux.cfg เป็นต้น)

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

และ t.cfg

menu title 32

ans s.cfg

menu title 64

สำหรับส่วนนี้ส่วนที่ยากคือ syslinux ไม่มีความสามารถในการแสดงข้อความอย่างง่ายดังนั้นเมนูจึงถูกใช้งานในทางที่ผิด

Julia 14 13 ไบต์

n->8sizeof(1)

อธิบาย:

• ฟังก์ชั่นอานนท์ทำทุกอย่าง (รวมถึงnothing) คืนค่าจำนวนเต็ม 32 หรือ 64
• ตัวอักษรจำนวนเต็มเป็นประเภทIntซึ่งขึ้นอยู่กับว่า 32 บิตหรือ 64 บิตเป็นทั้งInt32หรือInt64( 1อาจเป็นตัวเลขใด ๆ )
• การวางตัวเลขไว้ก่อนการเรียกใช้ฟังก์ชันจะเป็นการเพิ่มจำนวนทวีคูณ
• นี่เป็นรหัสSys.WORD_SIZEย่อสำหรับใช้ในคำตอบของ rahnema1

คำตอบที่สนุกอื่น ๆ คือ()->"$(Int)"[4:5]แต่ฉันไม่สามารถนับลงบนที่หนึ่ง

-1 ต้องขอบคุณ @Roman Gräf

จูเลีย, 20 17 16 ไบต์

n->Sys.WORD_SIZE

* ขอบคุณ @LyndonWhite บันทึก 3 ไบต์ * ขอบคุณ @ @ RomanGräfบันทึกไบต์

คำตอบก่อนหน้า:

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

ลองออนไลน์!

JavaScript (Node.js) ขนาด 24 ไบต์

_=>process.arch.slice(1)

นี้เป็นฟังก์ชั่นและผลตอบแทน'32', หรือถ้าค่า'64''rm'

C, 33 31 29 23 ไบต์

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

ขอบคุณที่แสดงความคิดเห็น @ceilingcat และ @Dennis สำหรับเคล็ดลับการเล่นกอล์ฟ!

PowerShell ขนาด 16 ไบต์

8*[IntPtr]::Size

รับขนาดตัวชี้เป็นไบต์คูณด้วย 8 เพื่อรับบิต

Python 2, 52, 48, 42 41 ไบต์

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

ขอบคุณมนุษย์ทั้งหมด!

Java 8, 45 ไบต์

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

Perl 6 , 17 ไบต์

say $*KERNEL.bits

ลองมัน

มีความเกี่ยวข้อง$?BITSซึ่งประกอบด้วยจำนวนบิตที่intมีอยู่ในรันไทม์

say $?BITS

ลองมัน

Windows CMD, 56 52 ไบต์ (ขอบคุณ Bob!)

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

ยังคงมีความยาวที่น่าประหลาดใจ - ยาวที่สุด!

C, Win32 API, 103 183 ไบต์

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

จริงๆแล้วมีมากกว่า 2 รายที่นี่ ตรวจสอบพวกเขา

• วิธีที่ง่ายที่สุด: IsWow64Processไม่มีอยู่: เราใช้ระบบปฏิบัติการ 32 บิต

สำหรับสองกรณีถัดไปเราจำเป็นต้องมีความรู้ว่าไบนารีของเราจะเป็นแบบ 32 บิต และคำอธิบายของสิ่งที่จะออกเป็นพารามิเตอร์ออกของIsWow64Process

ตัวชี้เป็นค่าที่ตั้งค่าเป็น TRUE ถ้ากระบวนการกำลังทำงานภายใต้ WOW64 หากกระบวนการทำงานภายใต้ Windows 32 บิตค่าจะถูกตั้งค่าเป็น FALSE หากกระบวนการเป็นแอปพลิเคชัน 64 บิตที่ทำงานภายใต้ Windows 64 บิตค่าจะถูกตั้งเป็น FALSE เช่นกัน

นั่นทำให้เรามีสองกรณีเพิ่มเติม:

• IsWow64Process มีอยู่และให้ผลตอบแทน TRUE -> เราอยู่ในเครื่อง 64 บิต
• IsWow64Process มีอยู่และให้ผลเป็น FALSE -> เราอยู่ในเครื่อง 32 บิต

เราไม่ต้องกังวลเกี่ยวกับส่วนที่แอปพลิเคชัน 64 บิตบน Windows 64 บิตให้ผลเป็น FALSE ดังที่เราทราบว่าแอปพลิเคชันของเราคือ 32 บิต

โอ้และมีอีกหนึ่งกรณีที่ไม่ได้รับการคุ้มครองโดยความท้าทายนี้และควรจะหายากอยู่ดี:

• มี IsWow64Process อยู่ แต่ล้มเหลว: เราใช้ค่าเริ่มต้นเป็นเครื่อง 32 บิต

สิ่งนี้จะครอบคลุมระบบปฏิบัติการ Windows NT ส่วนใหญ่ มีการทดสอบบน Win10 64-Bit, Win 7 64-Bit, Win 8.1 32-Bit และ WinXP SP1 32-Bit

คำตอบเดิม:

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

เพื่อให้แน่ใจว่าเราจำเป็นต้องแยกความแตกต่างเพียง 2 กรณี

• IsWow64Process ไม่มีอยู่ใน kernel32.dll => เราอยู่ในเครื่อง 32 บิต

• IsWow64Process ไม่มีอยู่ => เราอยู่ในเครื่อง 64 บิต

มูลค่าจริงที่จัดทำโดยIsWow64Processไม่เกี่ยวข้องกับการท้าทายนี้เนื่องจากเราต้องการให้ไบนารีเป็น 32 บิตในทุกกรณี

ต่างจากคำตอบส่วนใหญ่นี่ไม่ได้ขึ้นอยู่กับไบนารีของตัวเองที่ถูกคอมไพล์บนเครื่องที่มันทำงาน

ถ้าฉันรู้ว่าฟังก์ชั่นที่สั้นกว่านั้นมีเฉพาะใน 64 บิตและไม่ใช่ 32 บิตเครื่องฉันก็สามารถตอบให้สั้นลงได้

C #, 60 50 ไบต์

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

ขอบคุณ @TheLethalCoder

ทับทิมขนาด 22 ไบต์

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

["any string"].pack("p")ส่งกลับสตริงที่มีไบต์สอดคล้องกับตัวชี้ที่ชี้ไป"any string"และเป็น 8 ตัวอักษรหากระบบปฏิบัติการเป็น 64- บิตหรือ 4 ตัวอักษรถ้าระบบปฏิบัติการเป็น 32- บิต

R, 16 ไบต์

.Machine[[18]]*8

ส่งคืนขนาดตัวชี้

Perl, 18 15 18 ไบต์

say length pack p8

รหัสเครื่อง x86, 8 ไบต์

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

หากคอมไพล์เป็นเอ็กซีคิวต์ 64- บิทนั้นจะคืนค่า 64 อินeaxและหากคอมไพล์เป็น 32- บิตก็จะคืน 32 - โดยไม่คำนึงถึงระบบปฏิบัติการ

คำตอบนี้ขึ้นอยู่กับกฎว่า:

คุณสามารถสันนิษฐานได้ว่าผู้ใช้จะใช้ซอฟต์แวร์ 64 บิตทุกครั้งที่ทำได้

PHP, 18 ไบต์

<?=PHP_INT_SIZE*8;

สิ่งนี้จัดการกรณีทั้งหมดของ 32, 64 และซีพียูบิตอื่น ๆ อย่างถูกต้องโดยที่ PHP_INT_SIZE นั้นถูกต้องมันจะแสดงขนาดที่แม่นยำของ CPU ไม่ว่า CPU PHP นั้นจะทำงานอะไร!

ถ้า PHP ทำงานอยู่

ระบบปฏิบัติการ 32 บิต PHP_INT_SIZE == 4

ระบบปฏิบัติการ 64 บิต PHP_INT_SIZE == 8

ระบบปฏิบัติการ 16 บิต PHP_INT_SIZE == 2 (ตามหลักวิชา)

ระบบปฏิบัติการ 8 บิต PHP_INT_SIZE == 1 (ในทางทฤษฎี)

ระบบปฏิบัติการ 128- บิต PHP_INT_SIZE == 16 (ยังไม่ประสบความสำเร็จ แต่เป็นไปได้)

C # (29 ไบต์)

Console.Write(IntPtr.Size*8);

PowerShell, 17 52 ไบต์

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

ส่งคืน 64 หากข้อใดข้อหนึ่งต่อไปนี้เป็นจริง:

• Program Files (x86)คุณมีไดเรกทอรีบนไดรฟ์ปัจจุบันของคุณด้วยชื่อไฟล์ที่ลงท้ายด้วยวงเล็บใกล้ชิดคิดถูกในการตรวจสอบ
• archส่งกลับสตริงที่ลงท้ายด้วย4(ASCII 52) เช่นเมื่อเทียบกับเช่นx86_64i686

ลองจับมีวัตถุประสงค์เพื่อหลีกเลี่ยงข้อผิดพลาดที่คุณได้รับถ้าGCIผลตอบแทนอะไรและคุณไม่ได้มีซุ้มประตู ฉันไม่ได้พบวิธีที่สั้นกว่าที่จะทำได้จนถึงตอนนี้ gciถูกใช้งานมากกว่าlsเพราะบน Linux, lsจะสร้างข้อผิดพลาดที่มองเห็นได้

รุ่นนี้ควรตรวจสอบว่าระบบปฏิบัติการเป็นแบบ 64 บิตไม่ใช่แค่ PowerShell และผ่านการทดสอบการทำงานบน Windows และ Linux สำหรับการสนับสนุน Mac แทนที่ด้วยarchuname -m

เวอร์ชั่นก่อนหน้าของ Windows เท่านั้น: -!(ls \*`))*32+64

สวิฟต์ 4 รีเพลย์ / สนามเด็กเล่น, 12 ไบต์

Int.bitWidth

IntคือขนาดของคำโดยทำตัวเหมือนInt32หรือInt64ขึ้นกับระบบ

ทับทิมขนาด 10 ไบต์

p 0.size*8

ในขณะที่ทับทิมสามารถใช้จำนวนเต็มของความยาวใด ๆ Fixnumภายในจะเก็บค่าที่เหมาะสมในคำเครื่องเป็น เมธอดFixnum#sizeจะส่งคืนความยาวเป็นไบต์ของคำเครื่องเสมอ

Fixnumระดับจะถูกลบออกในรูบี 2.4.0 Integerการทำงานของมันถูกรวมอยู่ในระดับ รหัสย่อมาจาก

เชลล์ขนาด 26 ไบต์

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

Bash, 25 17 ไบต์

getconf LONG_BIT

ขอบคุณเดนนิสที่ช่วยตีกอล์ฟ

C, 22 ไบต์

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

นี่เป็นคำตอบตามขนาดตัวชี้ที่ถือว่าเป็นไบนารีดั้งเดิม 0ถูกโยนไปint**(ที่อยู่0x0) จากนั้นเราก็เพิ่ม 8-0 ซึ่งในความก้าวหน้า C, sizeof(int*)*8ตัวชี้โดย 4 ไบต์ * 8 บิต = 32, 8 ไบต์ * 8 บิต = 64 ดังนั้นเราจึงได้รับ(int**)0x20และ0x40ซึ่งจะถูกส่งเป็นจำนวนเต็มโดยการส่งคืนจากintฟังก์ชันการคืนค่าโดยปริยาย

C, สแตนด์อะโลน, 34 ไบต์

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

C, สนุกกับ Unicode, รหัส 30 คะแนน, 34 ไบต์ (UTF-8)

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

Java, 50 ไบต์

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

PHP, 29 ไบต์

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

https://3v4l.org/Y6JXv

Python 3 , 77 84 71 59 ไบต์

-13 ไบต์ขอบคุณ @JonathanAllan!
ลงไปที่ 59 โดย @Clearer

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

ลองออนไลน์!

การเขียนรหัสเวลากำปั้นของฉัน :)
ควรเอาท์พุทเวอร์ชันที่ถูกต้องแม้ในขณะที่ใช้ 32Bit-Python บน 64bit-OS
สมมติว่าplatform.machine()ให้i*86หรือx86สำหรับ 32Bit-OS ฉันไม่มีที่ว่างในการตรวจสอบสิ่งนี้ เอาท์พุทคือ0เมื่อระบบปฏิบัติการไม่ได้อยู่ใน 64/32 บิต
แก้ไข: เพิ่มคำสั่งการพิมพ์ดังนั้นมันจึงมีความยาว 7 ไบต์