เหตุใดคอมพิวเตอร์จึงนับจากศูนย์


55

คอมพิวเตอร์มักจะมีค่าตัวเลขเริ่มต้นจากศูนย์ ตัวอย่างเช่นอาร์เรย์ในภาษาการเขียนโปรแกรม C-based เริ่มต้นจากดัชนีศูนย์

มีเหตุผลทางประวัติศาสตร์อะไรบ้างสำหรับเรื่องนี้และข้อได้เปรียบเชิงปฏิบัติใดที่นับจากศูนย์มีมากกว่าการนับจากหนึ่ง

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



9
มีมากกว่าสองสามตัวอย่างของภาษาคอมพิวเตอร์ที่ใช้อาร์เรย์ 1 ต้นกำเนิด
Daniel R Hicks

23
ทำไมมนุษย์ไม่นับจาก 0
ไม่มีชื่อ

47
Woah, woah ไม่มีใครนับจากศูนย์เราทำดัชนีจากศูนย์ ไม่มีใครพูดองค์ประกอบ "ศูนย์" เราพูดองค์ประกอบ "แรก" ที่ดัชนี 0 ลองนึกถึงดัชนีว่าองค์ประกอบจะถูกชดเชยจากตำแหน่งแรกได้ไกลแค่ไหน องค์ประกอบแรกอยู่ที่ตำแหน่งแรกดังนั้นจึงไม่ได้ชดเชยเลยดังนั้นดัชนีของมันคือ 0 องค์ประกอบที่สองเป็นหนึ่งองค์ประกอบก่อนหน้าดังนั้นจึงชดเชย 1 องค์ประกอบและอยู่ที่ดัชนี 1
mowwwalker

14
@Ramhound ไม่มันไม่ใช่ การทำดัชนีแบบ zero-based นั้นไม่เกี่ยวข้องอย่างสมบูรณ์กับการใช้ไบนารี
Peter Olson

คำตอบ:


88

การนับอาร์เรย์จาก 0 ช่วยให้การคำนวณที่อยู่หน่วยความจำของแต่ละองค์ประกอบง่ายขึ้น

หากอาร์เรย์ถูกเก็บไว้ที่ตำแหน่งที่กำหนดในหน่วยความจำ (เรียกว่าที่อยู่) ตำแหน่งของแต่ละองค์ประกอบสามารถคำนวณได้

element(n) = address + n * size_of_the_element

หากคุณพิจารณาองค์ประกอบแรกเป็นอันดับแรกการคำนวณจะกลายเป็น

element(n) = address + (n-1) * size_of_the_element

ไม่แตกต่างกันมาก แต่เพิ่มการลบที่ไม่จำเป็นสำหรับการเข้าถึงแต่ละครั้ง

แก้ไข

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

  • Dijkstraตีพิมพ์บทความ "ทำไมการนับเลขควรเริ่มต้นที่ศูนย์" ( pdf ) ซึ่งเขาอธิบายว่าทำไมการเริ่มต้นด้วย 0 เป็นตัวเลือกที่ดีกว่า การเริ่มต้นที่ศูนย์จะช่วยให้แสดงช่วงได้ดีขึ้น


8
+1 สำหรับคำตอบที่ถูกต้อง โปรดทราบว่าการทำดัชนีแบบอิง 0 เป็นเพียงแบบแผน(ทั่วไปมาก)ของภาษาที่ใช้ มันไม่ได้เป็นสากล ตัวอย่างเช่นLua ใช้การจัดทำดัชนีแบบ 1 "การลบที่ไม่จำเป็น" อาจเป็นเหตุผลที่อยู่เบื้องหลังการจัดทำดัชนีแบบ 0 ในอดีต แต่ตอนนี้ภาษาส่วนใหญ่ใช้เพียงเพราะสิ่งที่ทุกคนคุ้นเคยแล้ว(ส่วนใหญ่ต้องขอบคุณ C)และไม่มีเหตุผลที่น่าสนใจในการเปลี่ยนแปลง การประชุม
BlueRaja - Danny Pflughoeft

2
มันไม่สมเหตุสมผล ตำแหน่งของแต่ละองค์ประกอบสามารถคำนวณได้address + n * size_of_elementตราบใดที่ "ที่อยู่" คือที่อยู่ขององค์ประกอบซีโรท สิ่งนี้ทำงานได้อย่างสมบูรณ์ไม่ว่าจะเป็นองค์ประกอบศูนย์หรือไม่ก็เป็นองค์ประกอบของอาร์เรย์หรือไม่ คำถามคือทำไมองค์ประกอบของศูนย์มีอยู่ไม่ใช่สาเหตุที่เราเก็บที่อยู่เป็นที่อยู่ขององค์ประกอบศูนย์ (อาจเป็นไปได้) (ซึ่งคำตอบนี้)
David Schwartz

3
@DavidSchwartz ลองใช้ภาษาเก่าเป็นซีถ้าจัดสรรหน่วยความจำคุณจะได้รับที่อยู่ที่หน่วยความจำเริ่มต้น หากคอมไพเลอร์เห็นสิ่งที่ต้องการv[n]ให้คำนวณที่อยู่ของนิพจน์ หากดัชนีเริ่มต้น 0 การคำนวณคือ v + x * ขนาด หากที่ 1 การคำนวณคือขนาด v + (x-1) * เช่น v [1] จะสอดคล้องกับ v + (1-1) * ขนาดนั่นคือ v.
Matteo

4
@David: ใน C (ภาษาที่นิยมการทำดัชนีแบบ 0 จริง ๆ )อาร์เรย์และพอยน์เตอร์นั้นส่วนใหญ่สามารถใช้แทนกันได้ดังนั้นจึงมีความสำคัญด้วยเหตุผลหลายประการที่*arrayอ้างถึงองค์ประกอบแรก ตัวอย่างหนึ่ง: ถ้าเราarrayชี้ไปที่ตำแหน่งหน่วยความจำก่อนองค์ประกอบแรกการส่งไปยังอาเรย์ของประเภทอื่นจะเป็นปัญหาเช่น ตำแหน่งของไบต์ที่สองในอาร์เรย์ของints จะขึ้นอยู่กับขนาดของคำ บนเครื่อง 32- บิตมันน่าจะอยู่ที่((char*)intArray + 5)!!
BlueRaja - Danny Pflughoeft

3
ไม่นี่ไม่ใช่ปัญหาของว่าอาร์เรย์มีองค์ประกอบศูนย์หรือไม่ เพราะคุณเห็นว่ายังมีการปรับขนาด ถ้าฉันมีอาร์เรย์ของวัตถุ 8 ไบต์และฉันซ้อนทับด้วยอาร์เรย์ไบต์ดัชนีไบต์ของวัตถุคืออะไร [42] ทำไมมันง่าย: 42 * 8. ปัญหาของการใช้ 1 คืออ็อฟเซ็ตของ 1 นี้คือ 1 ไบต์เมื่อฉันดูที่อาร์เรย์ไบต์และมันคือ 8 ไบต์เมื่อฉันดูอาร์เรย์ 8 ไบต์ที่ซ้อนกัน
Kaz

