_{Roubado de @Downgoat com permissão}

O objetivo deste desafio é (não) resolver o debate sobre a pronúncia de "gif".

"

A pronúncia de gif é debatida e, embora deva ser (e deva ser) pronunciada jif , ainda é geralmente contestada.

Neste desafio, você receberá um conjunto de palavras com g ou j , representando o som com o qual a palavra é pronunciada. Você também receberá um texto no qual precisará corrigir as grafias incorretas do gif .

Porque esta é a internet e todos estão sempre errados. É (não) cortesia comum corrigi-los.

Um exemplo de pronúncia incorreta seria:

Havia um gif de um rato comendo um burrito

A grafia errada de gif ? Inaceitável! Isso deve ser corrigido imediatamente:

Havia um jif (como no pote) de um rato comendo um burrito

Nós terminamos? Não, você ainda está errado.

Você está sempre errado

Isso deve funcionar de outra maneira:

No jif o gato usava um chapéu de gato

Esse erro ortográfico óbvio deve ser corrigido. Vamos corrigir isso para:

No gif (como no gráfico) o gato usava um chapéu de gato

Regras

• Entrada é uma sequência (a frase) e uma matriz de sequências (ou qualquer alternativa razoável, como uma sequência separada por vírgula) em qualquer ordem
• Você pode pegar as palavras ge jem qualquer ordem. Eles podem ser tomados separadamente.
• Cada instância de gif(em qualquer caso) na sentença deve ser substituída por jif (as in ___)onde ___está uma palavra selecionada uniformemente aleatória, iniciada com a j partir da matriz de cadeias de caracteres e vice-versa, por jifpalavras iniciadas por g.
• APENAS as palavras gife jifdevem ser substituídas (ou seja, "instável" não deve ser alterado). Essas palavras não fizeram nada errado.
• Você tem a garantia de que pelo menos uma palavra na matriz começa com ge pelo menos uma começa com j.
• A caixa deve ser preservada (por exemplo, GiF-> JiF).
• Você pode escrever um programa ou uma função
• Aplicam-se brechas padrão
• Precisamos (não) resolver o debate rapidamente; o menor código em bytes ganha

Exemplos

Entrada e saída separadas por uma única linha:

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

Isso é uma abominação, mas quero que alguém compartilhe minha dor.

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 o primeiro argumento #seja a sentença a ser (in) corrigida e o segundo argumento #2seja uma sequência de palavras separada por vírgula.

f[f@"g"="j"]="g";f[f@"G"="J"]="G"define uma função fque leva as letras g, G, j, e Jpara seus substitutos adequados. Isso é sempre um pouco mais curto que f@"g"="j";f@"j"="g";f@"G"="J";f@"J"="G".

Também defino zigual a, IgnoreCase->Truejá que o usarei duas vezes.

x:"g"|"j"~~y:"if "é um StringExpressionque corresponde "gif "ou "jif ", nomeando a primeira letra xe os três últimos caracteres y. Como a opção z(também conhecida como IgnoreCase->True) é passada para StringReplace, essas letras podem estar em qualquer combinação de maiúsculas e minúsculas.

Em seguida, substituo cada partida por

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

RandomChoice@StringCases[#2,f@x~~Except[","]..,z]seleciona aleatoriamente uma palavra do segundo argumento #2que começa com f[x], novamente ignorando maiúsculas e minúsculas porque a opção zé dada.

Ruby , 88 87 91 bytes

-1 byte de ETHproductions. +4 bytes porque as palavras que contêm "gif" ou "jif" não devem ser substituídas. -2 bytes porque as listas de palavras de substituição podem ser obtidas separadamente agora.

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

Experimente online!

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

Experimente online!

Requer que a lista de caracteres de substituição seja separada por nada além de vírgulas.

Explicação:

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

Experimente online!

É o melhor que posso fazer - pode ser uma maneira de fazê-lo mais rápido (provavelmente com regexes), mas meu cérebro está doendo agora.

Explicação: qé um mapeamento de dicionário simples, espero que esteja claro. s,g,jsão a sequência de entrada, a lista de palavras-g e a lista de palavras-j. ' '.joinune a compreensão da lista feita, for w in s.split()portanto, é para a lista de palavras em s.

A parte intermediária é a magia negra, que eu vou dividir por partes. Em primeiro lugar, a condição: False in(w[0]in q,w[1:2]in['i','I'],w[2:3]in['f','F'],w[3:]in",;!.").

w[0]in qverifica o primeiro caractere está nas chaves do qque são 'g','G','j','J'. A razão para separar qcomo uma variável é que também a usamos como um dict / map mais tarde.

w[1:2]in ['i','I']verifica se o segundo caractere é i ou I. O: 2 é necessário porque apenas a inserção w[1]resultaria em um travamento nas palavras de uma letra, mas as fatias não o fazem por algum motivo (eu pensei que eles fizeram, o que seja!)

w[2:3]in ['f','F']é análogo. Eu tive brevemente isso como apenas 2: antes que eu percebesse que precisava dar conta de gif, ou jif, seguido de pontuação!

w[3:]in",;!?."verifica se os caracteres subsequentes são pontuação. Admito que meu código não funcionará se alguém colocar 'gif ?!' mas eu não posso ser perfeito. Outra pessoa também pode aceitar o desafio de abrir aspas antes de gif ou jif.

False in(,,,)é basicamente uma grande NAND. Na verdade, é o mesmo valor que separar quatro itens ande trocar os argumentos, mas isso parece mais interessante e funciona melhor se você precisar estendê-lo para uma quinta andedição.

w ifsignifica que, se False estiver na lista condicional, retornamos a palavra inalterada - ela não atende aos nossos critérios. else, alteramos para:

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

ESTÁ BEM. q[w[0]]substitui a primeira letra corretamente. w[1:3]tachas no i ou I ef ou F, w[3:]tachas em qualquer pontuação à direita. Isso deixa a cláusula as.

" (as in "+choice(g if w[0]in 'jJ'else j)+')'coloca a string óbvia literal no início e o parêntese à direita, a parte interessante aqui é a choice(g if w[0]in 'jJ'else j)que escolhe aleatoriamente gou j, dependendo de se w[0]estiver 'jJ'. e acabei de perceber que tinha um pouco para trás, então resolvi isso o tempo todo.

Tem sido um longo dia. choiceestá no randommódulo, portanto, a importação. Eu acho que é tudo.

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 ge de jpalavras.

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

Provavelmente posso jogar mais na parte ternária, mas não consigo pensar em como agora. Além disso, leva as palavras g e j separadamente.