sfondo

Questa è la prima parte di un campo da golf a 3 buche sull'elaborazione del testo. L'idea di over-arching è che se prendi un testo di input e lo installi attraverso le soluzioni a tutte e tre le sfide (con una piccola quantità di codice di colla), sputerà un paragrafo formattato magnificamente. In questa prima sfida, il tuo compito è sillabare un pezzo di testo usando determinati schemi di sillabazione.

Ingresso

Il tuo programma dovrà prendere due input di stringa: un pezzo di testo e un elenco di schemi di sillabazione. Il primo input è semplicemente una stringa non vuota di caratteri e spazi ASCII stampabili; non conterrà interruzioni di linea o tilde ~. Il secondo input è un elenco di parole delimitate da virgole, che consistono in sillabe delimitate da tilde di caratteri ASCII minuscoli. Un esempio è ex~cel~lent,pro~gram~ming,abil~i~ties.

Produzione

Il programma modificherà il primo input nel modo seguente. Qualsiasi parola (sottostringa massima di caratteri alfabetici ASCII) la cui versione minuscola trattata si trova nel secondo input deve essere sostituita da quella versione trattata, ma il suo caso deve essere preservato. Con l'elenco di esempio sopra riportato, se il testo contiene la parola Excellent, deve essere sostituito da Ex~cel~lent; tuttavia, nonExcellently deve essere modificato. L'output deve essere questa stringa modificata.

Regole dettagliate e punteggio

Puoi assumere quanto segue sugli input:

• Il primo input non contiene tilde né spazi iniziali, finali o ripetuti. Non è vuoto
• Il secondo input contiene almeno una parola e ogni parola in essa contiene almeno due sillabe. Ogni sillaba non è vuota.
• Il secondo input non contiene una parola che si presenta come sillaba in un'altra parola.

Se lo si desidera, è possibile modificare l'ordine dei due input e, facoltativamente, aggiungere una nuova riga finale all'output.

È possibile scrivere una funzione o un programma completo. Vince il conteggio di byte più basso e non sono consentite scappatoie standard.

Casi test

Questi sono elencati nel 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

^{Qualsiasi possibile errore di sillabazione in questa sfida è dovuto a questo strumento di sillabazione .}

Pip, 60 54 byte

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

Repository GitHub per Pip

Accetta input come argomenti della riga di comando (che richiede virgolette attorno all'input 1, supponendo che contenga spazi). Non viene stampata alcuna nuova riga finale (aggiungere un xalla fine del programma per aggiungerne uno).

Un po 'ungolfed, con commenti:

 ; 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
}

Esecuzione di esempio:

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 byte

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

Ai fini del conteggio, ogni riga va in un file separato, \nviene sostituita con caratteri di nuova riga effettivi ed <empty>è un file vuoto. Per comodità, è possibile eseguire il codice sopra riportato da un singolo file (dove si <empty>trova una riga vuota) se si utilizza il -sflag interprete.

Javascript ES6, 117 141 caratteri

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

Test:

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

Ricerca regex di base e sostituzione

(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)

Violino

Modifica: corretto bug per test case 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 primo tentativo, molte cose possono essere abbreviate - continuerà domani!