หมายเหตุ

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

• นี่ไม่ใช่การประกวดความนิยมอีกต่อไปและไม่จำกัดความยาวของข้อมูลโดยการนับคะแนน หากคุณรู้จักกระทู้นี้มาก่อนโปรดตรวจสอบให้แน่ใจว่าคุณได้ทำความคุ้นเคยกับการเปลี่ยนแปลง

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

มันทำงานอย่างไร

• #คำตอบทั้งหมดควรจะรวมถึงชื่อของการเขียนโปรแกรมภาษาที่ด้านบนของโพสต์ที่นำโดย

• คำตอบอาจมี factoid หนึ่ง (และเพียงหนึ่ง) factoid นั่นคือสองสามประโยคโดยไม่มีรหัสที่อธิบายภาษา

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

• ไม่จำเป็นต้องเกี่ยวข้องกับตัวอย่าง ที่จริงแล้วเกร็ดเล็กเกร็ดน้อยที่เกี่ยวข้องมากเกินไปอาจซ้ำซ้อนกัน

• เนื่องจากนี่ไม่ใช่การประกวดภาษายินดีต้อนรับทุกภาษาเมื่อใดก็ตามที่มีการสร้างขึ้น

• คำตอบที่มีมากกว่าหนึ่งตัวอย่างของรหัสควรใช้กองย่อยเพื่อยุบทุกอย่างยกเว้น factoid และหนึ่งในตัวอย่าง

• เมื่อใดก็ตามที่เป็นไปได้ควรมีเพียงหนึ่งคำตอบต่อหนึ่งภาษาการเขียนโปรแกรม นี่คือวิกิชุมชนดังนั้นอย่าลังเลที่จะเพิ่มตัวอย่างในคำตอบใด ๆ แม้ว่าคุณจะไม่ได้สร้างมันขึ้นมาเอง มีStack Snippet สำหรับการบีบอัดโพสต์ซึ่งควรลดผลกระทบของการจำกัดความยาว 30,000 ตัวอักษร

คำตอบที่ลงวันที่ก่อนวันจริงแนวทางเหล่านี้ควรได้รับการแก้ไข โปรดช่วยพวกเขาปรับปรุงตามที่จำเป็น

คำตอบปัจจุบันเรียงตามตัวอักษรตามชื่อภาษา

$.ajax({type:"GET",url:"https://api.stackexchange.com/2.2/questions/44680/answers?site=codegolf&filter=withbody",success:function(data){for(var i=0;i<data.items.length;i++){var temp=document.createElement('p');temp.innerHTML = data.items[i].body.split("\n")[0];$('#list').append('<li><a href="/a/' + data.items[i].answer_id + '">' + temp.innerText || temp.textContent + '</a>');}}})

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><base href="http://codegolf.stackexchange.com"><ul id="list"></ul>

มาติกา

คุณอาจต้องการอ่านจากล่างขึ้นบนนี้เนื่องจากเป็นคำสั่งที่เขียนขึ้นและคำอธิบายบางอย่างจะอ้างถึงตัวอย่างก่อนหน้านี้หรือรับคำอธิบายจากด้านล่าง

รายการมีการเติบโตค่อนข้างยาว ฉันเริ่มลบตัวอย่างที่น่าสนใจน้อยลงและฉันจะเริ่มข้ามตัวอย่างในขณะนี้ ดูประวัติการแก้ไขสำหรับรายการที่สมบูรณ์ของตัวอย่างถึง 41 สำหรับอัญมณีจริงบางส่วนตรวจสอบตัวอย่าง81 , 64 , 44 , 23 , 19 , 12และ8

ความยาว 143 และ 144 ตัวอย่าง

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

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

มันอ่านไม่ได้เพราะฉันต้องตีมันลงเยอะ:

