[Question]
  [
In this challenge, you must take a string matching the regex `^[a-zA-Z]+$` or whatever is reasonable (you don't have to consider uppercase or lowercase letters if you want) (you may assume the string is long enough, and has the right structure for all the operations), and output another string, produced similarly to word at the end of a recent dadaist tweet by the POTUS (`"Despite the constant negative press covfefe"`).
## How to covfefify a string:
### First, get the first sound group (made up terminology).
How do you do this? Well:
* Find the first vowel (`y` is also a vowel)
```
  v
creation
```
* Find the first consonant after that
```
    v
creation
```
* Remove the rest of the string
```
creat
```
That is your first sound group.
### Next step:
Get the last consonant of the sound group
```
t
```
and replace it with the voiced or voiceless version. To do this, find the letter in this table. Replace with the letter given (which may be the same letter)
```
b: p
c: g
d: t
f: v
g: k
h: h
j: j
k: g
l: l
m: m
n: n
p: b
q: q
r: r
s: z
t: d
v: f
w: w
x: x
z: s
```
so, we get
```
d
```
Then, take the next vowel after that consonant. You can assume that this consonant is not at the end of the string. Join these two together, then repeat it twice:
```
didi
```
Concatenate this to the first sound group:
```
creatdidi
```
You're done: the string is covfefified, and you can now output it.
Test cases:
```
coverage: covfefe
example: exxaxa
programming: progkaka (the a is the first vowel after the g, even though it is not immediately after)
code: codtete
president: preszizi
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so please make your program as short as possible!
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~58~~ 57 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
<TḢị
e€Øyµ¬TĖEÐḟḢṪ;ç¥T
ḣÇḢ⁸ÇịµḢØYiị“ßȷ%Hẹrȧq’œ?ØY¤⁾cgy;ẋ2
```
A full program that accepts a list of lowercase characters and prints the result.
**[Try it online!](https://tio.run/nexus/jelly#@28T8nDHooe7u7lSHzWtOTyj8tDWQ2tCjkxzPTzh4Y75IKmdq6wPLz@0NITr4Y7Fh9uBIo8adwDp3d2HtgI5h2dEZgLZjxrmHJ5/Yruqx8NdO4tOLC981DDz6GR7oOShJY8a9yWnV1o/3NVt9P//f6WCovz0osTc3My8dCUA)**
### How?
```
<TḢị - Link 1, extract first value from y not less than x: number, x; list of numbers, y
     -                                                     e.g. 5, [3,4,7]
<    - x less than vectorised across y                             [0,0,1]
 T   - truthy indices                                              [    3]
  Ḣ  - head                                                             3
   ị - index into y                                                     7
e€Øyµ¬TĖEÐḟḢṪ;ç¥T - Link 2, indices of the letters to manipulate: list of characters, w
  Øy              - vowel+ yield = "AEIOUYaeiouy"                 e.g.  "smouching" 
e€                - exists in for €ach letter in w                       001100100
    µ             - monadic chain separation, call that v
     ¬            - not vectorised across v                              110011011
      T           - truthy indices                                       12  56 89
       Ė          - enumerate                      [[1,1],[2,2],[3,5],[4,6],[5,8],[6,9]]
         Ðḟ       - filter discard if:
        E         -   elements are equal                       [[3,5],[4,6],[5,8],[6,9]]
           Ḣ      - head                                        [3,5]
            Ṫ     - tail                                           5
                T - truthy indices of v                                    34  7
               ¥  - last 2 links as a dyad
              ç   -   call last link (1) as a dyad                         7
             ;    -   concatenate                                     5,7
                  -                                    ...i.e the indexes of 'c' and 'i'
ḣÇḢ⁸ÇịµḢØYiị“ßȷ%Hẹrȧq’œ?ØY¤⁾cgy;ẋ2 - Main link: list of characters, w
                                   -                             e.g.  "smouching"
 Ç                                 - call the last link (2) as a monad    [5,7]
ḣ                                  - head to index (vectorises)      ["smouc","smouchi"]
  Ḣ                                - head                             "smouc"
                                   -   implicit print due to below leading constant chain
   ⁸                               - link's left argument, w
    Ç                              - call the last link (2) as a monad    [5,7]
     ị                             - index into w                         "ci"
      µ                            - monadic chain separation, call that p
       Ḣ                           - head p                               'c'
        ØY                         - consonant- yield = "BCDFGHJKLMNPQRSTVWXZbcdfghjklmnpqrstvwxz"
          i                        - first index                          22
                          ¤        - nilad followed by link(s) as a nilad:
            “ßȷ%Hẹrȧq’             -   base 250 number = 1349402632272870364
                        ØY         -   consonant- yield = "BCDFGHJKLMNPQRSTVWXZbcdfghjklmnpqrstvwxz"
                      œ?           -   nth permutation  = "BCDFGHJKLMNPQRSTVWXZpctvkhjglmnbqrzdfwxs"
           ị                       - index into         (special case ->) 'c'
                           ⁾cg     - literal ['c','g']
                              y    - translate (change 'c's to 'g's)      'g'
                               ;   - concatenate with the headed p        "gi"
                                ẋ2 - repeat list twice                    "gigi"
                                   - implicit print ...along with earlier = smoucgigi
```
[Answer]
## JavaScript (ES6), ~~107~~ 103 bytes
*Saved 4 bytes thanks to [GOTO 0](https://codegolf.stackexchange.com/users/12474/goto-0)*
```
s=>([,a,b,c]=s.match`(.*?[aeiouy]+(.)).*?([aeiouy])`,a+(b=(a="bcdfgszkvtgp")[11-a.search(b)]||b)+c+b+c)
```
### Test cases
```
let f =
s=>([,a,b,c]=s.match`(.*?[aeiouy]+(.)).*?([aeiouy])`,a+(b=(a="bcdfgszkvtgp")[11-a.search(b)]||b)+c+b+c)
console.log(f("creation"))
console.log(f("coverage"))
console.log(f("example"))
console.log(f("programming"))
console.log(f("president"))
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~45~~ 39 bytes
```
Øa“œṣ$b|0Ḃ’ṃ,Ṛ$yṫµfØyḢṭḢẋ2
e€ØyIi-‘ɓḣ;ç
```
[Try it online!](https://tio.run/##RYwhDsJAFER9T/EFsiGA5QRoVOVCP83Ctt20DaEJogGBQGIKQVGBAByELjg2CI7xe5GFKswk8@ZlxihEaozOWZXt3xtSRWMwb1G5qLItqaVNatdISZ1et5HOUyoPpC51PtYdC6vFWedOj7erLP9sqCy6@mjoeQW9@k3gAJX33y30peAJsAQED3CE6MY2@EzWdWJDjJJFLEEYpH@hacwwnGLEPLRwxnwp0JJR6EXM93ngWcPQrQHG3MUg@QI "Jelly – Try It Online")
### How it works
```
e€ØyIi-‘ɓḣ;ç                Main link. Argument: s (string)
  Øy                        Vowels with y; yield "AEIOUYaeiouy".
e€                          Test each character in s for membership.
    I                       Increments; compute the forward differences of the
                            resulting array of Booleans.
     i-                     Find the first index of -1.
       ‘                    Increment this index to find the index of the first
                            consonant that follows a vowel.
                            Let's call this index j.
        ɓ                   Begin a new chain. Left argument: s. Right argument: j
         ḣ                  Head; yield the first j characters of s.
           ç                Call the helper link with arguments s and j.
          ;                 Concatenate the results to both sides.
```
```
Øa“œṣ$b|0Ḃ’ṃ,Ṛ$yṫµfØyḢṭḢẋ2  Helper link. Left argument: s. Right argument: j
Øa                          Alphabet; set the return value to “abc...xyz”.
  “œṣ$b|0Ḃ’                 Yield 7787255460949942. This is a numeric literal in
                            bijective base 250. The value of each digit matches its
                            1-based index in Jelly's code page.
           ṃ                Convert 7787255460949942 to base 26, using the digts
                            a = 1, b = 2, ..., y = 25, z = 0.
                            This yields "bcdfkszgvtgp".
            ,Ṛ$             Pair the result with its reverse, yielding
                            ["bcdfkszgvtgp", "pgtvgzskfdcb"].
                ṫ           Call tail with arguments s and j, yielding the j-th and
                            all following characters of s.
               y            Translate the result to the right according to the
                            mapping to the left, i.e., replace 'b' with 'p', 'c'
                            with 'g', etc. 'g' appears twice in the first string
                            of the mapping; only the first occurrence counts.
                            Let's call the resulting string r.
                 µ          Begin a new chain. Argument: r
                  fØy       Filter; remove non-vowels from r.
                     Ḣ      Head; take the first vowel.
                       Ḣ    Head; take the first character/consonant of r.
                      ṭ     Tack; append vowel to the consonant.
                        ẋ2  Repeat the resulting string twice.
```
[Answer]
# [CJam](https://sourceforge.net/p/cjam), ~~59~~ ~~58~~ ~~57~~ 56 bytes
```
q_{"aeiouy":V&,_T|:T^}#)/(_W>"cbdfkszgvtpg"_W%er@sV&0=+_
```
[Try it online!](https://tio.run/##S85KzP3/vzC@WikxNTO/tFLJKkxNJz6kxiokrlZZU18jPtxOKTkpJS27uCq9rKQgXSk@XDW1yKE4TM3AVjv@///k/LLUosT0VAA "CJam – TIO Nexus")
### Explanation
```
q_                   e# Read the input and copy it.
{                    e# Find the index of the first char for which the following is true:
 "aeiouy":V          e#  Push "aeiouy" and store it in V.
 &,                  e#  Check if the current char is in the vowel string (0 or 1).
 _T|:T               e#  Copy the result and OR with T (T is initially 0), storing back in T.
 ^                   e#  XOR with the original result. This will be 1 for the first 
                     e#  consonant appearing after a vowel.
}#                   e# (end find)
)/                   e# Increment the index and split the string into chunks of that size.
(                    e# Pull out the first chunk.
_W>                  e# Copy it and get the last character (the consonant).
"cbdfkszgvtpg"_W%er  e# Transliterate the consonant to voiced/voiceless alternative.
@s                   e# Bring all the other split chunks to the top and join them together.
V&0=                 e# First char of the set intersection of that and the vowels.
                     e# (i.e. the first vowel in the second half)
+                    e# Concatenate the new consonant and the vowel.
_                    e# Duplicate the result of that.
                     e# Implicit output of stack contents.
```
[Answer]
# C, ~~219~~ ~~213~~ ~~206~~ ~~179~~ 175 bytes
```
#define p putchar
#define q(a)for(;a strchr("aeiouy",*s);p(*s++));
f(s,c,h)char*s;{q(!)q()p(*s);p(c="pgt vkh jglmn bqrzd fwx s"[*s-98]);p(h=s[strcspn(s,"aeiouy")]);p(c);p(h);}
```
[Try it online!](https://tio.run/##NY1LEoIwEET3niLiZibiwp1WipNQLOKQEPxAyGD8UJ4djZbb7tf9aNMQzfOqNrbtjPDCX0dyOiz@yQAabR9AacFjIBcg06btr48sl4zKg@T1GlEtLHBOucO0lqymAZY4ACYgYVRkvhlFPDlxbM6XThyG8KyFvd0FZ6XkzX5XJc4VXCYR@@5z@Hfht6MvgOo1X3TbAeXxZ5NRTRZiua1SN1MfTdCNeQM "C (gcc) – TIO Nexus")
[Answer]
# [Perl 5](https://www.perl.org/), ~~81~~ ~~72~~ 71 bytes
*-1 byte thanks to Xcali!*
```
s![aeiouy]+(.)\K.*!($1=~y/bdfgpstvzck/ptvkbzdfsg/r.$&x/[aeiouy]/g)x2!ge
```
[Try it online!](https://tio.run/##K0gtyjH9/79YMToxNTO/tDJWW0NPM8ZbT0tRQ8XQtq5SPyklLb2guKSsKjlbv6CkLDupKiWtOF2/SE9FrUIfpkk/XbPCSDE99f//pMTs1NSkf/kFJZn5ecX/dQsA "Perl 5 – Try It Online")
[Answer]
# PHP, 121 Bytes
```
$v=aeiouy;preg_match("#(.*?[$v]+([^$v])).*?([$v])#",$argn,$t);echo$t[1],$z=strtr($t[2].$t[3],bcdfgkpstvz,pgtvkgbzdfs),$z;
```
[Try it online!](https://tio.run/##HYxBDsIgFET3HoOyACVN1CU2PQhBQymFpmn7A18Se3lENzN5L5OBAOXRQ4ATNdFvHbHRGZz3jchCc2fcvL8/EqLzr9WgDYw0rD33imZ9YepZi/PK7Cd4Q8T/RVDk0tmwU1RXLejRJYwYWcWbbmvetRjsOPkFEuZDgMe8@OEYp8TrWpbyBQ "PHP – Try It Online")
[Answer]
# Pyth, 54 bytes
```
L+hb?>F}RJ"aeiouy"<b2+hKtb*2+XhK"cgdsfbpvztkg")h@JKytb
```
This defines a function `y`, that expects a string. 
Try it online: [Test Suite](http://pyth.herokuapp.com/?code=L%2Bhb%3F%3EF%7DRJ%22aeiouy%22%3Cb2%2BhKtb%2A2%2BXhK%22cgdsfbpvztkg%22%29h%40JKytb%0Ayz&input=creation%0Acoverage%0Aexample%0Aprogramming%0Apresident&test_suite=1&test_suite_input=creation%0Acoverage%0Aexample%0Aprogramming%0Apresident%0Aaei&debug=0)
[Answer]
# Python 3, ~~155~~ 139 bytes
```
import re
def f(x,k='aeiouy])'):b,c,v=re.findall(f'(.*?[{k}([^{k}.*?([{k}',x)[0];return b+c+(('bcdfgkpstvz'+c)['pgtvkgbzdfs'.find(c)]+v)*2
```
*removed 16 bytes thanks to @ovs*
*removed 1 byte thanks to Gábor Fekete*
[Answer]
# Java 8, ~~243~~ ~~236~~ 222 bytes
```
s->{String q="[a-z&&[^aeiouy]]",a=s.replaceAll("(^"+q+"*[aeiouy]+"+q+").*","$1"),b="pgtvkhjglmnbqrzdfwxs".charAt("bcdfghjklmnpqrstvwxz".indexOf(a.charAt(a.length()-1)))+s.replaceAll(a+q+"*([aeiouy]).*","$1");return a+b+b;}
```
Uses `.replaceAll` regexes with capture groups to filter out the parts we don't want.
**Explanation:**
[Try it here.](https://tio.run/##jZDNjoIwFIX3PkXTTEwrQuKaMIkPMM5ilkSTSylYLKW0BVHDszPVYCazGWfT3J@v7Tmngh7CRnNV5aeJSbAWfYBQtwVCQjluCmAc7e4tQl/OCFUiRubC0tjPx4U/rAMnGNohhRI02fD9NjNtglMIr8tlegAumu6y3@M1JDYyXEv/9lZKgskBB22AV@mMBI@WRiu8xm8bTNdZgnXp@tOxKmWtstZc8@I8WByxI5itIzhjeVEeq5Pf6tZY15@HK46EyvnwWRB4chBJrkp3JDTcUEqDXzLgoYE8Rfx8HxvuOqMQBFmQxeMU3x3rLpPe8Wy8b0SOah/cnE26R0Dn1C7W8TpqOhdpv3JSERUxgpnh/mqjMH3E@AfY9NxAyV@CfIBay9ecNk1poK69zn@w3IqcKzeT42KcvgE)
```
s->{ // Method with String parameter and String return-type
  // Temp String we use multiple times:
  String q="[a-z&&[^aeiouy]]",
   // Regex to get the first part (i.e. `creation` -> `creat` / `example` -> `ex`)
   a=s.replaceAll("(^"+q+"*[aeiouy]+"+q+").*","$1"), 
   // Get the trailing consonant and convert it
   b="pgtvkhjglmnbqrzdfwxs".charAt("bcdfghjklmnpqrstvwxz".indexOf(a.charAt(a.length()-1)))
   // Get the next vowel after the previous consonant from the input-String
    +s.replaceAll(a+q+"*([aeiouy]).*","$1");
  // Return the result:
  return a+b+b;
} // End of method
```
[Answer]
# [Haskell](https://www.haskell.org/), 143 141 138 137 136 bytes
```
z h=elem h"aeiouy"
f i|(s,(m,c:x))<-span z<$>break z i,j:_<-filter z x,d<-"pgt.vkh.jglmn.bqrzd.fwx.s"!!(fromEnum c-98)=s++m++[c,d,j,d,j]
```
[Try it online!](https://tio.run/##LY2xTsMwFEV3vuLVYkgUxzNUSTc2mBirqnLtl8SJn21sp4SIfw8tMFzp3KMr3UGmCa3dthWGFi0SDEyi8fMXe@jAfBeJF8TVfinLpk5BOlibx8MlopxgBcPH/bmpO2MzxltfuG5qFvosrtMgxt6SE5ePuGrRfS4isd2u6KKnFzcTqPr5qWxTVVFVHRXXfLzntJE0riUZ3s5QhDm/5/jqQEBXwpGp22823jEOTPkrRtnjnXGRFOwvhuj7KImM6/9W@l9jMhpdZqftBw "Haskell – Try It Online")
[Answer]
# Python, ~~261~~ 260 bytes
```
def c(s,t='bpcgdtfvgksz'):
 q,r,t='aeiouy',range(len(s)),t+t[::-1]
 c=[i for i in r if i>[j for j in r if s[j]in q][0]and s[i]not in q][0]
 C=([t[2*i+1]for i in range(12)if s[c]==t[i*2]]or s[c])[0]
 return s[:c+1]+(C+s[[i for i in r if i>c and s[i]in q][0]])*2
```
A Non regex, Not esoteric solution. Took about 20 minutes to make, and an hour more to golf.
It probably has more list comprehension than the entire python standard library, mostly because I don't know regex...
[Try it online! (With testcases)](https://tio.run/##bVFNb9swDL37VxDZQXbiBkt6M@ABW9D@CVUHVaZdJbbkSkznpOhvzyR1SRqgPFj8eI98pMcDvVhzfzo12ILKfVFl8Fq6kmomUdv9gZVOmg7zHk2oFiV7HlXXUPvW7fyRZUA1LYhX1d1KZKBqrqG1DjRoA@FpQf/i25TaXlKeb0XwXwX/KaRpQqyFsQTnXAabOufE13O9WIlru6RjtS5SCyXqmrier4UIgBgXieqQ9s6ERKUCeZFvFp5/I0rBefJ5qijm69OPzd6THYDQkzYdtHujSFtTwl@nidDA8wG87PTOj1kWbxaReYSV0VPSY7phsDgyxnHqpfZZikbucA2iSe/RURqZR2wRFjzTePyKCxwnhSPB78QI8h6cs@62m5M6jP4TaA8JHFD57PH/OtBK3XuwV2HwxN7j@/HElrNlkD5ISirqJKVIvUenDX3pMkbJDci@vy64nBVZlo6iynem7Bs62SGrottii6y8yGQ4yWHsYxGnSU7ya210tnNyGMJfCPUY7eTuBqFs89m3ISS85aLXDRpKTPRHfdTsozj9Aw)
[Answer]
## Python 2, ~~251~~ ~~246~~ ~~245~~ ~~239~~ ~~237~~ ~~234~~ ~~229~~ 211 bytes
First submission here. 
```
def f(s):
  r=c='';n=0;w='aeiouy';a='bcdfghjklmnpqrstvwxz'
  for i in s:
    if n<2:r+=i
    if n<1and i in w:n=1
    if n==1and i in a:c='pgtvkhjglmnbqrzdfwxs'[a.index(i)];n=2
    if n==2and i in w:r+=c+i+c+i;break
  return r
```
[Try it online!](https://tio.run/##XZLBcqMwDIbP5Sk82YNhkslscyT1YbfTvkTbg4Jl4gI2lZ1A0umzpzY0CalnAEv6JX2yaQ9@a83qdJKomEpdlieMRCE4Xxvxd90JDqjt7sDXIPimkKrcvld1Y9oPcn7f9UeeMGWJaaYNc3lypxUzD6uc5kL/GPdg5BjvciPuR68QVzfkoV9b@n21fS9D7c0HHaXqesdfYKmNxD7V2VvgWZ1zV5OSoVMx1/PwrDeEUAV@9DsyjE5/HnfO24Z5dF6bkqmdKby2ZsE60t6jYZsDc1DqyrVJEk8gKtMoW8RdAQ6HEwkrDhnt2PQSG0NxeTpcjbjAOSQ/tEyjNhPikvYS328XOfYFtp79GzIC3hORpdtqBDq0/h/SngZxUKWz559xmAJdO2avYOyVf8bv1ytfzpYBvQE/UIgBJRtqt6SNn1RpI7JkUNfXAZezLEnGQ1l88sLukaBEnsetQoV8ccHk2EPT1jGIfQ89TGMt2ZKgacIthHi0KqhuFIWVY13p0eNtLjot0fghE91RHzX/ClzDAOGn5UW49zgCzya@M@vEdyacuKZgN9nyl@zMEPqevgE "Python 2 – Try It Online")
Fellow golfers that helped me:
```
 Destructible Lemon / Wheat Wizard - 5 bytes
 Hubert Grzeskowiak - 1 byte
 musicman523 - 16 bytes
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 90 bytes
```
->x{x[/(.*?#{$v='[aeiouy]'}+.).*?(#$v)/];$1+($1[-1].tr('bcdfgkpstvz','pgtvkgbzdfs')+$2)*2}
```
[Try it online!](https://tio.run/##Tc27DoMgGEDh3adolOQHrRpdG9sHsQ6oQIxVCCLxEp@dduhtPN9y9Fyvbin8RjNqOjn6Hi/uLr4u@1KmOAlvwY5sASVlnZzXCo4oIS/FAbIkrS4oizDKyjirEqMx1E3LRa8mYzc4gxLG9qLeWj4BiVBOwvxw6sQTDJ8dEO8N0jJNBfsCW@igHr9WWgpNh6EbxZ@xqWvZaIC4Jw "Ruby – Try It Online")
Ungolfing it a bit, we have something equivalent to:
```
def covfefefify(x)
  v = '[aeiouy]'
  # Match x to a regular expression capturing:
  # Group 1:
  #  some characters (non-greedy)
  #  followed by some (greedy) non-zero number of vowels
  #  followed by exactly one character
  # Ungrouped:
  #  Some more (non-greedy) characters
  # Group 2
  #  Exactly one other vowel
  # By switching between greedy and non-greedy matches, we can capture longest and shortest vowel/consonant sequences without writing out all the consonants
  x[/(.*?#{v}+.).*?(#{v})/]
  # Glue it back together, replace the necessary consonants, duplicate where needed
  $1+($1[-1].tr('bcdfgkpstvz','pgtvkgbzdfs')+$2)*2
end
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~175~~ ~~141~~ 110 bytes
```
->s{s=~/(.*?#{v='[aeiouy]'}+(#{c='[^aeiouy]'}))#{c}*(#{v})/;"#$1#{($2.tr('bcdfgkpstvz','pgtvkgbzdfs')+$3)*2}"}
```
[Try it online!](https://tio.run/##PcxBboMwFATQPaf4wlS2SUMUuqxIDoKoZMBYJAEsf@M0cdyrU6uLzmr0pBmzto9tqLb9CT1WPwdW5GfiXUVrIcdlfTQ07BjxXYSvf@E8Ssiju8APnynJjsSzrCysYbTt@kFdNVr3pO9UK@uuqn32A1K@yz54XoY0bFaiRajg7V53Rgo7LjN0i5NGKAnyW0z6JkGbRRkxTeOsYpc49nK2TZLoNW7/HopJaPDwwlcCMSnxWNwuK1p2LHmA/QmIH2psQpqEZPsF "Ruby – TIO Nexus")
* Saved 34 bytes thanks to [Eric Duminil](https://codegolf.stackexchange.com/users/65905/eric-duminil)
* Saved 31 bytes thanks to [Value Ink](https://codegolf.stackexchange.com/users/52194/value-ink) + optimized suggested `tr` arguments
**Ungolfed**
```
covfefify = -> (s) {
    from = 'bcdfgkpstvz'
    to   = 'pgtvkgbzdfs'
    vowels = "[aeiouy]"
    consonants = "[^aeiouy]"
    s.match(/(.*?#{vowels}+(#{consonants}))#{consonants}*(#{vowels})/)
    d = ($2.tr(from, to) + $3) * 2
    "#$1#{d}"
}
```
[Answer]
# Crystal, ~~203~~ ~~194~~ ~~187~~ ~~186~~ ~~184~~ 163 bytes
```
o=""
ARGV[v=c=0].each_char{|a|r=/#{a}/
"aeiouy"=~r&&(v=x=1)||(c=v)
o+=a if c<2||x
c>0&&(x&&break||(o+=(i="pgtvkgbqrzdfs"=~r)?"bcdfgkpqrstvz"[i]: a))}
p o+o[-2..-1]
```
[Answer]
## [Retina](https://github.com/m-ender/retina), 68 bytes
```
r`\B(?>([^aeiouy])+)([aeiouy]).*
$1$1$2$1$2
T-5>`fs\dbgcgk\ptzv`Ro`.
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7wvyghxknD3k4jOi4xNTO/tDJWU1tTIxrG1tPiUjEEQiMQ5grRNbVLSCuOSUlKT07PjikoqSpLCMpP0Pv/Pzm/LLUoMT2VK7UiMbcgJ5WroCg/vSgxNzczL50rOT8FJJBanJmSmlcCAA "Retina – Try It Online")
[Answer]
# [!@#$%^&\*()\_+](https://github.com/ConorOBrien-Foxx/ecndpcaalrlp), ~~102~~ ~~101~~ ~~100~~ ~~99~~ 80 bytes
```
`33554(_(^1%)%)$pgtevkhijglmnobqrzdufwxys(0*!@&)^(0*!!@&_^)Q++&!@%(0*!^&)+!@0&@@
```
42nd answer of this question, it looks like. Just one byte longer than BQN! It took much more time than it should. I'm pretty sure there are still some simple tricks that I'm missing.
Accept lowercase characters. The program does not actually contain digits - `01345Q` in the code above are unprintable characters with ASCII code 0, 1, 3, 4, 5 and 25 respectively.
[Try it online!](https://tio.run/##S03OSylITkzMKcop@P8/gZmZlZVFI14jjlFVU1VTpSC9JLUsOyMzKz0nNy8/qbCoKqU0rbyisliDQUvRQU0zDkQDGfFxmpLa2mqKDqoggTg1TW1FBwY1B4f//5Pzy1KLEtNTAQ "!@#$%^&*()_+ – Try It Online")
[Answer]
# MATLAB / Octave - ~~159~~ 158 bytes
The following works assuming the input string is all lowercase. 
```
a=input('','s');m=ismember(a,'aeiouy');s='pgt vkh jglmn bqrzd fwx s';m(1:find(m,1))=1;i=find(~m,1);f=a(1:i);d=s(f(end)-97);m(1:i)=0;v=a(find(m,1));[f d v d v]
```
# Explanation
1. `a = input('','s');`: Gets a string from STDIN and stores it into the variable `a`.
2. `m=ismember(a,'aeiouy');`: Returns a Boolean array that is the same size as the string `a` determining where vowels are located
3. `s='pgt vkh jglmn bqrzd fwx s';` The `covfefe` mapping of consonants as a string. This string is 25 characters long and omitting the vowels. The first position where the vowel `'a'` is supposed to be is removed while the other positions where the vowels are located are placed with a dummy space character. This is so that when we determine the first consonant appearing after the vowel, we will convert the consonant to a position to access a character in this string to determine the first component of the converted word.
4. `m(1:find(m,1))=1`: Sets the first position of the Boolean array up to where we have found the first vowel as all vowels. This will be so that when we search for the next consonant that follows the first vowel, we will ignore these characters.
5. `i=find(~m,1);`: Finds the first position of the string that is a consonant after the first vowel.
6. `f=a(1:i)`: Removes the string after the first consonant that follows the vowel. We simply sample from the first position of the string up to this point.
7. `d=s(f(end)-97);`: Take the last character of the string that is remaining and finds where we need to sample from the lookup string and gets that character. Subtracting a character and a number in MATLAB or Octave coalesces to form an integer by converting the character into its ASCII code. In this case, we subtract the last character by the character at the beginning of the alphabet to give us the position relative to the beginning. However, instead of subtracting by `b` (98), we subtract by `a` as MATLAB starts indexing by 1 instead of 0. `'a'`'s ASCII code is 97.
8. `m(1:i)=0;`: Takes the Boolean mask and sets all characters in the input string from the first position to the first consonant following a vowel to false.
9. `v=a(find(m,1));`: Finds the next vowel that follows the first consonant from the input string.
10. `[f d v d v]`: Output our `covfefe`ied string.
# Example Runs
```
>> a=input('','s');m=ismember(a,'aeiouy');s='pgt vkh jglmn bqrzd fwx s';m(1:find(m,1))=1;i=find(~m,1);f=a(1:i);d=s(f(end)-97);m(1:i)=0;v=a(find(m,1));[f d v d v]
coverage
ans =
covfefe
>> a=input('','s');m=ismember(a,'aeiouy');s='pgt vkh jglmn bqrzd fwx s';m(1:find(m,1))=1;i=find(~m,1);f=a(1:i);d=s(f(end)-97);m(1:i)=0;v=a(find(m,1));[f d v d v]
example
ans =
exxaxa
>> a=input('','s');m=ismember(a,'aeiouy');s='pgt vkh jglmn bqrzd fwx s';m(1:find(m,1))=1;i=find(~m,1);f=a(1:i);d=s(f(end)-97);m(1:i)=0;v=a(find(m,1));[f d v d v]
programming
ans =
progkaka
>> a=input('','s');m=ismember(a,'aeiouy');s='pgt vkh jglmn bqrzd fwx s';m(1:find(m,1))=1;i=find(~m,1);f=a(1:i);d=s(f(end)-97);m(1:i)=0;v=a(find(m,1));[f d v d v]
code
ans =
codtete
>> a=input('','s');m=ismember(a,'aeiouy');s='pgt vkh jglmn bqrzd fwx s';m(1:find(m,1))=1;i=find(~m,1);f=a(1:i);d=s(f(end)-97);m(1:i)=0;v=a(find(m,1));[f d v d v]
president
ans =
preszizi
```
# Try it online!
<http://www.tutorialspoint.com/execute_octave_online.php?PID=0Bw_CjBb95KQMdjROYVR0aFNrWXM>
When you hit the Execute button at the top, wait a few moments, then enter the desired string. Enter the string slowly as there seems to be a delay when entering in text.
[Answer]
## Clojure, ~~182~~ 156 chars
```
#(let[v #{\a\e\i\o\u\y}p(partition-by v %)[s m[c][n]](if(v(first %))(cons[]p)p)z[(or((zipmap"bcdfgkpstvz""pgtvkgbzdfs")c)c)n]](apply str(concat s m[c]z z)))
```
### How It Works
```
(partition-by v "president")
```
Returns a seq of `((\p \r) (\e) (\s) (\i) (\d) (\e) (\n \t))`
```
[s m [c] [n]] (if (v (first x)) (cons [] p) p)
```
Destructures the seq into `s=(\p \r)`, `m=(\e)`, `c=\s`, `n=\i`.
Or for "example" it's `s=[]`, `m=(\e)`, `c=\x`, `n=\a`.
```
(apply str (concat s m [c] [(l c) n] [(l c) n]))
```
Returns the output string by concatenating the pieces together and stringifying it.
And then I just removed as much whitespace as I could while still making it compile.
De-uglified:
```
(defn covfefify [x]
  (let [vowel? #{\a\e\i\o\u\y}
        parts (partition-by vowel? x)
        [start mid [consonant] [last-vowel]] (if (vowel? (first x)) (cons [] parts) parts)
        lookup #(or ((zipmap "bcdfgkpstvz" "pgtvkgbzdfs") %) %)]
    (apply str (concat start mid [consonant] [(lookup consonant) last-vowel] [(lookup consonant) last-vowel]))))
```
[Answer]
# BlitzMax, 190 bytes
```
s$=Input()For i=1To s.Length
f="aeiouy".Contains(s[i-1..i])If f v=i If c Exit
If v And c|f=0c=i
Next
t$="bpdtfvgkcgsz"x$=s[c-1..c]r=t.Find(x)~1If r>=0x=t[r..r+1]
x:+s[v-1..v]Print s[..c]+x+x
```
Takes a word from stdin and prints the result to stdout. The input word is assumed to be lowercase and to contain at least one vowel followed by a consonant.
A more readable version of the progam with formatting and variable declarations:
```
SuperStrict
Framework BRL.StandardIO
Local s:String = Input()
Local v:Int
Local c:Int
For Local i:Int = 1 To s.Length
    Local f:Int = "aeiouy".Contains(s[i - 1..i])
    If f Then
        v = i
        If c Then Exit
    End If
    If v And c | f = 0 Then c = i
Next
Local t:String = "bpdtfvgkcgsz"
Local x:String = s[c-1..c]
Local r:Int = t.Find(x) ~ 1
If r >= 0 Then x = t[r..r + 1]
x :+ s[v - 1..v]
Print s[..c] + x + x
```
How it works:
BlitzMax doesn't have any builtin regex functionality or similar, so a loop is used to iterate over the characters of the input word until it finds a vowel followed by a chain of at least one consonant. The variable c stores the position of the last of those consonants, v that of the vowel. The loop continues to see if there is another vowel after the chain and if so, v is updated accordingly.
Then the consonant at c is looked up in the string "bpdtfvgkcgsz", which acts as a replacement table. If the consonant is found in the table at any position, then that position is XOR-ed with 1 and the character at the resulting position gets used as its replacement. The XOR operation turns 0 into 1, 2 into 3, 4 into 5 etc. and vice versa, so that b gets swapped with p, d with t and so on. Finally, the original string up to c, the replacement character and the vowel at v are put together as required and printed.
Example results:
> 
> coverage covfefe
> 
> 
> creation creatdidi
> 
> 
> programming progkaka
> 
> 
> stupidity stupbibi
> 
> 
> blah blahhaha
> 
> 
> 
[Answer]
# R, 341 characters
```
f=function(x){g=function(x,y)el(strsplit(x,y));a=g(x,'');v=g('aeiouy','');n=letters[-c(1,5,9,15,21,25)];l=data.frame(n,g('pgtvkhjglmnbqrzdfwxs',''));y=min(match(n,a)[which(match(n,a)>min(match(v,a),na.rm=T))]);m=l[which(l$n==a[y]),2];e<-a[-c(1:y)][min(match(v,a[-c(1:y)]),na.rm=T)];paste0(paste0(a[c(1:y)],collapse=''),m,e,m,e,collapse="")}
```
Horrendous R attempt, why are strings so hard
Readable version:
```
f = function(x) {
  g = function(x, y)el(strsplit(x, y))
  a = g(x, '')
  v = g('aeiouy', '')
  n = letters[-c(1, 5, 9, 15, 21, 25)]
  l = data.frame(n, g('pgtvkhjglmnbqrzdfwxs', ''))
  y = min(match(n, a)[which(match(n, a) > min(match(v, a), na.rm = T))])
  m = l[which(l$n == a[y]), 2]
  e <-a[-c(1:y)][min(match(v, a[-c(1:y)]), na.rm = T)]
  paste0(paste0(a[c(1:y)], collapse = ''), m, e, m, e, collapse = "")
}
```
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 142 bytes
```
s=input()
g=lambda i,f='aeiuoy':i if s[i]in f else g(i+1,f)
q=g(g(0),c:='pgtcvkh jglmn bqrzd fwx s')
exit(s[:-~q]+(c[ord(s[q])-98]+s[g(q)])*2)
```
[Try it online!](https://tio.run/##Dcc7EoMgFADA3lO8Dog6k09jnOEkDAUq4EsUQTDRFLk6yXbrjzQu7tb4NefI0fktUVZYPqm5GxRgZThRGrflIC0CGogCJTowoKeowVIsL5VhReCWWnpmVd9y4m3qX88RHnaaHXRh/Qxg3jtEwgq9Y6JRtPU3yJL2YlmHf4Nk9b2RZRSWBibZ6cpyVl7HHw "Python 3.8 (pre-release) – Try It Online")
A little late to the party, but here's yet another non-regex Python answer! I interpreted the rules to allow printing to STDERR which saves a byte (`exit`/`print`). Using Python 3.8 over 3<=3.7 saves me a total of 1 byte with the walrus operator as opposed to defining the `c` variable elsewhere.
Thanks a lot to Post Rock Garf Hunter (-21 bytes) for the help!
[Answer]
# Perl, 71 bytes
```
s#[aeiouy]+(.)\K.*?([aeiouy]).*#"$1$2"=~y/bcdfgkpstvz/pgtvkgbzdfs/rx2#e
```
Also run with `perl -pe`. A few bytes less than the previous Perl solution. Admittedly I got some inspiration from there as well.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~101~~ ~~104~~ 88 bytes
-16 bytes thanks to Okx
I somehow hope this can be done *way* more efficiently.
```
žOÃćIsk>[DIs£¤žPså#\>]s[DIsèDžOså#\>]ŠŠ"bpcgdtfvgkhhjjkgllmmnnpbqqrrsztdvfwwxxzs"S2ôDí«ø`Šs¤sŠksŠèsŠì2×«
```
[Try it online!](https://tio.run/##MzBNTDJM/f//6D7/w80Gh1dk20W7eBYfWnxoydF9AcWHlyrH2MUWg4QOr3ABqoGKHF1wdIHeo4ZF5oe2HV59eNKjhimHpyUd2nJs0qPOBYdbHjXMObrw1KTDbYe2esUdnhsG5B/uK7iwA6gh2OjwFpfDaw@tPrwj4eiC4kNLio8uyAbiwytAxBqjw9MPrf7/Pzm/LLUoMT0VAA "05AB1E – Try It Online")
## Explanation
```
                  Argument: s
žOÃ0èk            Get index of first vowel in s
>[DIs£¤žPså#\>]   Increment index and split s until last character of substring is a consonant
s[DIsèDžOså#\>]   Increment index an get character at index in s until character is a vowel
ŠŠ                Rearrange stack
.•7¶ëÒ—Öb´ƒ≠Ä“šʒÆµJ^ÝV“Îpи•S2ôDí«ø`   Prepare character substitution map
Šs                Rearrange stack
¤                 Last character of substring
sŠ                Rearrange stack (yes, again)
k                 Index of last character in substitution key list
sŠ                Rearrange stack (it won't stop)
è                 Character at index in character substitution value list
sŠ                Rearrange stack (ONE LAST TIME)
ì2×«              Prepend substitution consonant before vowel, duplcicate and concatenate with the substring from the very beginning
```
[Answer]
# Vim, 107 keystrokes
Who needs Java, Python 3, Modern Pascal 2.0, C#, Python 2, R, Go, C, BlitzMax, Javascript, Crystal, Clojure, Lua, Matlab/Octave, Haskell and PHP when you have vim?
```
i ⎋o⏎bcdfghjklmnpqrstvwxz⏎pgtvkhjglmnbqrzdfwxs⎋1Ghqy/[aeiouy]⏎q/[^aeiouy]⏎mz@yyl`zpld$yhjpg*jyl`zpy2lPjdGX
```
`⎋` is the `Escape` key and `⏎` is the `Return` key
## Explanation
```
i ⎋                         Insert a space before the first character
o⏎bcdfghjklmnpqrstvwxz⏎     Insert the character data
  pgtvkhjglmnbqrzdfwxs⎋1Gh
qy/[aeiouy]⏎q               Find the first vocal after the space
/[^aeiouy]⏎mz               Find the next consonant and add a marker
@yyl`zp                     Find the next vocal and put it after the consonant 
ld$                         Delete the rest of the world
yhjpg*                      Search for the consonant in the first row of the character data
jyl                         Copy the character in the same position in the second row
`zpy2lPjdGX                 Paste it after the last vowel and repeat the two last characters
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~55~~ 42 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
η.ΔžOSåàyžPSÅ¿à*}ÐIsKžOÃнsθ.•gÍĆdQ¸G•Â‡ìDJ
```
-13 bytes thanks to *@Grimmy*.
[Try it online](https://tio.run/##AVgAp/9vc2FiaWX//863Ls6Uxb5PU8Olw6B5xb5QU8OFwr/DoCp9w5BJc0vFvk/Dg9C9c864LuKAomfDjcSGZFHCuEfigKLDguKAocOsREr//3Byb2dyYW1taW5n) or [verify all test cases](https://tio.run/##yy9OTMpM/V9TVmmvpPCobZKCkn3l/3Pb9c5NObrPP/jw0sMLKo/uCwg@3Hpo/@EFWrWHJ1QWewNlDjdf2Ft8bofeo4ZF6Yd7j7SlBB7a4Q7kHG561LDw8BoXr/86/5OLUhNLMvPzuJLzy1KLEtNTuVIrEnMLclK5Cory04sSc3Mz89KB7NTizJTUvBIA).
**Explanation:**
```
η                # Suffixes of the (implicit) input
                 #  i.e. "creation" → ["c","cr","cre","crea","creat","creati","creato","creatio","creation"]
 .Δ       }      # Find the first for which the following is truthy:
   žO            #  Push vowels (including y): "aeiouy"
     S           #  Convert it to a list of characters: ["a","e","i","o","u","y"]
      å          #  Check for each if they're in the current (implicit) suffix
                 #   i.e. "creat" → [1,1,0,0,0,0]
       à         #  Pop and push the max (basically check if any are truthy)
                 #   i.e. [1,1,0,0,0,0] → 1
   y             #  Push the suffix again
    žP           #  Push the consonants (excluding y): "bcdfghjklmnpqrstvwxz"
      S          #  Convert to a list of characters: ["b","c","d","f","g","h","j","k","l","m","n","p","q","r","s","t","v","w","x","z"]
       Å¿        #  Check for each if the suffix ends with it
                 #   i.e. "creat" → [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0]
         à       #  Pop and push the max (basically check if any are truthy)
                 #   i.e. [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0] → 1
   *             #  Check if both are truthy
                 #   i.e. 1 and 1 → 1
           Ð     # Triplicate the found suffix
            I    # Push the input
             s   # Swap the top two items on the stack
                 #  i.e. stack contains now: "creat","creat","creation","creat"
K                # Remove the suffix from the input
                 #  i.e. "creation" and "creat" → "ion"
 žOÃ             # Only leave the vowels
                 #  i.e. "ion" → "io"
    н            # Pop and push the first character
                 #  i.e. "io" → "i"
s                # Swap again so the prefix is a the top of the stack again
 θ               # Pop and push the last character
                 #  i.e. "creat" → "t"
  .•gÍĆdQ¸G•     # Push string "bcdfkszgvtgp"
            Â    # Bifurcate it (short for Duplicate & Reverse copy): "pgtvgzskfdcb"
             ‡   # Transliterate the character of "bcdfkszgvtgp" to the same index in "pgtvgzskfdcb"
              ì  # Prepend the second character in front of the first
                 #  i.e. "d" and "i" → "di"
               D # Duplicate it
J                # Join the stack together (and output implicitly)
                 #  i.e. "creat" and "di" and "di" → "creatdidi"
```
[See this 05AB1E tips of mine (section *How to compress strings not part of the dictionary?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `.•gÍĆdQ¸G•` is `"bcdfkszgvtgp"`.
[Answer]
# [Lexurgy](https://www.lexurgy.com/sc), ~~288~~ ~~286~~ 281 bytes
Docs [here](https://www.meamoria.com/lexurgy/html/sc-tutorial.html).
Lexurgy is an online tool meant for conlangers (people who make constructed languages) to apply sound changes to their conlangs via a series of programmable rules. As such, this tool involves many string operations.
* -2: remove the `u` and `w` classes and replace them with one-time substitutions.
* -5: fix a bug with the `example` case, combine some rules into a single step
```
Class v {a,e,i,o,u}
Class c {p,t,k,f,s,c,b,d,g,v,z,g,h,j,l,m,n,q,r,w,x}
a:
@c *=>@c ;/$ @c* @v* _//{$ _,$ @c _}
b:
@c=>* /; _
c:
{@v,@c}=>* /; @v {@v,@c}* _
* {{p,t,k,f,s,c,x},{b,d,g,v,z,g,x}}$1=>$1 {{b,d,g,v,z,g,x},{p,t,k,f,s,c,x}}/_ ;
e:
@c$1 ;=>; $1
f:
(@c @v)$1=>$1 $1/; _
;=>*
```
Ungolfed:
```
Class vowel {a,e,i,o,u}
Class unvoiced {p,t,k,f,s,c}
Class voiced {b,d,g,v,z,g}
Class consonant {@unvoiced,@voiced,h,j,l,m,n,q,r,w,x}
# find first consonant after first vowel
part-1:
 @consonant * => @consonant ; / $ @consonant* @vowel* _ // {$ _, $ @consonant _}
romanizer-a:
 unchanged
# delete the consonant after the seperator
part-2:
 @consonant => * / ; _
romanizer-b:
 unchanged
# remove everything except the second vowel
part-3:
 {@vowel, @consonant} => * / ; @vowel {@vowel, @consonant}* _
romanizer-c:
 unchanged
# voicings
part-4:
 * @voiced$1 => $1 @unvoiced / _ ;
 * @unvoiced$1 => $1 @voiced / _ ;
romanizer-d:
 unchanged
# swap mapped consonant and seperator
part-5:
 @consonant$1 ; => ; $1
romanizer-e:
 unchanged
# duplicate the `fe`
part-6:
 (@consonant @vowel)$1 => $1 $1 / ; _
romanizer-f:
 unchanged
# remove the seperator
part-7:
 ; => *
```
[Answer]
# Crystal, 130 Bytes
```
c=/[aeiouy]/
x,y,z=ARGV[0].partition /[^aeiouy]*#{c}*/
k=z[0]
b=((i="pgtvkgbqrzdfs"=~/#{k}/)?"bcdfgkpqrstvz"[i]: k)+z[c]
p y+k+b*2
```
# How it works
```
c = /[aeiouy]/
```
store a regex for searching first vowel to `c`.
```
x, y, z = ARGV[0].partition /[^aeiouy]*#{c}*/
```
split the first argument into three parts {"", String until one character before the first consonant after first vowel, rest of string} and store each of the elements into x, y and z.
```
k = z[0]
```
get the first character, the relevant consonant.
```
i = "pgtvkgbqrzdfs" =~ /#{k}/
```
get the index of the consonant inside the left string or `nil`.
```
b = ((i = ...) ? "bcdfgkpqrstvz"[i] : k) + z[c]
```
if `i` is not `nil`, use this index for the second string (kind of a golfed hash).
if `i` is `nil`, use the original character.
next, append the first vowel of `z`.
```
p y + k + (b * 2)
```
finally, print first part from first regex `y`, the first consonant `k` and two times the previous calculated string `b`.
[Try it online](https://tio.run/##LcrBCoMgGADgu08RdqmMOXYcSA8iDtRK5B/L1Mk02qu7y77zp30OUT5r1YxyudjtnQVFnzGPhWG9pcVLs@CLkz7aaLdXQ/nj34b20OdAEbDCrwIp1nWWYWdiAqN2X@Y1YPal7QEn7Ses9LwacLsPMRXMrbg30JPCtUCuyQSIGm61/gA).
[Answer]
# sed, 106 (105+1) bytes
This is sed with the `-E` flag, which apparently counts for one byte.
```
s/([aoeuiy][^aoeuiy])[^aoeuiy]*(.).*/\1\2/
h
s/.*(..)/\1\1/
y/bcdfgkpstvz/pgtvkgbzdfs/
x
s/.$//
G
s/\n//g
```
[Try it online!](https://tio.run/##PYtBDoIwEEX3cw4XlMRO8A7GQ4AmhQ61QdqmUwlweCtNjLuX999n0jkzVq3y9LbbvX38QPyprqSQNXZNd0F4AqM8jBRFNAgb9oMezRQ4LTsGk5bJ9LseGWEt7QkRbgd0DtHkPERSyXoHg18oKkNAq5rDiyBEb6KaZ@vMMeoiiK0mlz4@lAvn8/UL "sed – Try It Online")
]