38

ในขณะที่หลักการด้านล่างนี้ใช้กับทศนิยมเช่นเดียวกับฐานอื่น ๆ การนับจาก 0 ในคอมพิวเตอร์สามารถเข้าใจได้อย่างง่ายดายจากระบบเลขฐานสองคงที่ซึ่งแสดงถึงตัวเลขที่ใช้ในคอมพิวเตอร์ หากคุณมี 8 บิตดังนั้นจะมีการรวมกันที่เป็นไปได้ของ 256 1s และ 0s ที่สามารถแสดงได้ คุณสามารถใช้ 8 บิตเหล่านี้เพื่อแสดงตัวเลข 1-256 แต่สิ่งนี้จะเหลือ 0 ซึ่งมีประโยชน์ในวิชาคณิตศาสตร์เป็นตัวเลขในตัวมันเองดังนั้นพวกมันจึงใช้เพื่อแสดงตัวเลข 0-255

สิ่งนี้ตั้งค่าก่อนหน้าของลำดับธรรมชาติเริ่มต้นจาก 0 (0 ทั้งหมดในการแทนเลขฐานสอง) ถึง 255 (ทั้งหมด 1 ในจำนวน 8 บิต) พิจารณาระบบที่ใช้แทนตัวเลขเริ่มต้นที่ 0 เพราะเหตุผลคือ 0 เป็นหมายเลข "แรก" ในระบบดังนั้น 1 คือหมายเลข "ที่สอง" เป็นต้น

เหตุผลเพิ่มเติมว่าทำไมการเริ่มต้นจาก 0 ในคอมพิวเตอร์จึงสะดวกมากขึ้นเนื่องจากแนวคิดของออฟเซ็ต อ็อฟเซ็ตคือตัวเลขที่แสดงระยะทางจากตำแหน่งในหน่วยความจำหรือฮาร์ดดิสก์หรือสื่ออื่น ๆ ที่ "แอดเดรส" ในคอมพิวเตอร์ข้อมูลทั้งหมดจะถูกจัดเก็บเป็นเส้นตรงหมายความว่ามีคำสั่งไปยังข้อมูลหนึ่งไบต์แรกไบต์ที่สอง ฯลฯ สะดวกในการแสดงตำแหน่งของ "พื้นที่" ของข้อมูลผ่านทางออฟเซ็ต ไบต์แรกในบล็อกของข้อมูลคืออะไร มันอยู่ที่ offset '0' ซึ่งหมายความว่าจะพบ 0 ไบต์หลังจากไบต์แรกในบล็อกของข้อมูล แม้ว่าจะเป็นไปได้ที่จะมี "1" กำหนดไบต์แรกสิ่งนี้จะสร้างความยุ่งยากในการแสดงข้อมูลด้วยเหตุผลหลายประการ:

  • ด้วยการยกเว้น 0 จากการใช้ข้อมูลที่อยู่คุณจะลดจำนวนของสิ่งต่าง ๆ ที่คุณสามารถระบุด้วยตัวเลข 8 บิตต่อหนึ่ง
  • ในการคำนวณออฟเซ็ตซึ่งจำเป็นในระดับฮาร์ดแวร์ของการเข้าถึงข้อมูลในบางจุดคุณต้องลบเลขออกจากการนับซึ่งจะทำให้เกิดความซับซ้อน
  • ตัวชี้ไปยังบล็อกของข้อมูลชี้ไปที่บล็อกแรกเสมอดังนั้นเลขคณิตจะตรงไปตรงมาเมื่อคุณเริ่มต้นจาก 0 (เช่นไบต์ที่ 1 ในบล็อกแรกของกลุ่มแรกของข้อมูลคือ 0 + 0 + 0 เมื่อคุณเริ่มต้นจาก 0 มันคือ 1 + 1 + 1 - 1 -1 เมื่อคุณเริ่มจาก 1) เลขคณิตสำหรับสิ่งนี้เมื่อคุณเริ่มจาก 1 ด้วยโครงสร้างข้อมูลที่ซ้อนกันเช่นตัวอย่างนี้อาจทำให้เกิดความสับสน

31
ไม่มีอะไรเกี่ยวข้องกับการเป็นตัวแทนไบนารี ทั้งเลขฐานสองและเลขฐานสิบเริ่มต้นที่ 0
Matteo

2
หากคุณเริ่มนับจาก 0 คุณจะไม่ลดจำนวนที่อยู่ที่คุณสามารถทำได้ (ในทางทฤษฎี) จาก 1 เป็น 257
Matteo

6
@Matteo ไม่ได้อยู่ในไบต์เดียวที่คุณทำไม่ได้
OrangeDog

8
@Dougvj การนับตามศูนย์ไม่มีอะไรเกี่ยวข้องกับไบนารี ประเด็นที่คุณกำลังทำอยู่คือการใช้ประโยชน์จากตัวเลขทุกตัวในรูปแบบตัวเลขคงที่ซึ่งเป็นข้อกังวลโดยไม่คำนึงว่าคุณกำลังใช้ฐาน 2, ฐาน 10 หรือฐาน 23517
Peter Olson

2
-1 มันไม่มีอะไรเกี่ยวข้องกับการเป็นตัวแทนไบนารี
BlueRaja - Danny Pflughoeft

26

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

ไม่มีอะไรสับสนเกี่ยวกับการรับรู้นี้ไม่สอดคล้องกันระหว่างคอมพิวเตอร์และเทคนิคการนับมนุษย์ (ใด ๆ ) ลองแยกย่อยคำถาม

เหตุใดคอมพิวเตอร์จึงนับจากศูนย์

  • พวกเขาไม่นับจากศูนย์

คอมพิวเตอร์นับค่าเริ่มต้นจากศูนย์ ตัวอย่างเช่นอาร์เรย์ใน C

  • ดัชนี (ตัวแสดงจากตำแหน่งนับ) เริ่มต้นจากศูนย์ นับขององค์ประกอบในอาร์เรย์ที่มีองค์ประกอบหนึ่งที่ดัชนีศูนย์เป็นหนึ่ง

Zero นั้นใช้งานได้จริงเพื่อแสดงถึงความว่างเปล่าของบางสิ่งหรือจุดกึ่งกลางของสเกล มันไม่เป็นประโยชน์สำหรับการนับสิ่งใด ๆ เพราะมันเป็นไปไม่ได้โดยนิยามของศูนย์

ในความหมายเดียวกับจุดกึ่งกลางของสเกลสามารถใช้ศูนย์เพื่อแสดงขอบ (การเริ่มต้นที่แน่นอน) ของคอลเลกชัน คำถามนี้ไม่มีความหมายเพราะมันไม่สอดคล้องกันระหว่าง "ค่านับ" และ "นับจากศูนย์"