d=θ@t-φ@t;NDSolve[{#''@t==-#4#2''[t]Cos@d-##3#2'@t^2Sin@d-Sin@#@t&@@@{{θ,φ,1,.5},{φ,θ,-1,1}},θ@0==2,φ@0==1,θ'@t==φ'@t==0/.t->0},{θ,φ},{t,0,60}]

สิ่งที่เป็นระเบียบคือ Mathematica จะแสดงพล็อตเล็ก ๆ ของวิธีแก้ปัญหาโดยประมาณ:

โอเค แต่มันค่อนข้างง่อย เราต้องการที่จะรู้ว่าการเคลื่อนไหวของลูกตุ้มจริงดูเหมือนว่า ดังนั้นนี่คือตัวอย่างขนาด 144 อักขระซึ่งทำให้ลูกตุ้มเคลื่อนไหวขณะที่ติดตามวิถีของลูกตุ้มล่าง:

Graphics@{Line@{{0,0},p=θ~(h={Sin@#@#2,-Cos@#@#2}&)~t,p+φ~h~t},White,{0,0}~Circle~2.2}~Show~ParametricPlot[θ~h~u+φ~h~u,{u,0,t}]~Animate~{t,0,60}

ภาพเคลื่อนไหวที่ได้จะมีลักษณะดังนี้:

^{ฉันได้ไปโกงเล็กน้อย: ถ้าคุณวางแผนเกินกว่าt = 30ที่ParametricPlotเป็นค่าเริ่มต้นใช้จุดพล็อตที่น้อยเกินไปและสายกลายเป็นขรุขระค่อนข้าง แต่การเปลี่ยนแปลงที่น่าสนใจส่วนใหญ่เกิดขึ้นหลังจากนั้นดังนั้นฉันจึงใช้ตัวเลือกPlotPoints -> 200เพื่อทำให้ช่วงครึ่งหลังของภาพเคลื่อนไหวดูนุ่มนวลขึ้น มันไม่มีอะไรแตกต่างอย่างมีนัยสำคัญและครึ่งแรกจะดูแตกต่างอย่างไรก็ตาม}

ฉันคิดว่านี่จะเป็นตัวอย่างสุดท้ายของฉันจนกว่าฉันจะเกิดอะไรขึ้นกับสิ่งที่ใจจดจ่อ หวังว่าคุณจะสนุกกับเรื่องนี้!

ความยาว 100 ตัวอย่าง

GeoGraphics[{GeoStyling[Opacity[0.5]], NightHemisphere[]}, GeoBackground -> GeoStyling["ReliefMap"]]

ฉันกำลังคิดเกี่ยวกับGeoฟังก์ชั่นที่ดีบางอย่างสำหรับตัวอย่าง 100 แต่ในที่สุดฉันก็พบสิ่งที่ดีมากในTweet-a-Programซึ่งฉันต้องขโมย ด้านบนสร้างแผนที่ดวงอาทิตย์ที่สวยงามมากของโลกสำหรับเวลาและวันปัจจุบันโดยการซ้อนทับรูปร่างกึ่งทึบแสงของซีกโลกกลางคืนเหนือแผนที่บรรเทาทุกข์:

ความยาว 81 ตัวอย่าง

CellularAutomaton[{{0,2,3,If[0<Count[#,1,2]<3,1,3]}[[#[[2,2]]+1]]&,{},{1,1}},i,n]

ฉันสัญญาว่าเป็นหุ่นยนต์เซลลูล่าร์ตัวสุดท้าย แต่นั่นก็คือWireworldใน 81 ตัวอักษร เวลานี้ผมไม่ได้เข้ารหัสกฎในจำนวนเดียว) เพราะผมคิดว่ามันจะใหญ่ขัน (ผมไม่ได้รำคาญ figuring ออก) และ b) CellularAutomatonจะแสดงให้คุณยังการใช้งานของผู้อื่น เวลานี้กฎถูกระบุเพียงแค่เป็นฟังก์ชันบริสุทธิ์ซึ่งได้รับพื้นที่ใกล้เคียงของเซลล์และส่งกลับค่าใหม่ของเซลล์ นี่เป็นวิธีที่เป็นไปได้มากขึ้นสำหรับออโตมาตาเซลลูล่าที่มีมากกว่า 2 สี / สถานะ

อย่างไรก็ตามฉันได้ตั้งค่าตัวอย่างจาก Wikipedia ในi(นาฬิกาสองตัวสร้างสัญญาณและประตู XOR) และปล่อยให้มันวิ่ง 50 ขั้นตอน:

หากคุณสนใจการพล็อตและภาพเคลื่อนไหวที่แท้จริงอาจเป็นข้อมูลตัวอย่าง 77:

ListAnimate[ArrayPlot[#,ColorRules->{0->Black,1->Blue,2->Red,3->Yellow}]&/@w]

ความยาว 69 ตัวอย่าง

DSolve[r^2*R''[r]+2r*R'[r]-R[r]==0&&(R[r]==1&&R'[r]==2/.r->1),R[r],r]

กลับไปยังสิ่งที่มีประโยชน์ นอกเหนือจากระบบสมการปกติแล้ว Mathematica ยังสามารถแก้ระบบสมการเชิงอนุพันธ์ ด้านบนเป็นเทคนิคเพียงหนึ่งสมการเชิงอนุพันธ์กับเงื่อนไขขอบเขต แต่คุณยังสามารถระบุว่าเป็นระบบของสามสมการ เช่นเดียวกับฟังก์ชั่นการรวมDSolveสำหรับการแก้ปัญหาที่แน่นอนในขณะที่NDSolveจะแก้ปัญหาระบบตัวเลข ผลลัพธ์ข้างต้นเป็นวิธีแก้ปัญหาเดียว

{{R[r] -> 1/2 r^(-(1/2) - Sqrt[5]/2) (1 - Sqrt[5] + r^Sqrt[5] + Sqrt[5] r^Sqrt[5])}}

ซึ่งตอนนี้สามารถใช้งานได้ง่ายสำหรับการคำนวณเพิ่มเติมหรือการลงจุด

ความยาว 64 ตัวอย่าง

CellularAutomaton[{224,{2,{{2,2,2},{2,1,2},{2,2,2}}},{1,1}},i,n]

ฉันสัญญากับคุณว่าCellularAutomatonเวทมนตร์มากขึ้น! ตัวอย่างนี้คำนวณเกมแห่งชีวิตของ Conwaysพร้อมเงื่อนไขเริ่มต้นiสำหรับnขั้นตอนและให้ผลลัพธ์สำหรับการจับเวลากลางทั้งหมด

คำสองสามคำเกี่ยวกับพารามิเตอร์: 2คือจำนวนของสถานะเซลล์ {{2,2,2},{2,1,2},{2,2,2}}ให้น้ำหนักสำหรับ 9 เซลล์ในพื้นที่ใกล้เคียง 3x3 ทำให้มั่นใจได้ว่าเซลล์นั้นแตกต่างจากผลรวมของเพื่อนบ้านทั้ง 8 {1,1}บอกว่ากฎ CA ขึ้นอยู่กับเซลล์ 1 ก้าวออกไปในทิศทางใดทิศทางหนึ่ง สุดท้าย224เป็นกฎการอัพเดทจริงที่เข้ารหัสในจำนวนเดียว การหาจำนวนนี้สามารถเป็นบิตหากิน แต่มีการกวดวิชาที่มีประโยชน์อย่างเป็นธรรมในเอกสาร สำหรับออโตมาตาที่ซับซ้อนตัวเลขหนึ่งจะไม่ตัด (เพราะตัวเลขจะใหญ่) บางทีเราจะไปถึงที่นั่นพรุ่งนี้! ;)

อย่างไรก็ตามถ้าฉันป้อนกริดสุ่มเข้าไปiและ 200 เข้าไปnและส่งผลลัพธ์ผ่านภาพเคลื่อนไหวArrayPlotเราจะเห็นว่ามันใช้งานได้จริง:

ความยาว 59 ตัวอย่าง

SphericalPlot3D[Re[Sin[θ]Cos[θ]Exp[2I*φ]],{θ,0,π},{φ,0,2π}]

โปรดจำไว้ว่าพล็อตขั้วโลกจากตัวอย่าง 26 เราสามารถทำสิ่งเดียวกันในแบบ 3 มิติ! (อันที่จริงมีฟังก์ชั่นสองอย่าง: RevolutionPlot3DสำหรับเสาทรงกระบอกและเสาSphericalPlot3Dทรงกลม) เช่นเดียวกับGraphics3Dแปลงสามมิติที่หมุนได้โดยอัตโนมัติใน Mathematica ดังนั้นคุณไม่ต้องกังวลเกี่ยวกับมุมกล้องที่ดี แผนการด้านบนมีลักษณะคล้ายกับฮาร์มอนิกทรงกลม (ไม่มากนัก) และดูเหมือนว่า:

ความยาว 52 ตัวอย่าง

Manipulate[Plot[x^2a+x*b,{x,-3,3}],{a,.1,3},{b,0,3}]

อันนี้สวยดี Manipulateนำนิพจน์ใด ๆมากำหนดพารามิเตอร์ด้วยตัวแปรจำนวนมากจากนั้นให้วิดเจ็ตแก่คุณซึ่งคุณสามารถปรับแต่งพารามิเตอร์และดูการถ่ายทอดสดว่าการเปลี่ยนแปลงของนิพจน์เป็นอย่างไร โดยปกติแล้วคุณจะมีพล็อตบางประเภท สิ่งนี้มีประโยชน์อย่างยิ่งหากคุณใช้ Mathematica ในการบรรยายเพื่อแสดงให้เห็นว่าครอบครัวของโซลูชันตอบสนองต่อการปรับเปลี่ยนพารามิเตอร์อย่างไร ดังกล่าวข้างต้นแสดงให้เห็นถึงวิธีการaและbค่าสัมประสิทธิ์ขนาดและเปลี่ยนรูปโค้ง:

ความยาว 48 ตัวอย่าง

Import["http://www.google.com/doodles","Images"]

Importเป็นคำสั่งที่ทรงพลัง มันใช้สำหรับการโหลดไฟล์จากแผ่นดิสก์และจากเว็บ มันรู้รูปแบบไฟล์ค่อนข้างมากและสำหรับบางคน (เช่นหน้า HTML) สามารถแยกข้อมูลได้ทันที ด้านบนดาวน์โหลดภาพทั้งหมดจากหน้าดูเดิลของ Google

ความยาว 45 ตัวอย่าง

EdgeDetect@ExampleData@{"TestImage","Splash"}

เวลาสำหรับการประมวลผลภาพ Mathematica มาพร้อมกับข้อมูลตัวอย่างมากมายรวมถึงรูปภาพ (เช่น Lena) พื้นผิวแบบจำลอง 3 มิติและตัวอย่างเสียง อันดับแรกเราโหลดหนึ่งในนั้น:

ต้องการตรวจจับขอบหรือไม่ มันเป็นการเรียกฟังก์ชั่นเดียว:

ความยาว 44 ตัวอย่าง

ArrayPlot@CellularAutomaton[110,{{1},0},100]

ในที่สุดฉันมีตัวอักษรเพียงพอที่จะใช้CellularAutomatonและแสดงผลลัพธ์ :) เท่าที่ฉันทราบCellularAutomatonมันเป็นฟังก์ชั่นเดียวใน Mathematica ที่เกี่ยวข้องกับ CAs แต่ Stephen Wolfram ดูเหมือนจะพิจารณาตัวเองเป็นอันดับหนึ่งเมื่อพูดถึงออโตมาตาเซลลูลาร์ดังนั้นฟังก์ชั่นนี้จึงทรงพลังอย่างเหลือเชื่อ ด้านบนแสดงการใช้งานที่ง่ายที่สุด สิ่งนี้จะจำลองหุ่นยนต์ 1D เซลลูลาร์ 100 ขั้นตอนและจะคืนสถานะของหุ่นยนต์ในแต่ละขั้นตอนเหล่านั้นดังนั้นผลที่ได้คือสองมิติ กฎคือพารามิเตอร์แรกซึ่งสามารถระบุได้ในรายละเอียดผ่านรายการหรือเพียงแค่เข้ารหัสในจำนวนเดียว สำหรับตัวอย่างนี้ผมได้เลือกที่มีชื่อเสียงค่อนข้างทัวริงสมบูรณ์กฎ 110 {{1},0}กำหนดเงื่อนไขเริ่มต้น: เดียว1ด้านหน้าของฉากหลังของเลขศูนย์ บางทีฉันอาจจะแสดงคุณสมบัติเพิ่มเติมอีกCellularAutomatonในอนาคตเมื่อฉันมีตัวละครมากขึ้น: มันสามารถจำลอง CAs ในมิติที่สูงขึ้นโดยใช้ย่านที่ใหญ่กว่าและมากกว่าสองสถานะ

ArrayPlotเป็นอีกหนึ่งยูทิลิตี้การพล็อตที่ดีซึ่งเพิ่งจะแปลงรายการ 2D เป็นตารางสีทึบที่แสดงถึงค่า ในกรณีที่ง่ายที่สุด0จะรวมเข้ากับสีขาวและ1สีดำ ผลลัพธ์ของตัวอย่างคือ:

ความยาว 43 ตัวอย่าง

HighlightGraph[graph,FindVertexCover@graph]

เป็นเวลานานแล้วที่ฉันพูดถึงกราฟ มีปัญหาทางทฤษฎีกราฟทั่วไปจำนวนมากในตัว Mathematica พร้อมกับเครื่องมือสร้างภาพที่ดี ด้านบนสำหรับที่กำหนดgraphจะพบจุดยอดที่น้อยที่สุดของกราฟจากนั้นแสดงกราฟด้วยจุดยอดที่สูง เช่นถ้าgraphเป็นPetersenGraph[7,2]กลับมาจากข้อมูลโค้ด 18 เราได้รับ:

ความยาว 42 ตัวอย่าง

Animate[Plot[Sin[t-x],{x,0,10}], {t,0,10}]

มันค่อนข้างง่ายที่จะสร้างภาพเคลื่อนไหวใน Mathematica (และพวกเขาไม่จำเป็นต้องเป็นรูปภาพ) คุณเพียงให้นิพจน์ที่จะประเมินสำหรับแต่ละเฟรมและพารามิเตอร์จำนวนมากที่ควรแตกต่างกันไปตามเฟรม ข้างต้นเพียงแค่เคลื่อนไหวพล็อตของคลื่นไซน์เคลื่อนไหว ภาพเคลื่อนไหวจะมีลักษณะคล้าย GIF ต่อไปนี้:

ความยาว 40 ตัวอย่าง

SortBy[PlanetData[#, "EscapeVelocity"]&]

SortByทำตามที่คุณคาดไว้: เรียงลำดับรายการตามค่าที่ได้จากการทำแผนที่ฟังก์ชั่นที่กำหนดไปยังองค์ประกอบแต่ละรายการ แต่รอสายข้างต้นไม่ได้มีรายการเลย ตั้งแต่ Mathematica 10 มีการสนับสนุนสำหรับcurryingหรือแอพลิเคชันบางส่วนสำหรับการทำงานบางอย่าง นี่ไม่ใช่คุณสมบัติภาษาเช่นในภาษาที่ใช้งานได้อย่างพิถีพิถันยิ่งขึ้น แต่ถูกนำไปใช้งานด้วยตนเองสำหรับฟังก์ชั่นทั้งหมดซึ่งมักจะมีประโยชน์ หมายความว่าข้อมูลโค้ดด้านบนส่งคืนฟังก์ชันใหม่ซึ่งใช้รายการเท่านั้นและเรียงลำดับตามฟังก์ชันที่กำหนด สิ่งนี้มีประโยชน์มากหากคำสั่งการเรียงลำดับนี้เป็นสิ่งที่คุณจะใช้บ่อยตลอดทั้งรหัสของคุณ

และใช่มีอีกดี*Dataฟังก์ชั่น - ข้างต้นจะเรียงลำดับชื่อดาวเคราะห์โดยดาวเคราะห์ความเร็วหลบหนี

ความยาว 39 ตัวอย่าง

f[1]=1
f[2]=1
f[n_]:=f[n]=f[n-1]+f[n-2]

ฉันสัญญาว่าจะทำให้ฟีโบนักชีฟังก์ชั่นมีประสิทธิภาพมากขึ้น ตัวอย่างนี้แสดงให้เห็นว่า memoisation เล็กน้อยใน Mathematica โปรดทราบว่าสิ่งที่เปลี่ยนแปลงทั้งหมดนั้นเพิ่มเติมf[n]=ในบรรทัดที่สาม ดังนั้นเมื่อfถูกเรียกค่าใหม่ (พูดf[3]) แล้วf[3]=f[3-1]+f[3-2]จะได้รับการประเมิน การคำนวณนี้จะf[2]+f[1]กำหนดให้กับf[3](ด้วย=ไม่ใช่กับ:=!) และส่งคืนค่าในที่สุดสำหรับการโทรเริ่มต้นของเรา ดังนั้นการเรียกฟังก์ชั่นนี้จะเพิ่มนิยามใหม่สำหรับค่านี้ซึ่งชัดเจนกว่ากฎทั่วไป - และจะใช้สำหรับการโทรในอนาคตทั้งหมดfด้วยค่านั้น

จำไว้ว่าฟังก์ชั่น Fibonacci อื่นใช้เวลา 4 วินาทีสำหรับ 30 ค่า? ต้องการ 3 วินาทีสำหรับค่า 300,000

ความยาว 37 ตัวอย่าง

l//.{a___,x_,b___,x_,c___}:>{a,x,b,c}

ในตัวอย่างสุดท้ายฉันพูดถึงรูปแบบ สิ่งเหล่านี้มักถูกใช้ในกฎซึ่งสามารถใช้ในการปรับเปลี่ยนโครงสร้างที่ตรงกับรูปแบบที่แน่นอน ลองดูตัวอย่างนี้

{a___,x_,b___,x_,c___}:>{a,x,b,c}เป็นกฎ x_ด้วยการขีดเส้นใต้เดียวเป็นรูปแบบซึ่งหมายถึงค่าโดยพลการเดียว (ซึ่งอาจเป็นรายการหรือคล้ายกัน) a___เป็นรูปแบบลำดับ (โปรดดูตัวอย่าง 15) ซึ่งหมายถึงลำดับของค่า 0 หรือมากกว่า โปรดทราบว่าฉันใช้x_สองครั้งซึ่งหมายความว่าทั้งสองส่วนของรายการจะต้องมีค่าเดียวกัน ดังนั้นรูปแบบนี้ตรงกับรายการใด ๆ ที่มีค่าครั้งที่สองเรียกว่าองค์ประกอบxและเรียกร้องสามลำดับรอบทั้งสององค์ประกอบa, และb cสิ่งนี้จะถูกแทนที่ด้วย{a,x,b,c}- นั่นคือวินาทีที่xถูกทิ้ง

ตอนนี้//.จะใช้กฎจนกว่ารูปแบบจะไม่ตรงกันอีกต่อไป lดังนั้นข้อมูลดังกล่าวข้างต้นเอารายการที่ซ้ำกันทั้งหมดจากรายการ อย่างไรก็ตามมันมีประสิทธิภาพมากกว่านั้นเล็กน้อย: //.ใช้กฎนี้ในทุกระดับ ดังนั้นหากlตัวเองมีรายการ (ความลึกใด ๆ ) รายการที่ซ้ำกันจากรายการย่อยเหล่านั้นจะถูกลบด้วย

ความยาว 36 ตัวอย่าง

f[1]=1
f[2]=1
f[n_]:=f[n-1] + f[n-2]

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

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

ดังนั้นข้างต้นแน่นอนเป็นเพียงฟังก์ชั่นฟีโบนักชี และหนึ่งที่ไม่มีประสิทธิภาพมากที่ การคำนวณตัวเลข 30 ตัวแรกนั้นใช้เวลาประมาณ 4 วินาทีในเครื่องของฉัน เราจะเห็นว่าเราสามารถปรับปรุงประสิทธิภาพได้อย่างไรโดยไม่ต้องกำจัดคำจำกัดความซ้ำ

ความยาว 35 ตัวอย่าง

StreamPlot[{x^2,y},{x,0,3},{y,0,3}]

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

ความยาว 34 ตัวอย่าง

Solve[a*x^4+b*x^3+c*x^2+d*x==0, x]

Mathematica ยังสามารถแก้สมการ (หรือระบบสมการได้ แต่ตอนนี้เรามีตัวละครมากมายแล้ว) ผลลัพธ์จะเป็นสัญลักษณ์ตามปกติ

{
  {x -> 0}, 
  {x -> -(b/(3 a)) - (2^(1/3) (-b^2 + 3 a c))/(3 a (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)) + (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)/(3 2^(1/3) a)}, 
  {x -> -(b/(3 a)) + ((1 + I Sqrt[3]) (-b^2 + 3 a c))/(3 2^(2/3) a (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)) - ((1 - I Sqrt[3]) (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3))/(6 2^(1/3) a)}, 
  {x -> -(b/(3 a)) + ((1 - I Sqrt[3]) (-b^2 + 3 a c))/(3 2^(2/3) a (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)) - ((1 + I Sqrt[3]) (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3))/( 6 2^(1/3) a)}
}

โปรดทราบว่าการแก้ปัญหาจะได้รับเป็นกฎซึ่งฉันอาจแสดงรายละเอียดเพิ่มเติมในตัวอย่างบางส่วนในอนาคต

ความยาว 33 ตัวอย่าง

Dynamic@EdgeDetect@CurrentImage[]

ขอบคุณ Benwaffle สำหรับความคิดนี้ CurrentImage[]โหลดภาพปัจจุบันของเว็บแคมของคุณ EdgeDetectเปลี่ยนรูปภาพให้เป็นภาพขาวดำที่ขอบเป็นสีขาวและส่วนที่เหลือเป็นสีดำ (ดูตัวอย่างในตัวอย่างที่ 45) ความสนุกที่แท้จริงมาพร้อมกับDynamicทำให้การอัพเดทนิพจน์นั้นเกิดขึ้นเอง ดังนั้นผลลัพธ์นี้จะส่งกระแสข้อมูลภาพจากเว็บแคมของคุณและทำการตรวจจับขอบสดที่พวกเขา

ความยาว 32 ตัวอย่าง

NumberLinePlot[x^2<2^x,{x,-2,5}]

พล็อตประเภทที่ค่อนข้างผิดปกติ มันสามารถพล็อตเรื่องต่าง ๆ มากมายตามเส้นจำนวนเช่นจุดและช่วงเวลา คุณสามารถกำหนดเงื่อนไขและจะแสดงภูมิภาคที่เงื่อนไขนั้นเป็นจริง:

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

ความยาว 28 ตัวอย่าง

Graphics3D@{Sphere[],Cone[]}

ถึงเวลาสำหรับกราฟิกสามมิติ ด้านบนแสดงทรงกลมและทรงกรวยที่มีการบังคับพิเศษซึ่งมีพารามิเตอร์เริ่มต้นซึ่งมีลักษณะคล้ายลูกบอลคริสตัล:

ใน Mathematica คุณสามารถคลิกและลากวิดเจ็ตตัวเล็ก ๆ นี้เพื่อหมุนมันได้

ความยาว 27 ตัวอย่าง

CountryData["ITA", "Shape"]

มากขึ้น*Data! CountryDataมันค่อนข้างบ้า การสร้างรูปร่างของประเทศไม่ใช่แม้แต่ส่วนเล็ก มีข้อมูลมากมายเกี่ยวกับประเทศคุณอาจเขียนหนังสือทั้งเล่มเกี่ยวกับฟังก์ชั่นนี้ เช่น ... FemaleLiteracyFractionมี นอกจากนี้คุณยังสามารถค้นหาข้อมูลสำหรับจุดต่าง ๆ ในเวลา สำหรับรายการทั้งหมดดูการอ้างอิง

ความยาว 26 ตัวอย่าง

PolarPlot[Sin[5θ],{θ,0,π}]

เวลาสำหรับพล็อตที่น่าสนใจมากขึ้น PolarPlotเป็นเพียงพล็อตในพิกัดเชิงขั้ว แทนที่จะระบุ y สำหรับ x ที่ระบุให้คุณระบุรัศมี r สำหรับมุมที่กำหนดθ:

ความยาว 25 ตัวอย่าง

{{1,5},{2,3},{7,4}}.{8,9}

ในที่สุดเราก็มีตัวละครมากพอสำหรับคณิตศาสตร์เวกเตอร์ ด้านบนคำนวณการคูณเมทริกซ์ของเมทริกซ์ 2x3 และแถว 2-vector:

{53, 43, 92}

ความยาว 23 ตัวอย่าง

Rotate[Rectangle, Pi/2]

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

ความยาว 22 ตัวอย่าง

30~ElementData~"Color"

อีก*Dataฟังก์ชั่นในตัว ใช่สำหรับองค์ประกอบทางเคมีคุณไม่เพียงได้รับสิ่งต่าง ๆ เช่นเลขอะตอมจุดหลอมเหลวและชื่อ ... คุณสามารถรับสีได้ที่อุณหภูมิห้อง ด้านบนให้สีของสังกะสี:

SlateGray

ความยาว 21 ตัวอย่าง

Integrate[E^(-x^2),x]

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

1/2 Sqrt[π] Erf[x]

ความยาว 20 ตัวอย่าง

"Sun"~StarData~"Age"

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

ใช่แล้วและฉันไม่ได้พูดถึงว่า Mathematica (ตั้งแต่ 9) สนับสนุนปริมาณด้วยหน่วย? (เพิ่มเติมในภายหลัง) การประเมินด้านบนเป็น:

Quantity[4.57*10^9, "Years"]

ซึ่งจะแสดงเป็น

ความยาว 19 ตัวอย่าง

MandelbrotSetPlot[]

ใช่ ... ฟังก์ชั่นที่มีประโยชน์มาก ... ฉันใช้มันตลอดเวลา (บางครั้งความปรารถนาที่จะสนับสนุนสิ่งที่อาจคำนวณได้อาจจะไกลไปหน่อย ... )

ในการป้องกันของพวกเขาฟังก์ชั่นมีประโยชน์มากกว่านั้น: คุณสามารถให้ส่วนเฉพาะของกราฟที่คุณต้องการพล็อต

ความยาว 18 ตัวอย่าง

PetersenGraph[7,2]

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

ความยาว 17 ตัวอย่าง

Plot[x^x,{x,0,2}]

ในที่สุดตัวอักษรพอที่จะทำการพล็อต ด้านบนเป็นเพียงตัวอย่างที่ง่ายที่สุดของโครงเรื่องหนึ่งมิติ ฉันสัญญาว่าจะอวดแผนการทำความเย็นในภายหลัง

ความยาว 15 ตัวอย่าง

{##4,#,#2,#3}&

นี่แสดงให้เห็นถึงคุณสมบัติที่ทรงพลังสองอย่าง (และคุณสมบัติที่มีประโยชน์สำหรับการเล่นกอล์ฟ) สิ่งทั้งหมดเป็นฟังก์ชันบริสุทธิ์ที่ไม่มีชื่อเทียบได้กับlambdas ใน Python หรือ Procs ใน Ruby &ฟังก์ชั่นเพียวจะสิ้นสุดเพียงโดย ตัวดำเนินการนี้มีลำดับความสำคัญต่ำมากดังนั้นจึงมักจะรวมทุกอย่างที่เหลืออยู่ของมัน ข้อโต้แย้งของฟังก์ชั่นบริสุทธิ์ถูกอ้างถึงด้วย#บางครั้งตามด้วยสิ่งอื่น ๆ อาร์กิวเมนต์แรกคือ#หรือ#1อย่างที่สองคือ#2และอื่น ๆ

คุณสมบัติอื่น ๆ ที่เป็นSequences โดยทั่วไปแล้วจะมีลักษณะเหมือนเครื่องหมายในภาษาอื่น ลำดับเป็นเหมือนรายการที่ไม่มีรายการอยู่รอบตัวมันเป็นเพียงลำดับของค่าซึ่งสามารถใช้ในรายการอาร์กิวเมนต์ของฟังก์ชันและอื่น ๆ##โดยเฉพาะคือลำดับของอาร์กิวเมนต์ของฟังก์ชันบริสุทธิ์ทั้งหมด ##2เป็นลำดับของการขัดแย้งทั้งหมดที่เริ่มต้นจากที่สอง ดังนั้นถ้าเราตั้งชื่อฟังก์ชั่นด้านบนfและเรียกมันว่าชอบ

f[1,2,3,4,5]

เราจะได้รับ

{4,5,1,2,3}

ดังนั้นฟังก์ชั่นจะหมุนอิลิเมนต์อาร์กิวเมนต์ 3 ไปทางซ้าย สังเกตได้ว่า##4อ้างถึง4,5ซึ่งถูกแบนเข้าไปในรายการ

ความยาว 12 ตัวอย่าง

D[x^y^x,x,y]

ความแตกต่างบางส่วน Dจะแยกความแตกต่างของการแสดงออกครั้งแรกอย่างต่อเนื่องด้วยความเคารพต่อข้อโต้แย้งอื่น ๆ ของมันให้การแสดงออกที่เป็นสัญลักษณ์ของคุณเป็นผล ดังนั้นด้านบนคือd² (x ^ y ^ x) / dxdy (โดยที่d s เป็นบางส่วน) ซึ่ง Mathematica รายงานว่าเป็น

x^y^x (y^(-1 + x) + y^(-1 + x) Log[x] + x y^(-1 + x) Log[x] Log[y]) + 
  x^(1 + y^x) y^(-1 + x) Log[x] (y^x/x + y^x Log[x] Log[y])

ความยาว 9 ตัวอย่าง

Exp[I*Pi]

เรายังไม่ได้ทำการคำนวณทางคณิตศาสตร์ที่ซับซ้อน! ในขณะที่คุณสามารถดูเป็นจริงเพียงนามแฝงสำหรับπ Piอย่างไรก็ตามข้างต้นจริงจะกลับจำนวนเต็ม -1จำนวนเต็ม

ความยาว 8 ตัวอย่าง

Sunset[]

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

ความยาว 7 ตัวอย่าง

9!/43!!

ตัวอย่างนี้แสดงสิ่งดีๆบางอย่าง

Mathematica ไม่เพียง แต่มีโอเปอเรเตอร์ในตัว!แต่ยังมีแฟกทอเรียลสองเท่า!!(ซึ่งคูณจำนวนทุก ๆ จากnลงไป1) นอกจากนี้ยังรองรับจำนวนเต็มความแม่นยำโดยพลการ 43!!จะมีการประเมินว่าลงไปที่หลักสุดท้าย นอกจากนี้จำนวนตรรกยะจะถูกประเมินอย่างแม่นยำด้วย ดังนั้นเนื่องจากทั้งเศษและส่วนในนั้นมีจำนวนเต็ม Mathematica จะลดเศษส่วนเท่าที่จะทำได้แล้วนำเสนอคุณด้วย

128/198893132162463319205625

แน่นอนคุณสามารถใช้ลอยได้ทุกเมื่อที่คุณต้องการ แต่โดยทั่วไปถ้าข้อมูลของคุณไม่มีลอยตัวผลลัพธ์ของคุณจะถูกต้องแน่นอน

ความยาว 4 ตัวอย่าง

Here

มันเกี่ยวกับเวลาที่เราเริ่มต้นด้วยความบ้าคลั่งในตัวของ Mathematica ด้านบนทำในสิ่งที่มันบอกบนกระป๋องและ (สำหรับฉัน) ประเมินว่าGeoPosition[{51.51, -0.09}]ว่า

ความยาว 3 ตัวอย่าง

x-x

เพียงเพื่อแสดงFactoidดั้งเดิม: การทำงานข้างต้นแม้ว่าxจะยังไม่ได้กำหนดและจะส่งผลให้ใน0กรณีนั้น

ความยาว 2 ตัวอย่าง

3x

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

ความยาว 1 ตัวอย่าง

π

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

factoid

Mathematica สามารถทำการเปลี่ยนแปลงเชิงสัญลักษณ์ได้ดังนั้นตัวแปรจึงไม่ต้องการค่าที่จะทำงานกับมัน

ภาษาการเขียนโปรแกรมเช็คสเปียร์ที่น่าอับอาย

เช็คสเปียร์เขียนโปรแกรมภาษาที่ถูกสร้างขึ้นในปี 2001 โดยนักเรียนสองคนสวีเดน, คาร์ลHasselströmและจอนÅslundและมันรวมเป็นผู้เขียนประกาศ ,

ความหมายของภาษา BASIC กับภาษาแอสเซมบลีที่ใช้งานง่าย

คำตอบไปจากบนลงล่าง นอกจากนี้ยังเป็นเรื่องปกติที่จะเห็นฉันอ้างถึงตัวอย่างข้อมูลก่อนหน้าหรือเก่ากว่า

( ลิงค์สำหรับตัวเอง: แก้ไข )

factoid:

รหัสของเช็คสเปียร์มีลักษณะคล้ายกับที่ใคร ๆ ก็คาดหวังการเล่นของเชกสเปียร์ซึ่งตัวแปรเป็นตัวละครในการเล่นและการเปลี่ยนแปลงค่าของพวกเขาเมื่อพวกเขา "ดูถูก" หรือยกย่อง

ความยาว 1 ตัวอย่าง:

I

รหัสของเช็คสเปียร์แบ่งออกเป็นกิจการและการกระทำของตัวเองแบ่งออกเป็นฉากสำหรับสาเหตุ "ข้ามไปที่" การกำหนดพระราชบัญญัติตามที่Act Iหมายความว่ามันจะเป็นส่วนแรกของรหัสที่จะเรียกใช้ตัวอย่าง - แต่ไม่เพียง

ความยาว 2 ตัวอย่าง:

as

ใช้ในการเปรียบเทียบระหว่าง "อักขระ" สองตัว

ความยาว 3 ตัวอย่าง:

day

ถึงตอนนี้คุณอาจรู้สึกว่า SPL นั้นละเอียดมาก และแปลก และคุณยังไม่เห็นอะไรเลย dayใน SPL คือ 1. "บวก" และ "เป็นกลาง" คำนามจะถือว่าเป็น1เช่นเดียวกับทุกคน "เชิงลบ" -1คนที่มี

ความยาว 4 ตัวอย่าง:

rich

คือrichอะไร คำคุณศัพท์. ใน SPL คำคุณศัพท์ให้คุณค่าของคำนามที่แนบมาเพื่อคูณสอง ดูการนำไปใช้ในข้อมูลโค้ด 14

ความยาว 5 ตัวอย่าง:

Act I

การใช้ตัวอย่างโค้ดแรก การกระทำทั้งหมดอาจได้รับชื่อเช่นAct I: Hamlet must die!เนื่องจากทุกอย่างหลังจากตัวเลขโรมันถูกละเว้นโดยตัวแยกวิเคราะห์

ความยาว 6 ตัวอย่าง:

better

ทุกภาษามีเงื่อนไขและ SPL ก็ไม่มีข้อยกเว้น ยกเว้นเนื่องจากนี่เป็นภาษาที่มีไวยากรณ์ที่มีความยาว (และฉันบอกว่ามันแปลกหรือไม่) ข้อความที่มีเงื่อนไขของมันจะยาว การให้โอฟีเลียถามจูเลียตAm I better than you?ก็เหมือนมีif (Ophelia > Juliet)ภาษา "ปกติ" ส่วนใหญ่ และแน่นอนคุณสามารถถามวิธีอื่น ๆ : เทียบเท่าของAm I not better than you? if (Ophelia < Juliet)และคุณสามารถเดาได้ว่า=SPL นั้นถูกแปลเป็นอย่างไร: as good as- การใช้โค้ดขนาด 2

อย่างไรก็ตามgood/betterไม่ใช่วิธีเดียวที่จะทำการเปรียบเทียบในภาษาเช็กสเปียนนี้คุณสามารถใช้คำคุณศัพท์ใดก็ได้ หลักการเดียวกันของข้อมูลโค้ด 3 ใช้ที่นี่เป็นอย่างดีกับคำคุณศัพท์ "บวก" มีค่า>ในขณะที่ "เชิงลบ" <หมายถึงคนที่

ความยาว 7 ตัวอย่าง:

Juliet:

นี่คือการเรียกใช้ของตัวแปร หลังจากนี้คำแนะนำ / การประกาศของเขา / เธอ / อะไรก็ตามที่จะตามมา

ข้อ จำกัด ของ SPL คือมีตัวแปรจำนวน จำกัด : Romeo, Juliet, Hamlet, Ophelia, MacBeth เป็นต้นเป็นตัวอย่างของ "อักขระ" ที่จะปรากฏในโปรแกรม Shakesperian

ความยาว 8 ตัวอย่าง:

[Exeunt]

[Exeunt]จะถูกวางไว้เมื่อ "ตัวละคร" ทั้งหมดออกจาก "เวที" หวังว่าฉันจะอธิบายเพิ่มเติมเกี่ยวกับการโต้ตอบระหว่างตัวละครได้อีกเล็กน้อย โดยทั่วไปคือคำสั่งสุดท้ายของโปรแกรม SPL ใด ๆ แม้ว่า[Exeunt]จะไม่ใช่ "ตัวละคร" ของภาษาโดยเฉพาะ สำหรับตัวอย่างอื่นดูตัวอย่างข้อมูล 27

ความยาว 9 ตัวอย่าง:

as bad as

ตัวละครทั้งเก้าเพียงเพื่อเป็นตัวอย่างเท่านั้น=- ใช้ตัวอย่าง 2 ฉันเคยพูดว่า SPL แปลกหรือไม่ ดูตัวอย่าง 30 สำหรับตัวอย่าง (และใช่มีมากกว่าหนึ่งวิธีในการส่งออก)

ความยาว 10 ตัวอย่าง:

difference

วิธีแฟนซีในการเป็นตัวแทน-การลบ คุณสามารถดำเนินการทางคณิตศาสตร์ใน SPL ได้แม้ว่าคุณอาจต้องใช้เวลาทั้งวันในการทำให้ถูกต้อง

Factoid (เนื่องจากฉันสามารถจัดการถึงสิบตัวอย่างของรหัสลองพักสักหน่อยและมี factoid อื่นเกี่ยวกับ SPL)

หากคุณต้องการรันโค้ด shakesperian ของคุณทั้งหมดมีเว็บไซต์นี้ - ฉันยังคงทดสอบเพราะฉันพบว่ามันไม่ได้แม้แต่ห้านาทีที่ผ่านมา นอกจากนี้ยังมีวิธีการที่จะแปลเป็นภาษา C โดยใช้ล่าม

ไซต์อื่นสำหรับการเรียกใช้รหัส SPL คือเว็บไซต์นี้ที่ทำงานโดยการแปลรหัส SPL เป็นภาษาลึกลับอื่น: Oracle PL / SQL

ความยาว 11 ตัวอย่าง:

[Exit Romeo]

ใช่ ในที่สุดฉันก็สามารถพูดคุยเกี่ยวกับปฏิสัมพันธ์ระหว่างตัวละคร! เพื่อให้มีความคุ้มค่าการเปลี่ยนแปลงหรือการโต้ตอบกับคนอื่น ๆ "ตัวอักษร" จะต้องอยู่บนเวที - [Enter Romeo]เข้ากับ หากอักขระถูกระบุถึง แต่ไม่มีอยู่แสดงว่ามีข้อผิดพลาดรันไทม์และโปรแกรมหยุดทำงาน เพราะใน SPL ค่าของตัวแปรจะถูกกำหนดโดยจำนวนชื่อที่พวกเขายกย่องด้วย - หรือดูถูกด้วย - โดยตัวละครอื่น ๆ บนเวที ฉันรู้สึกว่าฉันควรยกตัวอย่างเพื่อล้างความสับสนเล็กน้อยคำอธิบายง่อยของฉันอาจสร้างขึ้น แต่บางทีมันเป็นการดีที่สุดที่จะเลื่อนตัวอย่างเล็กน้อย

ความยาว 12 ตัวอย่าง:

Remember me.

SPL นั้นค่อนข้าง "ธรรมดา" เอาล่ะ - แต่ก็มีสแต็ค! ยกตัวอย่างเช่นเมื่อโรมิโอบอกกับจูเลียตว่า "จำเขาได้" จริง ๆ แล้วเขาบอกให้คนที่เขารักเพื่อผลักดันคุณค่าของโรมิโอเข้ากอง การเจาะค่าทำด้วยRecall your happy childhood!หรือRecall your love for meหรือโดยพื้นฐานประโยคใด ๆ ที่ขึ้นต้นด้วยRecall- ส่วนที่เหลือเป็นเพียงศิลปะที่ดริฟท์เช่นตัวอย่าง 22

ความยาว 13 ตัวอย่าง

Let us return

วิธี Shakesperian gotoของการมี และนี่คือที่การกระทำและฉากมีประโยชน์ ถ้า Romeo บอก Juliet we shall return to Act II(ใช่มีอีกหลายวิธีในการเขียน) โปรแกรมจะข้ามไปยังส่วนเฉพาะของรหัส นอกจากนี้ยังเห็นพร้อมกับข้อความแสดงเงื่อนไข

ความยาว 14 ตัวอย่าง

my little pony

ใช่มันเป็นซีรีย์ย้อนกลับไปในยุค 80 2*1นี่มันเป็น ทำไม? เพราะ a ponyเป็นคำนามในเชิงบวก (ค่อนข้าง) และlittleเป็นคำคุณศัพท์ ดังนั้นการจดจำเกร็ดเล็กเกร็ดน้อยที่ 3 และ 4 ที่เรามีและlittle = "2 *"pony = "1"

ความยาว 15 ตัวอย่าง

Speak thy mind!

ในโปรแกรม SPL คุณจะเห็น (หรือSpeak your mind!ซึ่งเป็นเหมือนกัน) เป็นจำนวนมาก สิ่งนี้จะส่งออกค่าของ "อักขระ" แต่ละตัวเป็นตัวเลขตัวอักษรหรืออย่างอื่นทั้งนี้ขึ้นอยู่กับชุดอักขระที่คอมพิวเตอร์ของคุณใช้ นอกจากนี้ยังมีOpen your mind.สิ่งที่เกือบจะเหมือนกันแม้ว่าจะแสดงผลในรูปแบบตัวเลขเท่านั้น

ความยาว 16 ตัวอย่าง

You are nothing!

เมื่อมีคนบอกเรื่องนี้กับคุณในชีวิตจริงคุณจะรู้สึกหดหู่ใจ เมื่อ Ophelia บอกสิ่งนี้กับ Hamlet ในการเขียนโปรแกรม Shakespearian Hamlet รู้สึกไร้ค่า สิ่งนี้หมายความว่า? Hamlet = 0ที่

ความยาว 17 ตัวอย่าง

Ophelia, a wench.

ในบทภาพยนตร์ก่อนที่การเล่นจริงจะเริ่มต้นขึ้นตัวละครจะต้องนำเสนอ ในภาษาการเขียนโปรแกรมส่วนใหญ่ตัวแปรจะต้องประกาศก่อนการใช้งานด้วย เมื่อเห็นว่า SPL เป็นภาษาการเขียนโปรแกรมที่คล้ายกับบทภาพยนตร์นี่คือวิธีที่คุณประกาศตัวแปรโดยระบุว่าเป็นภาษาใดที่ปรากฏในระหว่างโปรแกรม

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

ความยาว 18 ตัวอย่าง

lying sorry coward

-4สำหรับสัตว์โลก ทำไม? 2*2*(-1) = -4เพราะ

ความยาว 19 ตัวอย่าง

Romeo:
 Remember me.

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

ความยาว 20 ตัวอย่าง

cube of thy codpiece

ฉันต้องการที่จะอธิบายรายละเอียดเพิ่มเติมเล็กน้อยสำหรับสิ่งนี้ แต่ความจริงจะได้รับการบอกสิ่งที่ฉันเกิดขึ้นยังคงสั้นเกินไปสำหรับความยาวตัวอย่างนี้ และฉันก็นำสิ่งนี้มาให้คุณซึ่งท้ายที่สุดก็เป็น-1เพราะ (-1) ³ = -1 (และcodpieceเป็นคำนาม "เชิงลบ" เนื่องจากพวกเขารู้สึกไม่สบายใจและทั้งหมด) SPL เข้าใจไม่กี่ดำเนินการทางคณิตศาสตร์ที่ซับซ้อนมากขึ้นเป็นบางยกกำลังและราก

Factoid (เป็นอีกอันหนึ่งเนื่องจากเราได้มาถึงเหตุการณ์สำคัญอีกครั้งแล้ว)

"Hello โครงการโลก" ใน Shakesperian มี 89 เส้นและมากกว่า 2,400 ตัวอักษรยาวเท่าที่เห็นนี่

ความยาว 21 ตัวอย่าง

Listen to your heart.

ในตัวอย่าง 15 คุณเอาท์พุทบางอย่าง ที่นี่คุณใส่หมายเลขลงในโปรแกรม หากคุณต้องการใส่ตัวอักษรคุณจะใช้Open your mind.แทน และไม่จำเป็นต้องพูดค่านี้จะถูกเก็บไว้ใน "ตัวอักษร" ที่ถูกพูดถึง

ความยาว 22 ตัวอย่าง

Recall your childhood!

การ popping จำนวนเต็มจากสแต็กทำได้ตามที่อธิบายไว้ในตัวอย่างที่ 12 เมื่อตัวอย่างเช่น Ophelia บอก Hamlet ในประโยคข้างต้นมันทำให้ Hamlet รับจำนวนเต็มจากสแต็กของเขาและถือว่าค่านั้น

แน่นอนว่าตราบใดที่คำrecallเริ่มต้นประโยคคุณสามารถเติมส่วนที่เหลือด้วยความคิดสร้างสรรค์ shakesperian ใจของคุณ

ความยาว 23 ตัวอย่าง

Are you better than me?

การติดตั้ง Snippet 6 เมื่อ "ตัวละคร" สร้างคำถามเช่นนี้กับคำถามอื่นสิ่งที่เขา / เธอกำลังทำนั้นเทียบเท่ากับif (x > y)ภาษาโปรแกรมทั่วไป การติดตามคำสั่งนี้จะต้องล่าช้าจนกว่าฉันจะมีตัวอักษรมากขึ้น

ความยาว 24 ตัวอย่าง

[Enter Romeo and Juliet]

ใช่ "ตัวอักษร" อาจใส่เป็นคู่ ไม่จำเป็นต้องมี "ตัวละคร" หนึ่งตัวเข้าสู่เวทีตามด้วยอีกคน

ความยาว 25 ตัวอย่าง

remainder of the quotient

25 %ตัวอักษรเพียงการเขียน 25 อักขระที่เหลือของการหาร และจะใช้งานอย่างไร นั่นมันยิ่งใหญ่กว่า - ดูตัวอย่าง 75

ความยาว 26 ตัวอย่าง

Let us return to scene II.

นี่คือgotoSPL ซึ่งทำงานเหมือนที่คาดไว้ในภาษาการเขียนโปรแกรม สิ่งหนึ่งคือ: คุณสามารถข้ามไปมาระหว่างฉากในฉากการแสดงเดียวกันและระหว่างฉากต่างๆ แต่คุณไม่สามารถข้ามไปมาระหว่างฉากในการกระทำต่าง ๆ ได้

ความยาว 27 ตัวอย่าง

[Exeunt Ophelia and Hamlet]

เมื่อมี "ตัวละคร" มากกว่าหนึ่งคนออกจากเวทีแทนที่จะเป็นExitและรักษาประเพณีของธรรมชาติของละคร SPL คำภาษาละติน "Exeunt" ถูกนำมาใช้ บางครั้งมันสามารถแทนที่ได้เพียงแค่ตัวอย่าง 8

ความยาว 28 ตัวอย่าง

Scene I: Ophelia's flattery.

ประกาศฉาก ในขณะที่คุณสามารถคาดหวังว่าคุณจะได้รับการจัดการกับฉันที่สำคัญคือScene Iส่วนที่เหลือเป็นปุยศิลปะ

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

ความยาว 29 ตัวอย่าง

You pretty little warm thing!

ใช่ แต่เป็นค่าคงที่อีกอันหนึ่ง (เนื่องจากเราต้องการวิธีเพิ่มจำนวนอักขระเพื่อให้มีการคำนวณทางคณิตศาสตร์) หนึ่งนี้จะมีค่าเท่ากับเพราะ82*2*2*1 = 8

ความยาว 30 ตัวอย่าง

You are as cowardly as Hamlet!

การพูดแบบนี้กับโรมิโอหมายความว่าRomeo = Hamletอย่างนั้น เช่นเดียวกับตัวอย่าง 9

Factoid (ใช่แล้วมีจุดสังเกตอื่นถึง!)

ภาษานี้ถูกสร้างขึ้นสำหรับการมอบหมายในหลักสูตรการวิเคราะห์ไวยากรณ์ - ดังนั้นจึงไม่มีการสร้างคอมไพเลอร์ SPL โดยผู้เขียน เพิ่มเติม: ดูเหมือนว่าผู้เขียน SPL ได้ตัดความสัมพันธ์กับการสร้างของพวกเขาเนื่องจากดูเหมือนว่าจะไม่มีการแก้ไขในภาษาตั้งแต่ปี 2001 ...

ความยาว 31 ตัวอย่าง

Am I as horrid as a flirt-gill?

ใช่ฉันรู้ว่ามันเป็นตัวอย่างที่ 23 ซ้ำแล้วซ้ำอีกแม้ว่าที่นี่เรากำลังเปรียบเทียบ "ตัวละคร" ที่พูดกับ "เจ้าชู้" (จากถ้าคุณต้องการif (Ophelia == -1)) สิ่งที่เป็น ...

ความยาว 32 ตัวอย่าง

If so, let us return to scene I.

... ตอนนี้ฉันสามารถแนะนำthenSPL และเงื่อนไขการข้ามไปยังและวิธี Shakesperian ของการใช้ลูป ตัวอย่างเช่นคุณสามารถทำให้โรมิโอได้รับค่า0เพิ่มมูลค่าของเขาในขณะที่ทำงานอื่น ๆ และหยุดเมื่อเขาอายุครบ 10 ปีโดยดำเนินการโปรแกรมต่อไป

ความยาว 33 ตัวอย่าง

If not, let us return to scene I.

เพียงแค่เตือนที่แทนเราสามารถดำเนินการแทนไปข้างหน้าเพื่อฉากอื่นถ้าเงื่อนไขที่เราทดสอบสำหรับเป็นเท็จ

ความยาว 34 ตัวอย่าง

Open your mind! Remember yourself.

คำแนะนำสองคำติดต่อกัน yippie! ตัวแรกอ่านตัวอักษรตัวที่สองดันตัวอักษรเข้าไปในหน่วยความจำของตัวละครอื่น

ความยาว 35 ตัวอย่าง

Act I: Death!

Scene I: Oh, shit.

วิธีที่เหมาะสมในการประกาศการกระทำและฉาก เพิ่มข้าวต้มศิลปะอย่างมีรสนิยม

ความยาว 36 ตัวอย่าง

Thou art as sweet as a summer's day!

อีกวิธีในการพูดว่า "ตัวละคร" ที่ถูกพูดถึงจะได้รับคุณค่า1- เพราะวันฤดูร้อนนั้นดีและน่ารื่นรมย์

ความยาว 37 ตัวอย่าง

Art thou more cunning than the Ghost?

โอฟีเลียถามคำถามนี้กับแฮมเล็ตแปลว่าเป็นภาษาโปรแกรมที่อ่านไม่ได้, if (Hamlet > the Ghost). มันเป็นข้อมูลโค้ด 23 อีกครั้งใช่แล้ว - แต่มันแสดงให้คุณเห็นว่าไม่จำเป็นต้องถาม "ตัวละคร" ว่ามันดีกว่ากัน: คำถามอื่น ๆ ก็ใช้ได้เช่นกัน

ความยาว 38 ตัวอย่าง

[Enter the Ghost, Romeo and the Ghost]

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

ความยาว 39 ตัวอย่าง

the sum of a fat lazy pig and yourself!

คำแนะนำแบบเต็มจะดูดีกว่านี้ฉันจะให้คุณ แต่ ... นี่คือการดำเนินการทางคณิตศาสตร์ครั้งแรกของเรา! มันหมายถึงอะไรจริงทั้งหมด? ดีpigเป็นสัตว์สกปรก (แม้จะอร่อย) ดังนั้นจึงเท่ากับ-1ได้สองคำคุณศัพท์หมายเท่ากับfat lazy pig 2*2*(-1) = -4แต่เกี่ยวกับyourselfอะไร มันเป็นสรรพนามสะท้อนกลับไม่ใช่ชื่อหรือคำคุณศัพท์ โปรดจำไว้ว่า SPL ขึ้นอยู่กับการสนทนาระหว่าง "ตัวอักษร"; ดังนั้นyourselfหมายถึง "ตัวละคร" อื่น ๆ บนเวที ดังนั้นเรามาถึงจุดสิ้นสุดและเราค้นพบว่า "ผลรวมของหมูขี้เกียจอ้วนและตัวคุณเอง" ในความเป็นจริงแล้ว-4 + xคือ

ความยาว 40 ตัวอย่าง

the sum of a squirrel and a white horse.

ใช่ผลรวมอีกอัน แต่อันนี้ง่ายกว่าตัวอย่างที่ 39 นี่เป็นเพียง1 + 2- 3ถ้าคณิตศาสตร์ของฉันถูกต้อง

Factoid (ยังอยู่กับฉันหลังจากเกร็ดความรู้ทางศิลปะสี่สิบชิ้นเหล่านี้หรือไม่คุณสมควรได้รับรางวัล)

SPL ในเวอร์ชั่น 1.2.1 สามารถดาวน์โหลดได้ที่นี่

ความยาว 41 ตัวอย่าง

Juliet:
 Speak thy mind!

[Exit Romeo]

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

ความยาว 42 ตัวอย่าง

Speak YOUR mind! You are as bad as Hamlet!

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

ความยาว 43 ตัวอย่าง

Am I as horrid as a half-witted flirt-gill?

จูเลียตถามสิ่งนี้ไม่ได้หมายความว่าเธอมีความนับถือต่ำ (แม้ว่ามันอาจจะเป็นในชีวิตจริง); มันเป็นอีกเรื่องหนึ่งifอย่างเกร็ดเล็กเกร็ดน้อยที่ 23 และ 37 โอ้ฉันเกือบลืมไปif (Juliet == -2)แล้ว

ความยาว 44 ตัวอย่าง

You are as evil as the square root of Romeo!

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

ความยาว 45 ตัวอย่าง

Hamlet:
 Art thou more cunning than the Ghost?

ตัวอย่างที่ 37 เขียนอย่างถูกต้องกับตัวละครที่พูดในบรรทัด

ความยาว 46 ตัวอย่าง

the product of a rural town and my rich purse.

ตกลง ... อย่างไรก็ตาม SPL อาจเป็นภาษาเดียวในโลกที่อนุญาตให้คุณเพิ่มจำนวนเมืองด้วยกระเป๋า ซึ่งหมายความซึ่งถ้าฉันไม่ผิดมากเท่ากับ(2*1)*(2*1)4

ความยาว 47 ตัวอย่าง

Romeo:
 Speak your mind.

Juliet:
 Speak YOUR mind!

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

ความยาว 48 ตัวอย่าง

You lying fatherless useless half-witted coward!

2*2*2*2*(-1)แปลมันโดยตรง -16ใช่มั้ย

ความยาว 49 ตัวอย่าง

Scene V: Closure.

Hamlet:
 Speak your mind!

[Exeunt]

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

ความยาว 50 ตัวอย่าง

Othello, a young squire.
Lady Macbeth, an old fart.

เพิ่มเติมการนำเสนอ "ตัวอักษร" ก่อนคำแนะนำที่เหมาะสม เช่นเดียวกับสิ่งเดียวที่มีความสำคัญต่อคอมไพเลอร์คือOthelloและLady Macbethดังนั้นส่วนที่เหลือของสายจึงพร้อมสำหรับการคว้า ...

อีกอย่างหนึ่ง: "ตัวละคร" ไม่จำเป็นต้องเกี่ยวข้องกันเพื่อให้ปรากฏในโปรแกรม SPL - เพื่อให้คุณสามารถมี Romeo, Othello และ Hamlet ในการเล่นเดียวกัน

Factoid (ครึ่งศตวรรษของสิ่งเหล่านี้เหรอ! หลังจากนี้ฉันคิดว่าฉันจะเกลียด William Shakespeare ... )

SPL ที่ไปที่ C แปลดังกล่าวในขณะที่ที่ผ่านมาและการพัฒนาโดยผู้สร้าง SPL เป็นไปตามFlexและวัวกระทิง

ความยาว 51 ตัวอย่าง

Othello:
 Recall your great dreams. Speak your mind!

(เบื่อโรมิโอ, จูเลียตและแฮมเล็ต ... มาหา Othello กันเถอะ!)

Recallคุณสามารถเดาได้ว่าเป็นกุญแจสำคัญที่นี่ "ตัวอักษร" Othello กำลังกำหนดแอดเดรสจะใช้ค่าจากสแต็กของเขา / เธอสมมติว่าค่านั้นและหลังจากนั้นจะส่งออก

ความยาว 52 ตัวอย่าง

Thou art as pretty as the sum of thyself and my dog!

ผลรวมอื่น อ้าปากค้าง Hamlet = Hamlet + 1สมมติว่าคนนี้จะถูกส่งไปยังหมู่บ้านหมายความว่า Hamlet += 1หรือ Hamlet++หรือ

ความยาว 53 ตัวอย่าง

Romeo:
 You are as vile as the sum of me and yourself!

อาใช่สิ่งที่ฉันลืมพูดถึงก่อนหน้านี้: "ตัวละคร" ที่พูดสามารถพูดถึงตัวเองในสายของตัวเอง

ความยาว 54 ตัวอย่าง

Juliet:
 Is the sum of Romeo and me as good as nothing?

อีกตัวอย่างของตัวอย่างก่อนหน้านี้รวมอยู่ในเงื่อนไข if (Romeo + Juliet == 0)ดังนั้นสิ่งที่เรามีที่นี่เป็น

ความยาว 55 ตัวอย่าง

Juliet:
 You are as lovely as the sweetest reddest rose.

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

ความยาว 56 ตัวอย่าง

Othello:
 You lying fatherless useless half-witted coward!

ทำ 48 ตัวอย่างอย่างถูกต้องด้วย "ตัวละคร" หากคุณขี้เกียจเกินกว่าที่จะเลื่อนขึ้น (อย่างที่ฉันเป็น) นี่หมายความว่าคนที่ถูกดูถูกกำลังรับค่า -16

ความยาว 57 ตัวอย่าง

Romeo:
 If not, let us return to Act I. Recall thy riches!

ฉันได้อธิบายวิธีการทำงานของ SPL โดยทั่วไปแล้ว อย่างไรก็ตามจำเป็นต้องมีการวิเคราะห์แบบอินไลน์เพิ่มเติม เราไม่ได้elseอยู่ที่นี่: ต่อตัวอย่างในตัวอย่างนี้หากเงื่อนไขล้มเหลวโปรแกรมจะกลับไปที่ Act I; แต่ถ้ามันเป็นเรื่องจริงมันก็จะทำตามคำแนะนำถัดไปซึ่งก็คือRecall- ป๊อปจากสแต็คนั่นคือ

ความยาว 58 ตัวอย่าง

Romeo:
 You are as disgusting as the square root of Juliet!

เกร็ดเล็กเกร็ดน้อยที่จับ 44 และนำเสนอวิธีการสอนควรนำเสนอ ถ้านี่เป็นบทสนทนาระหว่างโรมิโอกับโอเทลโลเราก็สามารถแปลมันเป็นภาษาจาวาOthello = Math.sqrt(Juliet)ได้

ความยาว 59 ตัวอย่าง

Othello:
 You are as vile as the sum of yourself and a toad!

ตกลงถ้าโอเทลโลกำลังคุยกับโรมิโอนี่จะเทียบเท่ากับRomeo+(-1); Romeo--, สั้น ๆ. ค่อนข้างธรรมดาใช่มั้ย นั่นคือ SPL สำหรับคุณ

ความยาว 60 ตัวอย่าง

Is the quotient between the Ghost and me as good as nothing?

สำหรับระยะสั้นif (The Ghost/Hamlet == 0)สมมติว่า "ฉัน" เป็นของแฮมเล็ต

ความยาว 61 ตัวอย่าง

Thou art as handsome as the sum of yourself and my chihuahua!

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

ความยาว 62 ตัวอย่าง

twice the difference between a mistletoe and a oozing blister!

ใช่ใช่การดำเนินการทางคณิตศาสตร์มากขึ้น โดยประมาณสามารถแปล SPL ขนาด 62 ไบต์เหล่านี้2*(1-2*(-1))ได้ นี่จะเป็นภาษากอล์ฟที่ยอดเยี่ยมใช่ไหม? ขวา.

ความยาว 63 ตัวอย่าง

You lying stupid fatherless rotten stinking half-witted coward!

Snippet 48 เอาท์พุท -16 หนึ่งนี้จะมีค่าเท่ากับ 2*2*2*2*2*2*(-1)-64:

ความยาว 64 ตัวอย่าง

your coward sorry little stuffed misused dusty oozing rotten sky

จากสิ่งที่ฉันเข้าใจเกี่ยวกับ SPL นี่เป็นสิ่งที่ถูกต้องสมบูรณ์แบบ คุณมีคำคุณศัพท์ที่ดูถูกเหยียดหยามมากมาย เนื่องจากคำคุณศัพท์ไม่มีความแตกต่างเป็นพิเศษไม่ว่าพวกเขาจะลบหรือไม่ (คุณค่าเพียงอย่างเดียวของพวกเขาคือการคูณจำนวนที่อยู่ทางขวาด้วยสอง) เราสามารถมีประโยคที่โง่ ๆ อย่างนี้ ซึ่งเทียบเท่ากับ 256 2*2*2*2*2*2*2*2*1=256เพราะ

ความยาว 65 ตัวอย่าง

You are nothing! You are as vile as the sum of thyself and a pig.

อืมเกลียดมากเลยใช่ไหม ดังนั้นสิ่งที่เรามีที่นี่เทียบเท่ากับy=0; y=y+(-1);อาจจะเป็น "กอล์ฟ" ถึงYou are a pig!แต่ heh

ความยาว 66 ตัวอย่าง

You are as beautiful as the difference between Juliet and thyself.

เอาจูเลียตออกจากตัวเองใช่มั้ย เรื่องนี้ง่ายมากที่จะถอดรหัส: Romeo=Juliet-Romeo;สมมติว่าเป็น Romeo ที่ถูกพูดถึง

ความยาว 67 ตัวอย่าง

Juliet:
 Am I better than you?

Romeo:
 If so, let us proceed to Act V.

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

ความยาว 68 ตัวอย่าง

The Ghost:
 You are as small as the sum of yourself and a stone wall!

ใช่ฉันได้รับความจำเจเล็กน้อย แต่ SPL เป็นเช่นนั้น อย่างที่ฉันได้กล่าวไปก่อนหน้านี้การแสดงออกของมันเป็นการผสมผสานระหว่างการดำเนินการทางคณิตศาสตร์ ดังนั้นนี่คือการเพิ่มขึ้นอีกครั้ง - เนื่องจากstone wallเป็น "คำนาม" ที่เป็นกลาง

ความยาว 69 ตัวอย่าง

Thou art as disgusting as the difference between Othello and thyself!

แทนที่จะเป็นการรวมเรามีการลบระหว่างตัวละครสองตัวคือโอเทลโลและใครก็ตามที่ถูกพูดถึง

ความยาว 70 ตัวอย่าง

You are as handsome as the sum of Romeo and his black lazy squirrel!

เรากลับไปที่เพิ่มเติมใช่ - โทรหาฉัน formulaic, heh Romeo + 2*2*1เราแปลนี้

ความยาว 71 ตัวอย่าง

Scene I: Dialogues.

[Enter Juliet]

Othello:
 Speak your mind!

[Exit Juliet]

ฉากอาจมีขนาดเล็กเช่นนี้ Julietเข้าสู่เวทีโอเทลโลบอกให้เธอเอาท์พุทค่าที่เก็บไว้ของเธอแล้วเธอก็ออกจากเวทีอีกครั้ง

ความยาว 72 ตัวอย่าง

twice the difference between a mistletoe and an oozing infected blister!

อีกหนึ่งการดำเนินการทางคณิตศาสตร์ - เพราะ SPL เต็มไปด้วยพวกเขา 2*(1-2*2*(-1))เราสามารถแปลนี้

ความยาว 73 ตัวอย่าง

You are nothing! Remember me. Recall your unhappy story! Speak your mind!

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

ความยาว 74 ตัวอย่าง

You are as sweet as the sum of the sum of Romeo and his horse and his cat!

ใช่ใช่ตัวอย่างที่น่าเบื่อฉันรู้ X = (Romeo + 1) + 1แต่นี้เป็น

ความยาว 75 ตัวอย่าง

Is the remainder of the quotient between Othello and me as good as nothing?

ตรงนี้มันค่อนข้างตรงไปตรงมา if (Othello % X == 0)ถ้าทักษะการถอดรหัสของคุณชำรุดก็แปลว่า

ความยาว 76 ตัวอย่าง

Thou art as rich as the sum of thyself and my dog! Let us return to scene I.

การกระโดดจากตัวอย่างข้อมูล 26 ด้วยการแสดงออกมาก่อน gotoใน SPL ไม่พบมักจะอยู่ใกล้กับสภาพที่มันอาจเป็นเช่นนี้ - และแน่นอนประเภทนี้gotoมักจะพบได้ในตอนท้ายของการกระทำหรือฉากตั้งแต่คำแนะนำหลังจากที่มันจะไม่ถูกรวบรวม / ดำเนินการ คำสั่งแรกนั้นค่อนข้างง่าย: x=x+1.

ความยาว 77 ตัวอย่าง

[Exit Hamlet]

[Enter Romeo]

Juliet:
 Open your heart.

[Exit Juliet]

[Enter Hamlet]

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

ความยาว 78 ตัวอย่าง

The Ghost:
 Speak thy mind.

Lady Macbeth:
 Listen to thy heart! Remember thyself.

ดังนั้นผี (พ่อผู้ตายของหมู่บ้านเล็ก) กำลังบอกเลดี้แมคเบ ธ เพื่อส่งออกคุณค่าของเธอในขณะที่เธอสั่งผีให้อ่านตัวเลขและผลักมันเข้าไปในกองของเขา

Piet

factoid

Piet เป็นภาษาการเขียนโปรแกรมซึ่งซอร์สโค้ดประกอบด้วยรูปภาพ ผังรายการเริ่มต้นด้วยพิกเซลด้านบนซ้ายและเลื่อนไปรอบ ๆ ภาพระหว่างพิกเซลและกลุ่มพิกเซลจนกว่าจะสิ้นสุด

เพื่อความชัดเจนโปรแกรม Piet มักจะแสดงเป็นเวอร์ชันขยาย ในกรณีเช่นนี้คำcodelนี้ใช้เพื่ออธิบายกลุ่มของพิกเซลที่มีสีเดียวกันซึ่งสอดคล้องกับแต่ละพิกเซลในรูปภาพต้นฉบับ

สำหรับความท้าทายนี้เนื่องจาก Piet ไม่ได้ใช้ตัวละคร codel ต่อหนึ่งเสียงจะถูกใช้สำหรับโปรแกรมตัวอย่าง

1 Codel

นี่เป็นโปรแกรมที่ถูกต้องมันไม่ทำอะไรเลยและยุติลง โฟลว์ควบคุมเริ่มต้นที่พิกเซลด้านซ้ายบนเท่านั้นและไม่มีทางออกซึ่งจะสิ้นสุดโปรแกรม

พิกเซลสามารถในกรณีนี้สีใด ๆ สำหรับผลเดียวกันแน่นอน

2 รหัส

สิ่งนี้จะอ่านตัวอักษรจาก stdin อย่างต่อเนื่องและเก็บค่ายูนิโค้ดทั้งหมดที่ทำงานอยู่ (แม้ว่าจะไม่ได้ทำอะไรเลยกับผลรวมนี้และมันจะไม่แสดง)

การไหลของโปรแกรม Progam จะย้ายไปมาระหว่างโค้ด 2 ตัวเนื่องจากวิธีการเดียวของแต่ละอันจะเข้าสู่อีกทางหนึ่ง คำสั่งใน piet ดำเนินการโดยการเคลื่อนที่จาก codel หรือภูมิภาคหนึ่งไปอีกอันหนึ่งขึ้นอยู่กับความแตกต่างของสีและความสว่างของ 2 ภูมิภาค inputเป็นคำสั่งย้ายจากซ้ายไปขวาแล้วaddเป็นจากขวาไปซ้าย ในaddคำสั่งแรกจะไม่มีอะไรเกิดขึ้นเนื่องจากมีเพียงค่าเดียวในสแต็กและข้อกำหนดระบุว่าคำสั่งที่ไม่มีค่าเพียงพอจะถูกละเว้น

โปรแกรมนี้เป็นลูปที่จะไม่มีวันสิ้นสุดเนื่องจากโปรแกรม piet ส่วนใหญ่จะมีขนาดเล็กมากเนื่องจากใช้เวลาอย่างน้อยสองสามโคเดลในการ "ดัก" การไหลของโปรแกรมและจบการทำงาน

3 รหัส

นี่เป็นโปรแกรม echo-type พื้นฐานมันจะอ่านตัวอักษรในแต่ละครั้งจาก stdin และพิมพ์ไปยัง stdout

อีกครั้งนี่คือการวนซ้ำไม่สิ้นสุด โปรแกรมที่เริ่มต้นด้วยการเดินทางจากซ้ายไปขวาซึ่งทำแล้วinput outputโปรแกรมจะไหลต่อไปในทิศทางเดียวกันทุกครั้งที่ทำได้ ที่ codel สีเขียวอ่อนทางออกเดียวคือเริ่มเคลื่อนที่กลับไปทางอื่น เมื่อเดินทางกลับจากขวาไปซ้ายจะพยายามดำเนินการsubtractและaddคำสั่ง แต่สแต็กนั้นว่างเปล่าดังนั้นสิ่งเหล่านี้จึงกลายเป็นไม่มีตัวเลือก

4 รหัส

พิมพ์ 2 เพื่อ stdout ไปเรื่อย ๆ

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

5 รหัส

อ่านอักขระซ้ำหลายครั้งในแต่ละครั้งจาก stdin และติดตามผลรวมของค่า unicode

นี่เป็นฟังก์ชั่นเดียวกับรุ่น 2-codel แต่ความท้าทายนี้เกี่ยวกับการจัดแสดงภาษาและสิ่งหนึ่งที่น่าสนใจเกี่ยวกับ piet ก็คือคุณสามารถมีภาพที่ดูแตกต่างกันซึ่งทำสิ่งเดียวกัน

ที่นี่เราเห็น codel สีขาวเป็นครั้งแรกซึ่งช่วยให้การไหลของโปรแกรมเลื่อนผ่านโดยไม่ต้องดำเนินการคำแนะนำ โค้ดสีม่วงและสีน้ำเงินทำหน้าที่ทั้งหมดได้ที่นี่ การเดินทางจากสีน้ำเงินไปแดงไม่ได้ทำอะไรเลยเพราะมันข้าม codel สีขาวที่อยู่ตรงกลาง สีแดง 2 อันอยู่pushที่หมายเลข 1 ลงบนสแต็กและpopมันกลับออกมาเมื่อมันเดินทางจากซ้ายไปขวาจากขวาไปซ้ายข้ามพวกมันจากนั้นข้ามโมเดลสีขาวดังนั้นจึงไม่มีคำสั่งใด ๆ ดำเนินการ

6 รหัส

อีกครั้งทำซ้ำฟังก์ชันการทำงานก่อนหน้านี้ด้วยรูปลักษณ์ที่แตกต่างกัน นี่เป็นอีกโปรแกรม echo ที่อ่านอักขระในแต่ละครั้งตั้งแต่ stdin ถึง stdout

ที่นี่เราเห็น codel สีดำตัวแรกของเรา การไหลของโปรแกรมไม่สามารถป้อน codel สีดำได้ดังนั้นจากแสงสีม่วงแดงที่อยู่ด้านบนขวาโปรแกรมจะล้มเหลวในการออกจากด้านขวาเนื่องจากขอบภาพล้มเหลวในการออกจากอันเนื่องมาจาก codel สีดำและเด้งกลับซ้ายเข้าไปใน codel สีแดง . ตัวแปลงสัญญาณสีน้ำเงินและสีเขียวตกแต่งอย่างหมดจดโปรแกรมจะไม่มีทางเข้า

7 รหัส

อีกหนึ่งโปรแกรมสะท้อนที่มีรูปลักษณ์แตกต่างกัน

ที่นี่เราเห็นบล็อก codel แรกของเรามีขนาดใหญ่กว่า 1 ใน piet บล็อกที่ต่อเนื่องกันของ codels ที่มีสีเดียวกันจะถือว่าเป็นบล็อกเดียว ขนาดของบล็อกไม่สำคัญยกเว้นเมื่อเรียกใช้งานpushคำสั่งดังนั้นโปรแกรมนี้จะถือว่าเหมือนกับรุ่น 3-codel ยกเว้นด้วยสีที่ต่างกัน

8 รหัส

อ่านตัวเลขจาก stdin และส่งออกจตุรัสไปยัง stdout ซ้ำ ๆ

การควบคุมการไหลเป็นรูปแบบตามเข็มนาฬิกาพื้นฐานเช่นเดียวกับในโปรแกรม 4-codel เริ่มต้นจากบนซ้ายให้การดำเนินงานในการสั่งซื้อที่มีinput, (ดันสำเนาพิเศษของมูลค่าด้านบนของสแต็คบนสแต็ค)duplicate , จากนั้นเป็นค่า 1 ลงบนสแต็กเลื่อนข้ามสีขาวเพื่อไม่ให้คำสั่งถูกเรียกใช้และจากนั้นเป็น 1 จากสแต็กเมื่อย้ายจากโมเดลล่างซ้ายไปยังมุมบนซ้าย นี่จะส่งคืนไปยังจุดเริ่มต้นของโปรแกรมด้วยสแต็กเปล่าและจะทำซ้ำmultiplyoutputpushpop

9 รหัส

เพิ่ม 1 + 2 = 3 แล้วยกเลิก

ตอนนี้เรามีโปรแกรมที่มีโค้ดมากกว่า 2 ตัวในทั้งสองมิติในที่สุดเราก็สามารถตั้งค่าภูมิภาคที่จะดักโปรแกรมและจบมันแทนที่จะวนซ้ำตลอดไป การดำเนินการครั้งแรกที่ย้ายจาก codel สีแดงไปยังพื้นที่สีแดงเข้มคือpush1 จากนั้นโปรแกรมจะหมุนและไหลลงสู่ codel สีแดงอ่อนตรงกลางและpushมีค่าเป็น 2 ไหลจากสีแดงอ่อนไปยังสีเหลืองอ่อนดำเนินการ การaddดำเนินการ แถบสีเหลืองอ่อนด้านล่างทำให้โปรแกรมหยุดทำงานเนื่องจากไม่มีทางที่โปรแกรมจะไหลออกเนื่องจากมุมทั้งหมดถูกปิดกั้น

โปรแกรม 1- และ 2 สูงกำลังกลายเป็นที่น่าเกลียดและไม่น่าสนใจอย่างรวดเร็วดังนั้นจากจุดนี้ไปฉันจะมุ่งเน้นไปที่ตัวเลขที่อนุญาตให้โค้ดอย่างน้อยสองสามตัวในแต่ละทิศทาง

12 รหัส

ในที่สุดโปรแกรมที่ทำสิ่งที่อาจโต้แย้งได้ว่ามีประโยชน์ (แม้ว่ามันจะยังยืดออกไปก็ตาม) อ่านตัวเลข 2 ตัวจาก stdin ตามลำดับแล้วส่งออกผลรวมของพวกเขาและทำเช่นนี้ซ้ำ ๆ

โปรแกรมจะไหลจากซ้ายไปขวาข้ามแถบสี 4 แท่งที่ทำให้เกิด 2 inputsตามด้วยaddคำสั่ง จากนั้นจะย้ายไปที่โมเดลล่างขวาและดำเนินการoutputและจากนั้นไปทางซ้ายข้ามภูมิภาคสีขาวกลับไปที่จุดเริ่มต้น

สิ่งนี้สามารถทำได้ใน 8 codels แต่เนื่องจากเรามีพื้นที่เพิ่มเติมเราจึงสามารถสร้างบางสิ่งที่ได้รับแรงบันดาลใจจากหน้าจอทีวีที่ไม่มีสัญญาณ

15 รหัส

อ่านตัวเลขจาก stdin และส่งออก 'square'

นี่ใช้เทคนิคสองสามอย่างเพื่อให้ได้รูปลักษณ์ที่สมมาตรกับโปรแกรมที่ทำอะไรบางอย่างจริงๆ แถบสีแดงซ้ายสุดเป็นสีที่แตกต่างกันใน codel ด้านล่างกว่าส่วนที่เหลือโดยใช้ประโยชน์จากความจริงที่ว่า (สำหรับฉันอย่างน้อย) ทั้งสองเฉดสีแดงมีลักษณะคล้ายกันมาก โปรแกรมจะย้ายจากบริเวณสีแดงที่เบาลงไปยัง codel สีฟ้าอ่อนจากนั้นตรงข้ามตรงกลางของโปรแกรมไปยังสีเขียวอ่อนทางด้านขวาที่ติดอยู่ จะดำเนินการinput, duplicate, multiplyและoutputการดำเนินงาน

codel สีแดงเข้มพร้อมกับ codels สีเขียวขนาดกลางที่ด้านบนและด้านล่างของคอลัมน์กลางได้รับการตกแต่งและโปรแกรมจะไม่ไปถึงพวกเขา

20 รหัส

อ่านตัวเลขจาก stdin จนกว่าจะอ่าน 0 ซึ่งจะส่งผลรวมของตัวเลขที่ป้อนและออกทั้งหมด

ในที่สุดเราก็มีพื้นที่เพียงพอที่จะควบคุมการไหลในรูปแบบของการpointerดำเนินการ 4 codels ด้านบนดำเนินการinput, duplicateและnotการดำเนินงานและจากนั้นอีกnotการดำเนินการย้ายจากสีม่วงแดงในด้านขวาบนไป 2 CODEL สีเหลืองด้านล่างนี้ค่ะ การnotดำเนินการจะดึงค่าสูงสุดออกจากสแต็กและกด 1 หากค่าสูงสุดเป็น 0 และ 1 เป็นอย่างอื่น ดังนั้นสองครั้งnotแทนที่ค่าที่ไม่ใช่ศูนย์ใด ๆ ด้วย 1 การย้ายจากแถบสีเหลืองลงไปเป็นสีน้ำเงินเข้มดำเนินการpointerการซึ่งปรากฏค่าด้านบนออกจากสแต็กและย้ายตัวชี้ทิศทางตามเข็มนาฬิกาหลายครั้ง

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

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

25 รหัส

นับถอยหลัง! อ่านตัวเลขจาก stdin แล้วพิมพ์การนับถอยหลังเป็น 1 เพื่อ stdout ครั้งละหนึ่งหมายเลข ตัวอย่างเช่นถ้า 5 ถูกอ่านจะพิมพ์ 54321

inputการดำเนินการครั้งแรกจากสีฟ้าเป็นสีเหลืองเป็น จากนั้นสีเหลืองคือตำแหน่งที่โปรแกรม "วนรอบ" เริ่มต้นขึ้น สีเหลือง> Magenta> สีฟ้าเป็นduplicateแล้วoutputจึงพิมพ์ค่าบนสแต็ค แต่เก็บสำเนา ย้ายลงทางด้านขวามือเราpush1 ค่าลงบนสแต็คจากนั้นดำเนินการsubtractionลดลงค่าที่ป้อนของเราโดย 1. ถัดไปคือduplicate, notและอื่น ๆnotย้ายจากสีม่วงแดงด้านล่างขวาเพื่อสีเหลืองเข้มด้านข้าง นี่เป็นการตรวจสอบศูนย์ / ไม่เป็นศูนย์เหมือนกับโปรแกรมก่อนหน้า การย้ายไปทางซ้ายเพื่อเข้าสู่ codel สีน้ำเงินอ่อนจะทำการดำเนินpointerการซึ่งจะย้ายไปทางซ้ายเพื่อเข้าสู่ cyan สีดำเพื่อจบโปรแกรมถ้าเราทำเสร็จหรือสูงสุดเป็นสีเหลืองเพื่อเริ่มลูปของเราอีกครั้งโดยไม่มีอินพุตเริ่มต้น แต่ค่าเดิมลดลง โดย 1

โคแดงสีแดงทั้ง 3 ตัวนั้นมีการตกแต่งและอาจมีสีใดก็ได้

30 รหัส

เครื่องกำเนิดไฟฟ้า Fibonacci พิมพ์เงื่อนไขของลำดับฟีโบนักชีไปจนถึง stdout และไม่หยุด

นี่เป็นการแนะนำครั้งแรกของrollผู้ปฏิบัติงานรวมถึงครั้งแรกที่ใช้พื้นที่ขนาดใหญ่กว่า 1 กับpushผู้ประกอบการเพื่อรับค่าเฉพาะลงบนสแต็ก

เช่นเคยเริ่มต้นในการย้ายขวาบนซ้าย การดำเนินการ 2 ครั้งแรกpush1 ลงบนสแต็กจากนั้นoutputตั้งแต่ลำดับ Fibonacci เริ่มต้นด้วยสอง 1 วินาที แต่โปรแกรมหลักวนซ้ำจะพิมพ์ 1 ครั้ง จากนั้นจะpushมีอีก 1 วินาทีบนสแต็กเพื่อจบลงในสีม่วงแดงเข้มที่มุมขวาบนเพื่อเริ่มโปรแกรมลูปหลัก

เลื่อนลงไปทางด้านขวาเราduplicateและoutputพิมพ์คำต่อไปของลำดับถัดไปจากนั้นduplicateอีกครั้งเพื่อรับสำเนาของค่าลำดับปัจจุบัน การเลื่อนไปทางซ้ายข้ามด้านล่างจะประมวลผล 2 pushการดำเนินการ เนื่องจากพื้นที่สีแดงอ่อนที่ด้านล่างขวามีขนาด 3 โคเดดและอันแรกpushจะผลัก 3 ลงบนสแต็กแทนที่จะเป็น 1

การขยับเข้าหาแสงสีน้ำเงินเป็นการrollดำเนินการ สิ่งนี้จะปรากฏค่า 2 บนสุดออกจากสแต็กและดำเนินการม้วนจำนวนเท่ากับค่าแรกที่ผุดขึ้นไปจนถึงความลึกเท่ากับค่าที่สองที่ผุด ในกรณีนี้มันจะทำการหมุน 1 ครั้งที่ความลึก 3 การหมุนต่อความลึกnจะใช้ค่าสูงสุดของสแต็ก (ค่าปัจจุบันของเราที่ทำซ้ำ) และฝังไว้nที่ความลึก ตอนนี้สแต็คของเราลึกเพียง 3 เท่านั้นดังนั้นมันจะฝังค่าสูงสุดที่ด้านล่าง

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

ไม่เคยใช้ลวดลายสีเหลืองตรงกลาง

54 รหัส

พิมพ์ "สวัสดี!" เพื่อ stdout

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

โปรแกรมเริ่มต้นด้วยpush5 จากภูมิภาคสีฟ้าด้านซ้าย จากตรงนี้มันไหลไปทางด้านบนด้วยduplicateการทำงาน6 อย่างเพื่อทำสแต็คด้วยจำนวน 5s ถัดไปคือpush1 subtractเพื่อวาง 4 ที่ด้านบนสุดของสแต็กจากนั้น 2 multiplyการดำเนินการเพื่อวาง 4 * 5 * 5 = 100 ที่ด้านบนของสแต็ก จากนั้นเป็นduplicateเวลา 2 100 วินาที

ตอนนี้โปรแกรมกระเด้งออกมาจากสีดำและเริ่มทำงานไปทางซ้ายตามด้านล่าง Pushการดำเนินงานของ 3 และ 2 และจากนั้น a rollเพื่อฝัง 2 100 ภายใต้ 5 ถัดไปคือpush1, ลบและเพิ่มเพื่อรับ 100 + 5-1 = 104 ที่ด้านบนของสแต็กซึ่งเป็น Unicode "h" 2 การดำเนินการต่อไปคือpush1 และpointerเพื่อให้ได้มุมและเริ่มเคลื่อนไปทางขวาตรงกลางแล้วoutputพิมพ์ "h"

ถัดไปคือadd100 + 5 = 105 ที่ด้านบนสุดของสแต็กและoutputพิมพ์ "i" สแต็กตอนนี้มีสอง 5s Push1 add, multiplyให้ (1 + 5) * 5 = 30 ในที่สุดpush3 และadd33 และoutputตามด้วย "!" จากนั้นโปรแกรมจะไปยังพื้นที่สีขาวที่เหลือเพื่อสิ้นสุดด้วยสีเขียวทางด้านขวา

> <> (ปลา)

(หมายเหตุ: ตัวอย่างบางส่วนสร้างขึ้นจากตัวอย่างก่อนหน้านี้ซึ่งแตกต่างจากคำตอบส่วนใหญ่ที่ฉันได้ตัดสินใจที่จะวางไว้ตั้งแต่แรกจนถึงล่าสุด)

factoid:

เช่น Befunge,> <> เป็นภาษา 2D แบบกองซ้อน ซึ่งหมายความว่าคำสั่งจะไม่ถูกดำเนินการเชิงเส้นเหมือนกับภาษาดั้งเดิมส่วนใหญ่ - การไหลของโปรแกรมสามารถขึ้นลงซ้ายหรือขวา!

ความยาว 1 ตัวอย่าง:

X

Xเป็นคำสั่งที่ไม่ถูกต้องใน> <> ดังนั้นข้อความแสดงข้อผิดพลาดsomething smells fishy...จะถูกพิมพ์ อันที่จริงนี่เป็นข้อความแสดงข้อผิดพลาดเพียงอย่างเดียวใน> <> ไม่ว่าสาเหตุจะถูกหารด้วยศูนย์หรือพยายามที่จะป๊อปอัพสแต็กเปล่า

ความยาว 2 ตัวอย่าง:

1n

โปรแกรมโฟลว์ใน> <> เริ่มต้นจากด้านบนซ้ายและเริ่มจากด้านขวา 1เพิ่ม 1 ลงบนสแต็กจากนั้นnพิมพ์เป็นตัวเลข (ตรงข้ามกับ ASCII ถ่าน) แต่> <> โปรแกรมนั้นเป็น toroidal ซึ่งหมายความว่าตัวชี้คำสั่งนั้นล้อมรอบเมื่อมันมาถึงจุดสิ้นสุดของบรรทัด ดังนั้นหลังจากที่nเราเริ่มต้นให้กด 1 พิมพ์พิมพ์ไปที่จุดเริ่มต้นกด 1 พิมพ์ ... และเราจะสิ้นสุดการพิมพ์1ของตลอดไป!

ความยาว 3 ตัวอย่าง:

"o;

นี่"คือการแยกสตริงoออกเป็น ASCII ถ่านและ;ยุติโปรแกรม แต่จริงๆแล้วโปรแกรมทำอะไรโดยรวม?

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

ใช่เราเพิ่งใช้เครื่องหมายอัญประกาศเดียวกันเพื่อเริ่มต้นและจบสตริง!

ความยาว 4 ตัวอย่าง:

42n;

จากสิ่งที่เราเห็นมาคุณอาจคาดหวังว่าสิ่งนี้จะผลักดัน 42 ส่งออกเป็นตัวเลขแล้วยุติ แต่คำแนะนำทั้งหมดใน> <> เป็นเพียงตัวอักษรเดียวดังนั้นสิ่งนี้จึงผลักดัน 4 และ 2ออกไปแล้วส่งออกด้านบนของสแต็กเป็นตัวเลข (เฉพาะ 2) และยกเลิก

ความยาว 5 ตัวอย่าง:

<v
;>

จำไว้ว่า> <> เป็นภาษา 2D นั่นหมายความว่าจะต้องมีวิธีในการเปลี่ยนทิศทางการไหลของโปรแกรม!

เช่นเดียวกับ Befunge >^v<วิธีหนึ่งที่คุณสามารถทำเช่นนี้คือผ่านทางลูกศร เพื่อแสดงให้เห็นถึงวิธีการทำงานให้ดูที่โปรแกรมด้านบน:

• โฟลว์ของโปรแกรมเริ่มต้นทันที
• < ทำให้โปรแกรมไหลไปทางซ้าย - เราออกไปทางซ้ายแล้ววนไปทางซ้าย v
• v ทำให้โปรแกรมไหลลง - เราลงไปที่ >
• > ทำให้การไหลของโปรแกรมถูกต้อง - เราออกไปทางขวาและล้อมรอบไป ;
• ในที่สุดเราก็ยุติ

ความยาว 6 ตัวอย่าง:

";"00p

คุณสมบัติที่ยอดเยี่ยมอีกอย่างของ <<> ก็คือมันสามารถตอบสนองได้ - โปรแกรมสามารถแก้ไขซอร์สโค้ดของตัวเองได้ทันที!

ตรงนี้เรากด a ;, ตามด้วยศูนย์สองตัว pแล้วปรากฏด้านบนสามองค์ประกอบy, x, v( yเป็นด้านบนของสแต็ค) และสถานที่ที่ตำแหน่งv x,yกล่าวอีกนัยหนึ่งpในโปรแกรมนี้ใส่เครื่องหมายอัฒภาคที่ตำแหน่ง0,0เปลี่ยนรหัสเป็น;;"00pเปลี่ยนรหัสลงจากนั้นอนุญาตให้โปรแกรมยกเลิกเมื่อตัวชี้คำแนะนำล้อมรอบและดำเนินการวาง;ใหม่

ความยาว 7 ตัวอย่าง:

\7*n;
6

ถ้าไม่เหมือน Befunge,> <> ยังมีมิเรอร์ ( \/|_#) ซึ่งสะท้อนทิศทางของการไหลของโปรแกรม ดังนั้นที่นี่เรา:

• เริ่มต้นทันที แต่ \สะท้อนให้เห็นถึงเราลง
• กด 6 และปิดแผ่น
• ตีด้านหลังของ \และสะท้อนกลับไปทางขวา
• กดปุ่ม 7
• ทวีคูณทวีคูณสองของสแต็ก
• เอาท์พุทและยุติ

การเคลื่อนที่ในแนวนอนผ่าน_กระจกเงาหรือแนวตั้งผ่าน|กระจกเงาเป็นสิ่งที่ไม่ต้องใช้

ความยาว 8 ตัวอย่าง:

"r00g>o<

อาจเป็นเรื่องง่ายที่สุด> <> quine หากมีการโยนข้อผิดพลาดได้ คำแนะนำใหม่สองคำที่นี่คือ:

• r: ย้อนกลับกองซ้อน
• g: รับ - ป็อปyแล้วxดันอักขระx,yไปที่สแต็ก (คู่กับp)

จากการใช้เคล็ดลับการตัดสตริงก่อนหน้านี้โปรแกรมจะเริ่มต้นr00g>o<จากนั้นกดคำพูดแรกอีกครั้ง <o>g00rสแต็คจะกลับแล้วให้ หลังจากนั้นเราจะผลักดันถ่านที่0,0ที่จะให้" <o>g00r"ในที่สุดเราดักจับoลูกศรสองอันออกด้านบนสุดของสแต็กจนกว่าจะไม่มีอะไรเหลือและเราได้รับข้อผิดพลาด

ความยาว 9 ตัวอย่าง:

x0\>
\1n>

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

ความยาว 10 ตัวอย่าง:

;a comment

ไม่มีไวยากรณ์ของความคิดเห็นใน> <> - ไม่จำเป็นต้องใช้ เพียงเขียนสิ่งที่คุณต้องการได้ทุกที่และตรวจสอบให้แน่ใจว่าไม่ได้ถูกเรียกใช้เป็นรหัส!

ความยาว 11 ตัวอย่าง:

1!X2!X+!Xn;

!เป็นแทรมโพลีนซึ่งกระโดดข้ามคำแนะนำ มันมีประโยชน์โดยเฉพาะอย่างยิ่งเมื่อใช้กับ?เป็นเงื่อนไขแทรมโพลีนซึ่งจะปรากฏขึ้นด้านบนสุดของสแต็ค เราจะดูว่ามันทำงานอย่างไรในภายหลัง

โค้ดด้านบนจะพิมพ์ 3 โดยข้ามไปที่Xs เท่านั้นที่ดำเนินการเท่านั้น1! 2! +! n;เพียงการดำเนินการ

ความยาว 12 ตัวอย่าง:

01v
ao>:@+:n

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

• a: กด 10 ซึ่งเราต้องการขึ้นบรรทัดใหม่ a-fกด 10 ถึง 15 ตามลำดับ
• :: ทำซ้ำด้านบนสุดของสแต็ก
• @: [5 4 3 2 1] -> [5 4 1 3 2]หมุนด้านบนสามองค์ประกอบของสแต็คเช่น

ติดตามสำหรับการทำซ้ำสองสามครั้งแรก:

ความยาว 13 ตัวอย่าง:

i:d=?v
l?!;o>

โปรแกรม "tac" ซึ่งอ่านในบรรทัดอินพุตและเอาต์พุตที่ตรงกันข้าม ขอบคุณ @tomsmeding สำหรับตัวอย่าง

=ดึงองค์ประกอบสองอันดับแรกและผลัก 1 ถ้าพวกเขาเท่าเทียมกันเป็นอย่างอื่น 0 บรรทัดแรกจะอ่านต่อไปเรื่อย ๆ จนกว่าจะพบ ASCII ถ่าน 13 (carriage return) ณ จุดนั้นมันจะย้ายไปที่บรรทัดที่สอง

การl?!;oวนซ้ำเป็นโครงสร้างที่สำคัญใน> <> ซึ่งส่งออกสแต็กทั้งหมด ไม่เหมือนกันซึ่ง>o<จะไม่ทำให้เกิดข้อผิดพลาดใด ๆ นี่คือวิธีการทำงาน:

• l ดันความยาวของสแต็ก
• เราตรวจสอบความยาวด้วย?:
  • หากความยาวไม่ใช่ศูนย์ดังนั้นคำสั่งถัดไป!จะถูกดำเนินการโดยข้าม;
  • หากความยาวเป็นศูนย์เราจะไม่ดำเนินการ!และยุติการทำงานเนื่องจาก;

โปรดทราบว่าไม่มีการส่งออกเกิดขึ้นจริงจนกว่าคุณจะตีกลับรถ

ความยาว 14 ตัวอย่าง:

32.

   X67*n;

นอกเหนือจากการเปลี่ยนทิศทางของโปรแกรมแล้วคุณสามารถย้ายตัวชี้คำแนะนำได้ทุกที่ที่คุณต้องการ!

.ปรากฏyขึ้นxและเคลื่อนย้ายตัวชี้คำสั่งไปx,yยังการรักษาทิศทาง อย่างไรก็ตามโปรดทราบว่าคุณต้องย้ายไปที่หนึ่งสี่เหลี่ยมก่อนที่คุณต้องการไป - ตัวชี้คำสั่งจะได้รับการปรับปรุงก่อนที่จะดำเนินการคำสั่งต่อไป ดังนั้นที่นี่ตัวชี้คำสั่งจะตกลงบนสิ่งที่ไม่ถูกต้องXแต่ทั้งหมดก็ไม่เป็นไรเนื่องจากตัวชี้ย้ายไปที่6ที่การดำเนินการก่อนดำเนินการต่อ

.ทำให้สามารถแปลงโปรแกรมส่วนใหญ่> <> เป็นหนึ่งซับได้ แต่ทำไมคุณถึงอยากเสียความสนุกของ 2D ไป? :)

ความยาว 15 ตัวอย่าง:

01+:aa*=?;:nao!

พิมพ์ตัวเลข0เป็น99หนึ่งในแต่ละบรรทัด โปรแกรมนี้แสดงให้เห็นถึงการใช้!trampoline อย่างเป็นระเบียบ- เพื่อให้มั่นใจว่า 0 เริ่มต้นจะถูกผลักเพียงครั้งเดียว

ความยาว 16 ตัวอย่าง:

"r00g!;oooooooo|

ควินที่เหมาะสมซึ่งไม่ทำให้เกิดข้อผิดพลาดซึ่งได้รับแรงบันดาลใจจากควินินบนหน้า esolangหน้า

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

หากเราเปลี่ยนเป็นเครื่องหมายคำพูดเดี่ยว (ซึ่งใช้สำหรับการแยกสตริงด้วย) ดังนั้นควินินสำรองซึ่งไม่ได้ใช้gคือ

'r3d*!;oooooooo|

ความยาว 17 ตัวอย่าง:

b2,63,.

   17,n;

เรามีการบวก ( +) การลบ ( -) การคูณ ( *) โมดูโล ( %) ... แต่การหารล่ะ มันอยู่ที่นั่น แต่เนื่องจาก/เป็นกระจกอยู่แล้วการแบ่งจึงถูกกำหนด,สัญลักษณ์แทน ที่น่าสนใจคือการแบ่งเป็นลอยส่วนไม่แบ่งจำนวนเต็ม!

11/2, 6/3โปรแกรมดังกล่าวข้างต้นสำรวจไม่ได้กำหนดพฤติกรรมบางอย่างโดยพยายามที่จะข้ามไป intepreter หลามดูเหมือนว่าโอเคถ้าครั้งแรกประสานงานไม่ได้เป็นจำนวนเต็ม (แม้ว่ามันจะกระโดดไปยังจุดที่ผิด) แต่ถ้าฉายาที่สองคือไม่ได้

ความยาว 18 ตัวอย่าง:

123456${{$}nnnnnn;

เราได้เห็นrว่าสแต็กจะกลับรายการและ@หมุนองค์ประกอบสามอันดับแรก ต่อไปนี้เป็นคำสั่งเพิ่มเติมที่ย้ายองค์ประกอบบนสแต็ก:

• $: สลับองค์ประกอบสองอันดับแรก
• {: เลื่อนทั้งกองไปทางซ้าย
• }: เลื่อนทั้งกองไปทางขวา

เพื่อแสดงวิธีการทำงานนี่คือการติดตามโปรแกรม:

123456 ------> 123465 ------> 234651 ------> 346512 ------> 346521 ------> 134652
       $ Swap        { L shift      { L shift       $ Swap        } R shift

256431จากนั้นเราจะส่งออกให้

ความยาว 19 ตัวอย่าง:

"reward"4[roooo]oo;

จนถึงตอนนี้ฉันกำลังพูดว่า "กอง", "กอง" ...

แม้ว่าโปรแกรมส่วนใหญ่จะใช้สแต็กเดียว แต่>> สามารถมีได้หลายกอง! นี่คือคำแนะนำที่เกี่ยวข้อง:

• [: แสดงxและย้ายxองค์ประกอบด้านบนไปยังสแต็กใหม่
• ]: ลบสแต็กปัจจุบันและย้ายค่าไปยังสแต็กที่ขีดเส้นใต้

นี่คือร่องรอยของโปรแกรมด้านบน:

       [r e w a r d]       Push "reward"
4[     [r e] [w a r d]     Move four elements to a new stack
r      [r e] [d r a w]     Reverse the current stack
oooo   [r e] []            Output "ward"
]      [r e]               Remove the current stack, no values to move
oo     []                  Output "er", giving "warder" altogether

โปรดทราบว่าเพียงกดrewardแล้วส่งออกอีกครั้งด้วยooooooจะพิมพ์drawerเนื่องจากลักษณะ "เข้าก่อนออกก่อน" ของกองซ้อน

ความยาว 20 ตัวอย่าง:

aa*5+\
7a*2+\
oo;  \

คุณสมบัติที่รู้จักกันน้อยของ> <> ก็คือเช่นเดียวกับงูหลามแบ็กสแลชสามารถใช้สำหรับการต่อเนื่องของบรรทัดในหลายกรณี *

รหัสดังกล่าวเป็นหน้าที่เช่นเดียวกับ

aa*5+7a*2+oo;

^{* ข้อจำกัดความรับผิดชอบ: สาเหตุที่ทำให้งานนี้อาจจะใช่หรือไม่ใช่ด้วยเหตุผลที่ต่างออกไปโดยสิ้นเชิง}

ความยาว 22 ตัวอย่าง:

1&fv ;n&<
&1->:0=?^:&*

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

โปรแกรมด้านบนคำนวณแฟคทอเรียลของf(15) พิมพ์ 1307674368000 นี่คือร่องรอยของการfแทนที่ด้วย4:

ความยาว 24 ตัวอย่าง:

"Hello, World!"rl?!;of0.

เรามีตัวอักษรมากพอสำหรับรายการโปรดของทุกคน! ที่นี่เราใช้. teleporter สำหรับเอาท์พุต

ความยาว 25 ตัวอย่าง:

0i:0(?v$a*$"0"-+!
   ;n~<

น่าเสียดาย> <> อนุญาตให้อ่านได้จาก STDIN ครั้งละหนึ่งตัวอักษรเท่านั้นซึ่งทำให้การอ่านเป็นตัวเลขยุ่งยากเล็กน้อย สำหรับการป้อนข้อมูลที่ประกอบด้วยตัวเลข 0-9 โปรแกรมนี้เป็น atoi เป็นหลักแปลงสตริงตัวเลขจาก STDIN เป็นตัวเลขบนสแต็ก (ซึ่งถูกพิมพ์แล้ว)

อีกข้อสังเกตหนึ่งคือใน EOF ให้iกด -1 ลงในสแต็ก สิ่งนี้ทำให้การตรวจสอบ EOF ง่ายขึ้นโดยเปรียบเทียบกับการใช้ 0 (หรือ "น้อยกว่า"

ตัวอย่างนี้ยังใช้~ซึ่งจะปรากฏและทิ้งองค์ประกอบด้านบนของสแต็ก

ความยาว 33 ตัวอย่าง:

i>:nao:1=?;\
 ^  ,2v?%2:/
 ^+1*3<

จนถึงตอนนี้ตัวอย่างข้อมูลส่วนใหญ่มีลักษณะเชิงเส้นตรงหรือเป็นเพียงตัวอย่างง่ายๆที่แสดงให้เห็นถึงการทำงานของ <> ตอนนี้ฉันสามารถยกตัวอย่างซึ่งเน้นว่ามันง่ายแค่ไหนที่จะเห็นภาพผังรายการใน> <> ด้วยโปรแกรมที่จัดวางอย่างดี

โปรแกรมอ่านด้วยอักขระ ASCII เดียวและรัน3x+1อัลกอริทึมบนจุดโค้ด (ใน> <> ตัวอักษรโดยทั่วไปจะเป็นจำนวนเต็ม) อัลกอริทึมแต่ละขั้นตอนจะถูกพิมพ์จนกว่าเราจะตี 1

นี่คือการติดตามสำหรับการวนซ้ำสองสามครั้งแรกที่มีการป้อนข้อมูลa(รหัสจุด 97):

ความยาว 44 ตัวอย่าง:

a&>i:0(?v"+"$\
/&^?=0l< "a*"/
\:1+&2p/\0
n
;

ฉันไม่รู้สึกเหมือนว่าฉันได้ทำpคำสั่งยุติธรรมโดยใช้มันแค่ครั้งเดียวในตัวอย่างที่ 6 ดังนั้นนี่คือฟังก์ชัน atoi ที่แตกต่างกัน มีอะไรเจ๋งเกี่ยวกับอันนี้? โปรแกรมเขียนนิพจน์ที่จำเป็นในการคำนวณจำนวนตามที่อ่านอินพุต!

ดังนั้นสำหรับอินพุทเช่น573หลังจากอ่านตัวอักษรทั้งหมดแล้วจุดสิ้นสุดของบรรทัดที่สามจะมีลักษณะเช่น\0a*5+a*7+a*3+นี้ซึ่งประเมินเป็น 573!

อีกครั้งอินพุตที่คาดว่าจะเป็นตัวเลขเท่านั้น ติดตาม GIF ที่นี่

ความยาว 74 ตัวอย่าง:

>i:'A'(?v:'N'(?v:'['(?v\
  :'a'(?v:'n'(?v:'{'(?v\
^      o<    +d<  -d-d<o

หากคุณสามารถลงมาที่นี่ได้คุณอาจเห็นด้วยกับฉันเมื่อฉันบอกว่านี่เป็นโปรแกรม ROT13 ที่อ่านง่ายมาก กำหนดถ่านc1เราพบถ่านแรกc2ในAN[an{เช่นว่าc1 < c2แล้วใช้ที่เหมาะสมชดเชยโดยการเพิ่ม / ลบd(13) โปรดทราบว่า[และ{เป็นตัวอักษรโดยตรงหลังZและzตามลำดับ

ลองในคอนโซลและดูการแปลงตัวอักษรในขณะที่คุณพิมพ์!

^{(คุณสามารถไปป์ในอินพุตได้ แต่เมื่อฉันทำ EOF หายไปตรวจสอบ:0(?;ว่ามันจะหยุดด้วยข้อผิดพลาดเมื่อพยายามพิมพ์ -1 เป็นอักขระ)}

C - แก้ไข

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

เหตุใดคุณสมบัติ C จึงเป็นเช่นนั้น

ความลับที่ซ่อนอยู่เบื้องหลังภาษาสคริปต์เหล่านี้คือล่ามนั้นน่าจะเขียนเป็นภาษา C (หรือเมื่อเร็ว ๆ นี้คือ C ++ หรือ Java) คอมไพเลอร์ C ++ แรกที่คอมไพล์แล้วจริง ๆ กับรหัส C ในความเป็นจริงจนกว่าจะมีตลาดสำหรับคอมไพเลอร์โดยตรงก็มักจะคุ้มค่ากว่าในการเขียนคอมไพเลอร์เพื่อสร้าง C จากนั้นก็คอมไพล์มัน

หากคุณกำลังทำงานบนแพลตฟอร์มขนาดเล็กมากแม้อาจไม่มีระบบปฏิบัติการให้ใช้งานคุณก็มีโอกาสที่จะทำงานใน C ทุกวันนี้อุปกรณ์เกือบทุกชิ้นมีไมโครคอนโทรลเลอร์ฝังอยู่ในนั้น เล็กและเร็ว C คือหนทางที่จะไป (เช่น FORTH สำหรับผู้ทำโทษตนเอง)

การรู้จัก C จะนำคุณเข้าใกล้โลหะมากเท่าที่คุณจะไปได้โดยไม่ต้องเข้าไปในแอสเซมเบลอร์และช่วยคุณในภาษาอื่น คุณมีความคิดที่ดีว่าฟังก์ชั่นเสมือนจริงของ C ++ นั้นทำงานอย่างไร คุณรู้ว่าเมื่อคุณเขียนฟังก์ชันเรียกซ้ำแบบ pass-by-value ใน PHP ซึ่งภายในนั้นมีการจัดสรรหน่วยความจำและการคัดลอกจำนวนมากดังนั้นคุณจึงลองใช้การอ้างอิงแบบอ้างอิงโดยสัญชาตญาณ การโทรกลับและการอ้างอิงไม่ได้ทำให้นักพัฒนา C คลั่งไคล้ Haskell อาจทำเช่นนั้น

ดังที่ Kernighan และ Ritchie ได้กล่าวไว้ในคำนำของภาษาซีคลาสสิกฉบับที่ 2 ซีไม่ใช่ภาษาใหญ่และไม่ได้รับการบริการที่ดีจากหนังสือเล่มใหญ่ ฉันกำลังพยายามทำตามคำแนะนำนี้: ตัวอย่างทำหน้าที่สองสามหรือมากกว่าถ้าเป็นไปได้

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

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

factoid

หินซี

ความยาว 0 ตัวอย่าง

โปรแกรมสร้างตัวเองที่สั้นที่สุดในโลกhttp://www.ioccc.org/1994/smr.hint

ความยาว 1 ตัวอย่าง

;

C ทำให้ความแตกต่างระหว่างการรวบรวมและการเชื่อมโยง เอนทิตีจำนวนมากใน C รวบรวมและเชื่อมโยงในภายหลัง - ตัวอย่างเป็นไลบรารีแบบคงที่และแบบไดนามิกทั้งหมด

เอนทิตีอื่นถูกรวมไว้และไม่สร้างรหัสด้วยตนเอง

เซมิโคลอนด้านบนจะรวบรวมเป็นรหัสวัตถุและไม่ทำอะไรเลย!

ความยาว 2 ตัวอย่าง

x;

C ซึ่งเป็นภาษาการเขียนโปรแกรมที่เก่ากว่าได้ผ่านการทำซ้ำหลายครั้ง การใช้งานที่แพร่หลายที่สุดได้รับการพัฒนาโดย Kernighan และ Ritchie และ K&R ตัวย่อ K&R C มีความโดดเด่นในการตั้งสมมติฐานจำนวนมากเกี่ยวกับรหัสของคุณหากคุณไม่ได้ระบุไว้อย่างชัดเจน

โดยเฉพาะอย่างยิ่งใน K&R C โค้ดข้างต้นจะถือว่าเป็นจำนวนเต็มทั่วโลกxเริ่มต้นที่ 0 รวบรวมในโหมด K&R จะผลิตไฟล์วัตถุที่ให้โปรแกรมใด ๆ ที่เชื่อมโยงกับตัวแปรนี้สำหรับการใช้งาน

ความยาว 3 ตัวอย่าง

??/

C แพร่หลายอย่างมากจนต้องมีคุณสมบัติความเข้ากันได้สำหรับระบบที่ไม่มีตัวอักษรทั้งหมดที่ใช้ ด้านบนเป็น trigraph สำหรับแบ็กสแลชซึ่งใช้ใน C เป็นอักขระที่ต่อเนื่องของบรรทัด ข้างต้นจะรวบรวมอาจมีคำเตือนว่าไม่มีบรรทัดต่อไปนี้

วัฒนธรรมที่พบบ่อยใน C คือการละเว้นคำเตือนการรวบรวมและฐานรหัสขนาดใหญ่จำนวนมากมักจะมีคำเตือนไม่กี่คำหรือมากกว่าเมื่อสร้างขึ้น

ความยาว 4 ตัวอย่าง

f();

อีกครั้งกับ K&R ข้างต้นคือ "กรอก" เพื่อหมายถึงการรวบรวมว่า "มีอยู่ด้วยการเชื่อมโยงทั่วโลกฟังก์ชั่นfที่จะให้ในภายหลังซึ่งจะใช้เวลาจำนวนคงที่ แต่ยังไม่ได้ระบุจำนวนอาร์กิวเมนต์

หมายเหตุ: f;ความแตกต่างพื้นฐานระหว่างนี้และ

ความยาว 5 ตัวอย่าง

s="";

K&R C มีชื่อเสียงในการให้อภัยอย่างแท้จริง เมื่อรวบรวมรหัสนี้จะให้จำนวนเต็มsสำหรับการเชื่อมโยงทั่วโลกซึ่งเริ่มต้นไปยังที่อยู่เริ่มต้นของสตริงที่ว่างเปล่า (ฉันคิดว่า) K&R จัดการกับการข่มขู่ทั้งหมดอย่างเงียบ ๆ รวมถึงการตัดถ้าจำนวนเต็มไม่ใหญ่พอที่จะเก็บที่อยู่

มันถูกสร้างขึ้นมาเหมือนสิ่งเหล่านี้ซึ่งได้สร้างบั๊กที่หายากจำนวนมากและให้แรงบันดาลใจมากมายในการแข่งขัน IOCCC

ความยาว 6 ตัวอย่าง

o=042;

gotcha ของตัวจับเวลาเก่าแม้ 0 นำหน้าในจำนวนตัวอักษรหมายถึงตัวเลขต่อไปนี้อยู่ในฐานแปด โค้ดข้างต้นเมื่อรวบรวมจะให้จำนวนเต็มoสำหรับการเชื่อมโยงทั่วโลกเริ่มต้นถึงทศนิยม 34

คุณสมบัติของ C นี้ได้กัดผู้พัฒนาหลายคนพยายามที่จะเพิ่มตัวเลขของพวกเขาเพื่อทำให้พวกเขาเข้าแถวได้ดีและยัง!

ความยาว 7 ตัวอย่าง

f(){f;}

รหัสข้างต้นเป็นฟังก์ชั่นที่มีร่างกาย แต่มันจะทำอะไร? มันดึงที่อยู่ของฟังก์ชั่นและไม่ทำอะไรเลย! โดยทั่วไปสิ่งที่ฟังก์ชั่นจะกลับมาไม่ได้กำหนด รหัสที่ไร้สาระเช่นนี้มักจะสามารถรวบรวมได้โดยไม่มีการเตือนล่วงหน้า

ความยาว 8 ตัวอย่าง

main(){}

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

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

ความยาว 9 ตัวอย่าง

#define Z

แกนนำหลักของไฟล์ส่วนหัว C คือ #defineคำสั่งของตัวประมวลผลล่วงหน้า โปรแกรม C คอมไพล์ในสเตจต่าง ๆ และหนึ่งในสเตจเหล่านี้นิยามเหล่านี้ถูกแทนที่ด้วยค่าจริง

เมื่อการโต้แย้งหายไป C จะบอกเป็นนัย1ดังนั้นข้างต้นจะแทนที่1ทุกที่Zใช้ในซอร์สโค้ด

โดยทั่วไปแล้วข้างต้นจะถูกใส่ลงในไฟล์ส่วนหัวและ#included ตามต้องการ

ความยาว 10 ตัวอย่าง

enum{P,Q};

enumคำหลักให้เป็นวิธีที่บางครั้งพิมพ์ปลอดภัยในการกำหนดชุดของคงตัว a เช่นเดียวกับการกำหนดพวกเขามักจะใช้ในไฟล์ส่วนหัว รหัสข้างต้นเมื่อรวมจะกำหนดPเป็นจำนวนเต็ม 0 และQ1

ความยาว 11 ตัวอย่าง

volatile v;

volatileคำหลักคือการปล่อยให้คอมไพเลอร์รู้ว่าตัวแปรที่อาจมีการเปลี่ยนแปลงโดยตัวแทนอื่น ๆ และจะไม่ทำให้สมมติฐานว่ามันจะยังคงอยู่อย่างต่อเนื่องระหว่างการเข้าถึง

ความยาว 12 ตัวอย่าง

#pragma once

#pragma once เป็นคำสั่ง preprocessor ที่ไม่ได้มาตรฐาน แต่ได้รับการสนับสนุนอย่างกว้างขวางเพื่อระบุว่าไฟล์ต้นฉบับปัจจุบันถูกรวมเพียงครั้งเดียวในการคอมไพล์ครั้งเดียว

เทคนิคดั้งเดิมและสนับสนุนอย่างเต็มที่คือการใช้#includeguards กับข้อเสียของรหัสเพิ่มและการปะทะกันชื่อที่เป็นไปได้

ความยาว 13 ตัวอย่าง

w(){for(;;);}

มีการประชุมจำนวนมากใน C และหนึ่งในนั้นคือวิธีการแสดงลูปไม่สิ้นสุด ในกรณีนี้for(;;)บ่งชี้ว่าไม่มีการเริ่มต้นไม่มีการตรวจสอบออกซึ่งเป็นค่าเริ่มต้นที่ 1 หมายถึงความจริง - คือไม่ทำลายและไม่มีรหัสวนลูป

บางครั้งเป็นไปได้ที่จะทำทุกอย่างภายใน ()วงและตัวมันเองไม่ต้องการร่างกาย ในกรณีนี้จะเพิ่มเซมิโคลอนดัมมีในตอนท้าย

ในโค้ดข้างต้นเมื่อรวบรวมมันจะให้ฟังก์ชั่นที่จะเข้าสู่การวนรอบไม่ว่างซึ่งเป็นหนึ่งในการออกแบบซอฟแวร์ที่ไม่มีใน - และไม่ส่งคืน

ความยาว 14 ตัวอย่าง

int a[]={1,2};

อาร์เรย์ใน C ไม่จำเป็นต้องระบุความยาว วงเล็บเหลี่ยมที่ว่างเปล่า[]บอกให้คอมไพเลอร์ "คิดออกเอง" อย่างไรก็ตามใน C ซึ่งแตกต่างจากภาษาอื่น ๆ ไม่มีวิธีในตัวที่จะป้องกันการเข้าถึงอาร์เรย์นอกขอบเขตเหล่านี้ซึ่งนำไปสู่การอุปมา "ยิงตัวเองในฝ่าเท้า" ที่ C เป็นที่รู้จักกัน

รหัสข้างต้นเมื่อรวบรวมจะให้อาร์เรย์ที่ไม่แน่นอนทั่วโลกaของสองจำนวนเต็มเริ่มต้นด้วย 1 และ 2

ความยาว 15 ตัวอย่าง

const long k=7;

constspecifer เป็นนอกจากนี้ในภายหลังเพื่อ C ที่ยืมมาจากภาษา C ++ คำถามสัมภาษณ์ทั่วไปคือ "มันเหมาะสมหรือไม่ที่จะกำหนดตัวแปรว่าเป็นvolatile const" constพร้อมกับenumและinlineมีวัตถุประสงค์เพื่อลดการพึ่งพา#defineซึ่งมีปัญหาเกี่ยวกับความปลอดภัยของประเภท

ความยาว 16 ตัวอย่าง

extern void **q;

externใช้เพื่อระบุว่ามีการประกาศตัวแปรที่อื่น void *ประเภทคือประเภททั่วไปมาตรฐานใน C ซึ่งหมายความว่ามันไม่จำเป็นต้องถูกทิ้งไว้อย่างชัดเจนหรือโยนจากในงบที่ได้รับมอบหมาย **ลำดับประกอบการหมายถึงตัวชี้ไปยังตัวชี้ซึ่งมักจะพัดจิตใจของมือใหม่ แต่เป็นอย่างดีที่ถูกต้องและมักจะใช้ซี

ความยาว 17 ตัวอย่าง

double d=4/3-1/3;

หากคุณจะพิมพ์ด้านบนผลลัพธ์จะเป็นหนึ่งและคุณคิดว่า super! เปลี่ยนเป็นdouble d=4/3-2/3;และอะไรคือคำตอบ? มันยังคงเป็นหนึ่ง! C กำลังใช้เลขคณิตเลขจำนวนเต็มเพื่อคำนวณ 4/3 → 1 และ 2/3 → 0 และ 1 - 0 → 1!

ความยาว 18 ตัวอย่าง

main(){puts("!");}

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

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

ความยาว 19 ตัวอย่าง

#include <stdlib.h>

การรวมไฟล์ส่วนหัวมักจะเป็นลายเซ็นส่วนตัวของนักพัฒนาซอฟต์แวร์ หลายคนรวมถึงlibและioไม่คำนึงว่าพวกเขามีความจำเป็น บางคำสั่งไฟล์ส่วนหัวเพื่อให้ความยาวเพิ่มขึ้นหรือลดลง ใส่ส่วนใหญ่ก่อน<> ""ส่วนตัวฉันใช้ลายเซ็นนี้ในวัน TA ของฉันเพื่อตรวจสอบการโกงในหมู่นักเรียน: ลายเซ็นส่วนหัวเดียวกัน มองใกล้ ๆ !

ความยาว 20 ตัวอย่าง

char*p=(char*)0x300;

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

ในโค้ดข้างต้นอยู่ของพอร์ตที่ถูกกำหนดให้เป็นเลขฐานสิบหก 300. คุณจะเข้าถึงค่าของพอร์ตโดยใช้*pในขณะ*p=0xff;ที่จะเปิดทุกบิตบนหรือv=*p;เพื่อดึงค่าปัจจุบัน

ความยาว 21 ตัวอย่าง

int w=sizeof(double);

sizeofผู้ประกอบการให้มีขนาดเป็นไบต์ของชนิด double d;int w=sizeof d;ด้วยชื่อตัวแปรวงเล็บไม่จำเป็นเช่น

ความยาว 22 ตัวอย่าง

asm("xorl %ecx,%ecx");

asmคอมไพเลอร์จะกำหนดวิธีการใช้งาน ด้านบนเป็นตัวอย่างโค้ด Linux gcc บนแพลตฟอร์ม Intel

Unix ดั้งเดิมมีขนาดเล็ก แต่ไม่สำคัญในรหัสในชุดประกอบ แม้กระทั่งทุกวันนี้ถ้าความเร็วเป็นสิ่งที่น่ากังวลและพกพาไม่ได้คุณจะเห็นว่ามันใช้แล้ว

ในระบบที่เข้ากันได้โค้ดข้างต้นจะรวบรวมและจะเป็นคำสั่งชุดประกอบแบบแยกตัวโดยไม่มีวิธีการเข้าถึงแบบดั้งเดิม! BTW xor R,Rเป็นสำนวนภาษาแอสเซมบลีทั่วไปสำหรับการล้างการลงทะเบียนอย่างรวดเร็ว

ความยาว 23 ตัวอย่าง

union u{char c;int i;};

unionจะให้อย่างน้อยพื้นที่มากพอสำหรับองค์ประกอบที่ใหญ่ที่สุด คุณอาจเห็นมันใช้ร่วมกับvoid *เพื่อให้ประเภท "opaque" ทั่วไปในไลบรารีบางอย่าง ในกรณีนี้สหภาพมักจะเป็นส่วนหนึ่งของโครงสร้างขนาดใหญ่โดยมีโครงสร้างที่มีเขตข้อมูลเพื่อระบุประเภทของสหภาพ

ความยาว 24 ตัวอย่าง

/*INTS*/int i,j,k;//INTS

ความคิดเห็น C ดั้งเดิมถูกคั่นด้วย/* comment */และยืม// comment to end of lineรูปแบบจาก C ++

ความยาว 25 ตัวอย่าง

int main(void){return 1;}

นี่เป็นตัวอย่างที่ตรงตามความยาว 8 ตัวอย่างด้านบน ระบุชนิดส่งคืนและประเภทฟังก์ชันและมีค่าที่ส่งคืนอย่างชัดเจน

การประชุมใน C คือการใช้ค่าตอบแทนของ0การประสบความสำเร็จและ1ความล้มเหลวหรือถ้าคุณต้องการที่จะเป็นอย่างเคร่งครัดสอดคล้องEXIT_SUCCESSและตามที่กำหนดในEXIT_FAILUREstdlib.h

ความยาว 26 ตัวอย่าง

typedef struct{int x,y;}P;

typedefมีประโยชน์อย่างยิ่งโดยเฉพาะ, typedef struct. ในแง่ที่ทันสมัยคุณอาจเรียกมันว่า "object-Orient-light"

หลังจากรวมข้างต้นรหัสสามารถใช้Pเป็นประเภทปกติในการประกาศและฟังก์ชั่นด้วยการตรวจสอบประเภทเต็ม ซึ่งแตกต่างจาก C ++ แต่คุณไม่สามารถกำหนดโอเปอเรเตอร์เช่น +, * หรือ << ดังนั้น "object-Orient-light"

ความยาว 27 ตัวอย่าง

#define C(x,y)(((x)+1)*(y))

C มี#defineไวยากรณ์มาโครที่สะดวก

ข้อผิดพลาด newbie ทั่วไปคือการละเว้นด้านในและ / หรือวงเล็บเหลี่ยมด้านนอกทำให้เกิดข้อผิดพลาดที่สำคัญกว่าผู้ประกอบการ

ความยาว 28 ตัวอย่าง

struct f{int s:1,e:8,m:23;};

C สามารถกำหนดบิตฟิลด์ได้อย่างชัดเจนซึ่งสามารถกำหนดและอ่านและจัดการเช่นจำนวนเต็มใด ๆ

ด้านบนเป็นการประมาณโครงสร้างข้อมูลจุดลอยตัวแบบกว้างเดี่ยวของ IEEE

ความยาว 36 ตัวอย่าง

f(unsigned x){return!!x&!(x&(x-1));}

ในหลายภาษาคุณไม่จำเป็นต้องสนใจว่าจะแสดงตัวเลขอย่างไร ใน C คุณจะต้องตระหนักถึงการเป็นตัวแทนภายในอย่างใกล้ชิด

ตัวอย่างที่ดีที่สุดของเรื่องนี้ที่ฉันคิดได้คือการพิจารณาว่าจำนวนเต็มเป็นพลังของสอง {1, 2, 4, 8, ... } ผู้ที่ไม่คุ้นเคยกับ C จะทำลูปและกะและทุกสิ่งสำหรับ O (log (n)) เวลาทำงานไม่เลว แต่ข้างบนเป็นฟังก์ชันที่จะทำเช่นเดียวกันใน O (1) เวลาทำงาน ฉันจะปล่อยให้มันเป็นแบบฝึกหัดสำหรับผู้อ่านเพื่อยืนยันว่ามันใช้งานได้ แต่มันไม่จริง ...

การ!!ประชุมมักจะใช้ในการบีบบังคับจำนวนเต็มจากที่ไม่ใช่ศูนย์และศูนย์ถึง 1 และ 0 ตามลำดับ นักพัฒนาซอฟต์แวร์ C หลายคนชอบที่จะใช้เทคนิคเหล่านี้ (มักจะเป็นไปได้ของผู้ที่ให้รหัสชัดเจน)

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

ความยาว 48 ตัวอย่าง

#include<complex.h>
double complex c=3.0+I*4.0;

C99 มีการรองรับหมายเลขที่ซับซ้อน อย่างที่คุณเห็นจากโค้ดมันใช้รูปแบบของตัวดัดแปลงสำหรับชนิดของจริง คุณสามารถใช้int complex c=3+I*4;แต่ภายในจะรวมกับชนิดจุดลอย รหัสดังกล่าวจะรวบรวมใน GCC gcc -std=c99 -c length-48.cใช้

หากคุณต้องการดู internals เพิ่มเติมลองรวบรวมด้วยสวิตช์ -E สำหรับรุ่นของฉัน GCC double _Complex c=3.0+(__extension__ 1.0iF)*4.0;ประกาศดังกล่าวข้างต้นจะกลายเป็น โปรดทราบว่าประเภทที่ซับซ้อนเป็นส่วนเพิ่มเติมที่สำคัญของภาษาไม่ใช่เพียงมาโครราคาถูกเพียงไม่กี่ตัว

นี่เป็นเพียงทีเซอร์เมื่อเราได้รับมากกว่า 125 ตัวอักษรจากนั้นเราสามารถเริ่มสนุกกับตัวเลขที่ซับซ้อน!

ความยาว 51 ตัวอย่าง

#include <math.h>
main(){double d=sqrt(sin(3.2));}

ด้วยเหตุผลต่าง ๆ C จะไม่เชื่อมโยงกับฟังก์ชันทางคณิตศาสตร์มาตรฐานโดยอัตโนมัติเช่น sin, cos, tan, sqrt เป็นต้นดังนั้นหากใช้ แต่ไม่เชื่อมโยงผู้พัฒนาจะถูกนำเสนอพร้อมข้อผิดพลาด linker ที่ไม่ได้กำหนด 'sqrt'หรือข้อผิดพลาดอื่น ๆ

ใน GCC gcc length-51.c -lmรหัสดังกล่าวข้างต้นจะรวบรวมและเชื่อมโยงการใช้

หมายเหตุsin(3.2)จะส่งคืนจำนวนลบซึ่งรากที่สองนั้นไม่ถูกต้องในโดเมนจริง ใน C ค่าพิเศษNaNจะถูกส่งกลับเพื่อระบุข้อผิดพลาดนี้ซึ่งโปรแกรมสามารถละเว้นได้ฟรี!

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

ความยาว 63 ตัวอย่าง

static int w;static int X(int x){static int s=0;s^=x;return s;}

หรือจัดรูปแบบมากขึ้นอย่างมีสติ:

static int w;
static int X(int x)
{
    static int s=7;
    s^=x;
    return s;
}

ดังที่คุณอาจเดาได้นี่คือทั้งหมดที่เกี่ยวกับคำหลักstaticที่มีความหมายมากกว่าหนึ่งใน C

ในสองกรณีแรกstaticกำลังบอกคอมไพเลอร์ว่าจำนวนเต็มwและฟังก์ชั่นXไม่สามารถมองเห็นได้นอกไฟล์นี้หรือหน่วยการรวบรวมนั่นคือภายใน

ฟังก์ชั่นเหล่านี้ไม่ได้มีวัตถุประสงค์ที่จะเรียกว่าภายนอกดังนั้นพวกเขาอาจไม่ตรวจสอบข้อโต้แย้งเพื่อความถูกต้องและตัดมุมอื่น ๆ เนื่องจากมีขอบเขตภายในคุณสามารถกำหนดใหม่wและXในไฟล์อื่น ๆ และโดยทั่วไปจะแยกกัน

ในกรณีสุดท้ายstaticบ่งชี้ว่าจำนวนเต็มsเก็บค่าระหว่างการเรียกใช้ฟังก์ชัน ครั้งแรกที่Xเรียกว่าsจะเป็นค่าเริ่มต้น7เมื่อมันเป็นเอกสิทธิ์ - ORed ด้วยxค่าใหม่จะถูกเก็บไว้

ภายในแม้ว่าจะขึ้นอยู่กับการนำไปใช้งานการจัดระเบียบหน่วยความจำตามปกติคือที่sอยู่บนฮีปซึ่งเป็นหน่วยความจำที่เริ่มต้นโดยเฉพาะขณะที่อาร์กิวเมนต์xอยู่ในสแต็ก ตัวแปรที่มีความสำคัญหากคุณต้องการใช้อัลกอริทึมแบบเรียกซ้ำตัวอย่างเช่น

gotcha ใน C เป็นการปะทะกันกับตัวแปรทั่วโลก จนกระทั่งwและXมีการกำหนดจริงstaticหากพวกเขาถูกกำหนดทั่วโลกที่ไหนสักแห่งแล้วwและXจะอ้างถึงหน่วยงานระดับโลกแทน

ที่นี่qและwอาจไม่สามารถเริ่มต้นเป็นค่าเดียวกันได้เนื่องจากมีการใช้ทั่วโลกในwการตั้งค่าq:

static int q = w;
static int w;

หากwไม่มีโกลบอลการรวบรวมควรล้มเหลว

ที่นี่qและwจะเริ่มต้นเป็นค่าเดียวกัน:

static int w;
static int q = w;

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

ใน C99 staticได้รับประโยชน์อีกอย่างหนึ่งเช่นint Y(int a[static 10]);ซึ่งหมายความว่ามีฟังก์ชั่นYที่ใช้อาร์เรย์อย่างน้อย 10 จำนวนเต็ม

ความยาว 74 ตัวอย่าง

void f(register int*p,register int*q,register int l){while(l--)*p++=*q++;}

หรือวางไว้อย่างสวยงาม:

void f(register int *p, register int *q, register int l)
{
    while (l--)
        *p++ = *q++;
}

คำสำคัญregisterให้คำแนะนำแก่คอมไพเลอร์ที่ใช้การลงทะเบียนฮาร์ดแวร์จะเป็นประโยชน์ที่นี่ ฟังก์ชั่นด้านบนจะคัดลอกlจำนวนเต็มจากqไปpโดยใช้การลงทะเบียนฮาร์ดแวร์ถ้าเป็นไปได้

บางครั้งการเพิ่มความเร็วอาจมีนัยสำคัญ ยกตัวอย่างเช่นในครอบครัวไมโครโปรเซสเซอร์ 68K เส้น*p++ = *q++อาจจะแปลให้เป็นคำสั่งเดียวกับหกหรือแปดถ้าคุณไม่ได้ใช้MOVE.W (Ap)+,(Aq)+ register68K ไมโครโปรเซสเซอร์ที่มีการโพสต์อย่างชัดเจนเพิ่มขึ้นและ pre-พร่องโหมดเพื่อให้นักพัฒนาเข้าใจถ้าเขารู้ว่าแพลตฟอร์มจะปรับแต่งโดยใช้รหัสx++และ--yเทียบกับและ++xy--

วันนี้คอมไพเลอร์ส่วนใหญ่ไม่สนใจregisterนอกจากที่ไม่อนุญาตให้ใช้ที่อยู่ของพวกเขา (เช่นในข้างต้น&lอาจทำให้เกิดข้อผิดพลาดของคอมไพเลอร์)

ความยาว 88 ตัวอย่าง

#include<stdio.h>
int f(int x){return(x>1)?x*f(x-1):1;}int main(){printf("%d\n",f(12));}

หรือด้วยเลย์เอาต์ saner:

#include <stdio.h>

int f(int x)
{
    return (x > 1)? x * f(x - 1): 1;
}

int main()
{
    printf("%d\n", f(12));
}

อ้าการสอบถามซ้ำ! ตัวอย่างเป็นโปรแกรมที่สมบูรณ์ในการรวบรวมเชื่อมโยงและเรียกใช้ ฟังก์ชันfคำนวณค่าแฟกทอเรียลของอาร์กิวเมนต์xโดยใช้สูตรแบบเรียกซ้ำ f (x) = x * f (x - 1) แฟคทอเรียลมีขนาดใหญ่ขึ้นอย่างรวดเร็วดังนั้นตัวอย่างเช่นf(12)ค่าที่ใหญ่ที่สุดที่คุณจะได้รับในจำนวนเต็ม 32 บิต

สำหรับตัวอย่างของจริงรหัส recursive มองเข้าไปในการใช้งานที่ไร้เดียงสาของฟังก์ชั่น Ackermann

คอมไพเลอร์อัจฉริยะสามารถปรับฟังก์ชั่นให้เหมาะสมโดยใช้คำใบ้inlineและ "ปลด" ฟังก์ชั่นเมื่อค่าคงที่ถูกจัดให้เป็นอาร์กิวเมนต์เพื่อ:

f(12)

กลายเป็น:

12 * 11 * 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1

ไม่มีการเรียกใช้ฟังก์ชันใด ๆ !

คอมไพเลอร์อื่น ๆ สามารถปรับฟังก์ชั่นใหม่ได้:

int f(int x)
{
    return (x < 2)? 1: f(x - 1);
}

และใช้สิ่งที่เรียกว่าการเรียกซ้ำแบบหาง สิ่งนี้มีผลแทนที่การเรียกใช้ฟังก์ชันสุดท้ายเป็น goto แบบง่ายและให้ฟังก์ชันนั้นจัดการกับการส่งคืน ประโยชน์ที่ได้รับคือการฟาดฟันน้อยลงเร็วขึ้นและเล็กลง

ในภาษาแอสเซมบลีโอกาสในการปรับให้เหมาะสมเหล่านี้ง่ายต่อการสังเกตและสามารถนำไปใช้ได้โดยสิ่งที่เรียกว่า "keyhole optimizer" ซึ่งโดยทั่วไปแล้วจะมองหารูปแบบขนาดเล็กและแทนที่ด้วยสิ่งที่เร็วกว่าและ / หรือเล็กกว่า

ความยาว 117 ตัวอย่าง

#include<stdio.h>
int main(int c,char**v){int a,b;sscanf(v[1],"%d%*[\t ,]%d",&a,&b);printf("%d\t%d\n",a,b);return 0;}

หรือ:

#include <stdio.h>

int main(int c, char **v)
{
    int a, b;

    sscanf(v[1], "%d%*[\t ,]%d", &a, &b);
    printf("%d\t%d\n", a, b);

    return 0;
}

C ยืมมาจากภาษาร่วมสมัยในเวลาแนวคิดของ I / O สากลที่สามารถนำไปใช้อย่างต่อเนื่องกับอุปกรณ์ใด ๆ ไม่ว่าจะเป็นคอนโซล, บัตรเจาะ, เทป, แผ่นดิสก์หรือเครื่องพิมพ์ แต่ในรูปแบบ C จริงมันอนุญาตให้นักพัฒนาเพื่อสร้าง งบสั้น ๆ แต่ทรงพลัง

ในตัวอย่างข้างต้นมันจะใช้อินพุตบรรทัดคำสั่งแยกสองจำนวนเต็มคั่นด้วยช่องว่างแท็บหรือเครื่องหมายจุลภาคและส่งออกพวกเขา ใช้ประโยชน์จากตัวscanfระบุที่ใหม่กว่า%*[\t ,]ซึ่งจะ: [\t ,]ดึงแท็บช่องว่างและเครื่องหมายจุลภาคทั้งหมดและ: *ละเว้นออก

ผมจำได้ว่าการแก้ไขบางรหัส c ++ ที่นักพัฒนาได้ทำทุกอย่าง "บริสุทธิ์" C ++ ทางกับ<<และคลังแสงของวิธีการเช่นและfind substrอย่างน้อยหนึ่งโหลเส้นและยังคงไม่สามารถจัดการจุลภาคเป็นตัวคั่น ฉันแทนที่โค้ด clunky ทั้งหมดด้วยsscanfบรรทัดเดียวเหมือนด้านบน!

ความยาว 132 ตัวอย่าง

#include<stdio.h>
int main(int c,char**v){while(--c){++v;printf("|%s|\n|%5s|\n|%-5s|\n|%.5s|\n|%5.5s|\n",*v,*v,*v,*v,*v);}return 0;}

หรือ:

#include <stdio.h>

int main(int c, char **v)
{
    while (--c)
    {
        ++v;
        printf("|%s|\n|%5s|\n|%-5s|\n|%.5s|\n|%5.5s|\n", *v, *v, *v, *v, *v);
    }

    return 0;
}

ฟังก์ชั่นprintf, sprintf, fprintfspecifiers ฯลฯ รูปแบบการใช้งานที่จะกำหนดความกว้างและช่องว่างของการส่งออก

รวบรวมและเรียกใช้ข้างต้นโดยใช้อาร์กิวเมนต์บรรทัดคำสั่งเพื่อดูผลลัพธ์ต่างๆ:

> main xyz 123456
|xyz|                                                                                                                                                
|  xyz|                                                                                                                                              
|xyz  |                                                                                                                                              
|xyz|                                                                                                                                                
|  xyz|                                                                                                                                 
|123456|                                                                                                                                             
|123456|                                                                                                                                             
|123456|                                                                                                                                             
|12345|                                                                                                                                              
|12345| 

สังเกตการ.5จำกัด เอาท์พุทสำหรับตัวระบุสูงสุดไม่เกินห้าตัวอักษรในขณะที่ส่วนนำ5ทำให้มั่นใจได้ว่าเอาต์พุตจะมีอย่างน้อยห้าตัวอักษรพร้อมกับ-ระบุการจัดตำแหน่งด้านซ้าย การรวมพวกมันเข้าด้วยกันตั้งเอาท์พุทที่ตัวอักษรห้าตัว

รหัสเครื่อง x86

factoid:

x86 รหัสเครื่องเป็นแอสเซมบลี x86 รุ่นประกอบที่ตัวประมวลผลทำงานจริง ได้รับการพัฒนากลับมาเมื่อหน่วยความจำและพื้นที่จัดเก็บที่มีราคาแพงและได้รับการออกแบบมาเพื่อจะค่อนข้างเข้ากันได้ย้อนกลับไปตลอดทางจนถึงอินเทล 8008. รักษารหัสปฏิบัติการขนาดเล็กเป็นหนึ่งในเป้าหมายและมันใช้คำแนะนำความยาวของตัวแปรและสถาปัตยกรรม CISCที่จะช่วยให้ บรรลุเป้าหมายนี้ (ซึ่งมีข้อเสียเปรียบในการทำให้ซับซ้อนยิ่งขึ้นเพื่อปรับปรุงประสิทธิภาพของโปรเซสเซอร์สมัยใหม่) สิ่งนี้พร้อมกับธรรมชาติของการประกอบและรหัสเครื่องโดยทั่วไปทำให้โปรแกรม x86 มีความสามารถที่กะทัดรัด

ความยาว 1:

ตอนนี้สำหรับโปรแกรมแรก:

0xC3

เปิดตัวแก้ไข hex ป้อนไบต์นั้นและบันทึกเป็น test.com

ตอนนี้คุณมีโปรแกรม MS-DOS ที่ถูกต้องซึ่งจะส่งกลับทันทีโดยไม่ต้องทำอะไรเลยเนื่องจาก 0xC3 เป็นคำสั่ง 'RET' อย่างไรก็ตามนี่แสดงให้เห็นอีกแง่มุมที่น่าสนใจสำหรับการเล่นกอล์ฟด้วย x86: รูปแบบไฟล์. com รูปแบบที่รันได้นี้ไม่มีส่วนหัว - ไฟล์จะถูกโหลดลงในหน่วยความจำเริ่มต้นจากที่อยู่ 0x100 และจากนั้นจะเริ่มต้นการดำเนินการที่ 0x100 ซึ่งหมายความว่าไม่มีไบต์ที่สูญเสียไปกับข้อมูลเมตา!

ความยาว 2:

โปรแกรมต่อไปของเรา:

0x4D 0x5A

หรือ 'MZ' ใน ASCII

ตกลงฉันโกงนิดหน่อยนั่นไม่ใช่โปรแกรมที่มีประโยชน์จริงๆเพราะมันสอดคล้องกับคำแนะนำ

DEC     BP
POP     DX

ซึ่งไม่มีประโยชน์สำหรับการเริ่มโปรแกรม. com ที่จริงแล้วนั่นคือจุดรวมของสองค่า - ไม่มีไฟล์. com ที่เหมาะสมควรเริ่มด้วย! .com ไฟล์ถูก จำกัด ขนาด 65280 ไบต์ (64KiB - 0x100) ดังนั้นเมื่อเริ่มโปรแกรมที่มีขนาดใหญ่ขึ้นจำเป็นต้องมีการพัฒนารูปแบบใหม่ นี่เป็นรูปแบบไฟล์. exe ซึ่งมีส่วนหัว อย่างไรก็ตาม MS-DOS จำเป็นต้องเก็บนามสกุล. com ไว้บนส่วนประกอบบางอย่างเพื่อให้สามารถใช้งานร่วมกับระบบย้อนหลังได้ดังนั้นจึงจำเป็นต้องมีวิธีการตรวจสอบว่าไฟล์. com นั้นเป็น. exe พวกเขาเลือก sting 'MZ' เป็นหมายเลขเวทย์มนตร์นี้และจนถึงทุกวันนี้หากคุณเปิดไฟล์ Windows .exe (หรือ. dll) ในโปรแกรมแก้ไข hex คุณจะเห็นว่าพวกเขาเริ่มต้นด้วยสองไบต์ มันทำให้ฉันประหลาดใจว่าแม้แต่โปรแกรม Windows ที่ทันสมัยที่สุดก็เริ่มด้วยข้อ จำกัด ด้านความเข้ากันได้จากยุค 70

ความยาว 3:

ตอนนี้สำหรับการวนซ้ำไม่สิ้นสุด:

41 E2 FD

ซึ่งแปลว่า

start:
inc cx
loop start 

โปรแกรมนี้จะเพิ่มค่าของ CX (ซึ่งจะเป็น> 0 ถึงเริ่มต้นด้วย) จากนั้นเรียกใช้คำสั่งลูป Loop เป็นตัวอย่างที่ยอดเยี่ยมของคำสั่ง CISC เนื่องจากมันรวมการทำงานง่าย ๆ 3 อย่างไว้ในการดำเนินงานที่มีวัตถุประสงค์พิเศษเพียงอย่างเดียวนั่นคือการลดค่าของ CX ตรวจสอบว่าเป็น 0 หรือไม่และข้ามไปยังป้ายเป้าหมายถ้าไม่ นอกจากนี้ยังมีรูปแบบของการวนรอบที่ตรวจสอบการตั้งค่าสถานะอื่น ๆ นอกเหนือจากการสิ้นสุดเมื่อ CX เป็น 0 เราสามารถทำเพียง 'เริ่มต้นกระโดด' สำหรับวงวนไม่สิ้นสุดที่ 2 ไบต์ แต่นี่น่าสนใจกว่า

ความยาว 4:

โปรแกรมที่มีประโยชน์น้อยที่สุด:

40 CD 10 C3

แปลเป็นชุดประกอบ:

inc ax    ; 1 byte
int 10h   ; 2 bytes
ret       ; 1 byte

โปรแกรมนี้ตั้งค่าคอนโซลเป็นตัวอักษร 40x25 ล้างหน้าจอแล้วกลับไปที่บรรทัดคำสั่ง AX ถูกตั้งค่าเป็นโหมดวิดีโอที่เราต้องการ (1) จากนั้น BIOS ขัดจังหวะ 10 ชม. ถูกเรียกให้ตั้งค่าโหมดวิดีโอ & ล้างหน้าต่างก่อนกลับมา คาดว่าจะเห็นการขัดจังหวะ BIOS ต่อไปในอนาคต

ความยาว 5:

ตอนนี้เราสามารถใช้โปรแกรมหยุดชั่วคราว:

B4 01 CD 21 C3

แปลเป็นชุดประกอบ:

mov ah,1  ; 2 bytes
int 21h   ; 2 bytes
ret       ; 1 byte

โปรแกรมนี้บอกให้ BIOS รอให้กดคีย์และ echos ไปที่หน้าจอก่อนกลับมา นี่แสดงให้เห็นถึงวิธีการที่ x86 สมาชิกบางคนสามารถอ่านหรือเขียนได้บางส่วน ในกรณีนี้เราตั้งค่าไบต์สูงสุดของ AX (AH) เป็น 1 ในตัวประมวลผล 32 บิตคุณสามารถทำงานบน 16 บิตต่ำโดยไม่มีผลต่อ 16 บิตด้านบน ความสามารถในการปรับเปลี่ยนการลงทะเบียนบางส่วนนี้สามารถเป็นประโยชน์สำหรับโปรแกรมเมอร์แอสเซมบลี แต่มีข้อบกพร่องสำหรับโปรเซสเซอร์ที่ทันสมัยพยายามดำเนินการออกคำสั่งเนื่องจากพวกเขาสามารถแนะนำการพึ่งพาข้อมูลเท็จ

ความยาว 9:

ตอนนี้จะแสดงผลลัพธ์:

68 00 B7 07 AB 40 79 FC C3

แปลเป็นชุดประกอบ:

; These two instructions set up ES, the 'extra segment'
push 0xb700 ; 3 bytes
pop  es     ; 1 byte
label:
stosw       ; 1 byte, Store Word - Copy AX to [ES:DI] then add 2 to DI
inc  ax     ; 1 byte
jns  label  ; 2 bytes, Jump Not Signed - Jump unless the sign flag is set (when inc AX yields 0x8000
ret         ; 1 byte

ผลลัพธ์คือชุดอักขระเริ่มต้นที่ทำซ้ำในสีที่ต่างกัน ไบต์ต่ำของ AX คือรหัสตัวอักษรและไบต์สูงระบุสีที่จะใช้

โปรแกรม 16 บิตสามารถจัดการได้ถึง 64KiB โดยตรง ในการหลีกเลี่ยงปัญหานี้ x86 ใช้ 'เซกเมนต์' - รีจิสเตอร์พิเศษที่จะถูกคูณด้วย 16 และเพิ่มการเข้าถึงหน่วยความจำทั้งหมดเพื่อให้หน่วยความจำที่สามารถกำหนดแอดเดรสได้ 20 บิต โปรแกรมสามารถเปลี่ยนค่าของการลงทะเบียนเซกเมนต์เหล่านี้เพื่อเข้าถึงหน่วยความจำเพิ่มเติม - หรือพื้นที่หน่วยความจำพิเศษ: โปรแกรมนี้แก้ไขเซกเมนต์พิเศษเพื่อเขียนลงในหน่วยความจำวิดีโอ การเข้าถึงหน่วยความจำประเภทต่าง ๆ ใช้การลงทะเบียนเซกเมนต์ที่ต่างกันทำให้สามารถเข้าถึงรหัสข้อมูลและสแต็กในหน่วยความจำที่แตกต่างกันในเวลาเดียวกัน ส่วนเริ่มต้นอาจถูกแทนที่ด้วยคำแนะนำมากมาย

ความยาว 20:

ลองทำอะไรที่จำได้เราจะใช้ 'Rule 90' ​​เพื่อวาดสามเหลี่ยม Sierpinski

B0 13 CD 10 68 0F A0 1F AC 31 C2 88 94 3E 01 87 D3 93 EB F4

ในการชุมนุม:

mov al,13h      ; 2b
int 10h         ; 2b - Set the video mode to 13h

push    0xA00F  ; 3b
pop     ds      ; 1b - Set the data segment to video memory

start:          ; This loop runs 'Rule 90' to draw Sierpinski triangles
lodsb           ; 1b - load al with [ds:si] then increment si

xor     dx,ax   ; 2b - xor the left and right values of the previous row of pixels
mov     [si+318],dl ;4b - store result to memory

xchg    dx,bx   ; 2b - swap register values
xchg    ax,bx   ; 1b - swapping with ax is 1 byte shorter

jmp     start   ; 2b - infinite loop

ตัวอย่างผลลัพธ์:

สำหรับโปรแกรมนี้เราใช้ 'โหมด 13' ที่โด่งดัง - โหมดกราฟิกที่มีความละเอียด 320x200 กับ 256 สี มันถูกใช้โดยเกม DOS ยอดนิยมมากมายเช่น Doom

ความยาว 21

มาดูกันว่าใครเป็นผู้ผลิตซีพียูที่เรากำลังใช้งานอยู่

0F A2 66 60 BB EE FF B9 0C 00 8A 17 43 B4 02 CD 21 E2 F7 FF E1

แปลเป็นชุดประกอบ:

cpuid         ; 2b  CPU ID - retrieve processor information based on the value in AX. For AX=0,
              ;     the 12 bytes in EBX, ECX, and EDX are loaded with a vendor identification string
pushad        ; 2b  Push all registers on the stack (32 bit version)
mov  bx,0xffee; 3b  Start of the vendor identification string on the stack
mov  cx,12    ; 3b  12 characters to print
print:    
mov  dl,[bx]  ; 2b  Character to print
inc  bx       ; 1b  Advance string position
mov  ah,2     ; 2b  Set AH to the 'Print character to STDOUT' value
int  21h      ; 2b  Call the bios interrupt to print
loop print    ; 2b  Decrement CX and jump if it is not zero
jmp  cx       ; 2b  Instead of restoring the stack, just jump right to the exit point

ตัวอย่างผลลัพธ์:

c:\misc>cpuid.com
GenuineIntel

โปรแกรมนี้ใช้คำสั่ง CPUID เพื่อรับข้อมูลเกี่ยวกับโปรเซสเซอร์ที่กำลังทำงานโดยเฉพาะสตริงการระบุผู้ขาย คนส่วนใหญ่จะเห็น 'GenuineIntel' หรือ 'AuthenticAMD' เว้นแต่ว่าพวกเขาจะมีผู้ผลิตซีพียูที่ผิดปกติหรือกำลังทำงานอยู่ในเครื่องเสมือนบางเครื่อง

ความยาว 26

ตอนนี้เราสามารถทำแอนิเมชั่นที่น่าสนใจ

B0 13 CD 10 C4 07 BB 40 01 59 99 89 F8 F7 F3 31 D0 AA E2 F6 26 FE 05 47 EB FA

ในการประกอบ

mov al,13h     ;2b
int 10h        ;2b Enter Video Mode 13h

les ax,[bx]    ;2b Set ES to (roughtly) video memory
mov     bx,320 ;3b Set up  BX asdivisor
pop     cx     ;1b Zeroize CX

start:
cwd            ;1b Sign extend AX to DX, AX will never have the sign bit set so this zeroizes DX in 1 byte
mov     ax,di  ;2b Copy video memory pointer
div     bx     ;2b Divide by width to get AX = Y pos, DX = X pos
xor     ax,dx  ;2b X pos ^ Y pos
stosb          ;1b Store and increment video pointer
loop    start  ;2b CX starts at 0, so this will loop until it wraps around

cycle:
inc     byte [es:di];3b Increment value in video memory to animate
inc     di     ;1b Increment video memory pointer
jmp     cycle  ;2b Infinite loop 

และผลลัพธ์จะเป็นดังนี้:

ฟังก์ชั่น X pos ^ Y pos สร้างเศษส่วนที่น่าสนใจโดยเฉพาะเมื่อเคลื่อนไหว

ความยาว 27

ไม่เพียง แต่คุณสามารถสร้างข้อความและกราฟิกในโปรแกรม x86 .com ขนาดเล็กคุณยังสามารถสร้างเสียงและเพลงได้ด้วย:

BA 31 03 B0 3F EE BA 30 03 B0 93 EE B4 01 CD 21 3C 1B EE 3C 1B B0 7F EE 75 EC C3

ในการชุมนุม:

    mov dx,0x331            ; value for the midi control port
    mov al,0x3F             ; command value to set midi mode to UART
    out dx,al               ; output the command to the midi control port
play_loop:
    mov dx,0x330            ; value for the midi data port
    mov al,0x93             ; midi instrument value (piano)
    out dx,al               ; output to midi data port
    mov ah,1
    int 0x21                ; read character from stdin, with echo
    cmp al,27               ; test if it is escape
    out dx,al               ; output the ascii value as the midi note to play
    mov al,0x7F             ; note duration
    out dx,al               ; output note duration
    jne play_loop           ; loop if escape was not pressed
    ret  

โปรแกรมนี้ใช้การ์ด midi เพื่อเปลี่ยนคีย์บอร์ดเป็นเปียโน ในการทำสิ่งนี้การ์ด midi ถูกตั้งค่าเป็นโหมด UART ซึ่งจะเล่น midi โน้ตทันทีที่ได้รับ จากนั้นโปรแกรมจะรอให้อักขระถูกกดและส่งออกค่า ASCII เป็นบันทึกไปยัง midi card โปรแกรมจะทำงานจนกว่าจะกดปุ่ม Escape

ความยาว 29

ลองใช้ระบบฟังก์ชั่นที่ทำซ้ำเพื่อสร้างเศษส่วน Dragon Curve:

B0 13 CD 10 89 D0 01 CA 29 C1 D1 FA D1 F9 73 03 83 E9 7A B4 01 CD 16 B8 02 0C 74 E6 C3

แปลเป็นชุดประกอบ:

mov  al,13h
start:
int  0x10    ; This does double duty, setting the video mode to 13h at program start,
             ; and calling the 'draw pixel at coordinates' interrupt when looping
mov  ax,dx   ; The next couple instructions are our IFS, the algorithm is aproximately
add  dx,cx   ; f(y) = 0.5x + 0.5y
sub  cx,ax   ; f(x) = 0.5x - 0.5y OR f(x) = 0.5x - 0.5y - 1
sar  dx,1    ;
sar  cx,1    ;
jnc  skip    ; This jump handles pseudo-randomly switching between the two functions for x,
             ; based on if the previous value of x was odd or not.
sub  cx,122  ; Magic number, chosen since it provides sufficent 'randomness' for a filled in
             ; fractal and a good scale to the fractal. 102 and 130 also work.
skip:
mov  ah,1
int  0x16    ; Get keyboard state, zero flag will be set if no key has been pressed
mov  ax,0xC02; Set up AH for the draw pixel function when int 0x10 is executed,
             ; AL = color, CX = column, DX = row
jz   start   ; Loop if a key hasn't been pressed
ret  

เอาท์พุท:

การกดคีย์ที่ไม่ได้ควบคุมจะทำให้โปรแกรมออกจากโปรแกรม นี่เป็นพื้นฐานของFire Coralโดย Desire บน Pouet.net

ความยาว 52

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

B3 07 D9 E8 B1 11 DE 0E 32 01 E2 FA BE 0A 24 56 B1 09 DF 34 AC D4 10 
86 E0 05 30 30 50 E2 F5 44 B4 2E 50 89 E2 B4 09 CD 21 FE 06 03 01 4B
75 D2 CD 20 0A 00

เมื่อเรียกใช้โปรแกรมจะส่งออกค่าคงที่ทางคณิตศาสตร์หลายค่า:

1.00000000000000000
3.32192809488736235
1.44269504088896341
3.14159265358979324
0.30102999566398120
0.69314718055994531
0.00000000000000000

เหล่านี้คือ One, Log2 (10), Log2 (e), Pi, Log10 (2), Log e (2) และ Zero

ในการชุมนุม:

org 100 ชม

mov     bl,7         ;Counter for the total number of constants to print
start:
fld1                 ;Floating point constant to load on the FP stack,
                     ;start with 1 since it's op-code is the lowest

mov     cl,17        ;Multiply the constant by 10, 17 times to get the
mult:                ;printing part as an integer
fimul   word[ten]
loop    mult

mov     si,10+'$'*256;ASCII new line (10) and the end-of-string ($)
                     ;characters. These are used both as
push    si           ;a constant memory location, and stored to the
                     ;stack to format and printing

mov     cl,9         ;print 18 digits (9 pairs)
fbstp   [si]         ;store the integer part of the floating point
                     ;number on top of the FP stack as a packed
                     ;binary-coded decimal number (1 digit/nibble),
                     ;and then pop the number off the FP stack

convert:
lodsb                ;load a pair of packed digits

db 0xd4,16 ; AAM 16  ;ASCII Adjust For Multiply instruction using
                     ;non-standard base 16. This puts AL/16 in AH,
                     ;and AL%16 in AL, unpacking the digit pair.

xchg    ah,al        ;Swap the digit order
add     ax,'00'      ;Convert the digits to ASCII values
push    ax           ;Store digits on the stack
loop    convert

inc     sp           ;AX now holds the 1st 2 digits to print,
mov     ah,'.'       ;so to insert a decimal point, the 2nd digit
push    ax           ;is replaced with a '.', the stack pointer
                     ;is adjusted to overwrite 1 byte, and then
                     ;AX is pushed on the stack

mov     dx,sp        ;Load DX with the start of the print string
mov     ah,9         ;Load AH with the 'Print String' constant
int     21h          ;Call the 'Print String' interrupt to display
                     ;the constant

inc     byte[start+1];Self-modifying code - increment the load
                     ;floating point constant op-code to iterate
                     ;through all of them

dec     bx
jnz     start        ;Exit when all 7 constants have been printed
int     20h


ten: dw  10

คณิตศาสตร์จุดลอยตัวในระบบ x86 ได้รับการจัดการโดยตัวเลือก x87 ร่วมโปรเซสเซอร์มันไม่ได้จนกว่า 486 ว่ามันถูกย้ายไปยังชิปตัวเดียวกัน x87 ยังมีสถาปัตยกรรมที่แตกต่างกันค่อนข้างเป็นแบบ stack-based โดยมีรีจิสเตอร์ 80 บิต 8 ตัว นอกจากนี้ยังมีโหมดการปัดเศษความแม่นยำและข้อยกเว้นแบบสวมได้ที่สามารถตั้งค่าได้หลากหลาย

โปรแกรมนี้พิมพ์ค่าสำหรับค่าคงที่เจ็ดค่าที่อบเข้าไปในโปรเซสเซอร์ อาจดูแปลกว่าพื้นที่การเรียนการสอนจะสูญเปล่าในค่าคงที่แบบง่ายเช่น 0 และ 1 แต่โปรดจำไว้ว่าชุดคำสั่งนั้นถูกสร้างขึ้นเมื่อหน่วยความจำมีขนาดเล็กและโดยทั่วไปคำแนะนำเหล่านี้จะมีขนาดเล็กกว่า 2 ไบต์ โปรแกรมยังใช้คำสั่งที่คลุมเครือ FBSTP -'Store BCD Integer and Pop ' ย้อนกลับไปเมื่อ x86 ได้รับการพัฒนาการดำเนินการกับตัวเลขBCDเป็นเรื่องธรรมดามากขึ้นและ x86 / x87 มีคำแนะนำหลายอย่างเพื่อลดความซับซ้อนของคณิตศาสตร์ BCD เช่น AAM 'ASCII Adjust for Multiple' ยังใช้ในโปรแกรม

ในโมเดลหน่วยความจำที่ไม่มีการป้องกันที่ใช้โดยโปรแกรม x86 รุ่นแรกไม่มีความแตกต่างระหว่างข้อมูลและรหัส ด้วยเหตุนี้จึงง่ายต่อการวนซ้ำตามคำแนะนำ 'โหลดค่าคงที่' ที่เข้ารหัสตามลำดับโดยเพียงเพิ่มค่าที่เหมาะสม

ความยาว 64

ข้ามการโพสต์รายการของฉันสำหรับMandelbrot Challengeโปรแกรมสามารถเขียนได้ที่แสดงเศษส่วน Mandelbrot สีขนาด 320x200 ใน 64 ไบต์เท่านั้น

B0 13 CD 10 C4 07 99 89 F8 B9 40 01 F7 F1 83 E8 64 FE CE 31 DB 31 F6 
89 F5 0F AF F3 01 F6 0F AF DB 70 19 0F AF ED 70 14 01 EB 70 10 29 EB
29 EB C1 FB 06 01 D3 C1 FE 06 01 C6 E2 DB 91 AA EB C6

ในการชุมนุม:

mov al,13h ; set up graphics mode 13
int 10h

les ax,[bx]; trick to set video memory

FillLoop:
cwd
mov ax,di  ; di is the current position on screen
mov cx,320 ; convert di int x,y screen coordinates
div cx     ; CX is the iteration counter, exit the loop if it hits
           ; zero before the value escapes.
sub ax,100 ; center the fractal vertically
dec dh     ; center the fractal horizontally

xor bx,bx
xor si,si

MandelLoop: ; Fairly standard Mandelbrot routine,
mov bp,si   ; exits if the values overflow
imul si,bx
add si,si
imul bx,bx
jo MandelBreak
imul bp,bp
jo MandelBreak
add bx,bp
jo MandelBreak
sub bx,bp
sub bx,bp

sar bx,6   ; We use fixed point math with the lowest 6
add bx,dx  ; bits being the fractional portion, so this
sar si,6   ; rescales the values after multiplication
add si,ax

loop MandelLoop

MandelBreak:
xchg ax,cx ; Write the escape itteraction as the color
stosb
jmp FillLoop

ผลลัพธ์ที่ได้คือภาพนี้:

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

Haskell

คุณอาจต้องการอ่านจากล่างขึ้นบน บางครั้งฉันอ้างอิงกลับไปยังตัวอย่างที่ต่ำกว่า แต่ไม่เคยไปที่ตัวอย่างที่สูงกว่าดังนั้นมันอาจช่วยทำความเข้าใจ

ผู้อ่านที่ไม่รู้จัก Haskell: ฉันชัดเจนหรือไม่ ฉันไม่ชัดเจนเมื่อไหร่ ฉันไม่สามารถบอกได้

ความยาว 86 ตัวอย่าง

อินสแตนซ์พับเก็บได้สำหรับโครงสร้างข้อมูลทรีของเรา (ตัวอย่าง 23) การพับเก็บได้เป็นประเภทคลาส - ตามชนิดคลาส (/ กลุ่ม) สิ่งเหล่านี้ขนานกับอินเตอร์เฟสใน Java โดยทั่วไปแล้วพวกเขาจะพูดถึงประเภทประเภทที่รวมกันซึ่งมีลักษณะทั่วไป; ตัวอย่างเช่นพวกเขาสามารถเพิ่มเข้าด้วยกัน ( Monoid), ภาชนะ ( Functor) สามารถพิมพ์เป็นข้อความ ( Showซึ่งเราได้พบแล้วในshowฟังก์ชั่น) และอื่น ๆ อันนี้รวมชนิดข้อมูลที่มีลักษณะเป็นลิสต์ซึ่งสามารถวนซ้ำหรือแบนเป็นรายการได้

ในตัวอย่างนี้เรากำหนดอินสแตนซ์โดยการกำหนดfoldrซึ่งเป็นหลักซ้ำประเภทข้อมูลจากขวาไปซ้าย ตอนนี้เราสามารถใช้โค้ดที่เขียนล่วงหน้าทั่วไปจำนวนมากได้ s a = N E a Eครั้งแรกที่เรากำหนดหน้าที่ผู้ช่วยที่จะได้รับต้นไม้เดี่ยวเพื่อหลีกเลี่ยงความยุ่งเหยิงทั้งหมด: ขณะนี้:

sum (N (s 3) 7 (N E 5 (s 8))     === 23
product (N (s 3) 7 (N E 5 (s 8)) === 840
toList (N (s 3) 7 (N E 5 (s 8))  === [3,7,5,8]

และอื่น ๆ

นี่คือภาพต้นไม้ของเรา:

7
| \
3  5
    \
     8

ความยาว 70 ตัวอย่าง

primes=sieve[2..] where
 sieve(p:xs)=p:sieve(filter(\x->x`mod`p/=0)xs)

นี่คือตะแกรงที่ดีที่สุด!

(หมายเหตุ: /=เป็น!=ภาษาอื่น ๆ )

วิธีนี้ใช้งานได้โดยการกำหนดฟังก์ชั่นsieveที่กรองรายการและเก็บเฉพาะตัวเลขที่ไม่สามารถหารได้ด้วยนายกคนก่อน ๆ มันถูกกำหนดซ้ำ - เพื่อsieveถูกกำหนดให้เป็นในการแยกรายการเพื่อเป็นองค์ประกอบแรกpและหางกรองจากหางหมายเลขใด ๆ หารด้วยp, sieveบิตที่เหลือแนบpกับจุดเริ่มต้นของการที่และผลตอบแทน

อีกครั้งเรากำลังทำงานกับรายการที่ไม่มีที่สิ้นสุดที่นี่ - แต่การคำนวณจะหยุดลงทันทีตราบใดที่คุณไม่ต้องใช้จำนวนเฉพาะของจำนวนเฉพาะเพื่อคำนวณ

take 4 primes === [2,3,5,7]

ความยาว 68 ตัวอย่าง

ในที่สุด quine!

main=do putStr s;print s where s="main=do putStr s;print s where s="

ในครั้งแรกที่คุณอ่านสิ่งนี้คุณอาจคิดว่าผลลัพธ์ของควินินนี้จะหายไปจากเครื่องหมายคำพูดและทำไมคุณถึงเขียนputStrครั้งเดียวprint? มันฟังเหมือนกัน

ใน Haskell putStrเป็นฟังก์ชั่นที่เพิ่งพิมพ์เนื้อหาของสตริงที่ได้รับเพื่อ stdout; printแม้ว่าจะพิมพ์สิ่งต่าง ๆ เพื่อ stdout ดังนั้นจึงprint 4เทียบเท่ากับputStr "4\n"แต่putStr 4ไร้สาระ - 4ไม่ใช่สตริง! ดังนั้นเมื่อprintรับค่ามันจะแปลงเป็นสตริงก่อนแล้วจึงพิมพ์สตริงนั้น โดยทั่วไปวิธีการแปลงสิ่งต่าง ๆ เป็นสายอักขระคือค้นหาวิธีที่คุณจะเขียนลงในโค้ด ดังนั้นวิธีที่คุณจะเขียนสตริงabcในสตริงในรหัส Haskell คือ"abc"ดังนั้นprint "abc"จริงพิมพ์ไม่"abc"abc

_{โชคดีที่ฉันมีคะแนนเสียงเพียงพอตอนนี้ฉันจะไม่ต้องตีสิ่งเหล่านี้}

ความยาว 33 ตัวอย่าง:

main=go 0
go n=do print n;go(n+1)

สิ่งสำคัญที่ควรทราบคือเราไม่ได้ใช้การวนซ้ำ Haskell ไม่วนซ้ำ Haskell เกิดขึ้นอีกครั้ง Haskell ไม่มีลูป มันลึกกว่าที่: Haskell ไม่ได้มีการควบคุมการไหล คุณอาจถามว่าอย่างไร มันไม่ต้องการอะไรเลย

เมื่อด้วยรายละเอียด โปรแกรมนี้พิมพ์ลำดับเลขจำนวนเต็มเพิ่มขึ้นแบบไม่ จำกัด โดยเริ่มจาก 0 goพิมพ์โดยเริ่มต้นด้วยอินพุตจากนั้นmainเรียก0ใช้

doเป็นพลัง syntax แบบพิเศษของ Haskell ในสถานการณ์นี้มันเพียงรวมการกระทำของ I / O เช่นเดียวกับที่>>ทำได้ (ดูตัวอย่างที่ 22)

ความยาว 26 ตัวอย่าง:

map f=foldr(\x y->f x:y)[]

mapฟังก์ชั่นนี้กำหนดฟังก์ชั่นที่ทุกคนคุ้นเคยfoldrกันดี โปรดสังเกตว่าแม้ว่าเราจะไม่ได้ประกาศmapประเภทของคอมพิวเตอร์ แต่อย่างใดรู้ว่าประเภทของมันคือ(a -> b) -> [a] -> [b]ได้รับฟังก์ชั่นจากaถึงbและรายการa s, กลับรายการของbs

รู้ได้ยังไง ?? ;-)

ความยาว 25 ตัวอย่าง:

main=putStr"Hello World"

มาตรฐาน Hello World หมายเหตุประเภท: mainมีประเภทIO ()และputStrมีประเภทString -> IO () (ฟังก์ชั่นจากสตริงการกระทำของ I / O ที่กลับไม่มีอะไร)

ความยาว 23 ตัวอย่าง:

data T a=E|N(T a)a(T a)

นี่คือคำจำกัดความมาตรฐานของต้นไม้ ง่ายกว่าบรรทัดทั้งหมดที่จำเป็นต้องใช้เพื่อกำหนดแผนผังใน Java, C หรือสิ่งอื่นใด

(ดูตัวอย่าง 10)

มาทำลายมันกันเถอะ:

data- ประกาศนี้ประกาศประเภทข้อมูล T a- aต้นไม้ที่มีองค์ประกอบของประเภท นี่คือประเภทที่เรากำหนด =- ค่าของทุกT aจะใด ๆ |ต่อไปนี้แยกออกจากท่อ E- หนึ่งในค่าที่เป็นไปได้ของT s- ต้นไม้ว่าง N (T a) a (T a)- ค่าที่เป็นไปได้อื่น ๆ ของทรี - โหนด แต่ละโหนดประกอบด้วยลูกซ้าย ( (T a)) องค์ประกอบ (a ) และลูกขวา ( (T a))

ความยาว 22 ตัวอย่าง:

main=putStrLn"y">>main

yesฟังก์ชั่น Haskell >>เป็นตัวดำเนินการที่รวมและลำดับการกระทำของ I / O สองรายการ >> :: IO a -> IO b -> IO bมันมีการพิมพ์ของ

mainมีการกำหนดซ้ำโดยตัวเองเป็น I / O การกระทำที่พิมพ์ครั้งแรก"y"และจากนั้นทำสิ่งที่mainตัวเองทำ

ความยาว 18 ตัวอย่าง:

fix f=r where r=f r

fixความหมายที่ดีกว่าสำหรับ (ดูตัวอย่างที่ 14. ) ปัญหาเกี่ยวกับคำจำกัดความแรกfix f = f(fix f)คือทุกครั้งที่เราเรียกการเรียกfix f fixคืนที่เรียกคืนfix fซึ่งfix fสร้างสำเนาที่ไม่มีที่สิ้นสุดของการคำนวณเดียวกัน เวอร์ชั่นนี้แก้ไขได้โดยการกำหนดr(ผลลัพธ์) ให้เป็นผลลัพธ์ เช่นf r = rนี้ r = f rดังนั้นขอกำหนด rตอนนี้เรากลับมา

ความยาว 17 ตัวอย่าง:

f n=product[1..n]

นี่คือวิธีการทำงานเพื่อกำหนดแฟกทอเรียล

ความยาว 16 ตัวอย่าง:

f n=(\x->x+x+x)n

(\x -> x + x + x)เป็นแลมบ์ดา (มีคนคิดว่า\คล้ายกับจดหมาย)

(\x -> x + x + x) nเป็นแลมบ์ดาที่นำไปใช้กับn(นี่เป็นสิ่งเดียวกันกับn + n + n)

fเป็นฟังก์ชั่นคูณด้วยสาม (ยังf = (*3))

ความยาว 15 ตัวอย่าง:

sum=foldl (+) 0

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

อีกวิธีที่จะคิดเกี่ยวกับการพับเป็นเหมือน 'การแทรก' การพับfระหว่างค่ารายการและการสะสมเริ่มต้นในด้านใดด้านหนึ่ง ยกตัวอย่างเช่นการประเมินfoldl (*) 1 [4,2,5]1 * 4 * 2 * 5

ความยาว 14 ตัวอย่าง:

fix f=f(fix f)

เครื่องคอมyบิเนเตอร์ มันมักจะเป็นชื่อfixเพราะมันพบ fixpoint f x = xของสมการ โปรดทราบว่าx = infinite loopบางครั้งยังสามารถแก้ปัญหาได้ดังนั้นfix (\x -> x^2 + 5*x + 7)จะไม่แก้สมการx^2 + 4*x + 7 = 0แต่กลับส่งกลับวนซ้ำไม่สิ้นสุด

คุณอาจสังเกตว่าx = infinite loopการแก้ปัญหาไม่ได้เสมอไปเพราะความเกียจคร้านของ Haskell

รุ่นนี้เป็นเวลาและพื้นที่รั่วไหล เราจะกำหนดมันใหม่ในตัวอย่างที่ยาวขึ้น

ความยาว 13 ตัวอย่าง:

f=sum.map(^2)

สิ่งนี้จะกำหนดฟังก์ชั่น fที่ให้รายการส่งคืนผลรวมของกำลังสองของมัน มันเป็นฟังก์ชั่นการประกอบของฟังก์ชั่น sumและฟังก์ชั่นmap(^2)ซึ่งในทางกลับกันคือฟังก์ชั่นที่ mapใช้กับฟังก์ชั่น (^2) ( ฟังก์ชั่นสแควร์ ) ซึ่งจะอยู่ในส่วนของฟังก์ชั่น ^ (ส่วนที่ถูกนำมาใช้ในข้อมูลโค้ด 2 และองค์ประกอบที่ข้อมูลโค้ด 3 )

ที่คุณสามารถดู, ฟังก์ชั่นที่มีความสำคัญมากทีเดียวในการทำงานภาษาเช่น Haskell ในความเป็นจริงจะได้รับการกล่าวว่า Haskell ภาษาที่มีมาตรฐานห้องสมุดส่วนใหญ่ฟังก์ชั่นที่ได้รับหน้าที่เป็นปัจจัยการผลิตหรือการกลับมาฟังก์ชั่นเป็นเอาท์พุท (นี้เป็นที่รู้จักกันทั่วไปว่าเป็นลำดับที่สูงกว่าฟังก์ชั่น

โดยทางเทคนิคแล้วฟังก์ชั่นอาร์กิวเมนต์สองตัวหรือมากกว่านั้นเป็นฟังก์ชันที่ส่งคืนฟังก์ชันเป็นเอาต์พุต

ความยาว 10 ตัวอย่าง:

data B=T|F

นี่คือคำจำกัดความของ Haskell booleans ที่มีชื่อแตกต่างกัน Bชนิดบูลีนเป็นชื่อ
คำจำกัดความนี้แนะนำตัวสร้างสองตัว: true ( T) และ false ( F)
ส่วนย่อยของโค้ดนี้จะบอกคอมไพเลอร์ว่าบูลีน ( B) ทุกตัวเป็นจริง ( T) หรือเท็จ ( F) หรือกล่าวอีกนัยB=T|Fหนึ่ง

ในความเป็นจริงชนิดข้อมูลทั้งหมดสามารถกำหนดได้ใน Haskell เมื่อในภาษาอื่น ๆ จำนวนการอ้างอิงและชนิดข้อมูลอาร์เรย์ต้องการการสนับสนุนพิเศษจากคอมไพเลอร์ ในทางปฏิบัติมีการสนับสนุนพิเศษใน Haskell เนื่องจากอาจไม่สะดวกเป็นอย่างมาก แต่ตัวอย่างเช่นBoolประเภทข้อมูลนั้นถูกกำหนดเป็นภาษาทั้งหมด

ความยาว 9 ตัวอย่าง:

main=main

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

ข้อเท็จจริงที่สนุกสนานคือคอมไพเลอร์ GHC Haskell สามารถตรวจจับลูปไม่สิ้นสุดชนิดเหล่านี้และโยนข้อยกเว้น catchable (!) เมื่อรัน

ความยาว 8 ตัวอย่าง:

f(x:_)=x

สิ่งนี้จะกำหนดฟังก์ชั่นfที่ให้รายการที่ไม่ว่างเปล่าซึ่งจะส่งคืนหัวของมัน

รูปแบบใน Haskell เป็นเหมือนการเรียงลำดับของ Python แต่เป็นการสรุปสำหรับทุกประเภท รูปแบบสามารถปฏิเสธหรือจับคู่ค่าและถ้าจับคู่ก็สามารถผูกตัวแปรกับค่าได้

รูปแบบในตัวอย่างนี้คือ:

• _: รูปแบบที่ตรงกับสิ่งใดและผูกตัวแปร
• x: xรูปแบบที่ผูกอะไรและผูกมันให้กับตัวแปร
• :: รูปแบบนี้เข้ากับรูปแบบของเด็กนั่นคือหนึ่งสำหรับหัวและอีกส่วนสำหรับหาง หากรายการไม่ว่างเปล่ามันจะจับคู่กับหัวและหาง

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

ความยาว 5 ตัวอย่าง:

x=2:x

โอ้โหมีคำอธิบายมากมายเหลือเกิน

ก่อนอื่น Haskell ขี้เกียจ ซึ่งหมายความว่านิพจน์ย่อยจะได้รับการประเมินเมื่อจำเป็นเท่านั้น

หมายเหตุ:ข้อมูลโค้ดนี้ไม่แสดงการมอบหมาย แต่เป็นคำจำกัดความ Haskell ไม่มีงานที่มอบหมาย

ข้อมูลโค้ดนี้กำหนดเป็นรายการที่ไม่มีที่สิ้นสุดทำขึ้นทั้งหมดx 2โดยทั่วไปแล้วในภาษาอื่นxจะต้องได้รับการประเมินก่อน2:xที่จะได้รับการประเมิน แต่ใน Haskell เราสามารถทำได้

รายการที่ไม่มีที่สิ้นสุดของ Haskell เป็นการเรียงลำดับของตัววนซ้ำและรายการเชื่อมโยงปกติ: มันทำหน้าที่เหมือนทั้งคู่ (การวนซ้ำในช่วงจะใช้หน่วยความจำคงที่เป็นต้น)

ความยาว 4 ตัวอย่าง:

2:[]

ข้อมูลโค้ดนี้เพียง encodes [2]รายการเดี่ยว :เป็นผู้ประกอบการConsใน Haskell ในความเป็นจริงไวยากรณ์รายการปกติเป็นเพียงน้ำตาลประโยคสำหรับผู้ประกอบการ cons และตัวอักษรรายการที่ว่างเปล่า สิ่งนี้ผูกมัดอย่างแน่นหนาในวิธีที่ Haskell จัดการกับการจับคู่รูปแบบและชนิดข้อมูล (โดยเฉพาะอย่างยิ่งแนวคิดของตัวสร้าง)

ความยาว 3 ตัวอย่าง:

f.g

ใน Haskell .ย่อมาจากองค์ประกอบของฟังก์ชั่น Haskell สามารถเขียนในรูปแบบ "ปลอดจุด" ซึ่งมีลักษณะเฉพาะโดยไม่ตั้งชื่ออาร์กิวเมนต์ของฟังก์ชันและใช้ตัว.ดำเนินการเพื่อควบคุมการไหลของข้อมูลแทน

ความยาว 2 ตัวอย่าง:

1-

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

ความยาว 1 ตัวอย่าง:

1

ใน Haskell, 1สามารถเป็นทั้งInt, Float, Double, Wordและอื่น ๆ ในความเป็นจริงคุณสามารถเขียนโค้ดเพื่อกำหนดเวอร์ชันของ1ประเภทใดก็ได้และใช้งานได้อย่างอิสระ
สิ่งนี้ทำใน JavaScript, Python และอื่น ๆ แต่ไม่เหมือนที่ทำด้วยความปลอดภัยเต็มรูปแบบ

factoid:

ในขั้นต้นคณะกรรมการ Haskell ตั้งใจจะเรียกภาษา "แกง" ตามชื่อของ Haskell B. Curry แต่ตัดสินใจที่จะเปลี่ยนชื่อเป็น Haskell เพราะอาจมีบางอย่างเกิดขึ้น หลังจากนั้นพวกเขาก็สังเกตเห็นความคล้ายคลึงกันของ Haskell กับ "ปาสกาล" และ "ยุ่งยาก"!

C #

C # คือการผสมผสานคุณสมบัติที่สนุกและบ้าคลั่งจาก Java, C, Haskell, SQL, และภาษาอื่น ๆ อีกมากมายและให้คุณสมบัติและ API ที่ดีมาก ๆ มันยังเป็นที่รู้จักกันดีในเรื่องของความสวยงาม แต่เราจะเห็นสิ่งที่เราสามารถทำได้!

ฉันจะไม่สนใจแผ่นสำเร็จรูปปกติที่จำเป็น:

class Program { public static void Main(string[] args) { ... } }

ความยาว 1:

;

คำสั่งถูกยกเลิกด้วยเครื่องหมายอัฒภาคใน C #! บรรทัดว่างเป็นไวยากรณ์ที่ถูกต้องสมบูรณ์

ความยาว 5:

x=5f;

เมื่อคุณระบุตัวเลขตามตัวอักษรใน C # คอมไพเลอร์จะถือว่าพวกเขาเป็น ints หรือ doubles (ขึ้นอยู่กับว่าพวกเขามีจุดทศนิยม) หากคุณต้องการใช้ทุ่นลอยตามตัวอักษรคุณควรระบุว่าโดยการใส่ 'f' ต่อท้ายหมายเลขหรือจะถูกส่งในช่วงรันไทม์ทำให้มีค่าใช้จ่ายเล็กน้อย

ความยาว 7 (ไบต์):

s=@"
";

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

ความยาว 8:

()=>x=y;

การแสดงออกนี้เป็นฟังก์ชั่นที่ไม่ระบุชื่อ ส่งคืนออบเจ็กต์ประเภทActionที่สามารถส่งผ่านได้และเรียกว่าฟังก์ชัน ฟังก์ชั่นไม่ระบุชื่อสืบทอดขอบเขตที่พวกเขาถูกประกาศและพวกเขาดึงตัวแปรท้องถิ่นใด ๆ ในขอบเขตนั้นกับพวกเขาไปทุกที่

ความยาว 9:

(a)=>a.p;

นี่คือฟังก์ชั่นนิรนามอีกตัวที่ใช้พารามิเตอร์และคืนค่า นิพจน์จะส่งคืนออบเจ็กต์ประเภทFunc(Func จะคืนค่าประเภทของตัวเองa.pคุณจะใช้Funcจำนวนมากเพื่อเชื่อมต่อกับ Linq

ความยาว 10:

enm.Any();

นี่เป็นครั้งแรกที่เรารู้จัก Linq! Linq เป็นชุดของวิธีการขยายที่สามารถเรียกบนวัตถุใด ๆ ที่เป็นนับ (การใช้อินเตอร์เฟซ IEnumerable บริการ) - ชอบและArray ListIEnumerable ใช้การประเมินที่ขี้เกียจ: ผ่านคอลเลกชันทีละรายการโดยไม่ทราบเกี่ยวกับการรวบรวมทั้งหมด - อาจไม่มีที่สิ้นสุด!

นั่นคือที่Anyมา - มันกลับมาtrueถ้า Enumerable มีอย่างน้อย 1 รายการ ดีกว่าการคำนวณความยาวทั้งหมด

ความยาว 11:

var a=1.5f;

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

ความยาว 15:

yield return 0;

นี่คือคำแถลงที่คุณอาจไม่ค่อยคุ้นเคย คุณรู้ว่าวัตถุสามารถนับได้โดยการรับ IEnumerable แต่คุณรู้หรือไม่ว่าฟังก์ชันนั้นสามารถนับได้? ประกาศฟังก์ชันที่มีชนิดส่งคืนเป็นIEnumerableและมีyield returnหลายครั้งตามที่คุณต้องการ เมื่อคุณได้รับ Enumerator เข้าสู่ฟังก์ชั่นการเรียกแต่ละครั้งเพื่อให้GetNextโปรแกรมเรียกใช้โค้ดทั้งหมดจนถึงครั้งต่อไปyield returnให้ส่งคืนค่านั้นแล้วหยุดชั่วคราวจนกว่าคุณจะเลื่อนไปข้างหน้าอีกครั้ง คุณใช้yield breakเพื่อสิ้นสุดการทำซ้ำ

ความยาว 16:

[Obsolete]int a;

ตัวอย่างนี้แสดงคุณลักษณะ แอตทริบิวต์เป็นแท็กประเภทหนึ่งที่คุณสามารถใช้กับการประกาศใด ๆ ในรหัสของคุณ aบางคนสั่งให้คอมไพเลอร์ที่จะทำบางสิ่งบางอย่างเช่นนี้ที่ปล่อยออกมาเตือนเลิกถ้าคุณโทร คุณสามารถสร้างของคุณเองโดยการขยายAttributeและคุณสามารถค้นหาได้โดยใช้การสะท้อน (อาจเพิ่มเติมในภายหลัง) คุณสามารถไป meta และ จำกัด ประเภทของการประกาศที่สามารถใช้กับAttributeUsageแอตทริบิวต์ได้

ความยาว 17

c.Count(t=>t==3);

นี่คือวิธีการเล่นกอล์ฟที่สะดวก กำหนดFuncที่แมองค์ประกอบของการนับcไปboolก็จะส่งกลับจำนวนขององค์ประกอบในcที่ที่ผลตอบแทนFunc trueดีกว่าการเขียนลูป

ความยาว 18:

foreach(T t in c);

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

ความยาว 19

c.Select(t=>t.a/2);

นี่คือฟังก์ชัน 'แผนที่' ของคุณสำหรับแฟน ๆ ที่ใช้งานโปรแกรม Select เป็นวิธีที่รัดกุมในการทำการแปลงโดยพลการ (กำหนดโดยการFuncส่งผ่าน) ในแต่ละองค์ประกอบของการแจกแจง มันจะส่งคืน IEnumerable ที่จะคายองค์ประกอบ "ที่ถูกแปลง" เมื่อคุณวนซ้ำ

ความยาว 21

Console.Write("Hi!");

บรรทัดนี้เขียนข้อความถึง stdout และอาจเป็นหนึ่งในเหตุผลหลักที่ C # ไม่ได้ใช้ในการเล่นกอล์ฟมากนัก!

ความยาว 23

typeof(T).GetMethods();

C # รองรับคุณสมบัติที่ทรงพลังมากที่เรียกว่า Reflection Reflection ช่วยให้คุณตรวจสอบโครงสร้างของรหัสของคุณในขณะทำงาน ตัวอย่างเช่นการเรียกนี้จะส่งกลับอาร์เรย์ของวิธีการทั้งหมดในประเภทที่ระบุ คุณสามารถตรวจสอบวิธีการเหล่านั้นเรียกพวกเขาหรือแม้กระทั่งปรับเปลี่ยนค่าของเขตข้อมูลและคุณสมบัติ คุณสมบัติ (ดูความยาว 16) เป็นวิธีที่ดีในการติดแท็กบางส่วนของรหัสของคุณเพื่อใช้กับ Reflection

ความยาว 25

from t in c select t.a/2;

นั่นคือ SQL ใช่ไหม ในรหัส C #? ค่อนข้างใกล้ การแสดงออกนี้ทำสิ่งเดียวกับที่ความยาว 19

ความยาว 27

for(var l;;l=new object());

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

ความยาว 29

var e=Enumerable.Range(0,99);

Enumerable.Rangeเป็นฟังก์ชั่นสนามกอล์ฟที่มีประโยชน์ มันส่งกลับโครงสร้างที่สามารถแจกแจงและจะให้ผลแต่ละตัวเลขในช่วงที่ระบุตามลำดับ พารามิเตอร์ที่สองคือการนับไม่ใช่ดัชนี

ความยาว 31

public int pr{get;private set;}

ที่นี่เราสามารถแสดง 'คุณสมบัติ' ง่าย ๆ คุณสมบัติ OOP และจุดเด่นอีกประการหนึ่งของ C # หากคุณเคยใช้ Java คุณอาจใช้วิธี 'รับ' และ 'ตั้ง' สำหรับเขตข้อมูลเพื่อแยกการช่วยการเข้าถึงหรือเรียกใช้รหัสเมื่อมีการเปลี่ยนแปลง ดี C # ช่วยให้คุณประกาศรหัสที่ด้านบนของเขตข้อมูลและยังตั้งตัวแยกการเข้าถึงแยกต่างหากสำหรับการรับและการตั้งค่า ตัวอย่างนี้จะสร้างตัวเริ่มต้นและผู้ตั้งค่าเริ่มต้นโดยอัตโนมัติ แต่ทำให้ตัวตั้งค่าเป็นแบบส่วนตัว

ความยาว 32

public static void m(this T o){}

ตัวอย่างนี้แสดงคุณลักษณะ C # ที่ดีสำหรับการออกแบบ API ด้วยการใช้thisตัวดัดแปลงกับพารามิเตอร์แรกของวิธีการแบบสแตติกวิธีนั้นจะกลายเป็นวิธี "ส่วนขยาย" เมื่อสิ่งนี้ถูกประกาศT.mสามารถเรียกใช้บนวัตถุชนิด T ใด ๆ ราวกับว่าเป็นวิธีการของ T ซึ่งสามารถใช้เพื่อเพิ่มฟังก์ชันการทำงานใหม่ให้กับคลาสที่มีอยู่ใด ๆ โดยไม่ต้องแก้ไขหรือแม้กระทั่งเข้าถึงรหัสต้นฉบับของมัน

ความยาว 38

int f(int a,ref int b,out int c){c=0;}

วิธีการนี้จะแสดงพารามิเตอร์ประเภทต่างๆผ่านคุณสามารถมีใน C # พารามิเตอร์ที่ไม่มีการแก้ไขจะผ่านค่า พารามิเตอร์ที่นำหน้าด้วยrefจะถูกส่งผ่านโดยการอ้างอิง: คุณสามารถกำหนดวัตถุใหม่ให้กับพวกเขาและพวกเขาจะดำเนินการกลับออกมาจากวิธีการ พารามิเตอร์ที่นำหน้าโดยoutเป็นเหมือนค่าตอบแทนเพิ่มเติม: คุณจะต้องกำหนดค่าในวิธีการและพวกเขาจะดำเนินการออกมาเช่นเดียวกับพารามิเตอร์อ้างอิง

ความยาว 42

Console.Write("It is \{DateTime.Now()}.");

มาตรฐาน C # 6 ใหม่ช่วยให้คุณประหยัดอักขระบางตัวเมื่อคุณต้องส่งออกสตริงที่ประกอบโดยใช้การแก้ไขสตริง คุณลักษณะนี้ช่วยให้คุณสามารถเขียนนิพจน์ใด ๆ ในวงเล็บปีกกาภายในสตริงตัวอักษรและสตริงจะถูกประกอบโดยอัตโนมัติด้วยค่าของการแสดงออกเหล่านั้นที่รันไทม์

ความยาว 48

IEnumerable f(){for(int a=0;;)yield return a++;}

ตอนนี้มีตัวละครมากพอที่จะทำอะไรบางอย่างโดยมีจุดประสงค์จริง! วิธีการนี้ใช้แนวคิดบางอย่างที่เราสำรวจไว้ข้างต้นเพื่อสร้าง Enumerable นับไม่ถ้วนที่จะส่งกลับจำนวนเต็มแบบหนึ่งต่อหนึ่งเริ่มต้นด้วย 0 โปรดจำไว้ว่า C # ใช้การประเมินแบบขี้เกียจกับ Enumerables ดังนั้นลำดับอนันต์จึงสมบูรณ์ วนซ้ำตามลำดับที่คุณต้องการและแบ่งออกได้ตลอดเวลา

ความยาว 56

int p{get{return mP;}set{mP=Math.Max(value,0);}};int mP;

นี่เป็นอีกตัวอย่างของ 'คุณสมบัติ' (ดูตัวอย่าง 31) ที่นี่ฉันได้กำหนดตัวอย่างโค้ดที่แตกต่างกันgetและsetแทนที่จะใช้โค้ดอัตโนมัติเหมือนเดิม ตัวอย่างนี้แสดงวิธีที่คุณสามารถใช้คุณสมบัติเพื่อตรวจสอบความถูกต้องของค่าที่กำหนดให้กับตัวแปร - ที่นี่ค่าไม่ได้รับอนุญาตให้น้อยกว่า 0 การใช้คุณสมบัติอื่น ๆ ที่ดี ได้แก่ การแจ้งเหตุการณ์เมื่อมีการเปลี่ยนแปลงค่าหรือสร้างค่าแคชใหม่ ที่อาจเป็นไปตามนี้

ความยาว 65

int v;public static implicit operator int(Program o){return o.v;}

คุณลักษณะนี้เรียกว่าการส่งโดยนัย มันเป็นเหมือนวิธีการขยายที่มันเป็นรหัสคงที่ที่ทำงานในชั้นเรียนที่เฉพาะเจาะจง (ดูตัวอย่าง 32) อย่างไรก็ตามการส่งโดยนัยไม่ได้ใช้โดยเรียกมัน - มันถูกใช้อย่างง่าย ๆ โดยการจัดการProgramวัตถุเป็นจำนวนเต็ม (เช่นint i=new Program()) เมื่อคุณทำสิ่งนี้วัตถุจะถูกแปลงอย่างเงียบ ๆ เป็นประเภทที่คุณใช้เป็นตามรหัสในการส่งโดยนัย วิธีปฏิบัติที่ดีที่สุดบอกว่าจะทำเช่นนี้ก็ต่อเมื่อไม่มีการสูญหายของข้อมูลอันเป็นผลมาจากการแปลง

ชวา

ความยาว 44 ตัวอย่าง

Object a=System.out.append("Hello, World!");

พิมพ์Hello, World!ไปยัง STDOUT

ความยาว 43 ตัวอย่าง

float[][][][][]a=new float[5][3][7][2][10];

aมี 10 อาเรย์ซึ่งแต่ละอันมี 2 อาเรย์ซึ่งแต่ละอันมี 7 อาเรย์ซึ่งแต่ละอันมี 3 อาร์เรย์ซึ่งแต่ละอันมี 5 floatเอส

ความยาว 42 ตัวอย่าง

interface A{static void main(String[]a){}}

โปรแกรมที่สมบูรณ์ เนื่องจากทุกอย่างใน a interfaceนั้นเป็นเนื้อแท้publicเราจึงสามารถละเว้นคำpublicจากวิธีหลักได้

ความยาว 36 ตัวอย่าง

class A{class B extends A{B.B.B b;}}

ABมีระดับชั้น A.Bซึ่งหมายความว่าเราสามารถประกาศตัวแปรประเภท

แต่Bเป็น subclass ของAซึ่งหมายความว่ามันมีทั้งหมดของวิธีการเขตการเรียนภายในและAของ ดังนั้นเราสามารถอ้างถึงประเภทB.Bเช่นกัน

ในรหัสนี้เราใช้ขั้นตอนนี้เพิ่มเติมและให้BตัวแปรประเภทB.B.Bเช่น

คุณธรรม: การทำตามคำถามที่ร้อนแรงใน SO สามารถสอนเทคนิคที่น่าสนใจมากมายให้คุณได้ถ้าไร้จุดหมาย

ความยาว 35 ตัวอย่าง

l.stream().map("a"::equals).count()

หากเป็นรายการของสายนี้บอกเราว่าคนอีกจำนวนมากที่เท่าเทียมกันl"a"

ความยาว 34 ตัวอย่าง

public static void main(String[]a)

ลายเซ็นวิธีการของวิธีการหลักของโปรแกรม มีเพียง 11 ตัวอักษรและเราสามารถสร้างโปรแกรมที่สมบูรณ์!

ความยาว 33 ตัวอย่าง

enum D {NORTH, EAST, SOUTH, WEST}

NORTH, EAST, SOUTHและมีค่าคงที่ทุกประเภทWESTD

ความยาว 32 ตัวอย่าง

Files.readAllBytes("hello.txt");

อ่านไฟล์ทั้งหมดแล้วส่งคืนbyte[]เนื้อหา

ความยาว 31 ตัวอย่าง

new String(new char[]{'h','i'})

"hi"เทียบเท่ากับ มีประโยชน์ถ้า"กุญแจเสียหาย

ความยาว 30 ตัวอย่าง

new JFrame().setVisible(true);

สร้างเฟรมที่มองเห็นได้ใหม่ซึ่งคุณสามารถวางองค์ประกอบอื่น ๆ ลงใน

ความยาว 29 ตัวอย่าง

throws ClassNotFoundException

บังคับให้ใช้วิธีการที่เรียกว่าทุกคนที่จะใช้try- catchบล็อกหรืออื่น ๆ ที่จะผ่านข้อผิดพลาดขึ้นสแต็ค การตรวจสอบข้อยกเว้นเป็นการตัดสินใจที่ขัดแย้งกันมากที่สุดของนักออกแบบ Java

ความยาว 28 ตัวอย่าง

int f(int x){return f(x-1);}

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

ความยาว 27 ตัวอย่าง

Object a=new String[]{"a"};

สร้างอาร์เรย์ของสตริงใหม่

ความยาว 26 ตัวอย่าง

Object.class.newInstance()

Objectสร้างใหม่

ความยาว 25 ตัวอย่าง

((Supplier)()->-~0).get()

เป็นการดีที่สุดที่จะหลีกเลี่ยงค่าคงที่การเข้ารหัสที่ยาก วิธีนี้เป็นวิธีเชิงวัตถุในการได้รับความคุ้มค่า1โดยไม่ต้องใช้ค่าคงที่อื่น ๆ 0กว่าใด

ความยาว 24 ตัวอย่าง

(Function<Long,?>)x->x+1

ฟังก์ชันตัวตายตัวแทน

ความยาว 23 ตัวอย่าง

l.removeIf(x->x%10==0);

ถ้าlเป็นรายการจำนวนเต็มจะลบค่าทั้งหมดหารด้วย 10

ความยาว 22 ตัวอย่าง

int i=(new int[7])[5];

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

ความยาว 21 ตัวอย่าง

Arrays.asList(2L,"a")

สร้าง ArrayList ด้วยองค์ประกอบเหล่านี้

ความยาว 20 ตัวอย่าง

System.out.print(s);

sพิมพ์

ความยาว 19 ตัวอย่าง

import java.util.*;

ช่วยให้การใช้รัดกุมของการเรียนเช่นList, Map, Scanner, และTimerRandom

ความยาว 18 ตัวอย่าง

Math.addExact(x,y)

เพิ่มจำนวนเต็มและx yหากล้นเกิดขึ้นวิธีการโยนข้อยกเว้นแทนที่จะให้คำตอบที่ไม่ถูกต้อง

ความยาว 17 ตัวอย่าง

Double.MIN_NORMAL

ค่าบวกที่น้อยที่สุดของประเภทdoubleซึ่งบิตนำของซิกนิฟิแคนด์คือ 0

ความยาว 16 ตัวอย่าง

System.in.read()

อ่านอักขระหนึ่งตัวจากคอนโซล

ความยาว 15 ตัวอย่าง

Long.reverse(x)

xกลับบิตในฐานเป็นตัวแทนของ

ความยาว 14 ตัวอย่าง

int x=050+120;

xขณะนี้ 160 เนื่องจากทุกสิ่งที่ขึ้นต้นด้วย0จะถือว่าเป็นฐานแปด

ความยาว 13 ตัวอย่าง

private C(){}

Constructor ส่วนตัวป้องกันคลาสอื่นไม่ให้สร้างอินสแตนซ์ รูปแบบนี้ถูกใช้โดยSystemและMathคลาสอื่น ๆ คอนสตรัคส่วนตัวยังสามารถใช้ในการบังคับใช้รูปแบบซิงเกิล

ความยาว 12 ตัวอย่าง

static class

ช่วยให้การสร้างการเรียนภายในโดยไม่ต้องชั้นนอกล้อมรอบ - วิธีการแก้ปัญหาที่จะเป็นปัญหา ที่ต้องเผชิญ โดย หลาย โปรแกรมเมอร์

ความยาว 11 ตัวอย่าง

throw null;

บ่อยครั้งที่จำเป็นต้องขว้าง a NullPointerExceptionแต่มันก็พูดมาก นี่เป็นทางเลือกที่ง่ายกว่ามาก

ความยาว 10 ตัวอย่าง

int[]a,b[]

กำหนดสองตัวแปรและa เป็นประเภทและbaint[]bint[][]เป็นประเภท

ความยาว 9 ตัวอย่าง

switch(x)

ไปที่สถานที่ขึ้นอยู่กับมูลค่าของ xไปยังสถานที่ที่ขึ้นอยู่กับค่าของ

ความยาว 8 ตัวอย่าง

break a;

แยกออกจากบล็อกที่มีป้ายกำกับ aเที่ยวบินออกจากบล็อกที่มีข้อความ

ความยาว 7 ตัวอย่าง

goto x;

gotoคำหลักที่สงวนไว้ใน C, C ++ และ Java ถ้าxเป็นป้ายกำกับรหัสนี้จะส่งโปรแกรมไปยังป้ายกำกับที่เหมาะสม - ใน C และ C ++ แต่มันชวามันก่อให้เกิดสิ่งลึกลับRuntimeExceptionก็เรียกลึกลับ อันที่จริงไม่มีวิธีใดที่จะใช้gotoคำหลักใน Java

ความยาว 6 ตัวอย่าง

\u003b

สิ้นสุดคำสั่ง Java นั้นแปลกแปลก

ความยาว 5 ตัวอย่าง

a-=-a

คู่ผสม aสองเท่าด้วยการลบการปฏิเสธของมัน

ความยาว 4 ตัวอย่าง

a&=b

ตั้งค่าaเป็น bitwise และของaและbและ

ความยาว 3 ตัวอย่าง

...

จำนวนอาร์กิวเมนต์ใด ๆ ที่รวมอยู่ในอาร์เรย์

ความยาว 2 ตัวอย่าง

<>

อนุญาตให้คอมไพเลอร์สามารถจำแนกประเภททั่วไปที่คุณอาจหมายถึง ไม่เหมือนจาวามาก

ความยาว 1 ตัวอย่าง

@

ระบุคำอธิบายประกอบเพื่อให้สามารถแสดงข้อมูลเพิ่มเติมเกี่ยวกับวิธีการและคลาสได้

factoid

ใน Java บางครั้งลูปไม่สิ้นสุดทำให้เกิดข้อผิดพลาดของคอมไพเลอร์ ตัวอย่างเช่นลูปwhile(true);ไม่สามารถยกเลิกได้โดยไม่ต้องออกจากเมธอดดังนั้นโค้ดใด ๆ หลังจากนั้นจะทริกเกอร์ข้อผิดพลาด "คำสั่งที่ไม่สามารถเข้าถึงได้" ตามที่ @Optimizer ชี้ให้เห็นว่ามีลูปไม่สิ้นสุดบางตัวเท่านั้นที่จะถูกจับได้ด้วยวิธีนี้

หลาม

ตอนนี้เริ่มต้นด้วยสิ่งใหม่ล่าสุดเพื่อความสะดวกของคุณ! หากต้องการอ่านความยาว 30 โดยเริ่มจากช่วงแรกสุดไปที่ประวัติการแก้ไข

หากใครมีข้อเสนอแนะอย่าลังเลที่จะแสดงความคิดเห็น

ความยาว 52:

i=0
while s[i-n:]:print(' '*n+s)[i:n+i];i+=1;i**7**7

ที่นำมาจากรายการของฉันในข้อความปลอม Marqueeท้าทาย sและnต้องตั้งค่าเป็นสตริงและจำนวนเต็มล่วงหน้า มันไม่จริงทำงานได้ดีในฟรีงูหลาม 2 ล่ามผมใช้ดังนั้นฉันเพิ่มวงเล็บรอบ(' '*n+s)[i:n+i]และคุณสามารถเห็นมันทำงานในหลาม 3 ล่ามที่นี่

ความยาว 43:

#-*-coding:rot13-*-
cevag h"Una fubg svefg"

ใน Python คุณสามารถเข้ารหัสแหล่งที่มาด้วยตัวแปลงสัญญาณที่เฉพาะเจาะจง สิ่งนี้แสดงให้เห็นว่าสามารถเขียนซอร์สใน Rot13 ได้อย่างไร # -*- coding: <codec-name-goes-here> -*-ไวยากรณ์ทั่วไปคือ:

นี่มันแปลแล้ว:

#-*-coding:rot13-*-
print u"Han shot first"

uระบุว่าสตริงต่อไปนี้แท้จริงเป็นสตริง Unicode สิ่งนี้จำเป็นถ้าคุณต้องการให้สตริงของคุณอยู่ใน Rot13 มิฉะนั้นสตริงทั้งหมดในซอร์สสามารถอ่านได้ง่ายแม้จะมีการเข้ารหัส หรือคุณสามารถใช้.encode("Rot13")หลังจากทุกสตริง (อย่าลืมใช้ Rot13 ในส่วนนี้ด้วย) ตามบทความนี้การเข้ารหัสทางเลือกบางอย่างคือ“ base64″,“ uuencode”,“ zlib” หรือ“ bz2″

ความยาว 33:

import cmath
print cmath.sqrt(-1)

นี้เป็นโมดูลหลามสำหรับซับซ้อน (จินตนาการ) หมายเลข ภาพพิมพ์นี้1jเนื่องจาก Python เป็นไปตามมาตรฐานทางวิศวกรรมและใช้jเป็นหน่วยจินตภาพถึงแม้ว่าฉันจะชอบiซึ่งเป็นที่นิยมใช้กันมากในวิชาคณิตศาสตร์และการใช้jและkนอกเหนือไปiจากquaternionsแต่ฉันเชือนแช อ่านคำสั่ง bug / change ที่นี่ (มันจะไม่เปลี่ยน)

ความยาว 30:

f=lambda n:n*f(n-1)if n else 1

ตอนนี้เรากำหนดฟังก์ชันแฟกทอเรียลของเราเองโดยใช้การเรียกซ้ำและประกอบไปด้วยสามส่วน! เท่าที่ฉันรู้มันเป็นกอล์ฟที่ได้รับใน Python นอกจากนี้ยังสามารถเขียนด้วยวิธีนี้: f=lambda n:n and f(n-1)*n or 1นำเสนอตัวดำเนินการบูลีนแบบ Python สองสามตัว (และทำด้วยตัวอักษร 30 ตัว) ดูความยาว 15 ตัวอย่างสำหรับข้อมูลเกี่ยวกับlambdaไวยากรณ์

ความยาว 29:

import math
math.factorial(7)

ค้นหา factorial ของ 7 คืน5040ค่า

ความยาว 25:

import math
print math.pi

โมดูลคณิตศาสตร์ของ Python มีฟังก์ชั่นและค่าคงที่มากมาย นี่คือ PI 3.14159265359ผลตอบแทน (ในรหัสด้านบนฉันนับบรรทัดใหม่เป็นอักขระ)

ความยาว 24:

f=lambda y:lambda x:x**y

นี่คือตัวอย่างของการปิด โทรศัพท์cube = f(3)จะทำให้ลูกบาศก์ฟังก์ชั่นนั้นจะสามารถเรียกว่ามีการพิมพ์print cube(24)13824

ความยาว 19:

print"Hello World!"

ในที่สุดก็มีพื้นที่เพียงพอที่จะพิมพ์เอาต์พุตพื้นฐาน! ไม่จำเป็นต้องใช้ช่องว่างที่นี่เนื่องจากเครื่องหมายคำพูดและวงเล็บยังเป็นตัวคั่น สิ่งนี้จะใช้งานได้ใน Python 2 เท่านั้นเนื่องจาก Python 3 เปลี่ยนprintฟังก์ชันที่จะถูกเรียกเหมือนฟังก์ชั่นอื่น ๆ ในหลาม 3 print("Hello World!")ใช้ สำหรับข้อมูลเพิ่มเติมเกี่ยวกับฟังก์ชั่นการพิมพ์และความแตกต่างระหว่างงูหลามที่ 2 และ 3 ให้ดูมีอะไรใหม่ในหลาม 3.0

ความยาว 16:

[x*3 for x in l]

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

ความยาว 15:

import this #:)

อันนี้เป็นความยาว 11 ตัวอย่าง แต่ฉันรู้ว่าฉันลืมแสดงไข่อีสเตอร์ Python (ยอดเยี่ยม) ! การนำเข้าโมดูลนี้จะพิมพ์The Zen of Python (ดู Factoid) ข้อเท็จจริงที่น่าสนใจ: โมดูลthis.pyถูกเข้ารหัสใน rot13 ซึ่งฉันหวังว่าจะนำเสนอในภายหลัง

ความยาว 14:

lambda x:x**.5

สิ่งนี้นิยามฟังก์ชันสแควร์รูทโดยใช้lambdaไวยากรณ์ของ Python สำหรับฟังก์ชันตามตัวอักษร ฟังก์ชั่นตัวอักษรในงูหลามสามารถมีการแสดงออกเท่านั้นไม่งบ แลมบ์ดานี้อาจจะกำหนดให้ตัวแปรส่งผ่านไปยังฟังก์ชั่นหรือดำเนินการในสายที่มีซึ่งจะส่งกลับ(lambda x:x**.5)(9) 3.0การใช้เลขชี้กำลังสำหรับสแควร์รูทเป็นอีกทางเลือกหนึ่งในการนำเข้าsqrtฟังก์ชั่นในmathโมดูล

ความยาว 13:

1 if x else 0

นี่คือตัวอย่างของผู้ประกอบการ Python ถ้าผู้ประกอบการ สิ่งนี้ถูกเพิ่มเข้ามาใน Python 2.5 เพื่อไม่ให้ผู้ใช้โค๊ด coders ทำงานด้วยการใช้งานบูลีน นี่1คือผลตอบแทนถ้าxประเมินเป็นTrueอย่างอื่น0จะถูกส่งกลับ

ความยาว 12:

s=input(">")

การดำเนินการนี้จะพิมพ์>ข้อความแจ้งและอนุญาตให้ผู้ใช้ป้อนค่า Python 2 ตีความค่าอะไรก็ตามที่ป้อนดังนั้นสตริงใด ๆ จำเป็นต้องมีเครื่องหมายคำพูด Python 3 เปลี่ยนแปลงสิ่งนี้ดังนั้นอินพุตที่ป้อนจะไม่ถูกตีความโดยอัตโนมัติ ที่จะใส่ได้โดยไม่ต้องแปลความหมายของมันในหลาม 2 raw_input()ใช้ ในหลาม 2 เทียบเท่ากับinput()eval(raw_input())

ความยาว 11:

eval("2e3")

2e3เป็นสัญลักษณ์ทางวิทยาศาสตร์สำหรับการลอย 2 x 10³ evalฟังก์ชั่นการตีความและประเมินสตริงใด ๆ ที่เป็นการแสดงออก ในกรณีนี้ก็มีผลเช่นเดียวกับการใช้ตัวอักษรหรือ2e3 float("2e3")มันกลับ2000.0มา

ความยาว 10:

range(013)

ฟังก์ชั่นนี้จะส่งกลับรายการของจำนวนเต็มจาก0กับค่าฐานแปด013ซึ่งเป็น11(พิเศษ) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]ความหมายว่ารายการจะเป็น ฟังก์ชั่นใช้เวลาถึงสามพารามิเตอร์คล้ายกับฟังก์ชั่นที่เราตรวจสอบก่อนหน้านี้:slice range(start, stop[, step])ความแตกต่างคือมีเพียงหนึ่งพารามิเตอร์พารามิเตอร์แสดงถึงค่าการหยุด

โปรดทราบว่า Python 3.x ไม่มีค่าเทียบเท่า มันrangeคล้ายกัน แต่จริงๆแล้วก็เหมือนกับ Python 2 ที่xrangeส่งคืนออบเจ็กต์ตัวสร้างแทนรายการ

ความยาว 9:

a,b = b,a

การมอบหมายหลายครั้ง นี่เป็นคุณสมบัติที่เรียบง่าย แต่สง่างามทำให้คุณสามารถกำหนดค่าได้หลายค่าพร้อมกัน ในตัวอย่างที่มีให้มันแลกเปลี่ยนและa bคุณถามคำถามเกี่ยวกับลำดับของการประเมินผล นิพจน์ทั้งหมดทางด้านขวาของผู้ประกอบการที่ได้รับการประเมินก่อนที่จะมีการมอบหมายใด ๆ สิ่งนี้เต้นหลายภาษาที่ต้องการการกำหนดค่ากลางให้กับตัวแปรชั่วคราว

ความยาว 8:

#comment

คุณรู้ว่ามันคืออะไร ... เดี๋ยวก่อนคุณไม่ได้? คุณรู้ไหมว่าสิ่งเหล่านั้นที่ให้คุณพิมพ์ข้อความโดยพลการเพื่ออธิบายบรรทัดของรหัสทำให้เข้าใจง่ายขึ้น? ไม่มี? ตกลง...

ความยาว 7:

l[::-1]

สมมติว่าlมีรายการอีกครั้งซึ่งจะส่งคืนรายการในลำดับย้อนกลับ อาร์กิวเมนต์ที่สามระบุขนาดขั้นตอน เนื่องจากทั้งสามอาร์กิวเมนต์สามารถเป็นค่าลบขนาดขั้นตอนเชิงลบหมายถึงการวนซ้ำในลำดับย้อนกลับ อาร์กิวเมนต์ที่หนึ่งและสองที่ว่างเปล่าแสดงให้เห็นว่าเรากำลังวนซ้ำทั้งรายการ

เราไปถึงจุดที่เราสามารถเริ่มใช้โครงสร้างที่น่าสนใจกว่านี้!

ความยาว 6:

l[-6:]

นี่เรียกว่าการดำเนินการแบ่ง หากlเป็นรายการสิ่งนี้จะส่งคืนรายการใหม่ที่มีองค์ประกอบหกรายการสุดท้ายของlรายการ -6แสดงให้เห็นถึงดัชนีเริ่มต้น (6 จากปลาย) และลำไส้ใหญ่หมายถึงการดำเนินต่อไปจนกว่าดัชนีสิ้นสุดหลังจากที่มัน (ซึ่งเราปล่อยให้ว่างเพื่อที่จะสิ้นสุด.) ถ้ารายการของเรามีตัวเลข 1 ถึง 10 [5, 6, 7, 8, 9, 10]นี้จะกลับมา

ความยาว 5:

1<x<5

หนึ่งในฟีเจอร์ที่ยอดเยี่ยมของ Python คือช่วยให้คุณสามารถเปรียบเทียบผู้ให้บริการเครือข่ายได้ ในภาษาอื่น ๆ 1 < x && x < 5จำนวนมากนี้จะพิมพ์เป็น จะดียิ่งขึ้นเมื่อคุณพิจารณาการเปรียบเทียบหลายอย่าง: 1 < x < y < 5ถูกต้องสมบูรณ์!

ความยาว 4:

0256

จำนวนเต็มที่มีศูนย์นำหน้าคือค่าฐานแปดตามตัวอักษร นี่เป็นเคล็ดลับที่ดีสำหรับการทำให้โค้ดสับสนเช่นกัน 174นี้จะส่งกลับค่าทศนิยม ในหลาม 3.x 0o256ค่าฐานแปดจะเขียนเป็น

ความยาว 3:

`3`

การล้อมรอบนิพจน์ใน backticks นั้นเหมือนกับการใช้repr()ซึ่งจะส่งคืนการแทนค่าสตริงของวัตถุ ฟังก์ชั่นพยายามที่จะส่งกลับสตริงในลักษณะที่เมื่อมันถูกส่งผ่านเป็นข้อโต้แย้งไปยังevalฟังก์ชั่นมันจะกลับวัตถุเดิม มันไม่เหมือนกับการใช้str()งานแม้ว่าบางครั้งผลลัพธ์จะเหมือนกัน สำหรับอินพุตนี้'3'จะถูกส่งคืนในทั้งสองกรณี นี่คือรายการโปรดของฉันสำหรับการตีกอล์ฟ!

ใช้งานได้กับ Python 2 เท่านั้น!

ความยาว 2:

[]

รายการว่างเปล่า

ความยาว 1:

_

อักขระขีดล่างเป็นชื่อตัวแปรที่ใช้มาก หากคุณใช้เปลือก Python (ล่ามแบบโต้ตอบ) จะเก็บผลลัพธ์ของคำสั่งที่เรียกใช้ล่าสุด (และจะส่งคืนอีกครั้ง) นอกจากนี้ตามหัวข้อนี้จะใช้สำหรับการค้นหาการแปลใน i18n

Factoid : Python เป็นภาษาที่คล้ายกับ Java และ C มันถูกสร้างขึ้นด้วยปรัชญาการออกแบบที่เฉพาะเจาะจง (นำมาจาก " PEP 20 - The Zen of Python ":

• สวยดีกว่าน่าเกลียด
• ชัดเจนดีกว่าโดยปริยาย
• เรียบง่ายดีกว่าซับซ้อน
• คอมเพล็กซ์ดีกว่าซับซ้อน
• จำนวนการอ่าน

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

JavaScript

สิ่งนี้ไปใหม่สุดไปหาเก่าที่สุด ลิงก์สำหรับตัวฉันเอง: [ แก้ไข ]

ความยาว 51 ตัวอย่าง:

console.log(require('fs').readFileSync(__filename))

Node.JS quine ในครั้งนี้แม้ว่ามันจะล้มเหลวข้อกำหนด "เข้มงวดมาก" เนื่องจากการอ่านซอร์สโค้ดของมันเอง

ความยาว 50 ตัวอย่าง:

a=new XMLHttpRequest;a.open('GET','file');a.send()

ที่สุด! คำขอ AJAX (ใช้Vanilla.JS ) เราเริ่มต้นเปิดและส่งคำขอ แต่ฉันวิ่งออกจากห้องเพื่อเพิ่มเครื่องมือจัดการและทำทุกอย่างกับผลลัพธ์

ความยาว 49 ตัวอย่าง:

msg=new SpeechSynthesisUtterance('Hello World!');

เตรียมแกนนำ "Hello World!" มันจะเป็นงานอีกเล็กน้อยที่จะพูดจริง ๆ นอกจากนี้เรายังสามารถปรับระดับเสียงระยะห่างอัตราและสำเนียงได้ ดูการสังเคราะห์เสียง API บน HTML5Rocks ยังไม่ได้รับการสนับสนุนโดย Firefox ไม่แน่นอน IE

ความยาว 48 ตัวอย่าง:

function repeat(){setTimeout(repeat,48)}repeat()

จำลองsetIntervalโดยซ้ำsetTimeoutไอเอ็นจี

ความยาว 47 ตัวอย่าง:

module.exports=function MyModule(a) {this.a=a};

NodeJS อีกครั้ง แต่หลักการเหมือนกันทุกที่ใน JS นี่คือฟังก์ชั่นคอนสตรัคเตอร์ขั้นพื้นฐานซึ่งสร้างวัตถุที่มีคุณสมบัติเดียว ( a) การตั้งค่าการmodule.exportsส่งออกฟังก์ชั่นสำหรับการใช้งานโดยrequire()มัน

ความยาว 46 ตัวอย่าง:

canvas.getContext('2d').fillRect(46,46,46,46);

สิ่งนี้ต้องมี<canvas id="canvas"></canvas>องค์ประกอบ มันใช้ประโยชน์จากความจริงที่ว่าองค์ประกอบที่มี ID ถูกบรรจุเป็นตัวแปรทั่วโลกดังนั้นองค์ประกอบสามารถเข้าถึงได้canvasจาก JS จากนั้นเราเติมด้วยสี่เหลี่ยมจัตุรัส 46x46 ที่ x = 46, y = 46

ความยาว 45 ตัวอย่าง:

JSON.parse(require('fs').readFileSync('jsn'))

กลับไปที่โหนด ที่นี่เราแยกไฟล์ JSON ชื่อjsnจากไดเรกทอรีปัจจุบัน

ความยาว 44 ตัวอย่าง:

(a=document.createElement('a')).href="/url";

อาคารใน # 39 ตอนนี้เราสร้างองค์ประกอบและกำหนดแอตทริบิวต์ มันยังไม่ได้อยู่ใน DOM แม้ว่า

ความยาว 43 ตัวอย่าง:

sq=[1,2,3,4,5].map(function(n){return n*n})

สร้างอาร์เรย์ของ 5 map()สี่เหลี่ยมแรกที่ใช้

ความยาว 42 ตัวอย่าง:

six="1+5",nine="8+1";eval(six+' * '+nine);

สิ่งนี้ทำงานบนหลักการเดียวกันกับนี้แต่ JS ขาด#defineและจบลงด้วยความอัปลักษณ์ ก็จะส่งกลับแน่นอนคำตอบให้กับชีวิตจักรวาลและทุกอย่าง

ความยาว 41 ตัวอย่าง:

c=function(){var i;return function(){}}()

จุดเริ่มต้นของการปิด cตอนนี้เป็นฟังก์ชั่น (ตัวหนึ่งภายใน) ที่มีการเข้าถึงตัวแปรภายในiแต่มันไม่ได้ทำอะไรเลย

ความยาว 40 ตัวอย่าง:

$('p').click(function(){$(this).hide()})

เรากำลังวางย่อหน้าเหล่านั้นทั้งหมดและใช้ jQuery

ความยาว 39 ตัวอย่าง:

script=document.createElement('script')

นี่คือจุดเริ่มต้นของการเพิ่มสคริปต์ภายนอกใหม่ สร้าง<script>องค์ประกอบที่ว่างเปล่าและอ้างอิงถึงมัน

ความยาว 38 ตัวอย่าง:

document.getElementsByClassName('abc')

ค้นหา.abcองค์ประกอบทั้งหมดในเอกสาร แน่นอนด้วย jQuery เป็นเพียง$('.abc')...

ความยาว 37 ตัวอย่าง:

b=JSON.parse(JSON.stringify(a={3:7}))

สร้างสองเหมือนกัน แต่วัตถุแยก, และa bถ้าคุณจะทำ

a={a:1};
b=a;
b.a=3;

คุณจะท้ายa=={a:3}เพราะaและbชี้ไปที่วัตถุเดียวกัน เราใช้ JSON เพื่อแยกพวกเขาออก

ความยาว 36 ตัวอย่าง:

(function f(){return "("+f+")()"})()

ควิน มันพิมพ์รหัสที่มาของตัวเอง

ความยาว 35 ตัวอย่าง:

document.body.style.display="none";

ดู # 32 อันนี้เพิ่งซ่อนเอกสารโดยไม่เขียนทับเนื้อหา

ความยาว 34 ตัวอย่าง:

Object.prototype.toString.call(34)

การโทรObject.prototype.toStringเป็นวิธีที่ดีในการบอกประเภทของวัตถุ ในขณะที่34..toString()เป็นข้อมูลโค้ดคือ"34"[object Number]

ความยาว 33 ตัวอย่าง: (เครดิตสำหรับสิ่งนี้จะไปยังผู้ใช้ที่ไม่ระบุชื่อ )

+0%-0.&(v\u0061r=~void[{}<<!(0)])

คิดว่านี่ไม่ใช่ JavaScript ที่ถูกต้อง? ลองใช้ดีกว่า ... (ใช้ Chrome);)

ความยาว 32 ตัวอย่าง:

document.body.innerHTML="hacked"

Halp! Hazxxors! สิบเอ็ด !! 11!

ความยาว 31 ตัวอย่าง:

a=[];for(i=0;i<31;i++)a.push(i)

ไม่ล้อเล่นฉันรอมานานแล้วที่จะใช้forลูปจริง ๆ! อันนี้สร้างอาร์เรย์จาก 0-30

ความยาว 30 ตัวอย่าง:

new Date().getDay()==1?"S":"E"

ครั้งแรกที่ใช้ผู้ประกอบการที่ประกอบไปด้วย ฉันไม่สามารถใส่ได้มากกว่านี้ใน 30 ตัวอักษรดังนั้นเราจะรู้ได้ว่าวันนี้เป็นวันอาทิตย์หรืออะไรอื่น : P

ความยาว 29 ตัวอย่าง:

Object.keys(window).push('i')

Object.keys(window)จะได้รับอาร์เรย์ของตัวแปรทั่วโลก (คุณสมบัติของwindow) .push()จะต่อท้ายรายการในอาร์เรย์นั้น คิดว่านี่เทียบเท่าwindow.i=undefinedหรือเปล่า Nope!

ความยาว 28 ตัวอย่าง:

setTimeout("a=confirm()",28)

การรอ 28 มิลลิวินาทีนั้นไม่มีประโยชน์ยกเว้นการสร้างเธรดใหม่

ความยาว 27 ตัวอย่าง:

document.querySelector('a')

มันเป็นความอัปยศที่ชื่อ DOM นั้นยาวมาก ฉันจะได้รับลิงค์เดียวที่นี่

ความยาว 26 ตัวอย่าง:

JSON.stringify({twenty:6})

ดู # 16 ตอนนี้เราได้รับ JSON จริง - สตริง

ความยาว 25 ตัวอย่าง:

new Badge("Good Answer");

สมมติว่าBadge()เป็นฟังก์ชั่นการสร้างการโต้แย้ง ... ตราคำตอบที่ดีเพิ่งสร้าง!

ความยาว 24 ตัวอย่าง:

do {alert(24)} while(!1)

จริงๆแล้วฉันไม่ได้ใช้do..whileอะไรมาก แต่ก็มีบางอย่างที่ทำ หากนี่เป็นwhileลูปธรรมดามันจะไม่เตือนอะไรเลยเพราะมันเป็นเท็จเสมอ do..whileจะทำงานอย่างน้อยหนึ่งครั้งเสมอดังนั้นเราจะได้เห็น 24

ความยาว 23 ตัวอย่าง:

window.parent==self.top

windowทั้งหมดเหล่านี้หมายถึงวัตถุเดียวกันที่รู้จักกันทั่วไป thisถ้าคุณเรียกใช้ฟังก์ชั่นได้ตามปกตินอกจากนี้ยังมี นั่นคือ 5 วิธีในการเข้าถึงวัตถุทั่วโลก!

ความยาว 22 ตัวอย่าง:

for(i in self)alert(i)

เตือนตัวแปรส่วนกลางทั้งหมด มันเกิดขึ้นเป็นself==windowอย่างนั้น (ดูตัวอย่างต่อไป)

ความยาว 21 ตัวอย่าง:

"2"+1==21 && 2+1=="3"

โอ้นี่เป็นกฎการคัดเลือกนักแสดงของ JS อีกครั้ง คำสั่งนี้เป็นจริง btw

ความยาว 20 ตัวอย่าง:

Math.random()<.5?0:1

เลือกตัวเลขสุ่มจาก 0-1 และปัดเศษโดยใช้ตัวดำเนินการประกอบ แม้ว่ามันจะง่ายกว่าที่จะใช้Math.round...

ความยาว 19 ตัวอย่าง:

[1,2,3].map(i=>i*i)

อันนี้เป็นของใหม่ เหมือนใหม่จริงๆ มันใช้ฟังก์ชั่นลูกศร ES6เพื่อคำนวณกำลังสองของ 1, 2 และ 3 ในปัจจุบันดูเหมือนว่า Firefox จะรองรับเท่านั้น

ความยาว 18 ตัวอย่าง:

location.href="/";

เช่น # 15 แต่คราวนี้มันไปที่โฮมเพจ PPCG ไม่ใช่ SE

ความยาว 17 ตัวอย่าง:

(function(){})()

มันเป็นตัวอย่างจาก 14 แต่ดีกว่า! ตอนนี้มันเป็น IIFE

ความยาว 16 ตัวอย่าง:

obj={not:'json'}

นี่อธิบายหนึ่งในสัตว์เลี้ยงของฉัน นี่คือวัตถุ , ไม่ JSON ! JSONเป็นรูปแบบการแลกเปลี่ยนข้อมูลตามวัตถุ JavaScript แต่ใช้รูปแบบที่เข้มงวดมากขึ้น

ความยาว 15 ตัวอย่าง:

open('//s.tk/')

ลองจินตนาการว่า เปิดโฮมเพจ SE โดยใช้การเปลี่ยนเส้นทางhttp://s.tk/

ความยาว 14 ตัวอย่าง:

function f(){}

w00t! ฟังก์ชั่น! น่าเสียดายที่ไม่มีที่ว่างให้ทำอะไร

ความยาว 13 ตัวอย่าง:

Math.random()

สร้างตัวเลขสุ่มจาก 0 ถึง 1 ต้องการกำหนดขีด จำกัด ของคุณเองหรือ โชคดี (ไม่จริงมันง่าย)

ความยาว 12 ตัวอย่าง:

new Date<=12

คำสั่งนี้ไม่เคยเป็นจริงใน JS JS ไม่ได้สร้างจนกระทั่ง '95 (ดู factoid) นานหลังจาก 1/1/1970 00: 00: 00.012

ความยาว 11 ตัวอย่าง:

Math.PI*121

พื้นที่ของวงกลมที่มีรัศมี 11

ความยาว 10 ตัวอย่าง:

if('j')9+1