Antecedentes

Esta es la primera parte de un campo de golf de 3 hoyos sobre procesamiento de texto. La idea general es que si toma un texto de entrada y lo canaliza a través de las soluciones a los tres desafíos (con una pequeña cantidad de código de pegamento), escupirá un párrafo bellamente formateado. En este primer desafío, su tarea es un guión de un fragmento de texto utilizando patrones de guiones dados.

Entrada

Su programa tomará dos entradas de cadena: un fragmento de texto y una lista de patrones de separación silábica. La primera entrada es simplemente una cadena no vacía de caracteres y espacios ASCII imprimibles; no contendrá saltos de línea o tildes ~. La segunda entrada es una lista de palabras delimitadas por comas, que consisten en sílabas delimitadas por tilde de caracteres ASCII en minúsculas. Un ejemplo esex~cel~lent,pro~gram~ming,abil~i~ties .

Salida

Su programa modificará la primera entrada de la siguiente manera. Cualquier palabra (subcadena máxima de caracteres ASCII alfabéticos) cuya versión en minúsculas con guiones se encuentre en la segunda entrada se reemplazará por esa versión con guiones, pero se conservará su mayúscula. Con la lista de ejemplo anterior, si el texto contiene la palabra Excellent, se reemplazará por Ex~cel~lent; Sin embargo, Excellentlydeberá no ser modificado. Su salida será esta cadena modificada.

Reglas detalladas y puntuación

Puede asumir lo siguiente sobre las entradas:

• La primera entrada no contiene tildes ni espacios iniciales, finales o repetidos. No esta vacio.
• La segunda entrada contiene al menos una palabra, y cada palabra contiene al menos dos sílabas. Cada sílaba no está vacía.
• La segunda entrada no contiene una palabra que aparece como una sílaba en otra palabra.

Puede cambiar el orden de las dos entradas, si lo desea, y opcionalmente agregar una nueva línea final a la salida.

Puede escribir una función o un programa completo. El conteo de bytes más bajo gana, y las lagunas estándar no se permiten.

Casos de prueba

Estos se enumeran en el formato 1st input [newline] 2nd input [newline] output.

Excellent programming abilities, you work excellently!
ex~cel~lent,pro~gram~ming,abil~i~ties
Ex~cel~lent pro~gram~ming abil~i~ties, you work excellently!

Superman (sometimes incorrectly spelled "Super-man") is super #&%@ing strong.
su~per,some~times,in~cor~rectly,spell~ing
Superman (some~times in~cor~rectly spelled "Su~per-man") is su~per #&%@ing strong.

IncONsISTent caPItalizATIon!
in~con~sis~tent,cap~i~tal~iza~tion
In~cON~sIS~Tent caP~I~tal~izA~TIon!

Such short words.
awk~ward
Such short words.

Digits123 are456cool789.
dig~its,dig~i~tal,are~cool
Dig~its123 are456cool789.

magic magic
ma~gic
ma~gic ma~gic

^{Cualquier posible error de separación silábica en este desafío se debe a esta herramienta de separación silábica .}

Pip, 60 54 bytes

Fwa^`([A-Za-z]+)`O{aQ'~?'~w@++y}M(LCwQ_RM'~FIb^',Yv)|w

Repositorio de GitHub para Pip

Toma entradas como argumentos de línea de comandos (lo que requiere comillas alrededor de la entrada 1, suponiendo que contenga espacios). No se imprime la nueva línea final (agregue una xal final del programa para agregar una).

Algo descabellado, con comentarios:

 ; Split 1st input on runs of letters, including the separators in the results
a^:`([A-Za-z]+)`
 ; Split 2nd input on commas
b^:',
 ; Iterate over the words w in that list
Fwa {
  ; Filter b for entries that match the current word (lowercase, with tildes removed)
 m:(LCw EQ _RM'~)FIb
  ; We expect this to be a list of 0 or 1 elements
  ; If it has one, m gets that element (the hyphenation pattern); if it's empty, m gets nil
 i:-1
 m:m@i
  ; Map this function to each character of pattern m: if it's tilde, return tilde;
  ; otherwise, return corresponding character of w
 m:{aEQ'~ ? '~ w@++i}Mm
  ; Output the result, unless it was nil (falsey), in which case output the original word
 Om|w
}

Ejecución de muestra:

C:\Users\dlosc> pip.py hyphens.pip "IncONsISTent caPItalizATIon!" in~con~sis~tent,cap~i~tal~iza~tion
In~cON~sIS~Tent caP~I~tal~izA~TIon!

Retina , 88 bytes

+is`(?<![a-z~])([a-z~]+)(?=([a-z]+)+[^a-z~].*(?<=[\n,]\1(?(2)!)(?<-2>~\2)+[\n,]))
$1~
\n.*
<empty>

Para fines de conteo, cada línea entra en un archivo separado, \nse reemplaza con caracteres de nueva línea reales y <empty>es un archivo vacío. Para mayor comodidad, puede ejecutar el código anterior desde un solo archivo (donde <empty>hay una línea vacía) si usa el -sindicador de intérprete.

Javascript ES6, 117 141 caracteres

f=(t,p)=>p.split`,`.map(p=>t=t.replace(RegExp("((?:^|[^a-z])"+p.replace(/~/g,")(")+")(?=$|[^a-z])","ig"),(...x)=>x.slice(1,-2).join("~")))&&t

Prueba:

document.querySelector(".question pre").textContent.split("\n\n").map(t=>(t=t.split("\n"))&&f(t[0],t[1])==t[2])
// Array [ true, true, true, true, true ]

Javascript (ES6), 173 169

Búsqueda y reemplazo básico de expresiones regulares

(a,b)=>(b.split`,`.map(s=>a=a.replace(eval(`/(^|[^a-z])(${s.replace(/~/g,"")})(?=[^a-z]|$)/gi`),(_,n,o)=>(x=0,n+s.split``.map((q,i)=>(q=='~'&&++x?q:o[i-x])).join``))),a)

Violín

Editar: error corregido para el caso de prueba magic magic,ma~gic

Perl, 146

$a=<>;$d=$_=~s/~//rg,$a=~s/(?<!\pL)$d(?!\pL)/h($&,$_)/gie for(split/,|\n/,<>);
print$a;
sub h{($g,$h)=@_;while($h=~/~/g){substr($g,"@-",0)='~'}$g}

Solo un primer intento, muchas cosas se pueden acortar, ¡continuará mañana!