Jakie masz ogólne wskazówki na temat gry w golfa w sed? Szukam pomysłów, które można by zastosować do problemów związanych z golfem i które są przynajmniej nieco specyficzne dla sed (np. „Usuń komentarze” nie jest odpowiedzią).

Proszę zamieścić jedną wskazówkę na odpowiedź.

Jeśli potrzebujesz użyć etykiet, na pewno będziesz chciał, aby nazwy etykiet były jak najkrótsze. W rzeczywistości doprowadzono do skrajności, możesz nawet użyć pustego ciągu jako nazwy etykiety:

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

Dokumentacja GNU sed opisuje spolecenie jako „szwajcarski scyzoryk sed” . Ale jeśli wszystko, co chcesz zrobić, to zastąpić wszystkie wystąpienia jednej postaci inną, wtedy ypolecenie jest tym, czego potrzebujesz:

y/a/b/

jest o jeden char krótszy niż:

s/a/b/g

Rozważ użycie rozszerzonej składni wyrażenia regularnego (w GNU sed). -rOpcja kosztuje jeden bajt w punktacji, ale używając go tylko raz, aby wyeliminować backslashy z parą \(...\)już zapłacił za siebie.

Podczas wielokrotnego zastępowania w pętli:

loop:
s/foo/bar/g
tloop

Zazwyczaj globalne nie jest konieczne, ponieważ pętla ostatecznie zastąpi wszystkie wystąpienia:

# GNU sed
:
s/foo/bar/
t

Zwróć także uwagę na powyższe rozszerzenie GNU: etykieta może mieć pustą nazwę, oszczędzając cenniejsze bajty. W innych implementacjach etykieta nie może być pusta, a przeskakiwanie bez przeniesienia etykiety przepływa do końca skryptu (tj. Takiego samego jak n).

Nie ma wbudowanej arytmetyki, ale obliczenia można wykonywać w jednostajnym lub jednokodowanym dziesiętnym. Poniższy kod konwertuje liczbę dziesiętną na UCD, gdzie x to jednostka, a 0 jako separator cyfr:

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

a oto konwersja z powrotem na dziesiętne:

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

Oba są zaczerpnięte z odpowiedzi na „Pomnóż dwie liczby bez użycia żadnych liczb” .

Zwykłe stare jednoargumentowe można przekonwertować za pomocą tej pary pętli z tej odpowiedzi na „{Curly Numbers};” , gdzie jest jednostka ;. Użyłem vi xdopasowałem Roman do 5i 10; bpochodzi od „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

Jak wspomniano w man sed(GNU), możesz użyć dowolnego znaku jako separatora dla wyrażeń regularnych, używając składni

\%regexp%

gdzie %jest symbolem zastępczym dla dowolnej postaci.

Jest to przydatne dla poleceń takich jak

/^http:\/\//

które są krótsze jako

\%^http://%

W podręczniku GNU sed wspomniano, ale nie w man sedtym, że można zmienić ograniczniki s///i y///.

Na przykład polecenie

ss/ssg

usuwa wszystkie ukośniki z obszaru wzoru.

Jeśli pytanie nie wyraźnie tego zabrania, konsensus w przypadku tego meta pytania jest taki, że dane liczbowe mogą być jednomyślne . To oszczędza ci 86 bajtów dziesiętnych do jednych zgodnie z tą odpowiedzią .

Rozwijając tę odpowiedź , dotyczącą konwersji między formatami liczb dziesiętnych i zwykłych liczb jednoznacznych, przedstawiam następujące alternatywne metody z ich zaletami i wadami.

Liczba dziesiętna do zwykłej: 102 + 1 (flaga r) = 103 bajty. Liczę \tjako dosłowną kartę, jako 1 bajt.

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

Wypróbuj online!

Zaleta: jest o 22 bajty krótszy, a dodatkowo działa z ujemnymi liczbami całkowitymi jako danymi wejściowymi

