ค่าของ i สำหรับ (i == -i && i! = 0) เพื่อคืนค่าจริงใน Java

ฉันมีifเงื่อนไขดังต่อไปนี้

if (i == -i && i != 0)

ค่าใดที่iจะคืนค่าtrueสำหรับเงื่อนไขนี้ใน Java

ฉันไม่สามารถนึกถึงคุณค่าของการiพิจารณาสัญกรณ์เสริมสองตัวใน Java ได้

ฉันชอบที่จะมีการพิสูจน์พีชคณิตของคำตอบใด ๆ ที่เงื่อนไขนี้มี (ในบริบทกับ Java)?

เพียงค่าที่ใช้การทำงานคือint Integer.MIN_VALUE

มันเป็นเพราะจำนวนเต็มจะถูกทำให้ไร้ผลโดยใช้วิธีเติมเต็มสอง

การใช้

System.out.println(Integer.toBinaryString(Integer.MIN_VALUE));

คุณเห็นว่าInteger.MIN_VALUEเป็น

10000000000000000000000000000000

การรับค่าลบทำได้โดยการสลับครั้งแรก0และ1ซึ่งให้

01111111111111111111111111111111

และโดยการเพิ่ม1ซึ่งให้

10000000000000000000000000000000

ดังที่คุณเห็นในลิงค์ที่ฉันให้ Wikipedia กล่าวถึงปัญหาเกี่ยวกับตัวเลขที่เป็นลบมากที่สุดและระบุว่าเป็นข้อยกเว้นเพียงประการเดียว:

จำนวนลบมากที่สุดในส่วนเติมเต็มของสองบางครั้งเรียกว่า "จำนวนประหลาด" เพราะเป็นเพียงข้อยกเว้นเท่านั้น

แน่นอนคุณมีปรากฏการณ์เดียวกันLong.Min_Valueถ้าคุณเก็บไว้ในlongตัวแปร

โปรดทราบว่านี้เป็นเพราะเพียงทางเลือกที่ทำเกี่ยวกับการจัดเก็บข้อมูลแบบไบนารีของ ints ในชวา อีกวิธีหนึ่ง (ไม่ดี) สามารถลบล้างได้โดยเพียงแค่เปลี่ยนบิตที่สำคัญที่สุดและปล่อยให้บิตอื่นไม่เปลี่ยนแปลงสิ่งนี้จะหลีกเลี่ยงปัญหานี้กับ MIN_VALUE ได้ แต่จะสร้าง0ค่าที่แตกต่างกัน 2 ค่าและเลขคณิตไบนารีที่ซับซ้อน (คุณจะมีได้อย่างไร เพิ่มขึ้นเช่น?)

Integer.MIN_VALUEค่าที่คุณกำลังมองหา

ฉันชอบที่จะมีการพิสูจน์พีชคณิตของคำตอบใด ๆ ที่เงื่อนไขนี้มี (ในบริบทกับ java)?

นั่นไม่ใช่หัวข้อสำหรับ Stack Exchange แต่คุณสามารถทำได้โดยเริ่มจากนิยามของจำนวนเต็ม Java ( JLS 4.2 )

"ประเภทอินทิกรัล ได้แก่ ไบต์สั้น int และยาวซึ่งมีค่าคือ 8 บิต 16 บิต 32 บิตและ 64 บิตที่ลงนามสองจำนวนเต็มเสริม ... "

และ

"ค่าของชนิดปริพันธ์คือจำนวนเต็มในช่วงต่อไปนี้ ... สำหรับ int ตั้งแต่ -2147483648 ถึง 2147483647 รวม"

และนิยามของตัวดำเนินการ Java unary '-' ( JLS 15.15.4 ):

"สำหรับค่าจำนวนเต็มการลบจะเหมือนกับการลบออกจากศูนย์ภาษาการเขียนโปรแกรม Java ใช้การแทนค่าสองส่วนเสริมสำหรับจำนวนเต็มและช่วงของค่าเสริมของทั้งสองไม่สมมาตรดังนั้นการปฏิเสธของ int เชิงลบสูงสุดหรือระยะยาวจะส่งผลให้ จำนวนลบสูงสุดเท่ากันการล้นเกิดขึ้นในกรณีนี้ แต่จะไม่มีข้อยกเว้นสำหรับค่าจำนวนเต็มทั้งหมด x, -x เท่ากับ (~ x) +1 "

เพิ่มเติมจากคำตอบที่ให้มา ...

มีทั้งหมดสี่ค่า

int i = Integer.MIN_VALUE;
long i = Long.MIN_VALUE;
Integer i = Integer.valueOf(Integer.MIN_VALUE);
Long i = Long.valueOf(Long.MIN_VALUE);

ค่าที่รวมจะถูกคลายออกดังนั้นจึงเป็นจริงสำหรับนิพจน์นี้ด้วย

