¿Qué consejos generales tienes para jugar al golf en sed? Estoy buscando ideas que se puedan aplicar a problemas de código de golf y que también sean al menos algo específicas para sed (por ejemplo, "eliminar comentarios" no es una respuesta).

Por favor, publique un consejo por respuesta.

Si necesita usar etiquetas, entonces seguramente querrá que los nombres de sus etiquetas sean lo más cortos posible. De hecho, llevado al extremo, incluso puede usar la cadena vacía como nombre de etiqueta:

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

La documentación de GNU sed describe el scomando como "navaja suiza de sed" . Pero si todo lo que quiere hacer es reemplazar todas las instancias de un personaje con otro, entonces el ycomando es lo que necesita:

y/a/b/

es un char más corto que:

s/a/b/g

Considere usar una sintaxis de expresiones regulares extendida (en GNU sed). La -ropción cuesta un byte en puntuación, pero usarla solo una vez para eliminar las barras invertidas de un par \(...\)ya se ha pagado por sí misma.

Al reemplazar repetidamente en un bucle:

loop:
s/foo/bar/g
tloop

Por lo general, no es necesario reemplazarlo globalmente, ya que el bucle eventualmente reemplazará todas las ocurrencias:

# GNU sed
:
s/foo/bar/
t

Tenga en cuenta también la extensión GNU anterior: una etiqueta puede tener un nombre vacío, ahorrando más bytes preciosos. En otras implementaciones, una etiqueta no puede estar vacía, y saltar sin una etiqueta transfiere el flujo al final del script (es decir, igual que n).

No hay aritmética integrada, pero los cálculos se pueden hacer en unario o en un decimal codificado. El siguiente código convierte el decimal a UCD, con x como unidad y 0 como separador de dígitos:

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

y aquí está la conversión de nuevo a decimal:

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

Ambos se toman de una respuesta a "Multiplicar dos números sin usar ningún número" .

El unario simple se puede convertir usando este par de bucles de esta respuesta a "{Números rizados};" , donde está la unidad ;. He usado vy xemparejar a Roman para 5y 10; bproviene de "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

Como se menciona en man sed(GNU), puede usar cualquier carácter como delimitador para expresiones regulares utilizando la sintaxis

\%regexp%

donde %es un marcador de posición para cualquier personaje.

Esto es útil para comandos como

/^http:\/\//

que son más cortos como

\%^http://%

Lo que se menciona en la sed de GNU Manual , pero no en man sedes que se puede cambiar los delimitadores de s///y y///así.

Por ejemplo, el comando

ss/ssg

elimina todas las barras del espacio del patrón.

Si la pregunta no lo prohíbe explícitamente, el consenso para esta meta pregunta es que la entrada numérica puede estar en unario. Esto le ahorra los 86 bytes de decimal a unario según esta respuesta .

Ampliando esta respuesta de sugerencia , con respecto a las conversiones entre formatos de números unarios decimales y simples, presento los siguientes métodos alternativos, con sus ventajas y desventajas.

De decimal a simple unario: 102 + 1 (indicador r) = 103 bytes. Conté \tcomo una pestaña literal, como 1 byte.

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

Pruébalo en línea!

Ventaja: es 22 bytes más corto y, como extra, funciona con enteros negativos como entrada

Desventaja: sobrescribe el espacio de espera. Sin embargo, dado que es más probable que necesite convertir el entero de entrada justo al comienzo del programa, esta limitación rara vez se siente.

Simple unario a decimal: 102 + 1 (bandera r) = 103 bytes

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

Pruébalo en línea!

Ventaja: es 14 bytes más corto. Esta vez, ambas versiones de punta funcionan para enteros negativos como entrada.

Desventaja: sobrescribe el espacio de espera

Para un desafío complicado, tendrá que adaptar estos fragmentos para que funcionen con otra información que pueda existir en el espacio del patrón o el espacio de espera, además del número para convertir. El código se puede jugar más, si sabe que solo trabaja con números positivos o que el cero solo no será una entrada / salida válida.

Un ejemplo de dicha respuesta de desafío, donde creé y usé estos fragmentos, es el recíproco de un número (1 / x) .

Hablemos de los comandos ty T, que aunque se explican en la página del manual, es fácil olvidarse de ellos e introducir errores accidentalmente, especialmente cuando el código se complica.

Declaración de la página de manual para t:

Si a s///ha realizado una sustitución exitosa desde que se leyó la última línea de entrada y desde el último comando t o T, bifurque a la etiqueta.

Ejemplo que muestra lo que quiero decir: supongamos que tiene una lista de números y desea contar cuántos negativos hay. Código parcial a continuación:

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

Se ve bien, pero no lo es. Si el primer número es positivo, ese código seguirá pensando que fue negativo, ya que el salto realizado a través tde la primera línea de entrada se realiza independientemente, ¡ya que hubo una ssustitución exitosa cuando inicializamos el contador! Correcta es: /-/b increment_counter.

