Rödaเป็นภาษาสคริปต์กระแสตามที่สร้างขึ้นโดยfergusq

คุณมีเคล็ดลับทั่วไปอะไรสำหรับการเล่นกอล์ฟในRöda ฉันกำลังมองหาความคิดที่สามารถนำไปใช้กับปัญหารหัสกอล์ฟและอย่างน้อยก็ค่อนข้างเฉพาะเจาะจงกับRöda (เช่น "ลบความคิดเห็น" ไม่ใช่คำตอบ)

กรุณาโพสต์หนึ่งเคล็ดลับต่อคำตอบ

ใช้ขีดล่าง

นี่อาจเป็นเคล็ดลับที่สำคัญที่สุด เกือบทุกโปรแกรมRödaที่ตีกอล์ฟใช้ขีดล่าง

ไวยากรณ์ขีดล่างคือน้ำตาลประโยคสำหรับforลูป บรรทัดของรหัสต่อไปนี้เทียบเท่า:

ls""|fileLength x for x|sort|pull
ls""|fileLength _|sort|pull

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

ขีดล่างสามารถใช้ได้ทุกที่ในงบ:

a[x:y+1]=[1]*(1+y-x) /* Sets range x..y (inclusive) */
seq x,y|a[_]=1       /* 6 bytes less */

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

a|[_^_1]  /* maps x to x^x */
a|[_2-_1] /* maps each pair (x,y) to y-x, eg. [1,2,4,8] -> [1, 4] */

อัฒภาค / บรรทัดใหม่บางตัวเป็นตัวเลือก

เมื่อเขียนรหัสRödaขอแนะนำให้ใช้บรรทัดใหม่หรืออัฒภาคเพื่อแยกข้อความทั้งหมด อย่างไรก็ตามเมื่อเล่นกอล์ฟคุณควรทราบว่าไม่จำเป็นต้องใช้เครื่องหมายอัฒภาคทั้งหมด

ต่อไปนี้เป็นรายการที่ไม่สมบูรณ์ของสถานที่ที่อัฒภาค / การขึ้นบรรทัดใหม่เป็นตัวเลือก ส่วนใหญ่ของพวกเขาไม่ใช้เมื่อคำสั่งต่อไปเริ่มต้นด้วยการดำเนินการ ( (, [, +ฯลฯ )

• หลังจากได้รับมอบหมาย
• หลังจากการเรียกใช้ฟังก์ชันเมื่อมีอาร์กิวเมนต์อย่างน้อยหนึ่งตัว (เช่น. f x) หรือเมื่อใช้วงเล็บ (เช่นf())
• ทุกที่ถ้าเส้น / คำสั่งต่อไปจะเริ่มต้นด้วย|, ), ]หรือ}

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

• คำสั่งที่เป็นสายฟังก์ชั่นและวงเล็บจะใช้เช่นเป็นเช่นเดียวกับ{f(x)[y]} {f(x);[y]}สิ่งนี้ใช้ได้เฉพาะในบริบทของคำสั่งไม่ใช่เมื่อการเรียกใช้ฟังก์ชันเป็นการแสดงออก
• คำสั่งคือการกำหนดและใช้วงเล็บเช่นx=(y)[z]เดียวกับx=(y);[z](ที่ไม่เหมือนกับx=((y)[z]))

และนี่คือบางสถานที่ที่มีการขึ้นบรรทัดใหม่ที่น่าเสียดายที่จำเป็น :

• หลังจากที่และ++--
• หลังจาก[...]นั้น

บ่อยครั้งที่เป็นไปได้ที่จะบันทึกไบต์ด้วยการจัดระเบียบงานที่มอบหมายใหม่ ตัวอย่างเช่น:

a=0;b=""c=[""]
b=""c=[b]a=0

x=f()y=i;z=a[0]
x=f()z=a[0]y=i

ใช้โครงสร้างการควบคุมส่วนต่อท้าย

แทบจะไม่เหมาะสมที่จะไม่ใช้คำต่อท้ายเนื่องจากคุณสามารถใช้{...}แทนdo...endได้

ตัวอย่างบางส่วน:

x|unless[not(_ in y)]do[0]else[1]done
x|[0]unless[not(_ in y)]else[1]

if[p<0]do c+=p;a-=p done
{c+=p;a-=p}if[p<0]

ใช้กระแสสำหรับการป้อนข้อมูล

ในกรณีที่การป้อนข้อมูลเป็นรายการขององค์ประกอบมันจะมีประโยชน์ในการดึงค่าจากกระแสแทนการรับพวกเขาเป็นอาร์เรย์