หมายเหตุ: เอกสาร Math.abs

สาธารณะคง int abs (int a)

ส่งคืนค่าสัมบูรณ์ของค่า int ถ้าอาร์กิวเมนต์ไม่เป็นลบอาร์กิวเมนต์จะถูกส่งกลับ ถ้าอาร์กิวเมนต์เป็นลบการปฏิเสธของอาร์กิวเมนต์จะถูกส่งกลับ

โปรดสังเกตว่าถ้าอาร์กิวเมนต์เท่ากับค่า Integer.MIN_VALUE ซึ่งเป็นค่า int ที่เป็นค่าลบมากที่สุดผลลัพธ์จะเป็นค่าเดียวกันซึ่งเป็นค่าลบ

และ

abs ยาวแบบคงที่สาธารณะ (ยาว a)

ส่งคืนค่าสัมบูรณ์ของค่ายาว ถ้าอาร์กิวเมนต์ไม่เป็นลบอาร์กิวเมนต์จะถูกส่งกลับ ถ้าอาร์กิวเมนต์เป็นลบการปฏิเสธของอาร์กิวเมนต์จะถูกส่งกลับ

โปรดสังเกตว่าถ้าอาร์กิวเมนต์เท่ากับค่า Long.MIN_VALUE ซึ่งเป็นค่ายาวที่เป็นค่าลบมากที่สุดผลลัพธ์จะเป็นค่าเดียวกันซึ่งเป็นค่าลบ

เป็นที่น่าแปลกใจที่ Math.abs อาจส่งคืนจำนวนลบ สิ่งนี้เกิดขึ้นอย่างใดอย่างหนึ่งเนื่องจาก a) ไม่มีค่าบวกสำหรับ -MIN_VALUE ในกรณีเหล่านี้ b) ทำการ-คำนวณผลลัพธ์ในจำนวนมากเกินไป

สิ่งที่น่าสนใจคือทำไม Byte.MIN_VALUE, Short.MIN_VALUE ไม่ทำสิ่งนี้ เนื่องจากการ-เปลี่ยนแปลงประเภทเป็นintสำหรับสิ่งเหล่านี้จึงไม่มีการล้น

Character.MIN_VALUE ไม่มีปัญหาเพราะเป็น 0

Float.MIN_VALUE และ Double.MIN_VALUE มีความหมายที่แตกต่างกัน ค่าเหล่านี้เป็นค่าที่สามารถแสดงได้น้อยที่สุดที่มากกว่าศูนย์ ดังนั้นพวกเขาจึงมีค่าลบที่ถูกต้องซึ่งไม่ใช่ตัวเอง

เช่นเดียวกับคนอื่น ๆ Integer.MIN_VALUEได้กล่าวถึงนี้เป็นจริงโดยเฉพาะ สำหรับการพิสูจน์ขอให้ฉันเสนอคำอธิบายที่เข้าใจง่ายกว่าในไบนารี (แม้ว่าจะยังคงฝังรากลึกอยู่ก็ตาม)

โปรดทราบว่าInteger.MIN_VALUEมีค่าเท่ากับ-2^31หรือ-2147483648และInteger.MAX_VALUEจะมีค่าเท่ากับหรือ2^31-1 คือซึ่งตอนนี้มีขนาดใหญ่เกินไปสำหรับจำนวนเต็ม (เนื่องจากเป็นอดีต) จึงทำให้จำนวนเต็มล้นทำให้อีกครั้ง เป็นจำนวนเต็มเดียวที่ทำเช่นนี้เนื่องจากเป็นจำนวนเดียวที่ไม่มีค่าเท่ากับลบนอกเหนือจาก 02147483647-Integer.MIN_VALUE2^31MAX_VALUEInteger.MIN_VALUEMIN_VALUE

การพิสูจน์พีชคณิตเบื้องต้นโดยใช้modulo 2^32เลขคณิต:

i == -iสามารถเขียนใหม่เป็น2 * i == 0(เพิ่มiทั้งสองด้าน) หรือi << 1 == 0.

สมการนี้มีคำตอบสองแบบของรูปแบบi == 0 >> 1กล่าวคือ0bและ10000000000000000000000000000000bได้มาจากการเลื่อนไปทางใดทางหนึ่ง0หรือ1ทางซ้าย

แก้ปัญหาถูกกีดกันยังคงมีการแก้ปัญหาi == 0i == 100000000000000000000000000000000b

อาจจะไม่ได้ให้ความรู้มากเกินไป แต่แทนที่จะคิดว่าคุณสามารถเรียกใช้รหัสนี้:

    for (int i = Integer.MIN_VALUE; i <= Integer.MAX_VALUE; i++)
    {
        if (i == -i && i != 0)
        {
            System.out.println(i);
        }
    }

เพื่อดูว่ามันพิมพ์ออกมา

-2147483648
-2147483648

เพียบ :)