_{Robado de @Downgoat con permiso}

El objetivo de este desafío es (no) resolver el debate sobre la pronunciación de "gif".

"

La pronunciación de gif se debate y, aunque se supone que es (y debería ser) pronunciada jif , todavía se discute comúnmente.

En este desafío, recibirás un conjunto de palabras que tienen un g o j , que representan el sonido con el que se pronuncia la palabra. También obtendrá un texto en el que debe corregir la ortografía incorrecta de gif .

Porque esto es internet y todos siempre están equivocados. Es (no) cortesía común corregirlos.

Un ejemplo de una pronunciación incorrecta sería:

Había un gif de un ratón comiendo un burrito

La ortografía incorrecta de gif ? ¡Inaceptable! Esto debe corregirse de inmediato:

Había un jif (como en el tarro) de un ratón comiendo un burrito

¿Terminamos? No, todavía estás equivocado.

Usted es siempre malo

Esto debe funcionar de otra manera:

En el jif, el gato llevaba un sombrero de gato

Este error ortográfico obvio debe corregirse, lo corregiremos para:

En el gif (como en el gráfico), el gato llevaba un sombrero de gato

Reglas

• La entrada es una cadena (la oración) y una matriz de cadenas (o cualquier alternativa razonable, como una cadena separada por comas) en cualquier orden
• Puedes tomar el gyj palabras en cualquier orden. Se pueden tomar por separado.
• Cada instancia de gif(en cualquier caso) en la oración debe ser reemplazada por jif (as in ___)where ___es una palabra seleccionada aleatoriamente uniforme que comienza con j desde el conjunto de cadenas, y viceversa jifcon palabras que comienzan cong .
• SOLO las palabras gify jifdeben ser reemplazadas (es decir, "jiffy" no deben cambiarse). Esas palabras no han hecho nada malo.
• Se le garantiza que al menos una palabra en la matriz comienza con gy al menos una comienza con j.
• El caso debe conservarse (por ejemplo, GiF-> JiF).
• Puedes escribir un programa o una función
• Se aplican lagunas estándar
• Necesitamos (no) resolver el debate rápidamente; el código más corto en bytes gana

Ejemplos

Entrada y salida separadas por una sola línea:

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 bytes

Esto es una abominación, pero quiero que alguien comparta mi dolor.

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]&

Functionque espera que el primer argumento #sea ​​la oración a (in) corregida y el segundo argumento #2a una cadena de palabras separadas por comas.

f[f@"g"="j"]="g";f[f@"G"="J"]="G"define una función fque toma las letras g, G, j, y Ja sus sustitutos apropiados. Esto es un poco más corto que f@"g"="j";f@"j"="g";f@"G"="J";f@"J"="G".

También establecí zigual a IgnoreCase->Trueya que lo usaré dos veces.

x:"g"|"j"~~y:"if "es una StringExpressionque coincide "gif "o "jif "nombra la primera letra xy los últimos tres caracteres y. Dado que la opción z(también conocida como IgnoreCase->True) se pasa a StringReplace, estas letras pueden estar en cualquier combinación de mayúsculas y minúsculas.

Luego reemplazo cada partido con

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

RandomChoice@StringCases[#2,f@x~~Except[","]..,z]selecciona aleatoriamente una palabra del segundo argumento #2que comienza con f[x], nuevamente ignorando mayúsculas y minúsculas porque zse da la opción .

Ruby , 88 87 91 bytes

-1 byte de ETHproductions. +4 bytes porque las palabras que contienen "gif" o "jif" no deben reemplazarse. -2 bytes porque las listas de palabras de reemplazo se pueden tomar por separado ahora.

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

Pruébalo en línea!

CJam , 78 bytes

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

Pruébalo en línea!

Requiere que la lista de caracteres de reemplazo esté separada por nada más que comas.

Explicación:

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 bytes

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

Pruébalo en línea!

Esto es lo mejor que puedo hacer, podría ser alguna forma de hacerlo más rápido (probablemente con expresiones regulares), pero ahora me duele el cerebro.

Explicación: qes un mapeo de diccionario simple, espero que esté claro. s,g,json la cadena de entrada, la lista de palabras g y la lista de palabras j. ' '.joinune la comprensión de la lista realizada, por for w in s.split()lo tanto, es para la lista de palabras en s.

El bit del medio es la magia negra, que desglosaré por partes. En primer lugar, la condición: False in(w[0]in q,w[1:2]in['i','I'],w[2:3]in['f','F'],w[3:]in",;!.").

w[0]in qcomprueba que el primer carácter está en las claves de las qcuales están 'g','G','j','J'. La razón para separarnos qcomo una variable es que también lo usamos como un dict / map más adelante.

w[1:2]in ['i','I']comprueba que el segundo carácter sea yo o yo. El: 2 es necesario porque solo ponerlo w[1]provocaría un bloqueo en las palabras de 1 letra, pero las porciones no lo hacen por alguna razón (¡pensé que lo hicieron, lo que sea!)

w[2:3]in ['f','F']es análogo Brevemente tuve esto como solo 2: ¡antes de darme cuenta de que necesitaba dar cuenta de gif o jif, seguido de puntuación!

w[3:]in",;!?."comprueba que los siguientes caracteres son signos de puntuación. Admito que mi código no funciona si alguien pone 'gif ?!' Pero no puedo ser perfecto. Alguien más puede asumir el desafío de abrir citas antes de gif o jif, también.

False in(,,,)es básicamente una gran NAND. En realidad, es el mismo bytecount que separar cuatro elementos ande intercambiar los argumentos, pero esto se ve mejor y funciona mejor si tiene que extenderlo a una quinta andedición.

w ifsignifica que si False está en la lista condicional, simplemente devolvemos la palabra sin cambios; no cumple con nuestros criterios. else, lo cambiamos a:

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

OKAY. q[w[0]]sustituye la primera letra correctamente. w[1:3]tachuelas en i o I y f o F, w[3:]tachuelas en cualquier puntuación final. Eso deja el como en la cláusula.

" (as in "+choice(g if w[0]in 'jJ'else j)+')'pone el literal de cadena obvio al comienzo y el paréntesis final, el bit interesante aquí es el choice(g if w[0]in 'jJ'else j)que elige aleatoriamente go j, dependiendo de si w[0]está en 'jJ'. y me di cuenta de que tenía esto un poco al revés, así que lo solucioné todo.

Ha sido un largo día. choiceestá en el randommódulo de ahí la importación. Creo que eso es todo.

JavaScript (ES6), 142 bytes

(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])})`)

Toma listas separadas gy de jpalabras.

Javascript (ES6), 151 bytes

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)]})`)

Probablemente pueda jugar golf por la parte ternaria más, pero no puedo pensar en cómo en este momento. Además, toma las palabras gyj por separado.