_{Volé à @Downgoat avec permission}

Le but de ce défi est de (non) trancher le débat sur la prononciation du "gif".

"

La prononciation de gif est débattue et bien qu'il soit censé (et devrait être) prononcé jif , il est encore couramment contesté.

Dans ce défi, vous recevrez un ensemble de mots qui ont un g ou j , représentant le son avec lequel le mot est prononcé. Vous obtiendrez également du texte dans lequel vous devrez corriger l'orthographe incorrecte de gif .

Parce que c'est Internet et tout le monde a toujours tort. Ce n'est pas une courtoisie courante de les corriger.

Un exemple d'une mauvaise prononciation serait:

Il y avait un gif d'une souris mangeant un burrito

La mauvaise orthographe de gif ? Inacceptable! Cela doit être corrigé immédiatement:

Il y avait un jif (comme dans un pot) d'une souris mangeant un burrito

Avons-nous fini? Non, vous vous trompez toujours .

Tu as toujours tort

Cela doit fonctionner dans l'autre sens:

Dans le jif le chat portait un chapeau de chat

Cette faute d'orthographe évidente doit être corrigée, nous la corrigerons pour:

Dans le gif (comme dans le graphique) le chat portait un chapeau de chat

Règles

• L'entrée est une chaîne (la phrase) et un tableau de chaînes (ou toute alternative raisonnable, telle qu'une chaîne séparée par des virgules) dans n'importe quel ordre
• Vous pouvez prendre les mots get jdans n'importe quel ordre. Ils peuvent être pris séparément.
• Chaque instance de gif(n'importe quel cas) dans la phrase doit être remplacée par jif (as in ___)où ___est un mot sélectionné uniformément au hasard commençant par j dans le tableau de chaînes, et vice versa pour les jifmots commençant par g.
• SEULEMENT les mots gifet jifdoivent être remplacés (ie "jiffy" ne doit pas être changé). Ces mots n'ont pas fait de mal.
• Vous êtes assuré qu'au moins un mot du tableau commence par get au moins un commence par j.
• La casse doit être conservée (par exemple GiF-> JiF).
• Vous pouvez écrire un programme ou une fonction
• Des échappatoires standard s'appliquent
• Nous devons (pas) régler rapidement le débat; le code le plus court en octets gagne

Exemples

Entrée et sortie séparées par une seule ligne:

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 octets

C'est une abomination, mais je veux que quelqu'un partage ma douleur.

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

Functionqui s'attend à ce que le premier argument #soit la phrase à (in) corriger et le second argument #2à une chaîne de mots séparés par des virgules.

f[f@"g"="j"]="g";f[f@"G"="J"]="G"définit une fonction fqui prend les lettres g, G, j, et Jà leur remplacement appropriés. C'est toujours un peu plus court que f@"g"="j";f@"j"="g";f@"G"="J";f@"J"="G".

J'ai également défini zégal à IgnoreCase->Truecar je vais l'utiliser deux fois.

x:"g"|"j"~~y:"if "est un StringExpressionqui correspond à "gif "ou "jif ", en nommant la première lettre xet les trois derniers caractères y. Étant donné que l'option z(également appelée IgnoreCase->True) est passée à StringReplace, ces lettres peuvent être dans n'importe quelle combinaison de majuscules et de minuscules.

Je remplace ensuite chaque match par

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

RandomChoice@StringCases[#2,f@x~~Except[","]..,z]sélectionne au hasard un mot du deuxième argument #2qui commence par f[x], en ignorant à nouveau la casse car l'option zest donnée.

Rubis , 88 87 91 octets

-1 octet de ETHproductions. +4 octets car les mots contenant "gif" ou "jif" ne doivent pas être remplacés. -2 octets car les listes de mots de remplacement peuvent être prises séparément maintenant.

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

Essayez-le en ligne!

CJam , 78 octets

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

Essayez-le en ligne!

Nécessite que la liste des caractères de remplacement ne soit séparée que par des virgules.

Explication:

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 octets

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

Essayez-le en ligne!

C'est le mieux que je puisse faire - cela pourrait être un moyen de le faire plus rapidement (probablement avec des regex) mais mon cerveau me fait mal maintenant.

Explication: qest un simple mappage de dictionnaire, j'espère que c'est clair. s,g,jsont la chaîne d'entrée, la liste des mots g et la liste des mots j. ' '.joinrassemble la compréhension de liste faite à travers for w in s.split()est donc pour la liste de mots dans l'art.

Le bit du milieu est la magie noire, que je décomposerai par morceaux. Tout d' abord, la condition: False in(w[0]in q,w[1:2]in['i','I'],w[2:3]in['f','F'],w[3:]in",;!.").

w[0]in qvérifie le premier caractère est dans les clés de qqui 'g','G','j','J'. La raison de la séparation en qtant que variable est que nous l'utilisons également comme dict / map plus tard.

w[1:2]in ['i','I']vérifie que le deuxième caractère est soit i soit I. Le: 2 est nécessaire parce que simplement mettre w[1]entraînerait un crash sur les mots à 1 lettre, mais les tranches ne le font pas pour une raison quelconque (je pensais que oui, peu importe!)

w[2:3]in ['f','F']est analogue. J'avais brièvement ceci comme 2: avant de réaliser que je devais rendre compte de gif, ou jif, suivi de ponctuation!

w[3:]in",;!?."vérifie que les caractères suivants sont des signes de ponctuation. J'admets que mon code ne fonctionne pas si quelqu'un met 'gif?!' mais je ne peux pas être parfait. Quelqu'un d'autre peut aussi relever le défi d'ouvrir des guillemets avant gif ou jif.

False in(,,,)est fondamentalement un grand NAND. C'est en fait le même nombre d'octets que de séparer quatre éléments avec andet d'échanger les arguments, mais cela semble plus cool et fonctionne mieux si vous devez l'étendre à une cinquième andchose.

w ifsignifie que si False est dans la liste conditionnelle, nous renvoyons simplement le mot inchangé - il ne répond pas à nos critères. else, nous le changeons en:

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

D'ACCORD. q[w[0]]remplace correctement la première lettre. w[1:3]punaises sur le i ou I et f ou F, w[3:]punaises sur toute ponctuation de fin. Cela laisse la clause as in.

" (as in "+choice(g if w[0]in 'jJ'else j)+')'met la chaîne de caractères évidente au début et la parenthèse de fin, le bit intéressant ici est celui choice(g if w[0]in 'jJ'else j)qui choisit au hasard à partir de gou j, selon si w[0]est dedans 'jJ'. et je viens de réaliser que j'avais ce bit en arrière, donc réparer tout au long, fait.

Ça a été une longue journée. choiceest dans le randommodule d'où l'importation. Je pense que c'est tout.

JavaScript (ES6), 142 octets

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

Prend des listes séparées get des jmots.

Javascript (ES6), 151 octets

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

Je peux probablement jouer au golf sur la partie ternaire plus, mais je ne peux pas penser à comment en ce moment. En outre, il prend séparément les mots g et j.