เมื่อเร็ว ๆ นี้คุณได้สร้างบัญชีในเว็บไซต์พนันซึ่งมีค่าธรรมเนียม 25 ดอลลาร์พวกเขาจะจ่ายเงินคืนให้คุณระหว่าง 0 ถึง 50 ดอลลาร์ หลังจากได้รับประมาณ 5 ดอลลาร์สองครั้งคุณตัดสินใจที่จะพิสูจน์ว่าไซต์นั้นเป็นการหลอกลวง หลังจากเข้าถึงไฟร์วอลล์ภายนอกด้วยรหัสผ่านเริ่มต้นคุณจะพบวิธีเข้าสู่เซิร์ฟเวอร์ฐานข้อมูลและค้นหาว่าจะเก็บค่าจำนวนเงินขั้นต่ำและจำนวนสูงสุดไว้ที่ใด คุณตัดสินใจที่จะเสียบ 25 '9 เป็นค่าสูงสุด แต่ได้รับข้อความแสดงข้อผิดพลาดว่าค่าสูงสุดต้องเป็นประเภท' uint64 ' อย่างไรก็ตามในตอนนี้คุณสังเกตเห็นว่าปุ่มตัวเลขบางตัวดูเหมือนจะพิมพ์ลงในรีโมทคอนโทรลไม่ถูกต้อง ความท้าทายจะปรากฏขึ้นก่อนที่คุณจะพิมพ์ราวกับว่าอยู่ในไซต์ Q + A

ใช้เฉพาะโปรแกรมที่ติดตั้งอย่างสะดวกสำหรับการทดสอบและการใช้ภาษาเฉพาะของคุณเอาท์พุทขนาดสูงสุดของค่าจำนวนเต็มแบบ 64 บิตที่ไม่ได้ลงนามอย่างไรก็ตามเกือบทุกอย่างยกเว้นเครื่องมือการเขียนโปรแกรมจะเสียบนเครื่องนี้ทำให้คุณไม่ต้องใช้หมายเลข 1 2,4,6,8 - ในซอร์สโค้ดหรือตัวอักษรคุณอาจสังเกตว่าดูเหมือนว่าจะใช้เวลานานกว่าในการดำเนินการโปรแกรมสำหรับโค้ดเพิ่มเติมแต่ละชิ้น ต้องการรวยก่อนวาด!

ความท้าทาย

• เขียนโปรแกรมที่เอาต์พุต 18446744073709551615 ซึ่งเป็นค่าสูงสุดของจำนวนเต็ม 64 บิตที่ไม่ได้ลงนามเป็นตัวเลขหรือสตริงเดียว

• ซอร์สโค้ดของคุณต้องไม่มีอักขระ '1', '2', '4', '6' หรือ '8'

• หากภาษาของคุณไม่มีจำนวนเต็ม 64 บิตหรือเทียบเท่าที่ไม่ได้ลงนามเอาต์พุตอาจอยู่ในรูปแบบสตริงหรืออื่น ๆ แต่ต้องเป็นตัวเลขข้างต้น

• นี่คือรหัส - กอล์ฟดังนั้นรหัสที่สั้นที่สุดในแต่ละภาษาชนะ!

ขี้ผึ้ง 3 ไบต์