ใช่แล้วคอมพิวเตอร์นับจากศูนย์ แต่พวกมันนับจากหนึ่ง คำสองคำมีความหมายแตกต่างกัน

tal·ly [tal-ee]

คำนาม

  1. บัญชีหรือการคำนวณ; บันทึกเดบิตและเครดิตคะแนนของเกมหรืออะไรทำนองนั้น
  2. ทุกอย่างที่เก็บคะแนนหรือบัญชีไว้ ..
  3. จำนวนหรือกลุ่มของรายการที่บันทึกไว้

นับ[kount]

กริยา (ใช้กับวัตถุ)

  1. เพื่อตรวจสอบ (หน่วยแยกหรือกลุ่มของคอลเลกชัน) ทีละคนเพื่อกำหนดจำนวนรวม; เพิ่มขึ้น; แจกแจง: เขานับตั๋วของเขาและพบว่าเขามีสิบ
  2. เพื่อคำนวณ คำนวณ; คำนวณ.
  3. เพื่อแสดงรายการหรือตั้งชื่อตัวเลขให้มากที่สุด: ปิดตาของคุณและนับจำนวน

(dictionary.com)


เหตุผลในทางปฏิบัติมีการอธิบายอย่างเพียงพอโดย Dougvj ฉันไม่มีอะไรเพิ่ม ถ้าเพียง แต่เราสามารถมีอาจารย์ CS (จาก 60s) เพื่อให้บัญชีประวัติศาสตร์ ...


ในความเป็นจริงคุณจะรู้ได้อย่างไรว่าคอมพิวเตอร์เริ่มต้นที่ใด สิ่งที่คุณรู้ก็คือเมื่อคุณใช้มันคุณจะบอกให้เริ่มจากศูนย์
Daniel R Hicks

ฉันกำลังพูดถึงคำจำกัดความของแนวคิดและตรรกะที่นี่ไม่ใช่วิธีการทำงานของคอมพิวเตอร์ ฉันรู้นิดหน่อยว่าคอมพิวเตอร์เริ่มอะไรเพราะฉันเรียนหลักสูตร CS
ЯрославРахматуллин

1
เพื่อจะอวดความสมบูรณ์คุณกำลังเปรียบเทียบคำกริยากับคำนาม ฉันคิดว่า "นับ" และ "นับ" มีความหมายเหมือนกันจริงๆและทั้งคู่สามารถใช้เป็นคำกริยาหรือคำนามได้
Brian

1
@Brian การสังเกตอย่างยุติธรรมและความตั้งใจของฉันคือแสดงให้เห็น (ในลักษณะอวดรู้) ว่าความสับสนเกิดจากการตีความคำที่ไม่ถูกต้อง ไม่มีความแตกต่างระหว่าง "องค์ประกอบที่ 1" และ "องค์ประกอบที่ตำแหน่ง 0" พวกเขาเป็นทั้งองค์ประกอบหนึ่ง ที่แรกไม่ใช่ " zeroth " ไม่มีสิ่งดังกล่าวเป็นนับจากศูนย์ การแจงนับเริ่มต้นที่หนึ่งโดยคำจำกัดความในขณะที่อยู่อาจเป็น -> 1, b-> 2 c-> 3 หรือ 0-> 1, 1-> 2, 2-> 3 ตัวอย่างที่พบมากที่สุดของ "นับจากศูนย์" สามารถพบได้ในหนังสือคณิตศาสตร์โรงเรียนมัธยมในรูปแบบของ {x₀, x₁, x₂} - แต่ห้อยเป็นดัชนี

1
มันเป็นเพียงแค่ว่านักออกแบบเดินเตร่ไปรอบ ๆ ก่อนที่พวกเขาจะตัดสินใจในโครงการปัจจุบัน สิ่งที่ดูเหมือน "ชัดเจน" ตอนนี้ไม่ได้ และน่าจะมีการเลือกรูปแบบที่แตกต่างออกไปและในตอนนี้ดูเหมือนจะ "ชัดเจน" มากกว่าสิ่งที่เรามี
Daniel R Hicks

12

ฉันคิดว่าสิ่งนี้ได้ถูกกล่าวถึงก่อนหน้านี้โดย " prof.dr. Edsger W. Dijkstra " - นักวิจัยของBurroughsในจดหมายลงวันที่ 11 สิงหาคม 1982: cf EWD831

หัวข้อ: ทำไมเลขควรเริ่มต้นที่ศูนย์ "มีเหตุผลที่จะชอบการประชุมหนึ่งไปยังอีกหรือไม่ใช่มี .... "