ในกรณีส่วนใหญ่องค์ประกอบอาเรย์จะถูกทำซ้ำโดยการผลักพวกมันไปยังสตรีมแล้วทำการวนซ้ำโดยใช้forลูป (หรือขีดล่าง) เนื่องจากองค์ประกอบถูกทำซ้ำจากสตรีมแล้วทำไมไม่กำหนดว่าควรจะมีตั้งแต่ต้น?

ตัวอย่างเช่นในการคำนวณผลรวมของกำลังสองของตัวเลขในอินพุต:

{|a|a|[_^2]|sum} /* Removing a redundant argument */
{[_^2]|sum}      /* saves 5 bytes */

วงเล็บเป็นทางเลือกในบริบทคำสั่ง สิ่งนี้ใช้แม้ว่าอาร์กิวเมนต์จะเริ่มต้นด้วยโอเปอเรเตอร์ ยกตัวอย่างเช่นจะสั้นกว่า[a()|sqrt-_] [a()|sqrt(-_)]วงเล็บหลังaมีผลบังคับใช้เช่นเดียวกับที่aอยู่ในบริบทนิพจน์ไม่ใช่ในบริบทของคำสั่ง

อย่างไรก็ตาม[a()|sqrt(_+1)*2]เป็นไปไม่ได้ที่จะเขียนและจำเป็นต้องใส่วงเล็บเสริมเพื่อช่วยในการแยกวิเคราะห์: [a()|sqrt((_+1)*2)]. บ่อยครั้งที่เป็นไปได้ที่จะเขียนการแสดงออกเช่นนั้นใหม่เพื่อไม่ให้เริ่มต้นด้วยวงเล็บ:[a()|sqrt 2*(_+1)]

ใช้,แทน/ ..ใน[]/ pushงบ

ที่เกี่ยวข้อง: ใช้,แทนand

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

นั่นหมายความว่าอะไรแบบนี้

["a"..b]        /*8 bytes (string "a" concatenated with variable b)*/

สามารถย่อให้เหลือเพียง

["a",b]         /*7 bytes*/

ประหยัด 1 ไบต์

[]/ push>print

ไม่เคยใช้printงบ []ข้อความสั่งพุชเป็นนักกอล์ฟเสมอ ความแตกต่างระหว่างprintและpushคือว่าก่อนหน้านี้ส่งออกขึ้นบรรทัดใหม่ในขณะที่หลังไม่ได้ อย่างไรก็ตามสิ่งนี้สามารถหลีกเลี่ยงได้

print"a"              /* 8 bytes */
["a                   /* 6 bytes; uses a literal newline */
"]

print"a",b            /* 10 bytes */
[`a$b                 /* 8 bytes; uses a literal newline and `` strings */
`]

การใช้``สตริง

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

print"\\"     /* 9 bytes */
print`\`      /* 8 bytes */

ไม่เพียงแค่นั้นคุณสามารถเข้ารหัสตัวแปรและนิพจน์ภายใน``สตริงโดยใช้$variableNameหรือ${expression}เป็นคุณลักษณะที่ไม่มีอยู่ใน""สตริง

_{เรากำลังแสดงผลสตริงที่"a"เชื่อมโยงกับค่าของตัวแปรbด้วยการขึ้นบรรทัดใหม่ในตัวอย่างเหล่านี้}

["a",b,"      /* 11
"]               bytes   */
[`a$b         /* 8
`]               bytes; encodes b in the string using $b */

ใช้,แทนand

เงื่อนไขในRödaเป็นลำธารและอาจประกอบด้วยหลายค่า andค่าเหล่านี้จะลดลงไปค่าบูลีนเป็นหนึ่งเดียวกับ

ซึ่งหมายความว่าคุณสามารถแทนที่andด้วย,ในเงื่อนไขเพื่อส่งค่าหลายค่าไปยังสตรีม:

x if[a and b]
x if[a,b]

สภาพที่ว่างเปล่าเป็นความจริง

นอกจากนี้ยังเป็นไปได้ที่จะมีเงื่อนไขที่ไม่มีค่าซึ่งเป็นความจริง

x while true
x while[]

เขียนรายการทดแทนในรูปแบบ *"...;..."/";"

replaceฟังก์ชั่นใช้เวลาปกติรายการของสตริงเป็นข้อโต้แย้ง อย่างไรก็ตามหากรายการมีความยาวมากมันจะมีประโยชน์ในการเก็บคู่ regex / replace ในสตริงแล้วแยกสตริงและใช้ตัวดำเนินการดาว:

replace"a","b","c","d"
replace*"a;b;c;d"/";"