_M{

คำอธิบาย:

_   # Create a bee going horizontally across the line, reading the code
 M  # Decrement the bee's counter, which starts at 0.
    # This will set the counter to 2^64-1, because as bees don't have a concept of
    # negative numbers, all values that are negative are translated to 2^64-n,
    # and in this case, n = -1, as we are calculating 0 - 1.
  { # Print the value

ลองออนไลน์!

ภาษานี้เหมาะสำหรับความท้าทายนี้

นี่คือสารสกัดจากหน้า Esolang บน Beeswax :

อย่างที่ทุกคนรู้ว่าผึ้งไม่มีแนวคิดเกี่ยวกับจำนวนลบ แต่พวกเขาค้นพบว่าพวกเขาสามารถใช้ที่อยู่ที่มีนัยสำคัญที่สุดในการแก้ไขปัญหานั้นได้ ดังนั้นพิกัดที่สัมพันธ์กับตำแหน่งของผึ้งจึงถูกรับรู้โดยการเติมเต็มของพิกัดทั้งสอง วิธีนี้ครึ่งหนึ่งของพื้นที่ที่อยู่ 64- บิตมีให้สำหรับการระบุที่อยู่ในพื้นที่โดยไม่มีการพันรอบในแต่ละทิศทาง

แอดเดรสเสริมที่เป็นบวก 64 บิตสองสูงสุดคือ 9223372036854775807 หรือ 0x7fffffffffffffffffff ในเลขฐานสิบหก 64 บิต ค่าทั้งหมดตั้งแต่ 0 ถึงค่านี้แปลเหมือนกันกับค่า 64 บิตเดียวกัน ค่าทั้งหมด n ในทิศทางตรงกันข้าม (ลบ) แปลเป็น 2 ^ 64-n ตัวอย่างเช่น: n = -1 แก้ไขโดย 18446744073709551615. n = -9223372036854775808 แก้ไขโดย 9223372036854775808

นี่คือความยาวที่ไม่ได้ลงชื่อโดยทั่วไป

แก้ไข: ฉันยังคงคาดหวังว่าเดนนิสจะแซงหน้าฉันด้วยโซลูชัน 2 ไบต์

C, 26 ไบต์

main(){printf("%lu",~0l);}

พิมพ์unsigned longค่า

ต้องมีขนาดเท่ากับlong64 บิต

CJam (4 ไบต์)

GG#(

การสาธิตออนไลน์

คำนวณนี้ 16 ¹⁶ - ใช้ 1 builtin G16 (และผู้ประกอบการพร่อง

SBCL ทั่วไป 64- บิต, 18 ไบต์

most-positive-word

คำที่เป็นบวกมากที่สุดในคอมไพเลอร์ 64 บิตคือ 64uint มันเป็นอะไรบางอย่าง.

Python3 REPL ขนาด 12 ไบต์

ใน REPL: ~-(~-3<<9*7)

ด้านนอกของ REPL: print~-(~-3<<9*7)<--> Python2!

นี่เป็นอีกคนหนึ่งที่ 17 ~-(~-3<<ord("?"))ไบต์:

คำอธิบาย

ไม่มีอะไรแฟนซีสุด ๆ นี่มันพังทลาย:

~-           | Subtract 1 from the next value.
  (          | 
   ~-3       | Subtract 1 from 3, resulting in 2
      <<     | Binary shift 2's digits to left,
        9*7  | by 9*7 (63).
           ) | The value inside the parentheses is now 2**64.

ส่งผลให้เกิดการแสดงออกเป็นประมาณ ( แต่ไม่มาก) ->~-(2<<63) (2**64)-1ฉันใช้ตัวดำเนินการลูกอ๊อดสองครั้งที่นี่ เคล็ดลับการเล่นกอล์ฟเกี่ยวกับมันนี่

นอกจากนี้ยังมีsys.maxintใน Python2 ซึ่งสามารถใช้งานได้ แต่ฉันจะไม่มองสิ่งนั้น

repl.it <- ลิงค์ทดสอบ

คริสตศักราช 15 13 ไบต์

บันทึก 2 ไบต์ด้วยการจัดการ

(a=9+7)^a-3/3

ไม่มีอะไรแฟนซีเพียง (16 ^ 16) -1

dc , 7 ไบต์

ฉันคิดว่าการอนุญาตให้ภาษาที่ใช้สแต็กปล่อยให้คำตอบไว้ที่เซลล์ด้านบนของสแต็กคล้ายกับค่าส่งคืนสำหรับฟังก์ชัน หากต้องการการพิมพ์อย่างชัดเจนให้เพิ่มpที่ส่วนท้ายของรหัส

AZ5E^z-

ลองออนไลน์!

มันคำนวณ (2 ⁶⁴ - 1) โดยใช้เทคนิคหลายอย่าง:

• 2ได้รับเป็นจำนวนหลัก ( Z) ที่พบในจำนวนเต็ม 10 ( A)

• 645Eจะได้รับเป็น โดยค่าเริ่มต้น dc ใช้ 10 เป็นฐานข้อมูลเข้า ถึงกระนั้นก็สามารถยอมรับตัวเลขในรูปแบบเลขฐานสิบหก แต่พวกเขาจะถูกแปลงแตกต่างจากที่คุณคาดหวัง ตัวอย่าง: (5E) _default = (5E) _{(input radix = 10)} = (5 * 10 ¹ ) + (14 _(E) * 10 ⁰ ) = 50 +14 = 64

• 1ถูกกำหนดให้เป็นความลึกของสแต็ก ( z) เนื่องจากมีเพียง (2 ⁶⁴ ) เท่านั้นที่มีอยู่ในขณะนั้น

เรื่องราวทางเลือก:

อย่างไรก็ตามในตอนนี้คุณสังเกตเห็นว่าปุ่มตัวเลขบางตัวดูเหมือนจะพิมพ์ลงในรีโมทคอนโทรลไม่ถูกต้อง คุณหายใจลึก ๆ และเริ่มทดสอบคีย์ตัวเลขแต่ละตัว มันเลวร้ายยิ่งกว่าที่คุณคิด! ไม่ใช่งานชิ้นเดียวและคุณเหลืองานที่จะผลิตจำนวนเต็มที่ต้องการโดยใช้ตัวอักษรและสัญลักษณ์เท่านั้น

โซลูชันใน dc: การคำนวณ (16 ¹⁶ - 1), ยังคงมี 7 ไบต์!

Fz+d^z-          # push 15, push 1, add, duplicate, exponentiate, push 1, subtract

ลองออนไลน์!

เยลลี่ 4 ไบต์

⁴*`’

ลองออนไลน์!

คำอธิบาย

⁴     # 16
 *    # exponentiate
  `   # last link as a monad, repeating the argument
   ’  # decrement

05AB1E , 4 ไบต์

žJn<

คำอธิบาย:

žJ   # Push 4294967296
  n  # Squared
   < # Decreased by one

ที่สุด! โอกาสที่จะใช้05AB1Ebuiltins สำหรับพลังของทั้งสอง!

ลองออนไลน์!

อีก 4 ไบต์ตอบ:

žxo<

คำอธิบาย:

  o  # 2 to the power of
žx   # 64
   < # Decreased by one

ลองออนไลน์!

(ถ้าใครสงสัยคำถามนี้เก่ากว่าคำตอบ 4 ไบต์อื่น ๆ ทั้งหมด)

MATLAB / Octave, 5 ไบต์

@Sanchises โพสต์คำตอบที่ยอดเยี่ยม MATLAB แต่อันนี้เป็นวิธีที่แตกต่างกันมากดังนั้นฉันจะโพสต์ต่อไป:

tic/0

ใน MATLAB ticส่งคืนจำนวนมิลลิวินาทีที่ผ่านมานับตั้งแต่เปิดโปรแกรม ค่าที่ส่งคืนคือสิ่งuint64สำคัญอย่างยิ่ง นี้ได้รับออกไปจากที่มีการโยนหมายเลขที่จะมาจากชนิดเริ่มต้นของuint64 MATLABsdouble

ตัวเลขใด ๆ ที่หารด้วย 0 ใน MATLAB จะถือว่าเป็นอนันต์ซึ่งสำหรับประเภทจุดที่ไม่ลอยตัว MATLAB จะแทนค่านี้เป็นค่าจำนวนเต็มสูงสุดสำหรับประเภทนั้น

วิธีนี้ใช้ได้กับอ็อกเทฟแม้ว่าจะใช้ล่ามที่คุณใช้มันอาจพ่นคำเตือน "การหารด้วยศูนย์" เช่นกัน คุณสามารถลองใช้รหัสออนไลน์ได้ที่นี่แม้ว่าฉันจะบอกว่าคุณได้รับคำเตือน / 0 ที่ไม่ปรากฏใน MATLAB

BC ,18, 16 ไบต์

• บันทึก 2 ไบต์, ขอบคุณ @MrScapegrace

(9-7)^(55+9)-3/3

PHP, 16 ไบต์

นี่เป็นเหมือนคำตอบจาก Ven: https://codegolf.stackexchange.com/a/110751/38505

printf("%u",~0);

https://repl.it/Frcy/0

เพื่อให้ทำงานได้คุณจะต้องอยู่ในสถาปัตยกรรม 64 บิต เพราะนี่คือ ~ 0 -1 ซึ่งเป็น 111111111111111111111111111111111111111111111111111111111111 1111 ในไบนารี 64 บิตเมื่อเทียบกับ 11111111111111111111111111111111 ใน 32 บิตและตัวเลขที่มี plataform ขึ้นอยู่กับ - อิสมาเอลมิเกล

MATLAB / Octave, 22 ไบต์

eye(['~rw}?='-9 ''])/0

ลองออนไลน์!

eyeจะใช้ในการสร้างหน่วยเมทริกซ์ (เมทริกซ์ที่มี1ในแนวทแยงศูนย์เป็นอย่างอื่น) หากไม่มีข้อโต้แย้งสิ่งนี้จะสร้าง1x1เมทริกซ์หน่วยหรือกล่าวอีกนัยหนึ่ง1ว่า ใช้อาร์กิวเมนต์ตัวเลือกซึ่งเป็นชนิดข้อมูล ('คลาส' ในคำศัพท์ MATLAB) ของเมทริกซ์ที่สร้างขึ้น เราจึงขอ1ของชั้นuint64และหารด้วยศูนย์ซึ่งส่งผลให้Infใน MATLAB intmax('uint64')ซึ่งได้รับการตัดที่

เวกเตอร์['~rw}?='-9 '']ประเมิน'uint64'ว่า Concatenating ถ่านที่ว่างเปล่าเพื่อเวกเตอร์เป็น 1 char('~rw}?='-9)ไบต์สั้นกว่าการใช้

การให้เหตุผลต่อคำตอบนี้: ในตัวintmaxจะประเมินค่าจำนวนเต็มสูงสุด 32 บิตที่น่าเศร้า ตัวเลือกต่อไปที่ชัดเจนคือuint64()ซึ่งมีตัวอักษรต้องห้าม ทางเลือกคือการใช้ฟังก์ชั่นที่รับสายเป็นชนิดข้อมูล ผู้สมัครที่ชัดเจนintmaxและcastแต่ทางเลือก ได้แก่zeros, และoneseye

eye(['~rw}?='-9 ''])/0    % Winning version! 22 bytes.
intmax(['~rw}?='-9 ''])   % Obvious candidate. 23 bytes.
1/zeros(['~rw}?='-9 ''])  % 24 bytes
cast(Inf,['~rw}?='-9 '']) % 25 bytes. Also an obvious candidate, but actually very long.

^{หมายเหตุ: MATLAB ถูกติดตั้งตามค่าเริ่มต้นในเว็บไซต์การพนันที่หลบทุกอย่าง}

JavaScript, 39 38 33 32 ไบต์

alert(0xafebff0+'737095'+0xc99f)

แก้ไข: บันทึก 5 ไบต์ขอบคุณ @Arnauld

Java 8, 30 ไบต์

()->Long.toUnsignedString(~0L)

ทดสอบออนไลน์

BF, 108 ไบต์

-[----->+<]>--.+++++++.----..++.+.---..----.+++++++.----.++++.-------.+++++++++.----..----.+++++.-----.++++.

หากแต่ละคำสั่งถูกพิจารณาว่าเป็น 3 บิตนี่อาจเป็น 41 ไบต์

เรติน่า28 28ไบต์

บันทึก 1 ไบต์ขอบคุณ Kritixi Lithos

bieegheeahdhajffbgbf
T`l`d

ลองออนไลน์!

คำอธิบาย

bieegheeahdhajffbgbf

แทนที่อินพุตที่ไม่มีอยู่ / ว่างด้วยสตริงนี้ สายอักขระนี้ถูกสร้างขึ้นโดย "inverse" ของโปรแกรมนี้ มันเข้ารหัสaผ่านjเป็น0ผ่าน9ตามลำดับ

T`l`d

นี่คือTขั้นตอนการชดเชยแสง lและdกำลังชุดตัวอักษรที่ใช้สำหรับการทับศัพท์ lแสดงถึงอักษรตัวพิมพ์เล็กdเป็นตัวเลขทั้งหมด ดังนั้นจึงแผนที่กลับไปabcdefghij0123456789

C ++, 46 ไบต์

int m(){std::cout<<unsigned long long(5+3-9);}

ครั้งแรกที่เคยเล่นกอล์ฟรหัส แต่ฉันมีความสุขมากกับตัวเอง จะใช้คำวิจารณ์ / ข้อเสนอแนะอย่างมีความสุข :)

Brain-Flak , 64, 62, 58 , 54 ไบต์

(((((()()()()){}){}){}){}){({}<(({}()){}[()])>[()])}{}

ลองออนไลน์!

[ลองออนไลน์!]

บันทึกสี่ไบต์ด้วย @Riley!

คำอธิบาย:

#Push a 64
(((((()()()()){}){}){}){})

#While true
{

  #Pop the top of the stack. We'll store this value for later, but first
  ({}

  #Before pushing the value
  <

    #Push (N + 1) * 2 - 1
    # (where N is the number underneath, originally 0)
    (({}()){}[()])

  >

  #And push the TOS minus one back on
  [()])

#endwhile
}

#Pop the zero left over
{}

#And decrement the number underneath
({}[()])

สำหรับบันทึกฉันพยายามกด 32 และสี่เท่า แต่นับเป็นจำนวนไบต์เดียวกัน

C # 6, 31 ไบต์

()=>System.Console.Write(~0UL);

ค่อนข้างเหมือนกับ Java

C # 5, 56 ไบต์

class P{static void Main(){System.Console.Write(~0UL);}}

ออกมา (gforth), 11 9 7 ไบต์

true U.

ลองออนไลน์

true-1เป็นเช่นเดียวกับ U.พิมพ์ตัวเลขเป็นจำนวนเต็มที่ไม่ได้ลงนาม

สิ่งนี้ใช้ได้กับ TIO หรืออาจเป็นเพราะมีสถาปัตยกรรม 64 บิต ฉันไม่แน่ใจ. -1 U.ตัวอย่างเช่นถ้าฉันใช้งานrepl.it ฉันจะได้รับ 2 ** 32-1 หาก repl.it รองรับจำนวนเต็มความยาวสองเท่าการส่งออกจะใช้UD.แทน

Python3 REPL ขนาด 11 ไบต์

~0^~0>>~077

มันทำงานอย่างไร

• ~ 0 คือ -1 (ส่วนเติมเต็มสองค่าลำดับอนันต์ของ '1)
• 077 คือ 63 ในฐานแปดดังนั้น ~ 077 คือ -64
• เลื่อนไปทางขวาพร้อมพารามิเตอร์ลบคือการเลื่อนไปทางซ้าย
• การรวมทั้งหมดเข้าด้วยกัน -1 xor (-1 << 64) คือตัวเลขที่เรากำลังมองหา

PowerShell , 29 14 ไบต์

0xC000PB/3-3/3

ลองออนไลน์!

ขอบคุณ @ n0rd สำหรับการเล่นกอล์ฟในครึ่งนี้

สิ่งนี้ใช้ประโยชน์จากPBโอเปอเรเตอร์unary แบบ inbuilt ที่ทำหน้าที่เป็น "คูณจำนวนก่อนหน้าด้วย1125899906842624" (กล่าวคือมีจำนวนไบต์อยู่ใน pebibyte) นั่นประกอบกับเลขฐานสิบหก0xC000หรือ49152อย่าง49152 pebibytesนั้น เราหารมันด้วยการ3ยอม18446744073709551616และลบ3/3เพื่อให้ได้ค่าสุดท้าย

JavaScript (ES6), 50 ไบต์

[...'䠎ᴐIF╏ɧ'].map(s=>s.charCodeAt()).join``

x64 แอสเซมบลี 7 ไบต์

ฐานสิบหก (ประกอบ): 4831C048FFC8C3

ถอดชิ้นส่วนแสดงความคิดเห็น:
XOR RAX,RAX ;Zero the value of 64 bit register RAX DEC RAX ;Decrement the value of RAX RET ;Return this value

RAX คือการลงทะเบียน 64 บิตและส่วนใหญ่มักจะใช้เพื่อคืนค่าอาร์กิวเมนต์จำนวนเต็ม (เช่น C) ด้วยการลดค่า 1 ค่าของมันจะเลื่อนจาก 0 ถึง ... 2 ^ 64-1 ซึ่งจำเป็นอย่างแท้จริง
ถึงแม้ว่าไบนารีที่ประกอบขึ้นมาจะมีส่วนประกอบหนึ่งและสี่และแปด แต่แอสเซมบลีก็ไม่ได้รวมอยู่ แต่ไฟล์ที่ประกอบจะถูกนับในชุดประกอบ หัวของฉัน
นอกจากนี้เอาต์พุตคือค่าส่งคืนในกรณีนี้

Brain-Flak , 223 193 ไบต์

รวม +1 สำหรับ-A
-30 ด้วย DJMcMayhem

((((((((((((((((((((((((()()()){}){}()){}){}())[()()()()])[][]())[[]()()])[]))()()()())[[]()()])[][()])[()()()()])()()()())[(()()()){}()])()()()()))()()())[()])[()()]))()()()())[(()()()){}()])

ลองออนไลน์!

นี่เป็นเพียงการผลักดันค่า ASCII และพิมพ์เป็นอักขระ

สำหรับการอ้างอิงก็จะใช้เวลา 338 ไบต์ในการสร้างจำนวนจริงโดยใช้เมตานักกอล์ฟจำนวนเต็ม

((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()()()){}()){}){}()){}()){({}[()])}{}()){}()){}())){}{})){}{})()){}{})){}{})){}{})()){}{})){}{})){}{}){}){}())){}{}){}())()){}{})){}{}){}){}){}())()){}{})()){}{})){}{}){}())){}{})()){}{})){}{})){}{})){}{})()){}{})()){}{})){}{}){}())){}{}){}){}())()){}{})()){}{})){}{})

ลองออนไลน์!

MATL, 8 ไบต์

l_5Z%EZD

สิ่งนี้อาจปรับปรุงได้ แต่ฉันยังไม่คุ้นเคยกับสตริงและประเภทใน MATL

ลองใช้ที่ matl.suever.net

คำอธิบาย:

l       % push 1
_       % unary minus
5       % push 5, corresponds to type 'uint64'
Z%      % convert 1 to this type
E       % double
ZD      % display as a string

Javascript 55 ไบต์

alert(""+(590300>>5)+(59530-3>>3)+7370955+(3*59*73>>3))

รหัสจะสร้างและแจ้งเตือนสตริง 18446744073709551615 โดยใช้การดำเนินการระดับบิต

590300 >> 5 18446
59530-3 >> 3 7440
7370955
3 * 59 * 73 >> 3 1615

Swift, 8 ไบต์

UInt.max

สนามเด็กเล่นด้านนอก / repl - 15 ไบต์

print(UInt.max)

TI-Basic, 10 ไบต์

9+7
Ans^Ans-0!