โปรดสังเกตว่า Dijkstra อยู่ในทีมออกแบบของALGOL 68จนถึงปลายปี 2511 Algol68 อนุญาตให้ใช้อาร์เรย์จาก 0, 1 หรือหมายเลขใด ๆ ที่โปรแกรมเมอร์เห็นว่าเหมาะสมสำหรับอัลกอริธึม cf ( "The Making of Algol 68"เล่าให้ฟังว่า "คุณช่วยกำหนดรูปสามเหลี่ยมได้ไหม?" บางคน (Tony Hoare?) ขัดจังหวะ "ไม่ใช่แค่รูปสามเหลี่ยม แต่เป็นรูปวงรี" ตอบ Aad และแสดงให้เห็นว่า ')

โดยเฉพาะอย่างยิ่งใน Algol68 เมื่ออาร์เรย์ (& เมทริกซ์) ถูกตัดพวกเขาจะได้ดัชนี @ 1 ดังนั้นจึงมีอคติต่อ [1: ... ] อาร์เรย์ แต่สามารถย้ายขอบเขตล่าง"1 st "เพื่อเริ่มต้นที่ตำแหน่ง"0 th "โดยระบุ "@ 0" เช่น vector x [4: 99 @ 2], matrix y [4: 99 @ 1,4: 99 @ 0] ในทำนองเดียวกันมีค่าเริ่มต้น / อคติจาก 1 ในdo ~ odลูป (ยกเว้น " จาก 0" ระบุไว้อย่างชัดเจน) และจาก 1 สำหรับกรณีจำนวนเต็มฉันใน ~, ~, ~ esacและ $ c (~, ~, ~ ) คำสั่ง$ choice

ดูเหมือนว่าความคิดเห็นของ Dijkstra เกี่ยวกับรายงานฉบับร่างเดือนมีนาคม 2511 ( MR93 ) และการยืนยันของเขาทำให้เกิดสิ่งที่เป็นสงครามไฟก่อน Usenet : "มีงานเขียนที่น่ารักแม้ว่าจะไม่มีไวยากรณ์และมีงานเขียนอื่น ๆ ที่มีไวยากรณ์มาก น่าขยะแขยงนี่เป็นสิ่งที่ฉันไม่สามารถอธิบายให้คนผิวเผินได้ " EWD230

รายงานขั้นสุดท้าย Algol 68 (FR) ออกมาเมื่อวันที่20 ธันวาคม 1968เมื่อไม่พอใจที่การประชุมมิวนิกและนำมาใช้โดยคณะทำงาน ต่อจากนั้นรายงานได้รับการอนุมัติจากสมัชชาIFIPขององค์การยูเนสโกเพื่อเผยแพร่

รอบ 23 ธันวาคม (?) 1968 Dijkstra, Duncan, Garwick, Hoare , Randell , Seegmuller, Turski, Woodger และ Garwick ได้ลงนามในAB31.1.1.1 "รายงานผู้ถือหุ้นส่วนน้อย", หน้า 7 (ตีพิมพ์เมื่อปี 1970)


10

ระยะทางที่คนอื่นนำมาเปรียบเทียบนั้นเป็นตัวอย่างที่ใช้งานได้จริง:

"บ้านของคุณอยู่ไกลจากปั๊มน้ำมันที่ใกล้ที่สุด?"

"1 ไมล์"

"คุณอยู่ที่ปั๊มน้ำมันใช่ไหม"

"ไม่ถ้าฉันอาศัยอยู่ที่ปั๊มน้ำมันมันจะเป็น 0 ไมล์"

"ทำไมคุณนับจากศูนย์แทนที่จะเป็นหนึ่ง"

อีกหนึ่งตัวอย่างที่ดีคือวันเกิด - เราไม่ได้บอกว่ามีใครอายุหนึ่งปีในวันที่พวกเขาเกิดเราบอกว่าอีกหนึ่งปีต่อมา

เราบอกว่าปีอธิกสุรทินหรือการเลือกตั้งประธานาธิบดีสหรัฐทุก ๆ สี่ปีแม้ว่าคุณจะนับจากหนึ่ง: 2000 , 2001, 2002, 2003, 2003, 2004เป็นห้าปี (อนึ่งชาวโรมันทำสิ่งนี้ชั่วระยะเวลาหนึ่งและเข้าใกล้เกินไปเป็นเวลาหลายปี)

ประเด็นของฉันคือเรา "นับ" จากศูนย์ตลอดเวลาในโลกแห่งความจริง - "กี่ตำแหน่งหลังจาก [เริ่มต้นของอาร์เรย์] เป็นองค์ประกอบที่คุณต้องการ" ก็เกิดขึ้นเป็นคำถามที่คุณตอบด้วยการนับจากศูนย์ ในหลายโปรแกรมคอมพิวเตอร์ คุณจะไม่พูดว่าองค์ประกอบแรกคือหนึ่งตำแหน่งหลังจากการเริ่มต้นคุณจะ? มันคือจุดเริ่มต้น


1
คณิตศาสตร์ของคุณเกี่ยวกับการเลือกตั้งจะหมดไปภายในหนึ่งปี ตัวอย่างของคุณมี 2 ปีการเลือกตั้งภายในระยะเวลา 5 ปี ภาพประกอบที่ถูกต้องน่าจะเป็นว่า 4 ปีผ่านไปจากการเลือกตั้งครั้งหนึ่งไปสู่การเลือกตั้งครั้งต่อไปคือปี 2000 -> 2001 (ช่วงเวลา 1 ปี), 2001 -> 2002, 2002 -> 2003, 2003 -> 2004
Jimmy

1
@ Jimmy นั่นคือประเด็นของฉัน- ถ้าคน "นับจากหนึ่ง" ในแง่ที่พวกเขาต้องการคอมพิวเตอร์พวกเขาจะนับ 2000 เป็นหนึ่งแทนที่จะเป็นศูนย์ นี่คือวิธีที่ชาวโรมันโบราณทำจริง ๆ (และจะอธิบายวัฏจักรเช่น "2000, 2004, 2008" เป็นรอบห้าปี)
Random832

2
ตัวอย่างวันเกิดของคุณไม่เป็นความจริงในระดับสากล ยกตัวอย่างเช่นในประเทศเกาหลีใต้ในปีแรกของชีวิตจะถูกนับเป็นหนึ่งแทนศูนย์
BennyMcBenBen

6

ตามที่กล่าวไว้แล้วโดยคนอื่น ๆคอมพิวเตอร์ไม่นับจากศูนย์

บางภาษาดัชนีจาก 0 การทำดัชนีจาก 0 มีข้อดีสองประการ:

  1. มันจะแปลงเป็นการประกอบแบบธรรมชาติเพราะสามารถตีความได้ว่าเป็นการชดเชยจากตัวชี้ไปยังตำแหน่งแรก

  2. คุณไม่ได้รับความแปลกประหลาดเมื่อคุณต้องการเชิงลบ ระหว่าง 1BC กับ 1AD กี่ปี ไม่มี. เพราะถึงแม้ว่า BC เป็นวันที่ติดลบได้อย่างมีประสิทธิภาพก็ไม่มีปีศูนย์ ถ้ามี 0AD ก็คงไม่มีปัญหาอะไร คุณจะเห็นปัญหาเดียวกันทั่วทั้งสถานที่ในทางวิทยาศาสตร์ที่ผู้คนได้กำหนดองค์ประกอบแรกอย่างไร้เดียงสาในชุดเป็น +1


ใช่และความโง่เขลาทั้งหมดของการรอจนถึงปี 2001 สำหรับสหัสวรรษใหม่ สิ่งนี้ทำให้สับสนว่าคนเหล่านั้นที่ยังไม่ได้ "รับ" อาร์เรย์ตามศูนย์เมื่อพวกเขาตะลุยในการเขียนโปรแกรม :)
Kaz

3
นอกจากนี้ถ้า "1 ไมล์" หมายถึง "ตรงนี้" ถ้าอย่างนั้นไมล์เป็น 1760 ฟุตก็หมายความว่า "1760 ฟุต" ก็หมายถึง "ตรงนี้" ด้วยใช่ไหม ผิด "1 ฟุต" หมายถึงตรงนี้โอ๊ะโอ! ในความโง่เขลาตามนี้ "ขวาที่นี่" คือเท้าข้างหนึ่งนิ้วหนึ่งนิ้วหนึ่งเซนติเมตร ฯลฯ
Kaz

1
@kaz where feet => หลา 1,603 หลาในหนึ่งไมล์
แบรด

3

การนับตามธรรมชาติเริ่มต้นที่ศูนย์

นี่คืออัลกอริทึมสำหรับการนับแอปเปิ้ลในตะกร้า:

count := 0

for each apple in basket
   count := count + 1

หลังจากดำเนินการตามข้างต้นให้countนับจำนวนแอปเปิ้ล มันอาจจะเป็นศูนย์เพราะตะกร้าสามารถว่างเปล่า

หากคุณไม่ได้ใช้บัตรเครดิตตลอดทั้งเดือนคุณจะได้รับใบเรียกเก็บเงิน 1 ดอลลาร์หรือไม่? หรือร้อยละ 1

