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

ฉันต้องการแยกภาษาเฉพาะโดเมนที่ผู้ใช้กำหนด ภาษาเหล่านี้มักจะใกล้กับสัญลักษณ์ทางคณิตศาสตร์ (ฉันไม่ได้แยกภาษาธรรมชาติ) ผู้ใช้กำหนด DSL ในสัญลักษณ์ BNF เช่นนี้ expr ::= LiteralInteger | ( expr ) | expr + expr | expr * expr การป้อนข้อมูลเช่น1 + ( 2 * 3 )ต้องได้รับการยอมรับในขณะที่การป้อนข้อมูลเช่น1 +ต้องได้รับการปฏิเสธเป็นไม่ถูกต้องและการป้อนข้อมูลเช่น1 + 2 * 3ต้องได้รับการปฏิเสธเป็นที่คลุมเครือ ความยากลำบากส่วนกลางที่นี่คือการรับมือกับไวยากรณ์ที่กำกวมในวิธีที่ใช้งานง่าย การ จำกัด ไวยากรณ์ให้ไม่คลุมเครือนั้นไม่ใช่ตัวเลือกนั่นคือวิธีการใช้ภาษา - แนวคิดคือผู้เขียนต้องการละเว้นวงเล็บเมื่อไม่จำเป็นต้องหลีกเลี่ยงความคลุมเครือ ตราบใดที่การแสดงออกไม่ชัดเจนฉันต้องแยกมันและถ้าไม่ฉันต้องปฏิเสธมัน โปรแกรมแยกวิเคราะห์ของฉันต้องทำงานกับไวยากรณ์ที่ไม่มีบริบทใด ๆ แม้แต่ที่คลุมเครือและต้องยอมรับอินพุตที่ไม่คลุมเครือทั้งหมด ฉันต้องการแผนผังการแยกวิเคราะห์สำหรับอินพุตที่ยอมรับทั้งหมด สำหรับการป้อนข้อมูลที่ไม่ถูกต้องหรือไม่ชัดเจนฉันต้องการข้อความแสดงข้อผิดพลาดที่ดี แต่เริ่มต้นด้วยสิ่งที่ฉันจะได้รับ โดยทั่วไปฉันจะเรียกใช้ parser …

20 formal-languages  parsers  compilers 

มีหลายวิธีในการกำหนดKolmogorov-Complexityและโดยทั่วไปคำจำกัดความทั้งหมดนี้จะเทียบเท่ากับค่าคงที่เพิ่มเติม นั่นคือถ้าK1K1K_1และK2K2K_2เป็นฟังก์ชันความซับซ้อนของ kolmogorov (กำหนดผ่านภาษาหรือรุ่นที่แตกต่างกัน) ดังนั้นจึงมีค่าคงที่cccเช่นนั้นสำหรับทุกสายxxx , |K1(x)−K2(x)|&lt;c|K1(x)−K2(x)|&lt;c|K_1(x) - K_2(x)| < c . ฉันเชื่อว่านี่เป็นเพราะสำหรับ Kolmogorov ทุกฟังก์ชันที่ซับซ้อนKKKและสำหรับทุก ๆxxxมันเก็บไว้K(x)≤|x|+cK(x)≤|x|+cK(x) \le |x| +cสำหรับบางคนคงคccc ฉันสนใจคำจำกัดความต่อไปนี้ของKKKโดยอิงจากทัวริง - เครื่องจักร จำนวนสถานะ : กำหนดK1(x)K1(x)K_1(x)ให้เป็นจำนวนขั้นต่ำqqqเช่นที่ TM ที่มีสถานะqqqแสดงผลxxxบนสตริงว่าง K2(x)K2(x)K_2(x)xxxMMM⟨M⟩⟨M⟩\langle M \rangleM xK2(x)=min|⟨M⟩|K2(x)=min|⟨M⟩|K_2(x) = \min |\langle M \rangle|MMMxxx มีและเทียบเท่า? ความสัมพันธ์ระหว่างพวกเขาคืออะไรและคนใดที่เข้าใจแนวคิดของความซับซ้อนของ Kolmogorov ได้ดีกว่าหากพวกเขาไม่เท่าเทียมกันK 2K1K1K_1K2K2K_2 สิ่งที่ทำให้ฉันเป็นพิเศษคืออัตราเพิ่มขึ้นด้วยซึ่งดูเหมือนจะไม่เป็นแบบเชิงเส้นมาก (หรืออย่างน้อยเป็นเส้นตรงกับค่าคงที่ซึ่งมากกว่า ) พิจารณา TM ที่ง่ายที่สุดที่เอาต์พุต - อันที่เพิ่งเข้ารหัสซึ่งเป็นส่วนหนึ่งของฟังก์ชันสถานะและช่วงการเปลี่ยนภาพ มันเป็นทันทีจะเห็นว่า …

