Bạn có lời khuyên chung nào cho việc chơi golf trong sed? 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 sed (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.

Nếu bạn cần sử dụng nhãn thì chắc chắn bạn sẽ muốn tên nhãn của mình càng ngắn càng tốt. Trong thực tế được đưa đến mức cực đoan, bạn thậm chí có thể sử dụng chuỗi rỗng làm tên nhãn:

:    # define label ""
p    # print pattern space
b    # infinite loop! - branch to label ""

Các tài liệu GNU sed mô tả các slệnh như "Swiss Army Knife sed của" . Nhưng nếu tất cả những gì bạn muốn làm là thay thế tất cả các phiên bản của một ký tự bằng một ký tự khác, thì ylệnh là thứ bạn cần:

y/a/b/

là một char ngắn hơn:

s/a/b/g

Xem xét sử dụng cú pháp regex mở rộng (trong GNU sed). Các -rtùy chọn chi phí một byte trong ghi bàn, nhưng sử dụng nó chỉ một lần để loại bỏ các dấu xồ nguợc từ một cặp \(...\)đã trả cho chính nó.

Khi liên tục thay thế trong một vòng lặp:

loop:
s/foo/bar/g
tloop

thường không cần thiết để thay thế trên toàn cầu, vì vòng lặp cuối cùng sẽ thay thế tất cả các lần xuất hiện:

# GNU sed
:
s/foo/bar/
t

Cũng lưu ý phần mở rộng GNU ở trên: một nhãn có thể có một tên trống, tiết kiệm nhiều byte quý giá hơn. Trong các triển khai khác, nhãn không thể để trống và nhảy mà không có nhãn chuyển luồng đến cuối tập lệnh (nghĩa là giống như n).

Không có số học tích hợp, nhưng các phép tính có thể được thực hiện bằng số thập phân hoặc số thập phân đơn nhất. Đoạn mã sau chuyển đổi thập phân thành UCD, với x là đơn vị và 0 là dấu phân cách chữ số:

s/[1-9]/0&/g
s/[5-9]/4&/g
y/8/4/
s/9/4&/g
s/4/22/g
s/[37]/2x/g
s/[26]/xx/g
s/[1-9]/x/g

và đây là chuyển đổi trở lại thập phân:

s/0x/-x/g
s/xx/2/g
y/x/1/
s/22/4/g
s/44/8/g
s/81/9/g
s/42/6/g
s/21/3/g
s/61/7/g
s/41/5/g
s/-//g

Cả hai đều được lấy từ một câu trả lời cho "Nhân hai số mà không sử dụng bất kỳ số nào" .

Unary old unary có thể được chuyển đổi bằng cặp vòng lặp này từ câu trả lời này thành "{Số xoăn};" , đơn vị ở đâu ;. Tôi đã sử dụng vvà xđể phù hợp với Roman cho 5và 10; bxuất phát từ "bis".

# unary to decimal
:d
/;/{
s/;;;;;/v/g
s/vv/x/g
/[;v]/!s/x\+/&0/
s/;;/b/g
s/bb/4/
s/b;/3/
s/v;/6/
s/vb/7/
s/v3/8/
s/v4/9/
y/;bvx/125;/
td
}

# Decimal to unary
:u
s/\b9/;8/
s/\b8/;7/
s/\b7/;6/
s/\b6/;5/
s/\b5/;4/
s/\b4/;3/
s/\b3/;2/
s/\b2/;1/
s/\b1/;0/
s/\b0//
/[^;]/s/;/&&&&&&&&&&/g
tu

Như đã đề cập trong man sed(GNU), bạn có thể sử dụng bất kỳ ký tự nào làm dấu phân cách cho các biểu thức thông thường bằng cách sử dụng cú pháp

\%regexp%

nơi %giữ chỗ cho bất kỳ nhân vật nào.

Điều này rất hữu ích cho các lệnh như

/^http:\/\//

mà ngắn hơn là

\%^http://%

Những gì được đề cập trong GNU sed thủ công nhưng không vào man sedlà bạn có thể thay đổi delimiters của s///và y///là tốt.

Ví dụ: lệnh

ss/ssg

loại bỏ tất cả các dấu gạch chéo từ không gian mô hình.

Nếu không bị cấm rõ ràng bởi câu hỏi, sự đồng thuận cho câu hỏi meta này là đầu vào số có thể là đơn nhất. Điều này giúp bạn tiết kiệm 86 byte số thập phân thành đơn nguyên theo câu trả lời này .

Mở rộng dựa trên câu trả lời về mẹo này , liên quan đến việc chuyển đổi giữa các định dạng số thập phân và số đơn giản, tôi trình bày các phương pháp thay thế sau đây, với những ưu điểm và nhược điểm của chúng.

Số thập phân đến đơn vị đơn giản: 102 + 1 (cờ r) = 103 byte. Tôi tính \tlà một tab theo nghĩa đen, là 1 byte.

h
:
s:\w::2g
y:9876543210:87654321\t :
/ /!s:$:@:
/\s/!t
x;s:-?.::;x
G;s:\s::g
/\w/{s:@:&&&&&&&&&&:g;t}

Hãy thử trực tuyến!

Ưu điểm: nó ngắn hơn 22 byte và là phần bổ sung, nó hoạt động với các số nguyên âm làm đầu vào

Nhược điểm: nó ghi đè lên không gian giữ. Tuy nhiên, vì nhiều khả năng bạn cần phải chuyển đổi số nguyên đầu vào ngay khi bắt đầu chương trình, nên hạn chế này hiếm khi được cảm nhận.

Đồng bằng đơn giản thành thập phân: 102 + 1 (cờ r) = 103 byte

s:-?:&0:
/@/{:
s:\b9+:0&:
s:.9*@:/&:
h;s:.*/::
y:0123456789:1234567890:
x;s:/.*::
G;s:\n::
s:@::
/@/t}

Hãy thử trực tuyến!

Ưu điểm: nó ngắn hơn 14 byte. Lần này cả hai phiên bản tip hoạt động cho số nguyên âm làm đầu vào.

Nhược điểm: nó ghi đè lên không gian giữ

Đối với một thử thách phức tạp, bạn sẽ phải điều chỉnh các đoạn mã này để hoạt động với các thông tin khác có thể tồn tại trong không gian mẫu hoặc không gian giữ, bên cạnh số cần chuyển đổi. Mã có thể được đánh gôn nhiều hơn, nếu bạn biết bạn chỉ làm việc với các số dương hoặc một mình số 0 sẽ không phải là đầu vào / đầu ra hợp lệ.

Một ví dụ về câu trả lời thách thức như vậy, nơi tôi đã tạo và sử dụng các đoạn mã này, là Đối ứng của một số (1 / x) .

Chúng ta hãy nói về tvà Tcác lệnh, mặc dù chúng được giải thích trong trang man, thật dễ dàng để quên nó và vô tình giới thiệu các lỗi, đặc biệt là khi mã bị phức tạp.

Tuyên bố trang Man cho t:

Nếu a s///đã thực hiện thay thế thành công kể từ khi dòng đầu vào cuối cùng được đọc và kể từ lệnh t hoặc T cuối cùng, thì phân nhánh thành nhãn.

Ví dụ cho thấy ý tôi muốn nói: giả sử bạn có một danh sách các số và bạn muốn đếm xem có bao nhiêu tiêu cực. Mã một phần dưới đây:

1{x;s/.*/0/;x}                   # initialize the counter to 0 in hold space
s/-/&/                           # check if number is negative
t increment_counter              # if so, jump to 'increment_counter' code block
b                                # else, do nothing (start a next cycle)

:increment_counter
#function code here

Có vẻ ổn, nhưng nó không phải là. Nếu số đầu tiên là số dương, mã đó vẫn sẽ nghĩ đó là số âm, bởi vì bước nhảy được thực hiện tcho dòng đầu tiên đầu tiên được thực hiện bất kể, vì đã có sự sthay thế thành công khi chúng tôi khởi tạo bộ đếm! Đúng là : /-/b increment_counter.

Nếu điều này có vẻ dễ dàng, bạn vẫn có thể bị lừa khi thực hiện nhiều lần nhảy qua lại để mô phỏng các chức năng. Trong ví dụ của chúng tôi, increment_counterkhối mã chắc chắn sẽ sử dụng rất nhiều slệnh. Quay trở lại với b maincó thể làm cho một kiểm tra khác trong "chính" rơi vào cùng một cái bẫy. Đó là lý do tại sao tôi thường trở về từ các khối mã với s/.*/&/;t label. Nó xấu, nhưng hữu ích.

Thay vì xóa không gian mẫu bằng s/.*//, hãy sử dụng zlệnh (chữ thường) nếu bạn đi với GNU sed. Bên cạnh số byte thấp hơn, nó có lợi thế là nó sẽ không bắt đầu chu kỳ tiếp theo như lệnh d, điều này có thể hữu ích trong một số tình huống.

Tôi biết đây là một luồng cũ, nhưng tôi chỉ tìm thấy các bộ chuyển đổi thập phân UCD vụng về đó, với gần một trăm byte, một số thậm chí còn làm rối không gian giữ hoặc yêu cầu các sedphiên bản bị lỗi đặc biệt .

Đối với thập phân sang UCD tôi sử dụng (68 byte; trước đây được đăng tốt nhất ở đây 87 byte)

s/$/\n9876543210/
:a
s/\([1-9]\)\(.*\n.*\)\1\(.\)/\3x\2\1\3/
ta
P;d

UCD đến thập phân là (cũng là 66 byte; trước đây được đăng tốt nhất ở đây 96)

s/$/\n0123456789/
:a      
s/\([0-8]\)x\(.*\n.*\)\1\(.\)/\3\2\1\3/
ta      
P;d

• \ntrong thay thế không phải là di động. Bạn có thể sử dụng một ký tự khác thay thế và lưu hai byte, nhưng bạn sẽ cần nhiều byte hơn để xóa phụ lục thay vì P;d; xem nhận xét tiếp theo. Hoặc, nếu không gian giữ của bạn trống, hãy thực hiện G;s/$/9876543210/mà không bị phạt byte.
• Nếu bạn cần xử lý thêm, bạn sẽ cần thêm một số byte s/\n.*//thay thế P;d.
• Bạn có thể lưu hai byte cho mỗi sedphiên bản GNU cũ bị lỗi
• Không, bạn không thể lưu sáu dấu gạch chéo ngược đó vì các biểu thức chính quy mở rộng không thực hiện phản hồi

Đọc toàn bộ đầu vào cùng một lúc với -z

Thường thì bạn cần phải thao tác trên toàn bộ đầu vào cùng một lúc thay vì một dòng tại một thời điểm. Các Nlệnh rất hữu ích cho điều đó:

:
$!{N;b}

... nhưng thông thường bạn có thể bỏ qua nó và sử dụng -zcờ thay thế.

Các -zlá cờ làm NUL sử dụng sed ( \0) như dòng tách đầu vào của nó thay vì \n, vì vậy nếu bạn biết đầu vào của bạn sẽ không chứa \0, nó sẽ đọc tất cả các đầu vào cùng một lúc như là một “dòng” duy nhất:

$ echo 'foo
> bar
> baz' | sed -z '1y/ao/eu/'
fuu
ber
bez

Hãy thử trực tuyến!

Nối một dòng mới trong một byte

Các Glệnh gắn thêm một dòng mới và các nội dung của vũ trụ giữ cho không gian mô hình, vì vậy nếu không gian tổ chức của bạn là trống rỗng, thay vì điều này:

s/$/\n/

Bạn có thể làm được việc này:

G

Chuẩn bị một dòng mới trong ba byte

Các Hlệnh gắn thêm một dòng mới và các nội dung của không gian mẫu cho không gian giữ, và xgiao dịch hoán đổi hai, vì vậy nếu không gian tổ chức của bạn là trống rỗng, thay vì điều này:

s/^/\n/

Bạn có thể làm được việc này:

H;x

Điều này sẽ gây ô nhiễm không gian giữ của bạn, vì vậy nó chỉ hoạt động một lần. Tuy nhiên, đối với hai byte nữa, bạn có thể xóa không gian mẫu của mình trước khi hoán đổi, đây vẫn là một khoản tiết kiệm của hai byte:

H;z;x

Trong sed, thứ gần nhất với chức năng mà bạn có thể có là nhãn. Một hàm rất hữu ích vì bạn có thể thực thi mã của nó nhiều lần, do đó tiết kiệm được rất nhiều byte. Tuy nhiên, trong sed, bạn sẽ cần chỉ định nhãn trả về và như vậy bạn không thể gọi "hàm" này nhiều lần trong toàn bộ mã theo cách bạn sẽ làm bằng các ngôn ngữ khác.

Cách giải quyết tôi sử dụng là thêm vào một trong hai ký ức một cờ, được sử dụng để chọn nhãn trả về. Điều này hoạt động tốt nhất khi mã chức năng chỉ cần một không gian bộ nhớ duy nhất (cái còn lại).

Ví dụ cho thấy những gì tôi muốn nói: lấy từ một dự án của tôi để viết một trò chơi nhỏ trong sed

# after applying the player's move, I overwrite the pattern space with the flag "P"
s/.*/P/
b check_game_status
:continue_turn_from_player
#code

b calculate_bot_move
:return_bot_move
# here I call the same function 'check_game_status', but with a different flag: "B"
s/.*/B/
b check_game_status
:continue_turn_from_bot
#code (like say 'b update_screen')

:check_game_status   # this needs just the hold space to run
#code
/^P$/b continue_turn_from_player
/^B$/b continue_turn_from_bot

Các nhãn nên được chơi golf tất nhiên chỉ một chữ cái, tôi đã sử dụng tên đầy đủ để giải thích rõ hơn.

Regex rỗng tương đương với regex đã gặp trước đó

^{(cảm ơn Riley vì đã khám phá ra điều này từ một bài nộp anagol )}

Dưới đây là một ví dụ trong đó chúng ta có nhiệm vụ tạo 100 @giây trong một bộ đệm trống.

s/$/@@@@@@@@@@/;s/.*/&&&&&&&&&&/ # 31 bytes
s/.*/@@@@@@@@@@/;s//&&&&&&&&&&/  # 30 bytes

Giải pháp thứ hai ngắn hơn 1 byte và sử dụng thực tế là các biểu thức chính trống được điền vào biểu thức chính thức gặp phải cuối cùng. Ở đây, đối với sự thay thế thứ hai, regex cuối cùng là .*, vì vậy regex trống ở đây sẽ được lấp đầy .*. Điều này cũng hoạt động với regexes trong /conditionals/.

Lưu ý rằng đó là regex gặp phải trước đây , vì vậy những điều sau đây cũng sẽ hoạt động.

s/.*/@@@@@@@@@@/;/@*/!s/$/@/;s//&&&&&&&&&&/

Regex trống được lấp đầy @*thay $vì bởi vì s/$/@/không bao giờ đạt được.

Chủ yếu là bước vô dụng:

y|A-y|B-z|

Điều này sẽ chỉ dịch Asang Bvà ysang z(... và -sang -;), nhưng không có gì khác, vì vậy

sed -e 'y|A-y|B-z|' <<<'Hello world!'

sẽ trở lại:

Hello world!

Bạn có thể đảm bảo điều này sẽ là vô ích, cho mẫu bằng cách sử dụng này trên các giá trị thập lục phân hợp cụ thể thấp hơn (chỉ chứa 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, ehoặc f.)