เมื่อคุณรีเซ็ตมาตรวัดระยะทางด้วยเครื่องวัดระยะทางในรถยนต์ของคุณจะเป็น 0001 หรือ 0000 หรือไม่

อาร์เรย์สามารถให้มุมมองที่หลากหลายของข้อมูลเดียวกัน

พิจารณาอาร์เรย์ของโครงสร้าง 32 บิตdซึ่งจะทำ 16 wคำบิตแต่ละ แต่ละคำที่ถูกสร้างขึ้นจากสอง 8 bบิตไบต์ ภายใต้การจัดทำดัชนีเป็นศูนย์การซ้อนทับดูสะดวกมาก:

d: |   0   |   1   |
w: | 0 | 1 | 2 | 3 |
b: |0|1|2|3|4|5|6|7|

วัตถุ 32 บิตd[1]เป็นที่อยู่ของคำw[2]ซึ่งคำนวณได้ง่ายโดยการคูณดัชนีด้วย 2 ซึ่งเป็นอัตราส่วนของขนาดของวัตถุ 32 และ 16 บิต b[4]นอกจากนี้ในไบต์อยู่ก็คือ

สิ่งนี้ใช้ได้เพราะศูนย์เป็นศูนย์ในทุกหน่วยของการวัด: ไบต์, คำ, คำสองคำและอื่น ๆ

ดูแผนภาพด้านบน: ดูเหมือนไม้บรรทัดที่การแปลงหน่วยใช้งานง่าย

ด้วยการจัดทำดัชนีตามเดียวมันแบ่ง:

d: |   1   |   2   |
w: | 1 | 2 | 3 | 4 |
b: |1|2|3|4|5|6|7|8|

ตอนนี้เราไม่สามารถคูณdดัชนีด้วย 2 เพื่อรับwดัชนีหรือ 4 เพื่อให้ได้bดัชนี การแปลงระหว่างหน่วยกลายเป็นเงอะงะ ยกตัวอย่างเช่นที่จะไปจากd[2]การที่เรามีการคำนวณb[4]((2 - 1) * 4) + 1 = 5

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

การแปลงระหว่างมุมมองที่แตกต่างกันของข้อมูลกลายเป็นการแปลงที่เป็นองศาเซลเซียส - ฟาเรนไฮต์

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

การย่อขนาดตัวเลขให้เล็กสุด

ในฐานใด ๆ ถ้าเราต้องการใช้ตัวเลขที่น้อยที่สุดเพื่อใช้ช่วงของค่าที่เป็นกำลังของฐานเราจะต้องเริ่มจากศูนย์ ตัวอย่างเช่นในฐานสิบสามหลักก็เพียงพอที่จะให้ค่าที่แตกต่างกันพันค่าจาก 0 ถึง 999 หากเราเริ่มจาก 1 เราจะล้นด้วยค่าเพียงค่าเดียวและเราต้องการตัวเลขสี่หลัก

สิ่งนี้มีความสำคัญในคอมพิวเตอร์เนื่องจากจำนวนหลักในไบนารี่แปลเป็นบรรทัดที่อยู่ของฮาร์ดแวร์ ตัวอย่างเช่นชิป ROM ที่มี 256 คำอยู่ในนั้นสามารถแก้ไขจาก 0 ถึง 255 ซึ่งต้องใช้ 8 บิต: 00000000 ถึง 11111111 หากได้รับการจัดการตั้งแต่ 1 ถึง 256 ต้องใช้เก้าบิต เราต้องเพิ่มการติดตามที่อยู่อีกครั้งอย่างสิ้นเปลืองไปยังแผงวงจรหรือวงจรรวม ดังนั้นสิ่งที่อาจเกิดขึ้นในทางปฏิบัติก็คือ 0 จะถูกเรียก1 ที่ระดับซอฟต์แวร์ API สำหรับการเข้าถึงชิปนั้น คำขอสำหรับคำที่ 1 จะนำ 00000000 ไปใช้จริงบนบัส 8 บิต หรืออื่น ๆ ขอ 1 จะแปลไปยังที่อยู่ 00000001 เป็นไปตามคาด แต่ขอ 256 จะแผนที่ไปยังที่อยู่ 8 บิตที่ไม่ได้ใช้อย่างอื่นมากกว่า 00000000 ที่อยู่ 9 บิต 100000000 ทั้งสองคนนี้ kludges ถุงกัดเป็นจริงการแก้ปัญหาใน ค้นหาปัญหาและหลีกเลี่ยงทั้งหมดโดยใช้ 0 ถึง 255 ที่ฮาร์ดแวร์ในซอฟต์แวร์และในส่วนต่อประสานผู้ใช้และเอกสารทั้งหมด

การกระจัดแบบหนึ่งที่พื้นฐานคือความโง่

พิจารณาทฤษฎีดนตรีตะวันตกเช่น เรามีสเกลคู่กับเจ็ดโน้ต แต่เราเรียกพื้นที่ที่มันครอบคลุมอ็อกเทฟ ! การผกผันของช่วงเวลานั้นเป็นไปตามกฎของเก้า : ตัวอย่างเช่นการกลับกันของหนึ่งในสามคือหก (ลบสามจากเก้า) ดังนั้นสามตัวเลขที่แตกต่างกันก็เล่นเพื่ออะไรที่ง่ายมาก: เจ็ด (โน้ตในสเกล), แปด (แปดเสียง) และเก้า (ลบจากถึงกลับหัว)

หากโน้ตเจ็ดใบทำผนังหรือ heptave และช่วงเวลาเป็นศูนย์โดยพื้นฐานแล้วเราจะลบจากเจ็ดถึงกลับด้าน ทุกอย่างขึ้นอยู่กับเจ็ด

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

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

ทฤษฎีดนตรีและการเขียนล้าสมัยไปมาก ส่วนใหญ่ไม่ได้เปลี่ยนไปนับตั้งแต่วันที่แต่งด้วยปากกาขนนกด้วยแสงเทียน

ระบบที่ใช้ระบบเดียวสร้างความสับสนให้กับคนคนเดียวกันที่ไม่สามารถจัดการกับอาร์เรย์ที่ไม่มีศูนย์

เมื่อปี 2000 กลิ้งไปรอบ ๆ หลายคนสับสนว่าทำไมสหัสวรรษใหม่ยังไม่เริ่ม ผู้ที่ชี้ให้เห็นว่ามันจะไม่เริ่มจนกว่าปี 2001 จะถูกมองว่าเป็นคนเซ่อปาร์ตี้และคนโง่ ท้ายที่สุดคุณอยู่ในวัย 20 ปีเมื่อคุณอายุ 20 ใช่ไหม? ไม่ใช่เมื่อคุณอายุ 21 ปีหากคุณคิดว่าสหัสวรรษเริ่มต้นในวันที่ 1 มกราคม 2000 คุณไม่มีสิทธิ์บ่นเกี่ยวกับอาร์เรย์ที่ใช้ศูนย์ในภาษาการเขียนโปรแกรมใด ๆ พวกมันทำงานอย่างที่คุณชอบ (แต่ใช่ผู้สนับสนุนของการกระจัดและอาร์เรย์ที่ใช้หนึ่งฐานคือ dweebs และพรรค poopers ศตวรรษควรเริ่มต้นใน XX00 ปีและพันปีใน X000 ปี)

