วิทยาศาสตร์คอมพิวเตอร์

ฉันวางแผนที่จะสอนหลักสูตรฤดูหนาวในหัวข้อที่หลากหลายซึ่งหนึ่งในนั้นจะเป็นคอมไพเลอร์ ตอนนี้ฉันเจอปัญหานี้ขณะที่คิดถึงงานมอบหมายที่จะมอบให้ตลอดทั้งไตรมาส แต่มันทำให้ฉันนิ่งงันดังนั้นฉันจึงอาจใช้มันเป็นตัวอย่างแทน public class DeadCode { public static void main(String[] args) { return; System.out.println("This line won't print."); } } returnในโปรแกรมข้างต้นจะเห็นได้ชัดว่าคำสั่งพิมพ์จะไม่ดำเนินการเพราะ คอมไพเลอร์บางครั้งให้คำเตือนหรือข้อผิดพลาดเกี่ยวกับรหัสที่ตายแล้ว ตัวอย่างเช่นรหัสข้างต้นจะไม่รวบรวมใน Java อย่างไรก็ตามคอมไพเลอร์ javac จะไม่ตรวจจับอินสแตนซ์ทั้งหมดของรหัสที่ตายแล้วในทุกโปรแกรม ฉันจะพิสูจน์ได้อย่างไรว่าคอมไพเลอร์ไม่สามารถทำได้?

32 computability  proof-techniques  compilers 

ฉันกำลังศึกษา CPU และรู้วิธีอ่านโปรแกรมจากหน่วยความจำและดำเนินการตามคำแนะนำ ฉันยังเข้าใจว่าระบบปฏิบัติการแยกโปรแกรมในกระบวนการและจากนั้นสลับไปมาระหว่างแต่ละโปรแกรมอย่างรวดเร็วจนคุณคิดว่าพวกเขากำลังทำงานในเวลาเดียวกัน แต่ที่จริงแล้วแต่ละโปรแกรมทำงานเพียงลำพังในซีพียู แต่ถ้าระบบปฏิบัติการเป็นกลุ่มของรหัสที่ทำงานใน CPU มันจะจัดการกระบวนการได้อย่างไร ฉันกำลังคิดและคำอธิบายเดียวที่ฉันคิดได้คือ: เมื่อระบบปฏิบัติการโหลดโปรแกรมจากหน่วยความจำภายนอกไปยัง RAM มันจะเพิ่มคำแนะนำของตัวเองลงในกลางคำแนะนำโปรแกรมดั้งเดิมดังนั้นจากนั้นโปรแกรมจะถูกดำเนินการโปรแกรม สามารถเรียกใช้ระบบปฏิบัติการและทำบางสิ่ง ฉันเชื่อว่ามีคำแนะนำที่ระบบปฏิบัติการจะเพิ่มลงในโปรแกรมซึ่งจะช่วยให้ CPU กลับไปใช้รหัส OS ในบางครั้ง และฉันก็เชื่อว่าเมื่อระบบปฏิบัติการโหลดโปรแกรมมันจะตรวจสอบว่ามีคำสั่งที่ห้ามไว้หรือไม่ (นั่นจะข้ามไปยังที่อยู่ที่ต้องห้ามในหน่วยความจำ) และกำจัดออกไป ฉันกำลังคิดเข้มงวดหรือไม่ ฉันไม่ใช่นักเรียน CS แต่จริงๆแล้วเป็นนักเรียนคณิตศาสตร์ ถ้าเป็นไปได้ฉันต้องการหนังสือที่ดีเกี่ยวกับเรื่องนี้เพราะฉันไม่พบใครที่อธิบายว่าระบบปฏิบัติการสามารถจัดการกระบวนการได้อย่างไรหากระบบปฏิบัติการนั้นเป็นรหัสที่ทำงานในซีพียูและมันไม่สามารถทำงานได้ในเวลาเดียวกัน เวลาของโปรแกรม หนังสือบอกเพียงว่าระบบปฏิบัติการสามารถจัดการสิ่งต่าง ๆ แต่ตอนนี้เป็นอย่างไร

32 operating-systems 