Wada: zastępuje przestrzeń wstrzymania. Ponieważ jednak bardziej prawdopodobne jest, że będziesz musiał przekonwertować całkowitą liczbę wejściową na samym początku programu, ograniczenie to jest rzadko odczuwalne.

Zwykły od jednego do dziesiętnego: 102 + 1 (flaga r) = 103 bajty

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

Wypróbuj online!

Zaleta: jest 14 bajtów krótszy. Tym razem obie wersje końcówek działają jako ujemne liczby całkowite jako dane wejściowe.

Wada: zastępuje przestrzeń wstrzymania

W przypadku skomplikowanego wyzwania musisz dostosować te fragmenty, aby współpracowały z innymi informacjami, które mogą istnieć w obszarze wzorca lub w miejscu przechowywania oprócz liczby do konwersji. Kod może być bardziej golfowany, jeśli wiesz, że pracujesz tylko z dodatnimi liczbami lub że samo zero nie będzie prawidłowym wejściem / wyjściem.

Przykładem takiej odpowiedzi na wyzwanie, w której stworzyłem i wykorzystałem te fragmenty, jest odwrotność liczby (1 / x) .

Porozmawiajmy o komendach ti T, że chociaż są one wyjaśnione na stronie podręcznika, łatwo o tym zapomnieć i przypadkowo wprowadzić błędy, szczególnie gdy kod się komplikuje.

Instrukcja strony podręcznika dla t:

Jeśli a s///dokonał pomyślnego podstawienia od czasu ostatniego odczytu linii wejściowej i od ostatniego polecenia t lub T, należy przejść do etykiety.

Przykład pokazujący, co mam na myśli: Załóżmy, że masz listę liczb i chcesz policzyć, ile jest negatywów. Kod częściowy poniżej:

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

Wygląda dobrze, ale tak nie jest. Jeśli pierwsza liczba jest dodatnia, kod nadal będzie myślał, że jest ujemna, ponieważ skok wykonany przez tpierwszy wiersz danych wejściowych jest wykonywany niezależnie, ponieważ spodczas inicjalizacji licznika wystąpiło pomyślne podstawienie! Prawidłowe jest: /-/b increment_counter.

Jeśli wydawało się to łatwe, nadal można Cię oszukać, wykonując wiele skoków tam i z powrotem w celu symulacji funkcji. W naszym przykładzie increment_counterblok kodu z pewnością użyłby wielu spoleceń. Powrót z b mainmoże spowodować, że kolejne sprawdzenie w „main” wpadnie w tę samą pułapkę. Dlatego zwykle wracam z bloków kodu za pomocą s/.*/&/;t label. To brzydkie, ale przydatne.

Zamiast wyczyścić przestrzeń wzorców za pomocą s/.*//, użyj zpolecenia (małe litery), jeśli korzystasz z GNU sed. Oprócz niższej liczby bajtów ma tę zaletę, że nie uruchamia następnego cyklu tak, jak drobi to polecenie , co może być przydatne w niektórych sytuacjach.

Wiem, że to stary wątek, ale właśnie znalazłem te niezdarne konwertery dziesiętne na UCD, z prawie stoma bajtami, niektóre nawet bałaganią przestrzeń wstrzymania lub wymagają specjalnych wadliwych sedwersji.

Do dziesiętnej UCD używam (68 bajtów, były najlepiej napisali tutaj 87 bajtów)

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

UCD na dziesiętne to (również 66 bajtów; poprzednio najlepiej opublikowany tutaj 96)

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

• \nw zastępstwie nie jest przenośny. Zamiast tego możesz użyć innego znaku i zapisać dwa bajty, ale będziesz potrzebować więcej bajtów, aby usunąć dodatek zamiast P;d; patrz następna uwaga. Lub, jeśli twoje pole trzymania jest puste, nie rób G;s/$/9876543210/kary bez bajtów.
• Jeśli potrzebujesz dalszego przetwarzania, będziesz potrzebować więcej bajtów s/\n.*//zamiast P;d.
• Możesz zapisać dwa bajty dla tych błędnych starych sedwersji GNU
• Nie, nie można zapisać tych sześciu ukośników odwrotnych, ponieważ rozszerzone wyrażenia regularne nie powodują odwołań wstecznych

