_{Rubato da @Downgoat con il permesso}

Il punto di questa sfida è di (non) risolvere il dibattito sulla pronuncia di "gif".

"

La pronuncia di gif è discussa e mentre dovrebbe essere (e dovrebbe essere) pronunciata jif , è ancora comunemente contestata.

In questa sfida ti verrà data una serie di parole che hanno una g o j , che rappresentano il suono con cui viene pronunciata la parola. Riceverai anche del testo in cui devi correggere gli errori di ortografia di gif .

Perché questa è Internet e tutti hanno sempre torto. È (non) cortesia comune correggerli.

Un esempio di pronuncia errata sarebbe:

C'era una gif di un topo che mangiava un burrito

L'ortografia errata di GIF ? Inaccettabile! Questo deve essere corretto immediatamente:

C'era un jif (come in un barattolo) di un topo che mangiava un burrito

Abbiamo finito? No, ti sbagli ancora .

Ti sbagli sempre

Questo deve funzionare diversamente:

Nel jif il gatto indossava un cappello da gatto

Questo ovvio errore di ortografia deve essere corretto, lo correggeremo per:

Nella gif (come nella grafica) il gatto indossava un cappello da gatto

Regole

• L'input è una stringa (la frase) e una matrice di stringhe (o qualsiasi alternativa ragionevole, come una stringa separata da virgola) in qualsiasi ordine
• Puoi prendere le parole ge jin qualsiasi ordine. Possono essere presi separatamente.
• Ogni istanza di gif(in ogni caso) nella frase deve essere sostituita da jif (as in ___)dove si ___trova una parola selezionata uniformemente casuale che inizia con j l'array di stringhe, e viceversa per jifcon parole che iniziano con g.
• SOLO le parole gife jifdovrebbero essere sostituite (cioè "jiffy" non dovrebbe essere cambiato). Quelle parole non hanno fatto nulla di male.
• Si garantisce che almeno una parola nell'array inizia con ge almeno una parola inizia con j.
• Il caso deve essere conservato (ad es. GiF-> JiF).
• È possibile scrivere un programma o una funzione
• Si applicano scappatoie standard
• Dobbiamo (non) risolvere rapidamente il dibattito; vince il codice più breve in byte

Esempi

Ingresso e uscita separati da una sola riga:

graphic, jar, jam, gram
I saw a jif of how to pronounce gif that showed gif is pronounced jif

I saw a gif (as in graphic) of how to pronounce jif (as in jar) that showed jif (as in jam) is pronounced gif (as in gram)


gravy, jeff
G is for gIf, h is for JiF, i is for gIF, j is for JIf

G is for jIf (as in jeff), h is for GiF (as in gravy), i is for jIF (as in jeff), j is for JIf (as in gravy)

joke, june, gorilla, great
Jiffy should not be treated as a GIF or JIF, like gifted.

Jiffy should not be treated as a JIF (as in june) or GIF (as in great), like gifted.

Mathematica, 164 165 byte

Questo è un abominio, ma voglio che qualcuno condivida il mio dolore.

