Röda là một ngôn ngữ kịch bản dựa trên luồng được tạo bởi fergusq .

Bạn có lời khuyên chung nào cho việc chơi golf ở Röda? Tôi đang tìm kiếm những ý tưởng có thể áp dụng cho các vấn đề về golf-code và ít nhất cũng hơi cụ thể đối với Röda (ví dụ: "xóa bình luận" không phải là một câu trả lời).

Xin vui lòng gửi một lời khuyên cho mỗi câu trả lời.

Sử dụng dấu gạch dưới

Đây có lẽ là mẹo quan trọng nhất. Gần như mọi chương trình Röda được đánh gôn đều sử dụng dấu gạch dưới.

Cú pháp gạch dưới là đường cú pháp cho forcác vòng lặp. Các dòng mã sau đây là tương đương:

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

Mỗi dấu gạch dưới thêm một biến mới vào một forvòng lặp vô hình xung quanh câu lệnh. Vòng lặp kéo một giá trị từ luồng cho mỗi biến / gạch dưới và sau đó lặp lại, cho đến khi không còn giá trị nào.

Dấu gạch dưới có thể được sử dụng ở bất cứ đâu trong các câu lệnh:

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

Nếu bạn phải tham khảo cùng một giá trị gạch dưới nhiều lần hoặc sử dụng các giá trị theo thứ tự ngược lại, bạn có thể đặt một số sau dấu gạch dưới:

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] */

Một số dấu chấm phẩy / dòng mới là tùy chọn

Khi viết mã Röda, thông thường nên sử dụng dòng mới hoặc dấu chấm phẩy để phân tách tất cả các câu lệnh. Tuy nhiên, khi chơi golf, điều đáng để biết là không phải tất cả dấu chấm phẩy đều thực sự cần thiết.

Dưới đây là danh sách không đầy đủ các địa điểm nơi dấu chấm phẩy / dòng mới là tùy chọn . Hầu hết trong số họ không áp dụng khi tuyên bố sau bắt đầu với một nhà điều hành ( (, [, +, vv).

• Sau khi chuyển nhượng
• Sau khi gọi hàm, khi có ít nhất một đối số (ví dụ f x:) hoặc khi sử dụng dấu ngoặc đơn (ví dụ f():)
• Ở khắp mọi nơi, nếu dòng / tuyên bố tiếp theo sẽ bắt đầu với |, ), ]hoặc}

Nếu câu lệnh tiếp theo bắt đầu bằng một toán tử, dấu chấm phẩy / dòng mới là tùy chọn nếu

• Câu lệnh là một lời gọi hàm và dấu ngoặc đơn được sử dụng, ví dụ {f(x)[y]}như {f(x);[y]}. Điều này chỉ hoạt động trong ngữ cảnh câu lệnh, không phải khi lệnh gọi hàm là một biểu thức.
• Câu lệnh là một phép gán và dấu ngoặc đơn được sử dụng, ví dụ x=(y)[z]như x=(y);[z](không giống như x=((y)[z])).

Và đây là một số nơi không may yêu cầu các dòng mới :

• Sau ++và --.
• Sau [...].

Thường có thể lưu byte bằng cách sắp xếp lại các bài tập. Ví dụ:

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

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

Sử dụng cấu trúc điều khiển hậu tố

Gần như không bao giờ tối ưu khi không sử dụng các câu lệnh hậu tố, vì bạn có thể sử dụng {...}thay chodo...end .

Vài ví dụ:

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]

Sử dụng luồng cho đầu vào

Trong trường hợp đầu vào là danh sách các phần tử, có thể có ích khi kéo các giá trị từ luồng thay vì lấy chúng dưới dạng một mảng.

Trong hầu hết các trường hợp, các phần tử mảng được lặp lại bằng cách đẩy chúng vào luồng và sau đó lặp lại nó bằng cách sử dụng một forvòng lặp (hoặc dấu gạch dưới). Vì các phần tử được lặp lại từ luồng, tại sao không xác định rằng chúng nên ở đó ngay từ đầu?

Ví dụ: để tính tổng bình phương của các số trong đầu vào:

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

Các dấu ngoặc là tùy chọn trong ngữ cảnh câu lệnh. Điều này áp dụng ngay cả khi đối số bắt đầu bằng một toán tử. Ví dụ, [a()|sqrt-_]ngắn hơn [a()|sqrt(-_)]. Các dấu ngoặc sau alà bắt buộc, như atrong ngữ cảnh biểu thức, không phải trong ngữ cảnh câu lệnh.

Tuy nhiên, viết [a()|sqrt(_+1)*2]là không thể, và dấu ngoặc đơn bổ sung là cần thiết để giúp trình phân tích cú pháp : [a()|sqrt((_+1)*2)]. Thông thường có thể viết lại biểu thức đó để nó không bắt đầu bằng dấu ngoặc đơn:[a()|sqrt 2*(_+1)]

Sử dụng ,thay vì ..trong []/ pushstatement

Liên quan: Sử dụng ,thay vìand

Các pushchức năng (cũng nhưprint chức năng) có thể mất bất kỳ số lượng đối số, và kết quả đầu ra mỗi một trong số họ không có dấu phân cách.

Điều đó có nghĩa là như thế này

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

có thể rút ngắn thành chỉ

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

tiết kiệm 1 byte.

[]/ push>print

Không bao giờ sử dụng printbáo cáo. []tuyên bố đẩy luôn golfier. Sự khác biệt giữa printvà pushlà cái trước xuất ra một dòng mới trong khi cái sau thì không. Tuy nhiên, điều này có thể được phá vỡ.

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 */
`]

Sử dụng ``chuỗi

Trong ""chuỗi, bạn sẽ phải thoát một số ký tự để sử dụng chúng. Ví dụ, để in dấu gạch chéo ngược, bạn sẽ phải có một chuỗi như thế nào "\\". Có một byte được thêm vào để thoát dấu gạch chéo ngược. Tuy nhiên, nếu bạn sử dụng ``, bạn không phải thoát ký tự này và có thể lưu một byte.

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

Không chỉ vậy, bạn có thể mã hóa các biến và biểu thức bên trong ``chuỗi bằng cách sử dụng $variableNamehoặc ${expression}, một tính năng không có trong"" chuỗi.

_{Chúng tôi đang xuất ra chuỗi được "a"nối với giá trị của biến bvới một dòng mới ở các ví dụ này.}

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

Sử dụng ,thay vìand

Các điều kiện trong Röda là các luồng và có thể bao gồm nhiều giá trị. Các giá trị này được giảm xuống một giá trị boolean với and.

Điều này có nghĩa là bạn có thể thay thế andbằng ,trong các điều kiện để đẩy nhiều giá trị vào luồng:

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

Điều kiện trống là sự thật

Cũng có thể có một điều kiện không chứa giá trị, đó là sự thật.

x while true
x while[]

Viết danh sách thay thế dưới dạng *"...;..."/";"

Các replacechức năng có thường là một danh sách các chuỗi như các đối số. Tuy nhiên, nếu danh sách rất dài, chỉ có ích khi lưu trữ các cặp regex / thay thế trong một chuỗi và sau đó tách chuỗi và sử dụng toán tử sao:

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