ปฏิทินเป็นใบ้ แต่อย่างน้อยเวลาของวันจะเป็นศูนย์

แต่ละนาทีใหม่ในนาฬิกาของคุณเริ่มต้นด้วย: 00 วินาที แต่ละชั่วโมงใหม่เริ่มต้นด้วย 00:00 นาทีและวินาที และอย่างน้อยในนาฬิกา 24 ชั่วโมงวันที่หมุนไปรอบ ๆ เมื่อเที่ยงคืนและเพิ่ม 11:59:59 เป็น 00:00:00

ดังนั้นหากคุณต้องการที่จะคำนวณวินาทีตั้งแต่เที่ยงคืนเวลา 13:53:04 13 * 3600 + 53 * 60 + 4เหมือนคุณก็มีการประเมิน ไม่มีการ1เพิ่มหรือการลบเบาจืด

ปิดพูดจาโผงผางเกี่ยวกับ MIDI

โอเคมันคืออะไรกับนักดนตรีแม้จะเป็นนักวิชาการด้านเทคนิค?

MIDI! มันใช้การกำหนดหมายเลขตามศูนย์สำหรับโปรแกรมและช่องในการแสดงข้อความลวดจริง แต่เฟืองแสดงเป็น 1 ตาม! สำหรับโปรแกรมอินสแตนซ์ 0 ถึง 127 จะเรียกว่า 1 ถึง 128 บนอุปกรณ์ส่วนใหญ่ แต่บางโปรแกรมเรียกว่า 0 ถึง 127 หรือแม้แต่ให้ผู้ใช้เลือกได้

โปรแกรม 71 ถึง 80 ถือเป็น "ธนาคาร" ของสิบ มันบอกว่าถูกต้องบนแป้นเหยียบ MIDI ของฉัน footswitch นั้นมีป้ายกำกับตั้งแต่ 1 ถึง 10 และถ้าฉันอยู่ในธนาคารที่เจ็ดพวกเขาเลือกโปรแกรม 71 ถึง 80 อย่างไรก็ตามอุปกรณ์หรือซอฟต์แวร์คอมพิวเตอร์บางโปรแกรมแสดงหมายเลขโปรแกรม 1-128 เป็น 0 ถึง 127 หรือแม้กระทั่งให้ผู้ใช้ ทางเลือก! อะไรคือสิ่งที่แย่กว่านั้นคือระบบที่ใช้ระบบเดียวหรือความโกลาหลที่สร้างขึ้นโดยใช้ทั้งระบบหนึ่งและศูนย์ในเวลาเดียวกัน

หมายเลขสถานี MIDI เรียกว่า 1 ถึง 16 แต่แสดงด้วยเลขฐาน 0 ถึง 15 ราวกับว่าทั้งๆที่มีการนำเสนอแบบอิงอยู่แล้วเกียร์บางตัวใช้ dispswitch สำหรับการกำหนดค่าหมายเลขช่องสัญญาณและบ่อยครั้งที่สวิตช์เหล่านี้ใช้รหัสไบนารี่พื้นฐานที่เป็นศูนย์ ดังนั้นหากคุณต้องการแชนเนล 3 คุณต้องสลับเป็น 0010 (ไบนารี 2)


1

ถ้าฉันจำได้อย่างถูกต้องจากคลาสภาษาเขียนโปรแกรมแนวคิดของฉัน ... ภาษาที่มีการจัดทำดัชนี 0 และอื่น ๆ ที่เป็น 1 ดัชนีจะต้องทำด้วยเหตุผลทางประวัติศาสตร์ Algol-68, ผู้เป็นบิดาแห่งภาษาการเขียนโปรแกรมนั้นได้รับการจัดทำดัชนี 1 ครั้งรวมถึง Fortran และภาษาอื่น ๆ อีกสองสามภาษาเช่น COBOL อย่างไรก็ตามในบางภาษาเหล่านี้คุณสามารถระบุได้อย่างชัดเจนว่าดัชนีเริ่มต้นของคุณคืออะไร มีตารางที่น่าสนใจของเรื่องนี้ที่นี่

โดยพื้นฐานแล้วกลับมาอยู่ในศาสตร์คณิตศาสตร์" Ye Olde Days " นักวิทยาศาสตร์และ "นักวิชาการ" คนอื่น ๆ มักจะใช้ภาษาที่มีการจัดทำดัชนี 0 ขณะที่ผู้ใช้ภาษาเช่น COBOL พบว่าไม่มีประโยชน์ที่จะเริ่มนับที่ 0 ดังนั้นในภาษาเหล่านั้น เริ่มต้นที่ 1 (ดูสับสนน้อยลง)

ทีนี้ถ้าคำถามของคุณอ้างถึงสาเหตุว่าทำไมคอมพิวเตอร์ ( ไม่ใช่ภาษา ) เริ่มนับจากศูนย์โดยธรรมชาติ ... ทีนี้ฉันเดาว่ามันอยู่ในไบนารีจริง ๆ : ex: 0000= ศูนย์ 0001= หนึ่ง ... เป็นต้นไป ออกมา ...


4
ไม่มีอะไรเกี่ยวข้องกับการเป็นตัวแทนไบนารี ทั้งเลขฐานสองและเลขฐานสิบเริ่มต้นจาก 0 (ตามที่คุณแสดงในตัวอย่าง)
Matteo

มันมีอย่างอื่นที่เกี่ยวข้องกับไบนารี ด้วยสี่บิต 0000 ถึง 1111 คุณสามารถจัดการกับหน่วยความจำ 16 คำได้ หากคุณใช้แบบอ้างอิงเดียวคุณต้องมีที่อยู่ห้าบรรทัดเพื่อแสดงเป็น 0001 ถึง 10,000 หรืออย่างอื่นคุณทำอย่างใดอย่างหนึ่ง MIDI ทำกับหมายเลขช่องสัญญาณ: 0000 ถูกใช้ภายใน แต่ส่วนต่อประสานผู้ใช้แสดง 1! หากฮาร์ดแวร์เป็นฐานสิบก็จะเป็นปัญหาเดียวกัน ตัวเลขสามหลักให้คุณหนึ่งพันที่อยู่ถ้าคุณเริ่มต้นจากศูนย์ แต่ถ้าคุณเริ่มต้นจาก 1 คุณต้องมีตัวเลขสี่หลัก
Kaz

1

หมายเลข 0 สามารถแสดงถึงความหมายต่าง ๆ : ค่าตัวเลขลำดับที่อยู่หน่วยความจำ ฯลฯ