StringReplace[f[f@"g"="j"]="g";f[f@"G"="J"]="G";z=IgnoreCase->1>0;#,x:"g"|"j"~~y:"if ":>{f@x,y,"(as in ",RandomChoice@StringCases[#2,f@x~~Except[","]..,z]}<>") ",z]&

Functionche si aspetta che il primo argomento #sia la frase da (in) corretta e il secondo argomento #2da una stringa di parole separate da virgola.

f[f@"g"="j"]="g";f[f@"G"="J"]="G"definisce una funzione fche prende le lettere g, G, je Jai loro sostituti adeguati. Questo è sempre leggermente più breve di f@"g"="j";f@"j"="g";f@"G"="J";f@"J"="G".

Ho anche impostato zuguale a IgnoreCase->Truepoiché lo userò due volte.

x:"g"|"j"~~y:"if "è un tipo StringExpressionche corrisponde "gif "o "jif ", nominando la prima lettera xe gli ultimi tre caratteri y. Poiché l'opzione z(nota anche come IgnoreCase->True) viene passata a StringReplace, queste lettere possono essere in qualsiasi combinazione di maiuscole e minuscole.

Sostituisco quindi ogni corrispondenza con

{f@x,y,"(as in ",RandomChoice@StringCases[#2,f@x~~Except[","]..,z]}<>") " 

RandomChoice@StringCases[#2,f@x~~Except[","]..,z]seleziona casualmente una parola dal secondo argomento #2che inizia con f[x], ignorando nuovamente il caso perché l'opzione zè data.

Rubino , 88 87 91 byte

-1 byte da ETHproductions. +4 byte perché le parole contenenti "gif" o "jif" non devono essere sostituite. -2 byte perché gli elenchi di parole di sostituzione possono essere presi separatamente ora.

->s,g,j{s.gsub(/\b(g|j)if\b/i){$&.tr("GgJj","JjGg")+" (as in #{($1[/g/i]?j:g).sample})"}}

Provalo online!

CJam , 78 byte

l',%:A;lS%{_ela"gifjif"3/&{_V=_el:B'g=1W?Z*+V\t" (as in "A{V=elB=!},mR')}O?S}%

Provalo online!

Richiede che l'elenco dei caratteri sostitutivi non sia separato da virgole.

Spiegazione:

l',%                        e# read line of input and split at commas
    :A;                     e# store in var A and pop off the stack
       lS%{...}%            e# for each word in the next line of input so:

_ela"gifjif"3/&             e#   intersection of ["gif" "jif"] and [lowercase(word)]
               {...}O?      e#   if set it non-empty, run block below, otherwise do nothing (push empty string)
                      S     e#   push space

_V=                         e#     extract first char
   _el:B                    e#     duplicate to lowercase and store in var B
        'g=1W?Z*+           e#     convert g/G <=> j/J
                 V\t        e#     store back to word
" (as in "                  e#     push string
           A{V=elB=!},      e#     filter replacements by words starting with the same char (case insensitive)
                      mR    e#     select random element
                        ')  e#     push ')' char

Python 3 , 237 byte

lambda s,g,j:' '.join([(w if False in(w[0]in q,w[1:2]in['i','I'],w[2:3]in['f','F'],w[3:]in",;!?.")else q[w[0]]+w[1:3]+" (as in "+choice(g if w[0]in 'jJ'else j)+')'+w[3:])for w in s.split()])
from random import*
q=dict(zip("gGjJ","jJgG"))

Provalo online!

Questo è il meglio che posso fare - potrebbe essere un modo per farlo più velocemente (probabilmente con regex) ma il mio cervello fa male ora.

Spiegazione: qè una semplice mappatura del dizionario, spero sia chiaro. s,g,jsono la stringa di input, l'elenco di parole g e l'elenco di parole j. ' '.joinunisce la comprensione della lista fatta attraverso for w in s.split()è quindi per la lista di parole in s.

La parte centrale è la magia nera, che analizzerò a tratti. In primo luogo, la condizione: False in(w[0]in q,w[1:2]in['i','I'],w[2:3]in['f','F'],w[3:]in",;!.").

w[0]in qcontrolla che il primo carattere sia nelle chiavi di qcui sono 'g','G','j','J'. Il motivo della separazione qcome variabile è che lo usiamo anche come dict / map in seguito.

w[1:2]in ['i','I']verifica che il secondo carattere sia io o I. Il: 2 è necessario perché il solo mettere w[1]comporterebbe un arresto anomalo delle parole di 1 lettera, ma le sezioni non lo fanno per qualche motivo (pensavo che lo facessero, qualunque cosa!)

w[2:3]in ['f','F']è analogo. L'ho avuto brevemente come solo 2: prima di rendermi conto che dovevo rendere conto di gif, o jif, seguito dalla punteggiatura!

w[3:]in",;!?."verifica che i caratteri successivi siano punteggiatura. Ammetto che il mio codice non funziona se qualcuno mette "gif ?!" ma non posso essere perfetto. Qualcun altro può accettare la sfida di aprire le virgolette anche prima di GIF o GIF.

False in(,,,)è fondamentalmente una grande NAND. In realtà è lo stesso conteggio parziale di separare quattro elementi ande scambiare gli argomenti, ma questo sembra più bello e funziona meglio se devi estenderlo a una quinta andcosa.

w ifsignifica che se False è nella lista condizionale, restituiamo semplicemente la parola invariata - non soddisfa i nostri criteri. else, lo cambiamo in:

q[w[0]]+w[1:3]+" (as in "+choice(g if w[0]in 'jJ'else j)+')'+w[3:]

OK. q[w[0]]sostituisce correttamente la prima lettera. w[1:3]punta su i o I e f o F, w[3:]punta su qualsiasi punteggiatura finale. Questo lascia la clausola as in.

" (as in "+choice(g if w[0]in 'jJ'else j)+')'inserisce l'ovvia stringa letterale all'inizio e la parentesi finale, il bit interessante qui è choice(g if w[0]in 'jJ'else j)che sceglie casualmente da go j, a seconda se w[0]è dentro 'jJ'. e mi sono appena reso conto di avere questo pezzo all'indietro in modo da sistemarlo.

È stata una lunga giornata. choiceè nel randommodulo quindi l'importazione. Penso che sia tutto.

JavaScript (ES6), 142 byte

(s,g,j,r=l=>l[Math.random()*l.length|0])=>s.replace(/\b[gj]if\b/gi,w=>`GJgj`[l=`JGjg`.search(w[0])]+w.slice(1)+` (as in ${r([g,j,g,j][l])})`)

Accetta elenchi di parole ge separati j.

Javascript (ES6), 151 byte

f=(s,g,j)=>s.replace(/\b(g|j)(if)\b/ig,(m,p,c)=>`${a=g,p=="j"?"g":p=="J"?"G":(a=j,p=="g"?"j":"J")}${c}(as in ${a[Math.floor(Math.random()*a.length)]})`)

Probabilmente posso golf più nella parte ternaria, ma non riesco a pensare a come in questo momento. Inoltre, prende le parole gej separatamente.