20 computability  kolmogorov-complexity 

พิจารณาต้นไม้ไบนารีแบบไม่มีป้ายกำกับ เราสามารถบีบอัดต้นไม้ดังกล่าวเมื่อมีการชี้ไปยัง subtreesและกับ (การตีความความเท่าเทียมกันของโครงสร้าง) เราเก็บ (WLOG)และแทนที่คำแนะนำทุกคนที่จะกับตัวชี้ไปยังTดูคำตอบของ uliสำหรับตัวอย่างT ′ T = T ′ = T T ′ TTTTT'T′T'T= T'T=T′T = T'===TTTT'T′T'TTT ให้อัลกอริทึมที่ใช้ต้นไม้ในความหมายข้างต้นเป็นอินพุตและคำนวณจำนวนโหนดที่เหลือหลังจากการบีบอัด อัลกอริทึมควรใช้ในเวลาที่ (ในรูปแบบค่าใช้จ่ายในเครื่องแบบ) กับจำนวนโหนดในการป้อนข้อมูลnO (nบันทึกn )O(nlog⁡n)\cal{O}(n\log n)nnn นี่เป็นคำถามสอบและฉันไม่สามารถหาวิธีแก้ปัญหาที่ดีและฉันไม่ได้เห็น

20 algorithms  data-structures  trees  binary-trees 

ฉันต้องการที่จะรู้ว่าประเภทเชิงปริมาณแบบ :เป็นประเภทย่อยหรือ กรณีพิเศษของประเภทมีมีลายเซ็นเดียวกัน: T_e = \ มีอยู่ X: \ left \ {a \ in X, f: X → \ {T, F \} \ right \}T a = ∀ X : { a ∈ X , f : X → { T , F } } T e T e = …

20 logic  type-theory  typing 