Si esto parecía fácil, aún podría ser engañado al hacer múltiples saltos de un lado a otro para simular funciones. En nuestro ejemplo, el increment_counterbloque de código seguramente usaría muchos scomandos. Regresar con b mainpodría causar que otra verificación en "main" caiga en la misma trampa. Es por eso que generalmente regreso de los bloques de código con s/.*/&/;t label. Es feo, pero útil.

En lugar de borrar el espacio del patrón con s/.*//, use el zcomando (en minúsculas) si va con GNU sed. Además del recuento de bytes más bajo, tiene la ventaja de que no comenzará el próximo ciclo como lo hace el comando d, lo que puede ser útil en ciertas situaciones.

Sé que este es un hilo viejo, pero acabo de encontrar esos torpes convertidores decimales a UCD, con casi cien bytes, algunos incluso desordenan el espacio de espera o requieren sedversiones especiales defectuosas .

Para decimal a UCD utilizo (68 bytes; anteriormente mejor publicado aquí 87 bytes)

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

UCD a decimal es (también 66 bytes; anteriormente mejor publicado aquí 96)

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

• \nEn el reemplazo no es portátil. En su lugar, puede usar un carácter diferente y guardar dos bytes, pero necesitará más bytes para eliminar el apéndice en lugar de P;d; Ver siguiente comentario. O, si su espacio de espera está vacío, no tenga G;s/$/9876543210/penalización de bytes.
• Si necesita más procesamiento, necesitará algunos bytes más en s/\n.*//lugar de P;d.
• Puede guardar dos bytes cada uno para esas sedversiones GNU antiguas con errores
• No, no puede guardar esas seis barras diagonales inversas ya que las expresiones regulares extendidas no hacen referencias inversas

Lea toda la entrada de una vez con -z

A menudo necesita operar en toda la entrada a la vez en lugar de una línea a la vez. El Ncomando es útil para eso:

:
$!{N;b}

... pero generalmente puede omitirlo y usar la -zbandera en su lugar.

El -zindicador hace que sed use NUL ( \0) como su separador de línea de entrada en lugar de \n, por lo que si sabe que su entrada no contendrá \0, leerá toda la entrada a la vez como una sola "línea":

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

Pruébalo en línea!

Agregar una nueva línea en un byte

El Gcomando agrega una nueva línea y el contenido del espacio de espera al espacio del patrón, por lo que si su espacio de espera está vacío, en lugar de esto:

s/$/\n/

Puedes hacerlo:

G

Anteponer una nueva línea en tres bytes

El Hcomando agrega una nueva línea y el contenido del espacio del patrón al espacio de espera, y xcambia los dos, por lo que si su espacio de espera está vacío, en lugar de esto:

s/^/\n/

Puedes hacerlo:

H;x

Esto contaminará tu espacio de espera, por lo que solo funciona una vez. Sin embargo, para dos bytes más, puede borrar el espacio de su patrón antes de cambiar, lo que sigue siendo un ahorro de dos bytes:

H;z;x

En sed, lo más parecido a una función que puede tener es una etiqueta. Una función es útil porque puede ejecutar su código varias veces, ahorrando así muchos bytes. Sin embargo, en sed necesitaría especificar la etiqueta de devolución y, como tal, no puede simplemente llamar a esta "función" varias veces a lo largo de su código de la forma en que lo haría en otros idiomas.

La solución alternativa que uso es agregar en una de las dos memorias una bandera, que se usa para seleccionar la etiqueta de devolución. Esto funciona mejor cuando el código de función solo necesita un único espacio de memoria (el otro).

Ejemplo que muestra lo que quiero decir: tomado de un proyecto mío para escribir un pequeño juego en 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

Por supuesto, las etiquetas deben tener una sola letra, utilicé los nombres completos para una mejor explicación.

Las expresiones regulares vacías son equivalentes a las expresiones regulares encontradas anteriormente

^{(gracias a Riley por descubrir esto de una presentación de anagol )}

Aquí hay un ejemplo donde tenemos la tarea de crear 100 @s en un búfer vacío.

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

La segunda solución es 1 byte más corta y utiliza el hecho de que las expresiones regulares vacías se completan con la última expresión regular encontrada. Aquí, para la segunda sustitución, la última expresión regular fue .*, por lo que la expresión regular vacía aquí se llenará .*. Esto también funciona con expresiones regulares en /conditionals/.

Tenga en cuenta que es la expresión regular encontrada anteriormente , por lo que lo siguiente también funcionaría.

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

La expresión regular vacía se llena en @*lugar de $porque s/$/@/nunca se alcanza.

Paso principalmente inútil:

y|A-y|B-z|

Esto solo se traducirá Ahacia By yhacia z(... y -hacia -;), pero nada más, así que

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

solo regresaremos:

Hello world!

Se podría asegurar que esto será inútil, por ejemplo mediante el uso de esta en los valores hexadecimales en minúscula (que contiene sólo 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, eo f.)