'ดัชนีศูนย์' ไม่ได้หมายความว่าโปรแกรมเมอร์นับจากศูนย์ มันแสดงถึงสถานที่แรกของบล็อกหน่วยความจำที่จัดสรรและ '0' เป็นที่อยู่ของมัน

ใน C การวนลูปผ่านอาร์เรย์สามารถเขียนได้ดังนี้:

int arr[N];
for (i=0; arr[N]; ++i) {
...
}

งานเดียวกันสามารถทำได้ใน C #:

Object[] arr;

for (Object o in arr) {
...
}

ฉันคิดว่าทั้งสองตัวอย่างไม่มีการนับ


1

การเริ่มต้นที่ศูนย์นั้นเป็นจริงเมื่ออธิบายระยะทางจากบางสิ่ง ดังนั้นในอาร์เรย์นี้:

[4,9,25,49]

ระยะทางจากจุดเริ่มต้นของอาร์เรย์ถึง 25 คือ 2 - คุณต้องข้ามสองขั้นตอนเพื่อไปที่นั่น ระยะทางถึง 4 คือศูนย์ - คุณไม่จำเป็นต้องย้ายจากจุดเริ่มต้นเลย

เป็นเรื่องจริงที่จะคิดเช่นนี้เมื่อเพิ่มระยะทาง (หรือดัชนี) - ฉันก้าวไปหนึ่งก้าวจากนั้นจึงก้าวเป็นศูนย์จากนั้นสองก้าวฉันจะอยู่ที่ไหน ฉันอยู่ที่ดัชนี 1 + 0 + 2 = 3 ข้ามสามขั้นตอนฉันจบที่ 49 ในอาร์เรย์ด้านบน


การนับจำนวนชั้นในอาคารควรเป็นแบบเดียวกัน (แม้ว่าเราจะไม่ทำแบบนั้นในสหรัฐอเมริกา) ระดับพื้นดินควรเป็นศูนย์เพราะคุณไม่ได้ขึ้นหรือลง มันเป็นตำแหน่งเริ่มต้น

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

1

จำวิธีแสดงตัวเลขในคอมพิวเตอร์ ลองหาbyteตัวแปรดู 0 แสดงเป็น 00000000 1ในไบนารี 1 คือ 00000001 2 คือ 00000010 และต่อไป

โปรดทราบว่าจำนวนต่ำสุดที่byteสามารถจัดเก็บคือ 0 ถ้าเราเริ่มดัชนีอาร์เรย์ด้วย 1 ระบบจะไม่มีประสิทธิภาพเนื่องจากตอนนี้เรามีอาร์เรย์ที่มีความยาว 255 แทนที่จะเป็น 256 เนื่องจากตัวเลขในโปรแกรม C คอมไพล์เป็นเลขฐานสอง ( intโดยปกติแล้วunsigned intดัชนีดัชนีในอาร์เรย์) ดูเหมือนว่าเป็นธรรมชาติที่จะใช้ 0 เป็นดัชนีเริ่มต้นเนื่องจากมีประสิทธิภาพมากกว่า

นอกจากนี้ใน C ++ a[p]แผ่ออกไป*(a+p*n)โดยที่nขนาดของประเภทข้อมูล ในคำอื่น ๆa[p]หมายถึง "ให้องค์ประกอบที่ดัชนีa+n*p" หากpเริ่มต้นด้วย1แล้วเราต้องการมีที่ว่างเปล่า / aส่วนที่ไม่ได้ใช้ที่ดัชนี

1. แน่นอนคำถามที่ชัดเจนว่า "ทำไม" เกิดขึ้น ทำไมไม่ตั้ง 00000000 ต่อ 1 ง่าย ๆ : การเพิ่มแบบไบนารี (ทำโดยการเรียงซ้อนของตัวบวกแบบเต็ม) เป็นเรื่องง่ายในฮาร์ดแวร์เมื่อ 00000000 เป็น 0 การเพิ่มแบบไบนารีเป็นส่วนสำคัญของการดำเนินการทางคณิตศาสตร์ทั้งหมด หากคุณทำให้มันเป็น 1 คุณจะต้องบอกคอมไพเลอร์ให้ลบ 1 จากตัวเลขทั้งหมดหรือคุณต้อง hardwire วงจรของวงจรบวกเพื่อลบหนึ่งก่อนจากภาคผนวกและตรึงมันกลับไปที่ผลรวม (โปรดทราบว่าคุณไม่สามารถลบได้ในภายหลังเนื่องจากอาจมีส่วนเกี่ยวข้องกับการพกพา)


@sec เพราะมันไร้สาระในระดับฮาร์ดแวร์ (ดูการแก้ไข)
Manishearth

1

modulo

สิ่งหนึ่งที่คำตอบที่ดีที่มีอยู่ยังไม่ได้กล่าวถึง: การทำดัชนีแบบ zero-based ทำงานได้ดีกับการดำเนินงานแบบโมดูโลซึ่งสามารถนำมารวมกันเพื่อสร้างรายการวงจร ลองคิดถึงตัวอย่างเกี่ยวกับสิ่งที่ชอบ

color = colors[i % colors.length]

ซึ่งอาจให้แต่ละวัตถุ (จัดทำดัชนีโดยi) สีที่แตกต่างจากรายการcolorsจนกว่าจะมีการใช้สีทั้งหมด ณ จุดนั้นมันจะเริ่มอีกครั้งจากจุดเริ่มต้น การแสดงแบบเดียวกันในการจัดทำดัชนีแบบอิงพื้นฐานนั้นค่อนข้างซุ่มซ่าม

color = colors[(i - 1) % colors.length + 1]

การดำเนินการโมดูโลแบบอัตโนมัติที่กำหนดโดยเลขคณิตเลขฐานสองแบบไม่มีการกำหนดพร้อมการล้อมรอบเป็นอีกตัวอย่างหนึ่งที่ทำให้เหตุผลนี้สมเหตุสมผล

จัดเลี้ยงสำหรับทั้งสอง

สิ่งที่จะต้องพิจารณาก็คือความจริงที่ว่ามันเป็นเรื่องง่ายสวยที่จะไม่ใช้องค์ประกอบแรกของอาร์เรย์ zero-based (สิ่งนี้ไม่ถือเป็นลักษณะforeachซ้ำและสร้างภาษาที่คล้ายกันซึ่งปฏิบัติต่ออาร์เรย์โดยรวม) โปรแกรมเมอร์หลายคนรวมถึงตัวเองอาจรู้สึกอึดอัดใจเล็กน้อยเกี่ยวกับพื้นที่ที่สูญเปล่า แต่ในสถานการณ์ส่วนใหญ่ปริมาณน้อยมากจนเป็นห่วง ไม่มีมูลความจริง ในทางกลับกันหากภาษากำลังใช้การจัดทำดัชนีแบบฐานเดียวก็ไม่มีทางที่จะจำลององค์ประกอบที่ศูนย์ดัชนีโดยไม่ต้องใช้โค้ดจำนวนมาก ดังนั้นในบางสถานการณ์การทำดัชนีแบบ zero-based จะดีกว่าแบบ one-based โดยเลือก zero เป็นพื้นฐานในทุกที่ เป็นวิธีการที่ยืดหยุ่นมากขึ้นเมื่อเทียบกับฐานเดียวทุกแห่งและมีความสอดคล้องมากกว่าตำแหน่งเริ่มต้นที่กำหนดค่าได้