ตามImmermanคลาสความซับซ้อนที่เกี่ยวข้องกับการสืบค้นSQLนั้นเป็นคลาสของการสืบค้นที่ปลอดภัยใน (แบบสอบถามที่มีคำสั่งซื้อครั้งแรก (กล่าวอีกนัยหนึ่งแบบสอบถาม SQL ทั้งหมดมีความซับซ้อนในและปัญหาทั้งหมดในสามารถแสดงเป็นแบบสอบถาม SQL ได้)Q ( F O ( C O U N T ) )Q(FO(คOยูยังไม่มีข้อความT))\mathsf{Q(FO(COUNT))}Q ( F O ( C O U N T ) )Q(FO(คOยูยังไม่มีข้อความT))\mathsf{Q(FO(COUNT))}Q ( F O ( C O U N T ) )Q(FO(คOยูยังไม่มีข้อความT))\mathsf{Q(FO(COUNT))} จากผลลัพธ์นี้จากมุมมองทางทฤษฎีมีปัญหาที่น่าสนใจมากมายที่สามารถแก้ไขได้อย่างมีประสิทธิภาพ แต่ไม่สามารถแสดงออกได้ใน SQL ดังนั้นส่วนเสริมของ SQL ที่ยังคงมีประสิทธิภาพน่าสนใจ ดังนั้นนี่คือคำถามของฉัน: มีส่วนขยายของ SQL (ถูกนำไปใช้และใช้ในอุตสาหกรรม …

20 database-theory  complexity-theory  finite-model-theory  descriptive-complexity 

พิจารณาความเป็นไปได้สองอย่างสำหรับปัญหา P vs. NP: P = NP และ P NP≠≠\neq ให้ Q เป็นหนึ่งในปัญหา NP-hard ที่รู้จักกันดี เพื่อพิสูจน์ P = NP เราต้องออกแบบอัลกอริทึมเวลาพหุนามเดียวสำหรับ Q และพิสูจน์ว่า A แก้ปัญหาได้อย่างถูกต้อง Q เพื่อพิสูจน์ P NP เราต้องแสดงให้เห็นว่า ไม่มีขั้นตอนวิธีเชิงพหุนามแก้ได้ Q. ในคำอื่น ๆ เราต้องแยกแยะอัลกอริธึมเวลาพหุนามทั้งหมด≠≠\neq ฉันเคยได้ยินคนพูดว่านี่ทำให้งานยากขึ้นเป็นลำดับที่สอง (สมมติว่ามันเป็นเรื่องจริง) มีเหตุผลที่คิดว่าการพิสูจน์ P = NP (สมมติว่า P = NP) จะง่ายกว่าการพิสูจน์ P NP (สมมติว่า P NP) …

20 complexity-theory  p-vs-np 

อัลกอริธึมการไหลสูงสุดจำนวนมากที่ฉันเห็นโดยทั่วไปว่านำไปใช้งานอัลกอริทึมของ Dinic พุช relabel และอื่น ๆ สามารถทำให้ต้นทุนเวลาของพวกเขาดีขึ้นด้วยการใช้ต้นไม้ไดนามิก (หรือที่รู้จักกันในชื่อต้นไม้ตัดลิงก์) Push relabel ทำงานในหรือหรือตามปกติ แต่มีต้นไม้แบบไดนามิกO ( V2E)O(V2E)O(V^2E)O ( V3)O(V3)O(V^3)O ( V2E--√)O(V2E)O(V^2\sqrt{E})O ( VEเข้าสู่ระบบ( ฉบับที่2/ E) )O(VElog⁡(V2/E))O(VE \log(V^2/E)) อัลกอริทึมของ Dinic ทำงานในแต่ด้วยต้นไม้แบบไดนามิกO ( V2E)O(V2E)O(V^2E)O ( VEเข้าสู่ระบบ( ฉบับที่) )O(VElog⁡(V))O(VE\log(V)) อย่างไรก็ตามการใช้งานจริงของอัลกอริธึม max-flow ในไลบรารีส่วนใหญ่ดูเหมือนจะไม่ใช้ประโยชน์จากโครงสร้างข้อมูลนี้ ต้นไม้แบบไดนามิกเคยใช้ในทางปฏิบัติสำหรับการคำนวณการไหลสูงสุดหรือไม่ หรือพวกเขามีค่าใช้จ่ายมากเกินไปที่จะเป็นประโยชน์สำหรับขนาดของปัญหาโลกแห่งความจริง? มีโดเมนปัญหาอื่น ๆ อีกหรือไม่ที่มีการใช้การเชื่อมโยงทรี? คำถามนี้เกี่ยวข้องกับคำถามที่ฉันถามใน cstheory: มีอัลกอริธึม Maximum Flow อันทันสมัยที่สุดหรือไม่?

20 reference-request  graphs  data-structures  network-flow 

หลายครั้งถ้าความซับซ้อนมีค่าคงที่เช่น 3n เราจะละเลยค่าคงที่นี้และพูดว่า O (n) ไม่ใช่ O (3n) ฉันไม่สามารถเข้าใจได้ว่าเราจะเพิกเฉยต่อการเปลี่ยนแปลงทั้งสามนี้ได้อย่างไร บางสิ่งบางอย่างเปลี่ยนแปลงอย่างรวดเร็ว 3 เท่ามากกว่าสิ่งอื่น! เหตุใดเราจึงละเลยข้อเท็จจริงนี้

20 complexity-theory  asymptotics  landau-notation 

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

20 computer-architecture  floating-point  number-formats 

ฉันสงสัยว่าจะหาเส้นรอบวงของกราฟที่ไม่มีทิศทางโดยตรงได้อย่างไร ฉันหมายถึง ) ตามความเหมาะสมฉันหมายถึงความซับซ้อนของเวลาต่ำสุด| E| =O( | V| )|E|=O(|V|)|E|=O(|V|) ฉันคิดถึงการปรับเปลี่ยนบางอย่างในอัลกอริทึมของ Tarjanสำหรับกราฟที่ไม่ได้บอกทิศทาง แต่ฉันไม่พบผลลัพธ์ที่ดี ที่จริงฉันคิดว่าถ้าฉันสามารถหาส่วนประกอบที่เชื่อมต่อ 2 ในแล้วฉันจะพบเส้นรอบวงโดยอุปนัยบางอย่างที่สามารถทำได้จากส่วนแรก ฉันอาจผิดทาง อัลกอริทึมใด ๆ ที่ไม่มีสัญญาณดีกว่าΘ ( | V | 2 ) (เช่นo ( | V | 2 ) ) ยินดีต้อนรับO ( | V| )O(|V|)O(|V|)Θ ( | V|2)Θ(|V|2)\Theta(|V|^2)o ( | V|2)o(|V|2)o(|V|^2)

20 algorithms  time-complexity  graph-theory 

นี่เป็นคำถามทั่วไป และถ้าใครต้องการทำให้การใช้งานเฉพาะเจาะจงฉันจะชอบสิ่งที่เกี่ยวข้องกับ Unix แต่ก่อนอื่นต้องรู้ปัญหาต่อไปนี้โดยทั่วไป: ฉันอ่านกระบวนการเดียวสามารถมีหลายเธรด หลายเธรดของกระบวนการเดียวกันจะแบ่งปันสิ่งต่าง ๆ ในหมู่พวกเขา ฉันต้องการที่จะรู้ว่าสิ่งที่พวกเขาแบ่งปันและสิ่งที่ไม่ กระบวนการพิจารณาประกอบด้วยพื้นที่ที่อยู่, สแต็ค, กอง, ตัวแปรทั่วโลก, รหัส, ข้อมูล, ทรัพยากรระบบปฏิบัติการสิ่งที่ในหมู่พวกเขาร่วมกันโดยกระทู้? ฉันมีการคาดเดาต่อไปนี้: ตัวแปรทั่วโลก -ฉันได้อ่านหัวข้อแบ่งปันตัวแปรทั่วโลก ในขณะที่การเขียนโปรแกรมใน Java และ C # ฉันได้ทำเธรดเพื่อแบ่งปันตัวแปรระดับชั้นเรียน ดังนั้นฉันจึงเชื่อว่าเธรดจะแชร์ตัวแปรทั่วโลก (แต่ไม่แน่ใจว่าแนวคิดในภาษาการเขียนโปรแกรมระดับสูงแปลว่าเป็นข้อเท็จจริงระดับระบบปฏิบัติการต่ำหรือไม่) ฮีป -เนื่องจากตัวแปรโกลบอลถูกเก็บไว้ในฮีปฮีปจะถูกแชร์ระหว่างเธรด สแต็ค -เนื่องจากแต่ละเธรดสามารถมีลำดับการเรียกใช้ / โค้ดของตัวเองได้จึงต้องมีสแต็กของตัวเองซึ่งมันอาจจะผลัก / ป๊อปอัพเนื้อหาของโปรแกรมตัวนับ (เมื่อพูดว่าการเรียกใช้ฟังก์ชัน ดังนั้นเธรดของกระบวนการเดียวกันจะไม่แชร์สแต็ก ตอนนี้ฉันไม่แน่ใจเกี่ยวกับการแบ่งปันสิ่งต่อไปนี้ พื้นที่ที่อยู่ -ไม่แน่ใจว่าสิ่งที่นับว่าอยู่ภายใต้พื้นที่ที่อยู่ แต่ฉันคิดว่าพื้นที่ที่อยู่โดยทั่วไปจะใช้ในบริบทของกระบวนการไม่ใช่เธรด และเนื่องจากเธรดทั้งหมดของกระบวนการเดียวกันอยู่ในพื้นที่แอดเดรสเดียวกันกับกระบวนการพาเรนต์จึงมีการกล่าวว่าเธรดใช้พื้นที่ที่อยู่ร่วมกัน (แต่พวกเขาจะรักษาสแต็คที่แตกต่างกันภายในพื้นที่ที่อยู่เดียวกันได้หรือไม่) ทรัพยากรระบบปฏิบัติการ -ฉันคิดว่านี่อาจเป็นการใช้งานเฉพาะอย่างยิ่ง ตัวอย่างเช่นกระบวนการหลักสามารถเลือกให้การจัดการไฟล์เดียวกันกับบางส่วนของเธรดและไม่ให้ทั้งหมด หรือฉันเข้าใจผิดและทรัพยากรระบบปฏิบัติการหมายถึงอย่างอื่นที่ไม่ใช่ไฟล์? รหัส -เธรดสามารถมีรหัสที่แตกต่างกันได้ดังนั้นรหัสที่ใช้ร่วมกันอาจไม่เป็นเช่นนั้นเสมอไป ข้อมูล …

20 operating-systems  threads 

ภาษาแอสเซมบลีถูกแปลงเป็นภาษาเครื่องโดยแอสเซมเบลอร์ ทำไมคอมไพเลอร์จะแปลงภาษาระดับสูงเป็นชุดประกอบ? แปลงจากภาษาระดับสูงเป็นรหัสเครื่องโดยตรงไม่ได้หรือ

19 compilers  code-generation  assembly 

บางครั้งมันง่ายที่จะระบุความซับซ้อนของเวลาของอัลกอริทึมที่ฉันตรวจสอบอย่างรอบคอบ อัลกอริทึมที่มีสองวงซ้อนกันของจะเห็นได้ชัด 2 อัลกอริทึมที่สำรวจทั้งหมดรวมกันเป็นไปได้ของกลุ่มของสองค่าจะเห็นได้ชัด NNNNN2N2N^2NNN2N2N2^N อย่างไรก็ตามฉันไม่ทราบวิธี "ระบุ" อัลกอริทึมที่มีความซับซ้อนตัวอย่างการนำไปใช้การผสานแบบเรียกซ้ำเป็นแบบหนึ่ง อะไรคือคุณสมบัติทั่วไปของการรวมหรืออัลกอริทึมอื่น ๆที่จะให้เบาะแสถ้าฉันวิเคราะห์มัน?Θ(NlogN)Θ(Nlog⁡N)\Theta(N \log N)Θ(NlogN)Θ(Nlog⁡N)\Theta(N \log N) ฉันแน่ใจว่ามีมากกว่าหนึ่งวิธีที่อัลกอริทึมอาจมีความซับซ้อนดังนั้นคำตอบใด ๆ และทั้งหมดก็ได้รับการชื่นชม BTW ฉันกำลังมองหาคุณสมบัติและเคล็ดลับทั่วไปไม่ใช่หลักฐานที่เข้มงวดΘ(NlogN)Θ(Nlog⁡N)\Theta(N \log N)

19 algorithm-analysis  time-complexity  intuition 

เป็นไปได้หรือไม่ที่และความสำคัญของเหมือนกับ cardinality ของ ? หรือหมายความว่าและต้องมีความแตกต่างกันหรือไม่P≠NPP≠NP\mathsf{P} \not = \mathsf{NP}PP\mathsf{P}NPNP\mathsf{NP}P≠NPP≠NP\mathsf{P} \not = \mathsf{NP}PP\mathsf{P}NPNP\mathsf{NP}

19 complexity-classes  p-vs-np 

ฉันมีข้อมูลจริงที่ฉันใช้สำหรับเกมไพ่จำลอง ฉันสนใจเฉพาะอันดับของการ์ดไม่ใช่ชุดสูท อย่างไรก็ตามมันเป็นสำรับไพ่มาตรฐาน525252ใบดังนั้นจึงมีเพียง444ของแต่ละอันดับที่เป็นไปได้ในสำรับ สำรับถูกสับสำหรับแต่ละมือดีแล้วจากนั้นฉันเอาท์พุทเด็คทั้งหมดไปยังไฟล์ ดังนั้นจึงมีเพียง131313สัญลักษณ์เป็นไปได้ในไฟล์ที่ส่งออกซึ่งเป็น2,3,4,5,6,7,8,9,T,J,Q,K,A2,3,4,5,6,7,8,9,T,J,Q,K,A2,3,4,5,6,7,8,9,T,J,Q,K,A( TTT= สิบอันดับ) แน่นอนว่าเราสามารถบิตแพ็คเหล่านี้โดยใช้444บิตต่อสัญลักษณ์ แต่แล้วเราก็สิ้นเปลืองการเข้ารหัส333จาก161616เป็นไปได้ ที่เราสามารถทำได้ดีกว่าถ้าเรากลุ่ม444สัญลักษณ์ที่เวลาและจากนั้นบีบอัดพวกเขาเพราะ13413413^4 = 28,56128,56128,561และที่สามารถใส่ค่อนข้าง "อบอุ่น" ใน151515บิตแทน16161616ข้อ จำกัด ทางทฤษฎีของ bitpacking คือ log ( 131313 ) / log ( 222 ) = 3.700443.700443.70044สำหรับข้อมูลที่มี131313สัญลักษณ์สุ่มสำหรับแต่ละการ์ดที่เป็นไปได้ อย่างไรก็ตามเราไม่สามารถมี525252ยกตัวอย่างเช่นกษัตริย์ในเด็คนี้ เราจะต้องมีเพียง444ของแต่ละตำแหน่งในแต่ละดาดฟ้าเพื่อการเข้ารหัสเอนโทรปีลดลงประมาณครึ่งหนึ่งบิตต่อสัญลักษณ์ประมาณ3.23.23.23.2 ตกลงดังนั้นนี่คือสิ่งที่ฉันคิด ข้อมูลนี้ไม่ได้สุ่มทั้งหมด เรารู้ว่ามี444ของแต่ละอันดับดังนั้นในแต่ละบล็อกของ525252ใบ (เรียกว่าสำรับสับไพ่) ดังนั้นเราจึงสามารถตั้งสมมติฐานและเพิ่มประสิทธิภาพได้หลายอย่าง หนึ่งในนั้นคือเราไม่ต้องเข้ารหัสการ์ดใบสุดท้ายเพราะเราจะรู้ว่ามันควรจะเป็นอะไร การออมอีกอย่างก็คือถ้าเราจบอันดับหนึ่ง ตัวอย่างเช่นหากไพ่333ใบสุดท้ายในเด็คเป็น777777777เราจะไม่ต้องเข้ารหัสเหล่านั้นเพราะตัวถอดรหัสจะนับไพ่จนถึงจุดนั้นและดูว่าตำแหน่งอื่นทั้งหมดได้รับการเติมและจะถือว่า333 " การ์ด "ที่หายไปทั้งหมด777วินาที ดังนั้นคำถามของฉันไปยังเว็บไซต์นี้คือสิ่งที่เพิ่มประสิทธิภาพอื่น ๆ ที่เป็นไปได้ที่จะได้รับไฟล์ที่ส่งออกแม้มีขนาดเล็กอยู่กับชนิดของข้อมูลนี้และถ้าเราใช้พวกเขาเราสามารถที่เคยเอาชนะทางทฤษฎี (แบบง่าย) bitpacking เอนโทรปีของ3.700443.700443.70044บิตต่อสัญลักษณ์หรือ แม้แต่ใกล้ถึงขีด จำกัด …

19 data-compression