ปล้นสลิง: สวัสดีครับผมร็อบโบว์ และขอพูดคุยเกี่ยว quiz0
>> ดังนั้นคำถามแรก
นี่คือคำถามที่ คุณจำเป็นต้องรหัสตัวเลข
127 ในหลอดไบนารี
ถ้าคุณต้องการคุณสามารถ ทำแปลงปกติ
จาก bi-- หรือจากทศนิยมเพื่อไบนารี
แต่ที่อาจจะ ที่จะใช้เวลามาก
ฉันหมายความว่าคุณสามารถคิดออกว่า ตกลง 1 ในนั้น 2 ในนั้น
4 อยู่ในนั้น 8 อยู่ในนั้น
วิธีที่ง่าย, 127 เป็น 128 ลบหนึ่ง
ที่หลอดไฟซ้ายสุดเป็น 128 บิต
ดังนั้น 127 เป็นจริงเพียงทั้งหมด ของหลอดไฟอื่น ๆ
ตั้งแต่ที่ซ้ายสุด หลอดไฟลบ 1
ที่มันสำหรับคำถามที่
>> คำถามหนึ่ง
ดังนั้นด้วย 3 บิตที่คุณสามารถ เป็นตัวแทนของ 8 ค่าที่แตกต่าง
ทำไมจึงเป็น 7 ที่ใหญ่ที่สุดที่ไม่ใช่เชิงลบ จำนวนเต็มทศนิยมที่คุณสามารถแสดง?
ดีถ้าเราสามารถทำได้เท่านั้น เป็นตัวแทนของ 8 ค่าแตกต่าง
แล้วสิ่งที่เรากำลังจะเป็น ที่เป็นตัวแทนเป็น 0 ถึง 7
0 จะขึ้นค่าใดค่าหนึ่ง
>> คำถามที่สอง
ด้วยบิต n กี่ที่แตกต่าง ค่าที่คุณสามารถแสดง?
ดังนั้นด้วยบิต n คุณมี 2 ค่าที่เป็นไปสำหรับแต่ละบิต
ดังนั้นเราจึงมี 2 ค่าที่เป็นไปได้ บิตแรก 2 ค่าที่เป็นไป
เป็นครั้งที่สอง 2 เป็นไปได้สำหรับที่สาม
และเพื่อให้เป็น 2 ครั้ง 2 ครั้งที่ 2 และ ในที่สุดคำตอบคือ 2 ถึง n
>> คำถามที่สาม
อะไร 0x50 ในไบนารี?
ดังนั้นจำไว้ว่าเลขฐานสิบหกมีมาก การแปลงเลขฐานสองตรงไปตรงมา
ดังนั้นที่นี่เราก็ต้องมองไปที่ 5 และ 0 อิสระ
ดังนั้นสิ่งที่ 5 ในไบนารี?
0101 ที่เป็นบิตที่ 1 และ 4 บิต
มีอะไรในไบนารี 0?
ไม่ยุ่งยาก
0000
ดังนั้นเพียงแค่นำพวกเขาเข้าด้วยกันและ ที่เต็มจำนวนในไบนารี
01010000
และถ้าคุณต้องการคุณสามารถ ถอดที่ศูนย์ซ้ายสุด
มันเป็นเรื่องที่ไม่เกี่ยวข้อง
>> ดังนั้นแล้วอีกทางเลือกหนึ่ง สิ่งที่เป็น 0x50 ในทศนิยม?
หากคุณต้องการคุณ could-- ถ้าคุณ สะดวกสบายมากขึ้นกับไบนารี,
คุณสามารถใช้คำตอบไบนารีที่ และแปลงที่เป็นทศนิยม
หรือเราก็สามารถจำได้ เลขฐานสิบหกที่
เพื่อให้ 0 อยู่ในสถานที่ที่ 0-th และ 5 ที่อยู่ใน 16 ไปยังสถานที่แรก
ดังนั้นที่นี่เรามี 5 ครั้งที่ 16 ครั้งแรกบวก 0 ครั้งที่ 16 ให้เป็นศูนย์,
คือ 80
และถ้าคุณมองไปที่ ชื่อเพื่อคำถามที่ว่า
มันเป็นซี 80 ซึ่งเป็นชนิดของ คำใบ้ที่จะตอบปัญหานี้
>> คำถามที่ห้า
เรามีสคริปต์ Scratch นี้ซึ่งเป็น การทำซ้ำ 4 ครั้งเนยถั่วเยลลี่
ดังนั้นวิธีการที่เราทำตอนนี้รหัสที่ใน C?
ดีที่เรามีตรงนี้ส่วนหนึ่งเป็นตัวหนา เป็นเพียงส่วนหนึ่งที่คุณมีในการดำเนินการ
ดังนั้นเราจึงมี 4 วงที่วนลูป 4 ครั้ง printf ไอเอ็นจีเนยถั่วลิสงวุ้น
กับสายใหม่เป็นปัญหาขอ
>> คำถามที่หกปัญหา Scratch อื่น
เรามาดูกันว่าเราอยู่ในวงตลอดไป
เรากำลังจะบอกว่าฉันตัวแปร แล้วการเพิ่มฉัน 1
ตอนนี้เราต้องการที่จะทำในซีมี หลายวิธีที่เราจะได้ทำอย่างนี้
ที่นี่เราที่เกิดขึ้นกับรหัส ห่วงตลอดไปในขณะที่ (จริง)
ดังนั้นเราประกาศตัวแปรฉันเพียง เหมือนเรามีฉันตัวแปรในเกา
ประกาศฉันตัวแปรและตลอดไป ในขณะที่ (จริง) เราบอกฉันตัวแปร
ดังนั้น printf% i-- หรือคุณอาจจะเคยใช้% d
เราบอกว่าตัวแปรที่และ แล้วเพิ่มมัน i ++
>> คำถามที่เจ็ด
ตอนนี้เราต้องการที่จะทำบางสิ่งบางอย่างที่คล้ายกันมาก กับมาริโอจุด C จากปัญหาตั้งหนึ่ง
เราต้องการที่จะพิมพ์ hashtags เหล่านี้ เราต้องการที่จะพิมพ์ห้า
โดยสามสี่เหลี่ยมผืนผ้า hashes เหล่านี้
ดังนั้นเราจึงมีวิธีการที่จะทำเช่นนั้น?
ดีเราจะให้คุณทั้ง พวงของรหัสและคุณก็
ต้องกรอกข้อมูลในฟังก์ชั่นการพิมพ์ตาราง
>> ดังนั้นสิ่งที่จะ PrintGrid มีลักษณะอย่างไร
ที่ดีที่คุณกำลังที่ผ่านมา ความกว้างและความสูง
ดังนั้นเราจึงมีด้านนอก 4 ห่วงที่วนลูป
ทั้งหมดแถวนี้ ตารางที่เราต้องการที่จะพิมพ์ออกมา
แล้วเรามีที่ซ้อนกันระหว่างวงที่ 4 ที่พิมพ์ไปแต่ละคอลัมน์
ดังนั้นสำหรับแต่ละแถวเราพิมพ์สำหรับ แต่ละคอลัมน์กัญชาเดียว
จากนั้นที่ท้ายแถวที่เราพิมพ์ บรรทัดใหม่เดียวจะไปแถวถัดไป
และที่มันสำหรับตารางทั้ง
>> คำถามที่แปด
ฟังก์ชั่นเช่น PrintGrid มีการกล่าวถึง มีผลข้างเคียง แต่ไม่กลับมา
มูลค่า
อธิบายความแตกต่าง
ดังนั้นนี้ขึ้นอยู่กับคุณความทรงจำ สิ่งที่มีผลข้างเคียงคือ
ดีกลับ value-- เรารู้ว่า PrintGrid ไม่
มีค่าตอบแทนตั้งแต่ ที่นี่มันบอกว่าเป็นโมฆะ
ดังนั้นสิ่งที่จะกลับมาเป็นโมฆะ ไม่ได้จริงๆกลับอะไร
ดังนั้นสิ่งที่เป็นผลข้างเคียงหรือไม่
ดีผลข้างเคียงคือ สิ่งที่จัดเรียงของยังคงมีอยู่
หลังจากเสร็จสิ้นการทำงาน ที่ไม่ได้กลับมาเพียงแค่
และมันก็ไม่ได้เป็นเพียงปัจจัยการผลิตจาก
>> ดังนั้นสำหรับตัวอย่างเช่นเราอาจจะ เปลี่ยนตัวแปรทั่วโลก
ที่จะมีผลข้างเคียง
ในกรณีนี้โดยเฉพาะอย่างยิ่ง ผลข้างเคียงที่สำคัญมาก
เป็นพิมพ์ที่หน้าจอ
เพื่อให้เป็นผลข้างเคียง ที่ PrintGrid มี
เราพิมพ์สิ่งเหล่านี้ไปยังหน้าจอ
และคุณสามารถคิด ที่เป็นผลข้างเคียง,
นับว่าเป็นสิ่งที่ คงอยู่หลังจากที่ฟังก์ชั่นนี้จะสิ้นสุดลง
นั่นคือสิ่งที่อยู่นอกขอบเขต ของฟังก์ชันนี้ว่าในท้ายที่สุด
จะถูกเปลี่ยนแปลง เนื้อหาของหน้าจอ
>> คำถามที่เก้า
พิจารณาโปรแกรมด้านล่าง ที่หมายเลขบรรทัด
ได้ถูกเพิ่มสำหรับ ประโยชน์ของการสนทนา
ดังนั้นในโปรแกรมนี้เราเป็นเพียง โทร GetString, เก็บไว้
ใน S ตัวแปรแล้ว พิมพ์ว่าตัวแปร S
ตกลง
เพื่ออธิบายว่าทำไมสายหนึ่งอยู่
CS50 #include จุดชั่วโมง
เราไม่จำเป็นต้อง # include CS50 จุดชั่วโมงทำไม?
ดีที่เรากำลังเรียกร้อง getString ฟังก์ชั่น
และ GetString ถูกกำหนด ในห้องสมุด CS50
ดังนั้นถ้าเราไม่ได้มี #include CS50 จุดชั่วโมง
เราจะได้รับการประกาศโดยปริยายว่า ของข้อผิดพลาดการทำงานของ GetString
จากคอมไพเลอร์
ดังนั้นเราจึงจำเป็นที่จะรวม library-- เราต้องรวมไฟล์ส่วนหัว
หรืออื่น ๆ คอมไพเลอร์จะไม่ ยอมรับว่ามีอยู่ GetString
>> อธิบายว่าทำไมสายที่สองคือปัจจุบัน
มาตรฐานดังนั้นจุดชั่วโมง io
มันตรงเดียวกัน เป็นปัญหาที่เกิดขึ้นก่อนหน้านี้
ยกเว้นแทนของการจัดการกับ getString เรากำลังพูดเกี่ยวกับ printf
ดังนั้นถ้าเราไม่ได้บอกว่าเราต้อง รวมถึงมาตรฐาน io จุดชั่วโมง
แล้วเราจะไม่สามารถ ที่จะใช้ฟังก์ชั่น printf,
เพราะคอมไพเลอร์ จะไม่ทราบเกี่ยวกับเรื่องนี้
>> Why-- สิ่งที่สำคัญ ของโมฆะในสายสี่
ดังนั้นที่นี่เรามีหลัก int (void)
ที่เพียงแค่บอกว่าเราว่า ไม่ได้รับบรรทัดคำสั่งใด ๆ
ข้อโต้แย้งหลัก
จำไว้ว่าเราจะพูด int หลัก int argc สตริงวงเล็บ argv
ดังนั้นที่นี่เราก็บอกว่าเป็นโมฆะจะบอกว่าเรา ปฏิเสธอาร์กิวเมนต์บรรทัดคำสั่ง
>> อธิบายเกี่ยวกับหน่วยความจำว่า สิ่งที่ GetString ในสายหกผลตอบแทน
GetString จะกลับมาบล็อก หน่วยความจำอาร์เรย์ของตัวอักษร
มันจริงๆกลับ ตัวชี้ไปยังตัวอักษรตัวแรก
โปรดจำไว้ว่าสตริงเป็นดาวถ่าน
ดังนั้นพวกเขาเป็นตัวชี้ไปครั้งแรก ตัวละครในสิ่งที่เป็นสตริง
ที่ผู้ใช้ป้อนที่แป้นพิมพ์
และหน่วยความจำที่เกิดขึ้นจะ malloced, เพื่อให้หน่วยความจำที่อยู่ในกอง
>> คำถามที่ 13
พิจารณาโปรแกรมด้านล่าง
ดังนั้นสิ่งที่โปรแกรมนี้จะทำ เป็น printf ไอเอ็นจี 1 หารด้วย 10
ดังนั้นเมื่อรวบรวมและ ดำเนินการโครงการนี​​้
เอาท์พุท 0.0 แม้ว่า 1 หารด้วย 10 เป็น 0.1
ดังนั้นทำไมมัน 0.0 คืออะไร?
ดีนี้เป็นเพราะ ส่วนจำนวนเต็ม
ดังนั้น 1 เป็นจำนวนเต็ม, 10 เป็นจำนวนเต็ม
ดังนั้น 1 หารด้วย 10 ทุกอย่าง จะถือว่าเป็นจำนวนเต็ม
และใน C, เมื่อเราทำส่วนจำนวนเต็ม เราตัดทศนิยม
ดังนั้น 1 หารด้วย 10 คือ 0 แล้วเรากำลังพยายาม
ในการพิมพ์ที่เป็นลอยดังนั้น ศูนย์พิมพ์เป็นลอยเป็น 0.0
และนั่นเป็นเหตุผลที่เราได้รับ 0.0
>> พิจารณาโปรแกรมด้านล่าง
ตอนนี้เรากำลังพิมพ์ 0.1
จึงไม่มีการแบ่งจำนวนเต็ม เราเพียงแค่พิมพ์ 0.1,
แต่เรากำลังพิมพ์ ถึง 28 ตำแหน่งทศนิยม
และเราได้รับนี้ 0.1000, ทั้งกลุ่ม ของศูนย์, 5 5 5, blah blah blah
ดังนั้นคำถามที่นี่คือเหตุผลที่ไม่ได้ พิมพ์ว่าแทนที่จะว่า 0.1?
>> ดังนั้นเหตุผลที่นี่คือตอนนี้ ลอยไม่แน่ชัดจุด
โปรดจำไว้ว่าลอยเป็นเพียง 32 บิต
ดังนั้นเราสามารถเป็นตัวแทนของจำนวน จำกัด ลอยค่าจุดกับผู้ที่ 32
เกร็ด
ดีที่สุดมีเพียบ ลอยตัวค่าหลายจุด
และมีมากมายหลายแบบลอยตัว ค่าจุดในระหว่าง 0 และ 1,
และเราสามารถที่จะเห็นได้ชัด แสดงค่ามากขึ้นกว่าที่
ดังนั้นเราจะต้องเสียสละเพื่อ จะสามารถที่จะแสดงค่ามากที่สุด
>> ดังนั้นค่าเช่น 0.1 เห็นได้ชัด เราไม่สามารถเป็นตัวแทนที่ว่า
ดังนั้นแทนที่จะเป็น 0.1 ที่เราทำ ดีที่สุดที่เราสามารถเป็นตัวแทนนี้ 0.100000 5 5
5
และที่ใกล้สวย แต่ สำหรับจำนวนมากของการใช้งาน
คุณต้องกังวลเกี่ยวกับ ลอยไม่แน่ชัดจุด
เพราะเราก็ไม่สามารถเป็นตัวแทนของ จุดที่ลอยอยู่ทั้งหมดว่า
>> คำถามที่ 15
พิจารณาโค้ดด้านล่าง
เราแค่พิมพ์ 1 บวก 1
ดังนั้นจึงไม่มีเคล็ดลับที่นี่
1 บวก 1 ประเมินที่ 2 และ แล้วเราพิมพ์ว่า
เพียงแค่นี้ก็พิมพ์ 2
>> คำถามที่ 16
ตอนนี้เรากำลังพิมพ์ตัวอักษร 1 บวก 1 ตัว
ดังนั้นทำไมทำอย่างนี้ไม่ได้ พิมพ์สิ่งเดียวกัน
ดีตัวละคร 1 บวกตัวละคร 1 ตัวละครที่ 1 มีค่า ASCII 49
ดังนั้นนี้จริงๆบอกว่า 49 บวก 49, และ ในท้ายที่สุดนี้จะพิมพ์ 98
ดังนั้นนี้ไม่ได้พิมพ์ 2
>> คำถามที่ 17
เสร็จสิ้นการดำเนินการ ของแปลกด้านล่างในลักษณะดังกล่าว
ที่ฟังก์ชันจะส่งกลับจริงถ้า n เป็นเลขคี่และเท็จถ้า n คือแม้
นี่คือจุดประสงค์ที่ดี สำหรับผู้ประกอบการสมัย
ดังนั้นเราจึงใช้เวลา n โต้แย้งของเรา ถ้าสมัย n 2 เท่ากับ 1 ดี
นั่นหมายความว่า n แบ่ง โดยมี 2 ส่วนที่เหลือ
ถ้า n หารด้วย 2 มีส่วนที่เหลือที่ หมายความว่า n เป็นเลขคี่ดังนั้นเราจึงกลับจริง
อื่นที่เรากลับเท็จ
นอกจากนี้คุณยังสามารถทำได้ n mod 2 เท่ากับ ศูนย์กลับเท็จอื่นกลับจริง
>> พิจารณาฟังก์ชัน recursive ด้านล่าง
ดังนั้นถ้า n เป็นน้อยกว่าหรือ เท่ากับ 1 กลับ 1
อื่นกลับมาครั้ง n f ของ n ลบ 1
ดังนั้นสิ่งที่เป็นฟังก์ชั่นนี้หรือไม่?
ดีนี้เป็นเพียงแค่ ฟังก์ชั่นแฟกทอ
นี้จะแสดงเป็นอย่างดี n เป็นปัจจัย
>> ดังนั้นคำถาม 19 ตอนนี้เราต้องการที่จะ ใช้ฟังก์ชัน recursive นี้
เราต้องการที่จะให้มันซ้ำแล้วซ้ำอีก
ดังนั้นเราจะทำอย่างไรที่?
ดีสำหรับพนักงาน การแก้ปัญหาและอีกครั้งมี
หลายวิธีที่คุณสามารถทำได้ ที่เราเริ่มต้นกับผลิตภัณฑ์ int นี้
เท่ากับ 1
และตลอดนี้ สำหรับวงเราจะ
ที่จะคูณผลิตภัณฑ์เพื่อในที่สุด จบลงด้วยปัจจัยแบบเต็ม
ดังนั้นสำหรับฉัน int เท่ากับ 2 ฉันเป็น น้อยกว่าหรือเท่ากับ n, i ++
>> คุณอาจจะสงสัยว่าทำไมฉันเท่ากับ 2
ดีจำไว้ว่าที่นี่เรามีให้ ให้แน่ใจว่ากรณีฐานของเราถูกต้อง
ดังนั้นถ้า n มีค่าน้อยกว่าหรือเท่ากับ 1, เรากำลังกลับมา 1
ดังนั้นกว่าที่นี่เราเริ่มต้นที่ฉันเท่ากับ 2
ดีถ้าฉันเป็น 1 แล้วยกกำลังหรือ ถ้า n เป็น 1 แล้วสำหรับวง
จะไม่ดำเนินการในทุก
และเพื่อให้เราจะเพียงแค่ ผลิตภัณฑ์กลับมาซึ่งเป็น 1
ในทำนองเดียวกันถ้า n เป็น อะไรที่น้อยกว่า 1--
ถ้าเป็น 0, ลบ 1, อะไรก็ตาม เราจะยังคงได้รับกลับมาที่ 1
ซึ่งเป็นสิ่งที่ รุ่น recursive จะทำ
>> ตอนนี้ถ้า n เป็นมากขึ้น กว่า 1 แล้วเราจะ
ที่จะทำอย่างน้อยหนึ่ง ทวนของวงนี้
ดังนั้นสมมติว่า n คือ 5 แล้วเรา จะทำผลิตภัณฑ์ครั้งเท่ากับ 2
ดังนั้นตอนนี้ผลิตภัณฑ์ที่ 2
ตอนนี้เรากำลังจะทำ ครั้งผลิตภัณฑ์เท่ากับ 3
ตอนนี้ก็ 6
สินค้าเท่ากับครั้งที่ 4 ตอนนี้ก็ 24
สินค้าเท่ากับครั้งที่ 5 ตอนนี้ก็ 120
ดังนั้นแล้วในที่สุดเราก็กลับมา 120 ซึ่งเป็นปัจจัย 5 อย่างถูกต้อง
>> คำถามที่ 20
นี้เป็นหนึ่งในสถานที่ที่คุณต้องกรอกข้อมูล ในตารางด้วยวิธีใดก็ตามนี้
สิ่งที่เราได้เห็นว่า เหมาะกับการทำงานขั้นตอนเหล่านี้
ครั้งนี้ครั้งการทำงานเชิง
เพื่อให้เป็นอัลกอริทึมสิ่งที่ เป็นโอเมก้า 1 แต่ O ใหญ่ของ n?
ดังนั้นอาจจะมีเพียบ คำตอบมากมายที่นี่
หนึ่งที่เราอาจจะได้เห็นมากที่สุด บ่อยครั้งที่เป็นเพียงการค้นหาเชิงเส้น
>> ดังนั้นในกรณีที่ดีที่สุด สถานการณ์สินค้าเรา
มองหาอยู่ที่ จุดเริ่มต้นของรายการ
และในโอเมก้า 1 ขั้นตอน สิ่งแรกที่เราตรวจสอบ
เราก็กลับมาทันที ที่เราพบรายการ
ในสถานการณ์กรณีที่เลวร้ายที่สุด รายการที่อยู่ในท้ายที่สุด
หรือรายการไม่ได้อยู่ในรายชื่อที่ทั้งหมด
ดังนั้นเราจึงต้องค้นหา รายการทั้งหมดทั้งหมด n
องค์ประกอบและที่ว่าทำไมมัน o ของ n
>> ดังนั้นตอนนี้มันเป็นสิ่งที่ทั้ง โอเมก้าของบันทึก n n และ O ใหญ่ของ n บันทึก n
ดีสิ่งที่เกี่ยวข้องมากที่สุด เราได้เห็นที่นี่เป็นที่รวมการจัดเรียง
ดังนั้นรวมการจัดเรียงจำ เป็นที่สุดที
ของ n บันทึก n โดยที่ทีถูกกำหนดไว้ ถ้าทั้งสองโอเมก้าและโอใหญ่จะเหมือนกัน
ทั้ง n log n
>> อะไรคือสิ่งที่โอเมก้า ของ n และ n O ของตาราง?
ดีอีกครั้งมี คำตอบที่เป็นไปได้หลาย
ที่นี่เราเกิดขึ้นที่จะบอกว่าการจัดเรียงฟอง
จัดเรียงแทรกก็จะทำงานที่นี่
โปรดจำไว้ว่าการจัดเรียงฟองที่ มีการเพิ่มประสิทธิภาพที่ที่
ถ้าคุณมีความสามารถที่จะได้รับ ผ่านรายการทั้งหมด
โดยไม่จำเป็นต้องทำ การแลกเปลี่ยนใด ๆ แล้วดี
เราสามารถกลับทันทีว่า รายชื่อที่ถูกแยกจะเริ่มต้นด้วย
ดังนั้นในสถานการณ์กรณีที่ดีที่สุด มันเป็นเพียงแค่โอเมก้าของ n
ถ้ามันไม่ได้เป็นเพียงอย่าง รายการที่จัดเรียงจะเริ่มต้นด้วย
แล้วเรามี O ของ n ยกกำลังแลกเปลี่ยน
และในที่สุดเรามีการจัดเรียงตัวเลือก สำหรับ n ยกกำลังทั้งโอเมก้าและขนาดใหญ่ทุม
>> คำถามที่ 21
อะไรจำนวนเต็มล้น?
ดีอีกครั้งเช่นเดียวกับก่อนหน้านี้ เรามีเพียงบิตหลายขีด
เพื่อเป็นตัวแทนของจำนวนเต็ม ดังนั้นอาจ 32 บิต
สมมติว่าเรามีจำนวนเต็มลงนาม
สูงสุดแล้วในท้ายที่สุด จำนวนบวกที่เราสามารถเป็นตัวแทนของ
2 ถึง 31 ลบ 1
ดังนั้นสิ่งที่เกิดขึ้นถ้าเราพยายามที่จะ แล้วเพิ่มจำนวนเต็มที่?
ดีเรากำลังจะไปตั้งแต่วันที่ 2 ถึงวันที่ 31 ลบ 1 ตลอดทางลงไปลบ 2
ถึงวันที่ 31
ดังนั้นล้นจำนวนเต็มนี้ เมื่อคุณให้การเพิ่ม,
และในที่สุดคุณไม่สามารถ รับการใด ๆ ที่สูงขึ้นและมันก็
wraps ตลอดทางกลับ ไปรอบ ๆ เพื่อเป็นค่าลบ
>> สิ่งที่เกี่ยวกับหน่วยความจำล้น?
ดังนั้นบัฟเฟอร์ overflow-- จำสิ่งที่เป็นบัฟเฟอร์
มันเป็นเพียงก้อนของหน่วยความจำ
สิ่งที่ต้องการอาร์เรย์เป็นบัฟเฟอร์
ดังนั้นหน่วยความจำล้นคือเมื่อ คุณพยายามที่จะเข้าถึงหน่วยความจำ
เกินปลายแถวที่
ดังนั้นถ้าคุณมี อาร์เรย์ของขนาด 5 และคุณ
พยายามเข้าถึงวงเล็บอาร์เรย์ 5 หรือ 6 หรือวงเล็บวงเล็บ 7
หรืออะไรที่เกิน ปลายหรือแม้แต่อะไร
วงเล็บอาร์เรย์ below-- ลบ 1-- ทั้งหมดของผู้ที่มีหน่วยความจำล้น
คุณสัมผัสความทรงจำในรูปแบบที่เลวร้าย
>> คำถามที่ 23
ดังนั้นในหนึ่งที่คุณต้องนี้ ที่จะใช้ strlen
และเราบอกคุณว่าคุณสามารถ สมมติ S จะไม่เป็นโมฆะ
ดังนั้นคุณจึงไม่ต้อง จะตรวจสอบสำหรับ null ใด ๆ
และมีหลายวิธี คุณอาจจะได้ทำอย่างนี้
ที่นี่เราเพียงแค่ใช้ตรงไปตรงมา
เราเริ่มต้นด้วยเคาน์เตอร์, n n คือ การนับจำนวนตัวอักษรที่มี
ดังนั้นเราจึงเริ่มต้นที่ 0 แล้วเรา ย้ำผ่านรายการทั้งหมด
>> เป็น S วงเล็บเท่ากับ 0 ตัวละครที่เทอร์มิ null?
จำได้ว่าเรากำลังมองหา ตัวละครที่เทอร์มิ null
เพื่อกำหนดระยะเวลาสตริงของเรา
ที่จะยุติ สตริงที่เกี่ยวข้องใด ๆ
เพื่อให้เป็น S วงเล็บเท่ากับ 0 ที่เทอร์มิ null?
ถ้ามันไม่ได้แล้วเราจะ มองไปที่ S วงเล็บ 1, s ขายึด 2
เราให้ไปจนกว่าเรา หาเทอร์มิ null
เมื่อเราได้พบมันแล้ว n มี ความยาวรวมของสตริง
และเราก็สามารถกลับมาว่า
>> คำถามที่ 24
ดังนั้นนี้เป็นหนึ่งในสถานที่ที่คุณ ต้องทำให้การค้าออก
ดังนั้นสิ่งหนึ่งที่เป็นสิ่งที่ดีในหนึ่ง วิธีการ แต่ในสิ่งที่มันไม่ดี?
ดังนั้นที่นี่รวมมีแนวโน้มที่จะจัดเรียง จะเร็วกว่าการจัดเรียงฟอง
ต้องบอก that-- ดีมี เป็นคำตอบหลาย ๆ ที่นี่
แต่อย่างใดอย่างหนึ่งที่สำคัญคือการจัดเรียงฟองที่ เป็นโอเมก้าของ n สำหรับรายการที่เรียงลำดับ
>> โปรดจำไว้ว่าตารางเราเพิ่งเห็นก่อนหน้านี้ว่า
ดังนั้นฟองเรียงลำดับของโอเมก้า n, สถานการณ์กรณีที่ดีที่สุด
คือมันสามารถที่จะเพียงแค่ไปกว่า รายการครั้งเดียวตรวจสอบ
เดี๋ยวก่อนสิ่งนี้มีอยู่แล้ว เรียงลำดับและการกลับมา
ผสานเรียงลำดับไม่ว่าสิ่งที่ คุณทำคือโอเมก้าของ n บันทึก n
ดังนั้นสำหรับรายการที่เรียงลำดับฟอง การจัดเรียงเป็นไปได้เร็วขึ้น
>> ตอนนี้สิ่งที่เกี่ยวกับรายการเชื่อมโยง?
ดังนั้นรายการที่เชื่อมโยงสามารถขยายและหดตัว เพื่อให้เหมาะสมกับหลาย ๆ องค์ประกอบที่จำเป็น
ต้องบอก that-- ดังนั้น มักจะเปรียบเทียบโดยตรง
เป็นไปได้ที่เชื่อมโยง รายการที่มีอาร์เรย์
ดังนั้นแม้ว่าอาร์เรย์สามารถ สามารถเติบโตและหดตัว
เพื่อให้เหมาะสมกับหลายองค์ประกอบ ตามความจำเป็นรายการที่เชื่อมโยง
เมื่อเทียบกับ array-- อาร์เรย์มีการเข้าถึงแบบสุ่ม
เราสามารถจัดทำดัชนีในการใด ๆ โดยเฉพาะอย่างยิ่งองค์ประกอบของอาร์เรย์
>> ดังนั้นสำหรับรายการที่เชื่อมโยงเราไม่สามารถ เพียงไปที่องค์ประกอบที่ห้า
เรามีการสำรวจจากจุดเริ่มต้น จนกว่าเราจะได้รับไปยังองค์ประกอบที่ห้า
และที่จะป้องกันไม่ให้เรา ทำสิ่งที่ต้องการค้นหาแบบไบนารี
การพูดของการค้นหาแบบไบนารีค้นหาแบบไบนารี มีแนวโน้มที่จะได้เร็วขึ้นกว่าการค้นหาเชิงเส้น
ต้องบอก that-- ดังนั้นสิ่งที่เป็นไปได้อย่างใดอย่างหนึ่ง
คือการที่คุณไม่สามารถทำไบนารี ค้นหาในรายการที่เชื่อมโยง
คุณจะสามารถทำมันได้ในอาร์เรย์
แต่อาจจะสำคัญกว่า คุณจะไม่สามารถดำเนินการค้นหาไบนารี
ในอาร์เรย์ที่ไม่ได้แยก
ล่วงหน้าที่คุณอาจจำเป็นต้องเรียงลำดับ อาร์เรย์และเพียงแล้วสามารถ
คุณค้นหาไบนารี
ดังนั้นหากสิ่งที่คุณไม่ได้ เรียงลำดับเริ่มต้นด้วย
แล้วการค้นหาเชิงเส้นอาจจะได้เร็วขึ้น
>> คำถามที่ 27
เพื่อพิจารณาโปรแกรมด้านล่าง ซึ่งจะอยู่ในภาพนิ่งถัดไป
และนี่คือหนึ่งที่เรากำลัง จะต้องการที่จะระบุอย่างชัดเจน
ค่าตัวแปรต่างๆ
ดังนั้นให้ดูที่ว่า
>> ดังนั้นสายหนึ่ง
เรามี int x เท่ากับ 1
นั่นเป็นสิ่งเดียวที่เกิดขึ้น
ดังนั้นที่เส้นหนึ่งที่เราเห็นในของเรา โต๊ะและที่ A, B, และ tmp ทั้งหมด
สลบไป
ดังนั้นสิ่งที่เป็น X?
ดีที่เราเพียงแค่ตั้งค่าเท่ากับ 1
แล้วแถวสองได้ดี เราจะเห็นว่าและมีการตั้งค่าที่ 2,
และโต๊ะที่มีอยู่แล้ว เต็มไปสำหรับเรา
ดังนั้น x 1 และ y คือ 2
>> ตอนนี้สายสามเราตอนนี้ ภายในฟังก์ชันแลกเปลี่ยน
สิ่งที่เราผ่านการแลกเปลี่ยน?
เราผ่านเครื่องหมาย x สำหรับ และเครื่องหมายและสำหรับ B
ที่มีปัญหาก่อนหน้านี้ ระบุว่าที่อยู่ของ x
เป็น 0x10 และที่อยู่ของ y เป็น 0x14
ดังนั้น A และ B จะเท่ากับ 0x10 และ 0x14 ตามลำดับ
>> ตอนนี้ที่เส้นสามสิ่งที่ x และ y คืออะไร?
ดีไม่มีอะไรที่มีการเปลี่ยนแปลง เกี่ยวกับ x และ y ที่จุดนี้
แม้ว่าพวกเขากำลัง ภายในกรอบกองหลัก
พวกเขายังคงมีเหมือนเดิม ค่าพวกเขาก่อน
เรายังไม่ได้ปรับเปลี่ยนหน่วยความจำใด ๆ
ดังนั้น x 1, y คือ 2
สิทธิ์ทั้งหมด
ดังนั้นตอนนี้เรากล่าวว่า int tmp เท่ากับดาว
ดังนั้นที่เส้นสี่ทุกอย่าง จะเหมือนกันยกเว้นสำหรับ tmp
เรายังไม่ได้เปลี่ยนค่าใด ๆ อะไรยกเว้น tmp
เรามีการตั้งค่า tmp เท่ากับดาว
ดาวคืออะไร?
ดีจุดกับ x ดังนั้นดาว เป็นไป x เท่ากันซึ่งเป็น 1
เพื่อให้ทุกอย่างจะถูกคัดลอก ลงและ tmp ตั้งค่าเป็น 1
>> ตอนนี้บรรทัดถัดไป
ดาวเท่ากับดาวข
ดังนั้นโดยสาย five-- ดีอีกครั้งทุกอย่าง จะเหมือนกันยกเว้นสิ่งที่เป็นดาว
ดาวคืออะไร?
ดีเราก็บอกว่าดาวคือ x
ดังนั้นเรากำลังจะเปลี่ยน x เพื่อดาวขเท่ากัน
ดาวขคืออะไร? และ จุด B ไปและ
ดังนั้นดาว B คือ y
ดังนั้นเราตั้งค่า x เท่ากับ y, และทุกอย่างอื่นเหมือนกัน
ดังนั้นเราจะเห็นในแถวถัดไปที่ X คือตอนนี้ 2 และส่วนที่เหลือจะถูกคัดลอกเพียงลง
>> ขณะนี้อยู่ในบรรทัดถัดไปดาวขเท่ากับ tmp
ดีเราก็บอกว่าดาว B คือ y, ดังนั้นเราตั้งค่าและเท่ากับ tmp
ทุกสิ่งทุกอย่างเป็นเดียวกัน เพื่อให้ทุกอย่างได้รับการคัดลอกลง
เรากำลังตั้งค่าและเท่ากับ tmp ซึ่งเป็น หนึ่งและทุกอย่างอื่นเหมือนกัน
>> ตอนนี้ในที่สุดสายเจ็ด
เรากลับมาอยู่ในหน้าที่หลัก
หลังจากที่เราเสร็จสิ้นการแลกเปลี่ยน
เราได้สูญเสีย A, B, และ tmp แต่ในท้ายที่สุดเรา
จะไม่เปลี่ยนแปลงค่าใด ๆ อะไรที่จุดนี้
เราเพียงแค่คัดลอก x และ y ลง
และเราเห็นว่า x และ y เป็น ตอนที่ 2 และ 1 แทน 1 และ 2
แลกเปลี่ยนได้ดำเนินการประสบความสำเร็จ
>> คำถามที่ 28
สมมติว่าคุณพบ ข้อความผิดพลาด
ด้านล่างในเวลาทำการ ในปีหน้าเป็น CA หรือ TF
ให้คำแนะนำวิธีการแก้ไขปัญหาแต่ละข้อผิดพลาดเหล่านี้
ดังนั้นการอ้างอิงที่ไม่ได้กำหนดที่จะ GetString
ทำไมคุณอาจเห็นนี้หรือไม่?
ดีถ้านักเรียนใช้ getString ในรหัสของพวกเขา
พวกเขาได้อย่างถูกต้องกัญชารวม CS50 จุดชั่วโมงเพื่อให้บริการ ได้แก่ ห้องสมุด CS50
>> ดีสิ่งที่พวกเขาทำ ต้องแก้ไขข้อผิดพลาดนี้
พวกเขาต้องทำ lcs50 เส้นประที่ บรรทัดคำสั่งเมื่อพวกเขากำลังรวบรวม
ดังนั้นหากพวกเขาไม่ผ่าน lcs50 รีบเสียงดังกราวพวกเขากำลัง
จะไม่ให้มีการเกิดขึ้นจริง รหัสที่ใช้ GetString
>> คำถามที่ 29
ประกาศโดยปริยาย strlen งานห้องสมุด
อย่างนี้ตอนนี้พวกเขายังไม่ได้ ทำแฮชที่เหมาะสมรวมถึงการ
ในกรณีนี้โดยเฉพาะอย่างยิ่งไฟล์ส่วนหัว พวกเขาต้องการที่จะรวมเป็นสตริงจุดชั่วโมง
และรวมทั้งสตริงจุดชั่วโมงตอนนี้ student-- ตอนนี้คอมไพเลอร์
มีการเข้าถึง ประกาศของ strlen,
และก็รู้ว่ารหัสของคุณ ใช้ strlen ได้อย่างถูกต้อง
>> คำถามที่ 30
การแปลงร้อยละอื่น ๆ กว่าข้อโต้แย้งข้อมูล
ดังนั้นนี่คืออะไร?
ยังจำได้ว่าร้อยละเหล่านี้ signs-- ว่าพวกเขากำลังที่เกี่ยวข้องกับ printf
ดังนั้นใน printf เราอาจ percent-- เราอาจจะพิมพ์อะไรบางอย่าง
เช่นเดียวกับร้อยละฉันเครื่องหมาย n
หรือเราอาจจะพิมพ์เหมือนฉันเปอร์เซ็นต์ พื้นที่ผมเปอร์เซ็นต์พื้นที่ร้อยละฉัน
ดังนั้นสำหรับแต่ละคน สัญญาณเปอร์เซ็นต์ที่เราต้องการ
ที่จะผ่านตัวแปรในตอนท้ายของ printf
>> ดังนั้นถ้าเราบอกว่าร้อยละวงเล็บ printf ฉันเครื่องหมายวงเล็บปิด n ใกล้ชิด
ดีเราบอกว่าเรากำลัง จะพิมพ์จำนวนเต็ม
แต่เราก็ไม่ผ่าน printf จำนวนเต็มในการพิมพ์จริง
ดังนั้นที่นี่เพิ่มขึ้นร้อยละ แปลงกว่าข้อโต้แย้งข้อมูล?
ที่บอกว่าเรามี ทั้งกลุ่มร้อยละ
และเราไม่ได้มีตัวแปรมากพอ ที่จริงการกรอกข้อมูลลงในร้อยละที่
>> และแล้วแน่นอนสำหรับคำถามที่ 31 แน่นอนหายไป 40 ไบต์ในหนึ่งบล็อก
ดังนั้นนี่คือข้อผิดพลาด Valgrind
นี้จะบอกว่า ที่ไหนสักแห่งในรหัสของคุณ
คุณมีการจัดสรรที่ 40 ไบต์ขนาดใหญ่เพื่อให้คุณ malloced 40 ไบต์
และคุณจะไม่ปล่อยให้เป็นอิสระมัน
ส่วนใหญ่คุณเพียงแค่ต้อง ที่จะหาการรั่วไหลของหน่วยความจำบางส่วน
และหาที่คุณต้องการ บล็อกของหน่วยความจำฟรี
>> และคำถาม 32, การเขียนที่ไม่ถูกต้องที่มีขนาด 4
ครั้งนี้เป็นข้อผิดพลาด Valgrind
นี้ไม่ได้จะทำอย่างไร ที่มีการรั่วไหลของหน่วยความจำในขณะนี้
นี้เป็นส่วนใหญ่ likely-- ผมหมายถึงมัน การเรียงลำดับของหน่วยความจำที่ไม่ถูกต้องสิทธิบางอย่าง
และส่วนใหญ่จะเป็นบางส่วน การเรียงลำดับของหน่วยความจำล้น
ที่คุณมีอาร์เรย์อาจจะ อาร์เรย์จำนวนเต็มและขอ
บอกว่ามันเป็นขนาด 5 และคุณ ลองสัมผัสวงเล็บอาร์เรย์ 5
ดังนั้นถ้าคุณพยายามที่จะเขียนถึงว่า ค่าที่ไม่ชิ้นส่วนของหน่วยความจำ
จริงที่คุณจะสามารถเข้าถึงและ เพื่อให้คุณกำลังจะได้รับข้อผิดพลาดนี้
บอกว่าการเขียนที่ไม่ถูกต้องที่มีขนาด 4
valgrind จะรู้จักคุณ พยายามที่จะสัมผัสความทรงจำที่ไม่เหมาะสม
>> และที่มันสำหรับ quiz0
ฉันร็อบโบว์และนี่คือ CS50