Przeczytaj cały tekst naraz za pomocą -z

Często trzeba operować całym wejściem zamiast jednego wiersza na raz. NKomenda jest przydatna, że:

:
$!{N;b}

... ale zwykle możesz go pominąć i -zzamiast tego użyć flagi.

-zFlag sprawia sed użytkowania NUL ( \0) jako separator linii wejściowej zamiast \n, więc jeśli znasz swoje wejście nie będzie zawierać \0będzie czytać wszystkie wejścia jednocześnie jako pojedynczy „line”:

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

Wypróbuj online!

Dodaj nowy wiersz w jednym bajcie

GPolecenie dołącza do nowej linii i zawartość miejsca przechowywania do przestrzeni wzoru, więc jeśli przestrzeń hold jest pusty, zamiast tego:

s/$/\n/

Możesz to zrobić:

G

Przygotuj nowy wiersz w trzech bajtach

HPolecenie dołącza do nowej linii i zawartości przestrzeni wzorca do miejsca przechowywania i xzamienia dwa, więc jeśli przestrzeń hold jest pusty, zamiast tego:

s/^/\n/

Możesz to zrobić:

H;x

Spowoduje to zanieczyszczenie przestrzeni wstrzymania, więc działa tylko raz. Jednak w przypadku dwóch kolejnych bajtów można wyczyścić obszar wzorców przed zamianą, co wciąż oznacza oszczędność dwóch bajtów:

H;z;x

W sed, najbliższą funkcją, którą możesz mieć, jest etykieta. Funkcja jest przydatna, ponieważ możesz wykonać jej kod wiele razy, oszczędzając w ten sposób wiele bajtów. W sednie jednak musisz podać etykietę zwrotną i jako taki nie możesz po prostu wywołać tej „funkcji” wiele razy w całym kodzie, tak jak zrobiłbyś to w innych językach.

Obejściem, którego używam, jest dodanie do jednej z dwóch pamięci flagi, która służy do wyboru etykiety zwrotnej. Działa to najlepiej, gdy kod funkcji potrzebuje tylko jednej przestrzeni pamięci (drugiej).

Przykład pokazujący, co mam na myśli: wzięty z mojego projektu, aby napisać małą grę w 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

Etykiety powinny być oczywiście golfowane tylko na jedną literę, dla lepszego wyjaśnienia użyłem pełnych nazwisk.

Puste wyrażenia regularne są równoważne z wcześniej napotkanym wyrażeniem regularnym

^{(podziękowania dla Riley za odkrycie tego po złożeniu anagolu )}

Oto przykład, w którym mamy za zadanie utworzenie 100 @s w pustym buforze.

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

Drugie rozwiązanie jest o 1 bajt krótsze i wykorzystuje fakt, że puste wyrażenia regularne są wypełniane ostatnim napotkanym wyrażeniem regularnym. Tutaj, dla drugiego podstawienia, ostatnim wyrażeniem regularnym było .*, więc puste wyrażenie regularne zostanie tutaj wypełnione .*. Działa to również z wyrażeniami regularnymi w /conditionals/.

Zauważ, że jest to wcześniej napotkany regex, więc poniższe również by działały.

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

Puste wyrażenie regularne zostaje wypełnione @*zamiast, $ponieważ s/$/@/nigdy nie jest osiągane.

Przeważnie bezużyteczny krok:

y|A-y|B-z|

Będzie to tłumaczyć tylko Ado Bi ydo z(... i -do -), ale nic więcej, tak

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

po prostu wróci:

Hello world!

Można to zapewnić będą bezużyteczne, na próbce za pomocą tego na małymi wartościami szesnastkowym (zawierające tylko 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, elub f).