หากบางสิ่งนั้นเรียบง่ายก็ควรอธิบายให้สมบูรณ์ด้วยคำสองสามคำ สิ่งนี้สามารถทำได้สำหรับ calcul-แคลคูลัส: calcul-แคลคูลัสเป็นไวยากรณ์ไวยากรณ์ (โดยทั่วไปโครงสร้าง) ที่มีกฎการลด (ซึ่งหมายถึงขั้นตอนการค้นหา / แทนที่จะถูกนำไปใช้ซ้ำกับทุกรูปแบบที่เกิดขึ้นเฉพาะจนกว่าจะไม่มีรูปแบบดังกล่าว) ไวยากรณ์: Term = (Term Term) | (λ Var . Term) | Var กฎการลด: ((λ var body) term) -> SUBS(body,var,term) where `SUBS` replaces all occurrences of `var` by `term` in `body`, avoiding name capture. ตัวอย่าง: (λ a . a) -> (λ a …

32 functional-programming  type-theory 

โปรแกรม 579 บิตในBinary แลมบ์ดาแคลคูลัสมีสถานะหยุดการทำงานที่ไม่รู้จัก: 01001001000100010001000101100111101111001110010101000001110011101000000111001110 10010000011100111010000001110011101000000111001110100000000111000011100111110100 00101011000000000010111011100101011111000000111001011111101101011010000000100000 10000001011100000000001110010101010101010111100000011100101010110000000001110000 00000111100000000011110000000001100001010101100000001110000000110000000100000001 00000000010010111110111100000010101111110000001100000011100111110000101101101110 00110000101100010111001011111011110000001110010111111000011110011110011110101000 0010110101000011010 กล่าวคือไม่ทราบว่าโปรแกรมนี้ยุติหรือไม่ ในการพิจารณาว่าคุณต้องแก้ไขการคาดคะเนของโคลลาตซ์ - หรืออย่างน้อยที่สุดสำหรับตัวเลขทั้งหมดไม่เกิน 2 ^ 256 ในพื้นที่เก็บข้อมูลนี้มีคำอธิบายที่สมบูรณ์เกี่ยวกับวิธีการรับโปรแกรมนี้ มีโปรแกรม BLC ที่สั้นกว่า (มาก) ที่ยังไม่ทราบสถานะหยุดพักหรือไม่?

32 algorithms  computability  kolmogorov-complexity 

ฉันต้องการความช่วยเหลือในการทำความเข้าใจอัลกอริธึมการตรวจจับรอบของฟลอยด์ ฉันได้อธิบายเกี่ยวกับ wikipedia ( http://en.wikipedia.org/wiki/Cycle_detection#Tortoise_and_hare แล้ว ) ฉันสามารถดูว่าอัลกอริทึมตรวจจับรอบในเวลา O (n) อย่างไรก็ตามฉันไม่สามารถมองเห็นความจริงที่ว่าเมื่อเต่าและกระต่ายมาพบกันเป็นครั้งแรกการเริ่มต้นของวงจรสามารถถูกกำหนดได้โดยการเลื่อนตัวชี้ของเต่ากลับไปที่จุดเริ่มต้นแล้วขยับทั้งเต่าและกระต่ายทีละขั้น จุดที่พวกเขาพบกันครั้งแรกคือจุดเริ่มต้นของวงจร ใครช่วยได้โดยให้คำอธิบายหวังว่าจะแตกต่างจากวิกิพีเดียเพราะฉันไม่สามารถเข้าใจ / เห็นภาพได้

32 algorithms  linked-lists 

มีแลมบ์ดาแคลคูลัสทัวริงพิมพ์อยู่หรือไม่? ถ้าเป็นเช่นนั้นมีตัวอย่างอะไรบ้าง?

31 computability  lambda-calculus  type-theory 

ฉันเพิ่งเสร็จสิ้นบทแรกของบทนำสู่ทฤษฎีการคำนวณโดยMichael Sipserซึ่งอธิบายพื้นฐานของขอบเขตออโตมาตา เขากำหนดภาษาปกติเป็นสิ่งที่สามารถอธิบายได้ด้วยออโต้ จำกัด แต่ฉันไม่สามารถหาที่ที่เขาอธิบายได้ว่าทำไมภาษาปกติเรียกว่า "ปกติ" อะไรคือต้นกำเนิดของคำว่า "ปกติ" ในบริบทนี้ หมายเหตุ: ฉันเป็นสามเณรดังนั้นโปรดลองอธิบายอย่างง่าย ๆ !

31 formal-languages  regular-languages  terminology  finite-automata  history 

สมมติว่าและเป็นสองสตริงที่มีความยาวเท่ากัน anagrammingของสองสายคือการทำแผนที่ bijectiveเช่นว่าสำหรับแต่ละฉันb 1 b 2 … b na1a2…ana1a2…ana_1a_2\ldots a_nb1b2…bnb1b2…bnb_1b_2\ldots b_na i = b p ( i ) ip:[1…n]→[1…n]p:[1…n]→[1…n]p:[1\ldots n]\to[1\ldots n]ai=bp(i)ai=bp(i)a_i = b_{p(i)}iii อาจมีแอนนาแกรมมากกว่าหนึ่งรายการสำหรับคู่สายเดียวกัน ตัวอย่างเช่นถ้า `abcab` และเรามีและและอื่น ๆb = p 1 [ 1 , 2 , 3 , 4 , 5 ] → [ 4 , 5 , 1 , …

31 algorithms  strings  search-algorithms  natural-language-processing 

ฉันกำลังเรียนรู้เกี่ยวกับต้นไม้ Radix (หรือที่เรียกว่าพยายามบีบอัด) และ Patricia พยายาม แต่ฉันค้นหาข้อมูลที่ขัดแย้งกันว่าจริงหรือไม่ ต้นไม้ radix สามารถรับได้จาก trie ปกติ (ไม่บีบอัด) โดยการรวมโหนดกับพาเรนต์เมื่อโหนดเป็นชายด์เดียว นี่ก็ถือเป็นความพยายามของ Patricia โครงสร้างข้อมูลทั้งสองแตกต่างกันอย่างไร? ตัวอย่างเช่นNISTแสดงรายการทั้งสองเหมือนกัน: ต้นแพทริเซีย (โครงสร้างข้อมูล) คำจำกัดความ: การนำเสนอแบบย่อของ trie ซึ่งโหนดใด ๆ ที่เป็นชายน์เดียวถูกรวมเข้ากับพาเรนต์ รู้จักกันในชื่อ radix tree แหล่งข้อมูลมากมายบนเว็บอ้างสิทธิ์เหมือนกัน อย่างไรก็ตามเห็นได้ชัดว่า Patricia พยายามเป็นกรณีพิเศษของต้นไม้ Radix รายการWikipediaพูดว่า: PATRICIA พยายามคือ Radix จะพยายามด้วย Radix เท่ากับ 2 ซึ่งหมายความว่าแต่ละบิตของคีย์จะถูกเปรียบเทียบเป็นรายบุคคลและแต่ละโหนดจะเป็นสองทาง (เช่นซ้ายกับขวา) สาขา ฉันไม่เข้าใจสิ่งนี้จริงๆ ความแตกต่างในวิธีเปรียบเทียบเท่านั้นเมื่อทำการค้นหา แต่ละโหนดจะเป็น "สาขาสองทาง" ได้อย่างไร …

31 data-structures  trees 

บอกว่าฉันต้องจำลองการกระจายแบบไม่ต่อเนื่องดังนี้ P(X=k)={12N,1−12N,if k=1if k=0P(X=k)={12N,if k=11−12N,if k=0 P(X = k) = \begin{cases} \frac{1}{2^N}, & \text{if $k = 1$} \\ 1 - \frac{1}{2^N}, & \text{if $k = 0$} \end{cases} วิธีที่ชัดเจนที่สุดคือการวาดบิตสุ่มและตรวจสอบว่าทั้งหมดนั้นเท่ากับ (หรือ ) อย่างไรก็ตามทฤษฎีสารสนเทศกล่าวNNN000111 S=−∑iPilogPi=−12Nlog12N−(1−12N)log(1−12N)=12Nlog2N+(1−12N)log2N2N−1→0S=−∑iPilog⁡Pi=−12Nlog⁡12N−(1−12N)log⁡(1−12N)=12Nlog⁡2N+(1−12N)log⁡2N2N−1→0 \begin{align} S & = - \sum_{i} P_i \log{P_i} \\ & = - \frac{1}{2^N} \log{\frac{1}{2^N}} - \left(1 - \frac{1}{2^N}\right) …

31 algorithms  information-theory  randomness  pseudo-random-generators  entropy 

เหตุใดคอมพิวเตอร์จึงใช้ระบบเลขฐานสอง (0,1) เหตุใดพวกเขาจึงไม่ใช้ระบบหมายเลข Ternary (0,1,2) หรือระบบหมายเลขอื่นแทน

31 computer-architecture  binary-arithmetic 

ฉันมีปัญหาในการเข้าใจอย่างชัดเจนว่าทำไม PSPACE โดยทั่วไปเชื่อว่าแตกต่างจาก EXPTIME ถ้า PSPACE เป็นชุดของปัญหาที่แก้ไขได้ในพหุนามอวกาศในขนาดอินพุตดังนั้นจะมีคลาสของปัญหาที่ประสบกับการระเบิดเวลาแบบเอ็กซ์โพเนนเชียลมากกว่าและไม่ได้ใช้ประโยชน์จากพื้นที่ชี้แจงf(n)f(n)f(n) คำตอบของ Yuval Filmus มีประโยชน์อย่างมากแล้ว อย่างไรก็ตามทุกคนสามารถร่างข้อโต้แย้งที่หลวม ๆ ของฉันได้หรือไม่ว่าทำไมมันอาจเป็นกรณีที่ PSPACE ≠ EXPTIME (เช่น PSPACE นั้นไม่ใช่เซตย่อยที่เหมาะสมของ EXPTIME) เราไม่ต้องการพื้นที่แบบเอ็กซ์โพเนนเชียลเพื่อเอาชนะขอบเขตบนสำหรับจำนวนการกำหนดค่าระบบทั้งหมดที่ทำได้ด้วยพื้นที่ที่ขยายขนาดแบบพหุนามด้วยขนาดอินพุต เพียงแค่พูดว่าฉันสามารถเข้าใจว่าทำไม EXPTIME ≠ EXPSPACE เป็นเรื่องเปิด แต่ฉันไม่เข้าใจเกี่ยวกับความสัมพันธ์ระหว่าง PSPACE และ EXPTIME

31 complexity-theory  complexity-classes  intuition 

ดังนั้นTSP (ปัญหาการเดินทางพนักงานขาย) ปัญหาการตัดสินใจเป็นNP สมบูรณ์ แต่ฉันไม่เข้าใจว่าฉันสามารถตรวจสอบได้อย่างไรว่าวิธีแก้ปัญหาที่กำหนดให้กับ TSP นั้นดีที่สุดในเวลาพหุนามเนื่องจากไม่มีวิธีที่จะหาทางออกที่ดีที่สุดในเวลาพหุนาม (ซึ่งเป็นเพราะปัญหาไม่ได้อยู่ใน P) อะไรที่อาจช่วยให้ฉันเห็นว่าการตรวจสอบสามารถทำได้จริงในเวลาพหุนาม

31 complexity-theory  np-complete  traveling-salesman 

ฉันสงสัยว่ามีตัวอย่างที่ดีสำหรับปัญหา NP-Hard ที่เข้าใจง่ายที่ไม่ใช่NP-Completeและไม่สามารถตัดสินใจไม่ได้? ตัวอย่างเช่นปัญหาการหยุดชะงักคือ NP-Hard ไม่ใช่ NP-Complete แต่ไม่สามารถตัดสินใจได้ ฉันเชื่อว่านี่หมายความว่ามันเป็นปัญหาที่วิธีแก้ปัญหาสามารถตรวจสอบได้ แต่ไม่ใช่ในเวลาพหุนาม (โปรดแก้ไขข้อความนี้หากไม่ใช่กรณี)

31 complexity-theory  computability  np-hard 

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

31 algorithms  efficiency  arrays  sorting