0

ระบบคอมพิวเตอร์ใช้ทั้งจำนวนธรรมชาติ (นับจาก 0) และจำนวนเต็ม (นับจาก 1) ผู้คนนับสิ่งต่าง ๆ ในจำนวนเต็มซึ่งทำให้พวกเขาใช้งานง่ายสำหรับรายการลำดับเลขและภาษาการเขียนโปรแกรมจำนวนมากใช้ประโยชน์จาก: BASIC, COBOL, Fortran, Lua และ Pascal ทั้งหมดนับจาก 1 ภาษาเหล่านั้นมีเป้าหมายเหมือนการประมวลผลข้อมูลการวิเคราะห์เชิงตัวเลข และการสอนซึ่งรายการที่เรียบง่ายใช้งานง่ายเป็นข้อได้เปรียบ

ตัวเลขทั้งหมดไม่น่าเชื่อเมื่อคุณเริ่มวิเคราะห์และจัดการโครงสร้างของข้อมูลแทนที่จะประมวลผลทุกอย่างตามลำดับ เมื่อคุณจำเป็นต้องอ้างถึงลำดับในสูตรหรืออัลกอริทึมมันง่ายกว่าและมีข้อผิดพลาดน้อยกว่าในการหาเลขจาก 0 เช่นที่นักคณิตศาสตร์ทำ: 0 , 1 , 1 , nและอื่น ๆ มิฉะนั้นคุณต้องปรับด้วย +1 และ –1 เพื่อให้ได้ข้อมูลที่ถูกต้องและง่ายต่อการเข้าใจผิดสร้างข้อบกพร่อง ดังนั้นภาษาที่ออกแบบมาสำหรับนักวิทยาศาสตร์คอมพิวเตอร์มักใช้หมายเลขธรรมชาติ: C, Java และ Lisp ทั้งหมดนับจาก 0

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


Java ... สำหรับนักวิทยาศาสตร์คอมพิวเตอร์ ฮ่า ๆ!
Kaz

0

คำตอบง่ายๆคือตัวเลขตัวแรกไม่ใช่ 1 คือ 0

คำอธิบาย: สูตรการคำนวณตัวเลขหลายหลักในฐานใด ๆ คือ:

n = sum(i=0 to n, Di^i)

WHERE 
n = numeric result
i = index (starting with 0)
Di = is the digit at index i

ลองใช้ระบบทศนิยมมันเป็นระบบที่เราคุ้นเคยมากที่สุด

ดูหมายเลข 1234 เราสามารถเขียนเป็น:

4 x 10^0 = 4
3 x 10^1 = 30
2 x 10^2 = 200
1 x 10^3 = 1000

in other words, sum of digits raised to the power if their index.

ดังนั้นไม่ใช่แค่คอมพิวเตอร์เราคนนับจาก 0 ด้วย


0

ดัชนีอาเรย์คือออฟเซ็ตจากตำแหน่งหน่วยความจำฐานไปยังตำแหน่งหน่วยความจำขององค์ประกอบ องค์ประกอบที่ฉันคือฐาน + ฉัน องค์ประกอบแรกตั้งอยู่ที่ตำแหน่งฐานดังนั้นจึงอยู่ที่ตำแหน่ง 0 (ฐาน + 0)


0

นอกจากประสิทธิภาพการคำนวณแล้วยังมีอีกแง่มุมหนึ่งในการนับ มีสองวิธีในการให้แต่ละองค์ประกอบในลำดับหมายเลขตามลำดับ:

  1. จำนวนองค์ประกอบก่อนหน้า (ทั้ง) (หมายเลขที่สำคัญ)
  2. ตำแหน่งขององค์ประกอบ (หมายเลขลำดับ)

อายุของผู้คนเป็นตัวเลขสำคัญ: ในปีแรกหลังจากการเกิดของทารกมันคือ 0 ปีเพราะมันมีชีวิตอยู่ตลอดทั้งปีศูนย์

จำนวนปีในวันที่เป็นเลขลำดับ: ในปีแรก Anno Domini (AD), ปีคือ 1 AD ไม่มีปีเป็น 0 เช่นเดียวกับไม่มีข้อที่ศูนย์อะไร

ภาษาการเขียนโปรแกรม (เช่น Matlab และ Mathematica) โดยที่ดัชนีขององค์ประกอบแสดงตำแหน่งของมันในอาเรย์เริ่มนับจาก 1: องค์ประกอบแรก ในภาษาอื่น ๆ (เช่นภาษาที่ใช้ภาษา C) ดัชนีขององค์ประกอบคือจำนวนองค์ประกอบก่อนหน้าดังนั้นองค์ประกอบแรกคือ 0


แน่นอนว่าMatteo นั้นถูกต้องเพียงบางส่วนเมื่อระบุว่าการจัดทำดัชนีแบบ zero-based นั้นมีประสิทธิภาพมากกว่า

element(n) = address + n * element_size

การจัดทำดัชนีแบบฐานเดียวสามารถทำได้อย่างมีประสิทธิภาพหากที่อยู่ของอาร์เรย์ทั้งหมดได้ถูกelement_sizeลบออกไปแล้วหนึ่งอัน สิ่งนี้สามารถทำได้เมื่อจัดสรรอาเรย์แล้วในกรณีนี้จะเป็นไปอย่างรวดเร็ว:

array_address = address - element_size
element(n) = array_address + n * element_size

-1

คอมพิวเตอร์มักจะมีค่าตัวเลขเริ่มต้นจากศูนย์ ตัวอย่างเช่นอาร์เรย์ในภาษาการเขียนโปรแกรม C-based เริ่มต้นจากดัชนีศูนย์

0 …คุณกำลังสับสนกับแนวคิดที่แตกต่าง: ภาษาการเขียนโปรแกรมคอมพิวเตอร์และการนับ

  1. การใช้ 2 สถานะ (โดยส่วนใหญ่จะทำในสิ่งที่ถูกต้อง) หมายความว่าคุณสามารถเลือกตัวเลข 2 หลักเพื่อจับคู่กับ (ถึงพูดอ้างอิง) "3" และ "5" (หรือ "F" และ ",") จะใช้ได้ แต่คุณจะถามว่าทำไมคอมพิวเตอร์นับจาก "3" (หรือจาก "F") ทางเลือกธรรมชาติคือ 0 และ 1 อย่างเห็นได้ชัด
  2. อาร์เรย์ใน Pascal เริ่มจาก 1 ภาษานั้นค่อนข้างเป็นนามธรรมมากกว่าระดับ C ต่ำ
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.