En este desafío, debe tomar una cadena que coincida con la expresión regular ^[a-zA-Z]+$o lo que sea razonable (no tiene que considerar letras mayúsculas o minúsculas si lo desea) (puede suponer que la cadena es lo suficientemente larga y tiene la estructura correcta para todos los operaciones), y genera otra cadena, producida de manera similar a la palabra al final de un reciente tweet dadaísta por POTUS ( "Despite the constant negative press covfefe").

Cómo codificar una cadena:

Primero, obtenga el primer grupo de sonido (terminología compuesta).

¿Cómo haces esto? Bien:

• Encuentra la primera vocal ( ytambién es una vocal)

    v
  creation
  

• Encuentra la primera consonante después de eso

      v
  creation
  

• Retira el resto de la cuerda

  creat
  

Ese es tu primer grupo de sonido.

Próximo paso:

Obtener la última consonante del grupo de sonido.

t

y reemplácelo con la versión con voz o sin voz. Para hacer esto, encuentre la letra en esta tabla. Reemplace con la letra dada (que puede ser la misma letra)

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

entonces, obtenemos

d

Luego, toma la siguiente vocal después de esa consonante. Puede suponer que esta consonante no está al final de la cadena. Une estos dos juntos, luego repítelo dos veces:

didi

Concatena esto con el primer grupo de sonido:

creatdidi

Ya ha terminado: la cadena está codificada y ahora puede generarla.

Casos de prueba:

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

Este es el código de golf , ¡así que haga su programa lo más corto posible!

Jalea ,  58  57 bytes

<TḢị
e€Øyµ¬TĖEÐḟḢṪ;ç¥T
ḣÇḢ⁸ÇịµḢØYiị“ßȷ%Hẹrȧq’œ?ØY¤⁾cgy;ẋ2

Un programa completo que acepta una lista de caracteres en minúscula e imprime el resultado.

Pruébalo en línea!

¿Cómo?

<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

JavaScript (ES6), 107 103 bytes

Guardado 4 bytes gracias a GOTO 0

s=>([,a,b,c]=s.match`(.*?[aeiouy]+(.)).*?([aeiouy])`,a+(b=(a="bcdfgszkvtgp")[11-a.search(b)]||b)+c+b+c)

Casos de prueba

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

Jalea , 45 39 bytes

Øa“œṣ$b|0Ḃ’ṃ,Ṛ$yṫµfØyḢṭḢẋ2
e€ØyIi-‘ɓḣ;ç

Pruébalo en línea!

Cómo funciona

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 = 0, b = 1, ..., z = 25.
                            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.

CJam , 59 58 57 56 bytes

q_{"aeiouy":V&,_T|:T^}#)/(_W>"cbdfkszgvtpg"_W%er@sV&0=+_

Pruébalo en línea!

Explicación

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.

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);}

Pruébalo en línea!

Perl 5 , 81 72 bytes

s![aeiouy]+(.)\K.*!($1=~y/bcdfgkpstvz/pgtvkgbzdfs/r.$&x/[aeiouy]/g)x2!ge

Pruébalo en línea!

PHP, 121 bytes

$v=aeiouy;preg_match("#(.*?[$v]+([^$v])).*?([$v])#",$argn,$t);echo$t[1],$z=strtr($t[2].$t[3],bcdfgkpstvz,pgtvkgbzdfs),$z;

Pruébalo en línea!

Pyth, 54 bytes

L+hb?>F}RJ"aeiouy"<b2+hKtb*2+XhK"cgdsfbpvztkg")h@JKytb

Esto define una función y, que espera una cadena. Pruébelo en línea: Test Suite

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

eliminado 16 bytes gracias a @ovs

eliminado 1 byte gracias a Gábor Fekete

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

Utiliza .replaceAllexpresiones regulares con grupos de captura para filtrar las partes que no queremos.

Explicación:

Pruébalo aquí

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

Haskell , 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]

Pruébalo en línea!

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

Una solución no regex, no esotérica. Tomó unos 20 minutos para hacer, y una hora más para jugar al golf.

Probablemente tiene más comprensión de la lista que toda la biblioteca estándar de Python, principalmente porque no sé expresiones regulares ...

Pruébalo en línea! (Con estuches)

Rubí , 90 bytes.

->x{x[/(.*?#{$v='[aeiouy]'}+.).*?(#$v)/];$1+($1[-1].tr('bcdfgkpstvz','pgtvkgbzdfs')+$2)*2}

Pruébalo en línea!

Desafiando un poco, tenemos algo equivalente a:

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

Python 2, 251 246 245 239 237 234 229 211 bytes

Primera presentación aquí.

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

Pruébalo en línea!

Compañeros de golf que me ayudaron:

 Destructible Lemon / Wheat Wizard - 5 bytes
 Hubert Grzeskowiak - 1 byte
 musicman523 - 16 bytes

Rubí , 175 141 110 bytes

->s{s=~/(.*?#{v='[aeiouy]'}+(#{c='[^aeiouy]'}))#{c}*(#{v})/;"#$1#{($2.tr('bcdfgkpstvz','pgtvkgbzdfs')+$3)*2}"}

Pruébalo en línea!

• Guardado 34 bytes gracias a Eric Duminil
• Ahorró 31 bytes gracias a Value Ink + trargumentos sugeridos optimizados

Sin golf

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

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]

MATLAB / Octave - 159158 bytes

Lo siguiente funciona asumiendo que la cadena de entrada está en minúsculas.

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]

Explicación

1. a = input('','s');: Obtiene una cadena de STDIN y la almacena en la variable a.
2. m=ismember(a,'aeiouy');: Devuelve una matriz booleana que tiene el mismo tamaño que la cadena que adetermina dónde se encuentran las vocales
3. s='pgt vkh jglmn bqrzd fwx s';El covfefemapeo de consonantes como una cadena. Esta cadena tiene 25 caracteres y omite las vocales. La primera posición donde 'a'se supone que está la vocal se elimina, mientras que las otras posiciones donde se ubican las vocales se colocan con un carácter de espacio ficticio. Esto es así cuando determinamos la primera consonante que aparece después de la vocal, convertiremos la consonante a una posición para acceder a un carácter en esta cadena para determinar el primer componente de la palabra convertida.
4. m(1:find(m,1))=1: Establece la primera posición de la matriz booleana hasta donde encontramos la primera vocal como todas las vocales. Esto será para que cuando busquemos la siguiente consonante que sigue a la primera vocal, ignoremos estos caracteres.
5. i=find(~m,1);: Encuentra la primera posición de la cuerda que es una consonante después de la primera vocal.
6. f=a(1:i): Elimina la cuerda después de la primera consonante que sigue a la vocal. Simplemente muestreamos desde la primera posición de la cadena hasta este punto.
7. d=s(f(end)-97);: Toma el último carácter de la cadena que queda y encuentra dónde necesitamos muestrear de la cadena de búsqueda y obtiene ese carácter. Restando un carácter y un número en MATLAB u Octave se une para formar un número entero al convertir el carácter en su código ASCII. En este caso, restamos el último carácter por el carácter al comienzo del alfabeto para darnos la posición relativa al comienzo. Sin embargo, en lugar de restar por b(98), restamos por acuando MATLAB comienza a indexar por 1 en lugar de 0. 'a'El código ASCII es 97.
8. m(1:i)=0;: Toma la máscara booleana y establece todos los caracteres en la cadena de entrada desde la primera posición hasta la primera consonante después de una vocal en falso.
9. v=a(find(m,1));: Encuentra la siguiente vocal que sigue a la primera consonante de la cadena de entrada.
10. [f d v d v]: Salida de nuestra covfefecadena ied.

Ejecuciones de ejemplo

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

Pruébalo en línea!

http://www.tutorialspoint.com/execute_octave_online.php?PID=0Bw_CjBb95KQMdjROYVR0aFNrWXM

Cuando presione el botón Ejecutar en la parte superior, espere unos momentos, luego ingrese la cadena deseada. Ingrese la cadena lentamente ya que parece haber un retraso al ingresar texto.

Clojure, 182156 caracteres

#(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)))

Cómo funciona

(partition-by v "president")

Devuelve una secuencia de ((\p \r) (\e) (\s) (\i) (\d) (\e) (\n \t))

[s m [c] [n]] (if (v (first x)) (cons [] p) p)

Desestructura la SEC en s=(\p \r), m=(\e), c=\s, n=\i.

O "ejemplo" que es s=[], m=(\e), c=\x, n=\a.

(apply str (concat s m [c] [(l c) n] [(l c) n]))

Devuelve la cadena de salida concatenando las piezas juntas y encadenándolas.

Y luego eliminé tanto espacio en blanco como pude mientras lo hacía compilar.

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

R, 341 caracteres

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

Horrendo intento de R, ¿por qué las cuerdas son tan duras?

Versión legible:

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

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

Toma una palabra de stdin e imprime el resultado en stdout. Se supone que la palabra de entrada es minúscula y contiene al menos una vocal seguida de una consonante.

Una versión más legible del programa con formato y declaraciones variables:

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

Cómo funciona:

BlitzMax no tiene ninguna funcionalidad de expresión regular incorporada o similar, por lo que se usa un bucle para iterar sobre los caracteres de la palabra de entrada hasta que encuentre una vocal seguida de una cadena de al menos una consonante. La variable c almacena la posición de la última de esas consonantes, v la de la vocal. El ciclo continúa para ver si hay otra vocal después de la cadena y, de ser así, v se actualiza en consecuencia. Luego, la consonante en c se busca en la cadena "bpdtfvgkcgsz", que actúa como una tabla de reemplazo. Si la consonante se encuentra en la tabla en cualquier posición, entonces esa posición es XOR-ed con 1 y el carácter en la posición resultante se usa como su reemplazo. La operación XOR convierte 0 en 1, 2 en 3, 4 en 5, etc. y viceversa, de modo que b se intercambia con p, d con t y así sucesivamente. Finalmente, la cadena original hasta c,

Resultados de ejemplo:

cobertura de cobertura

creación creatdidi

programación progkaka

estupidez stupbibi

bla bla bla

Perl, 71 bytes

s#[aeiouy]+(.)\K.*?([aeiouy]).*#"$1$2"=~y/bcdfgkpstvz/pgtvkgbzdfs/rx2#e

También corre con perl -pe. Unos pocos bytes menos que la solución Perl anterior. Es cierto que también obtuve algo de inspiración.

05AB1E , 101 104 88 bytes

-16 bytes gracias a Okx

De alguna manera espero que esto se pueda hacer de manera más eficiente.

žOÃćIsk>[DIs£¤žPså#\>]s[DIsèDžOså#\>]ŠŠ"bpcgdtfvgkhhjjkgllmmnnpbqqrrsztdvfwwxxzs"S2ôDí«ø`Šs¤sŠksŠèsŠì2׫

Pruébalo en línea!

Explicación

                  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

Cristal, 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

Cómo funciona

c = /[aeiouy]/

almacenar una expresión regular para buscar la primera vocal c.

x, y, z = ARGV[0].partition /[^aeiouy]*#{c}*/

divide el primer argumento en tres partes {"", cadena hasta un carácter antes de la primera consonante después de la primera vocal, resto de la cadena} y almacena cada uno de los elementos en x, y y z.

k = z[0]

obtener el primer carácter, la consonante relevante.

i = "pgtvkgbqrzdfs" =~ /#{k}/

obtener el índice de la consonante dentro de la cadena izquierda o nil.

b = ((i = ...) ? "bcdfgkpqrstvz"[i] : k) + z[c]

si ino es así nil, use este índice para la segunda cadena (una especie de hash de golf).

si ies así nil, usa el carácter original.

a continuación, agregue la primera vocal de z.

p y + k + (b * 2)

finalmente, imprime la primera parte de la primera expresión regular y, la primera consonante ky dos veces la cadena calculada anterior b.

Pruébalo en línea .

Retina , 68 bytes

r`\B(?>([^aeiouy])+)([aeiouy]).*
$1$1$2$1$2
T-5>`fs\dbgcgk\ptzv`Ro`.

Pruébalo en línea!

LUA, 164 157 bytes

w=arg[1]
i,j,a,b=w:find('[aeiouy]+([^aeiouy]+)(.)')
print(w:sub(1,j-#a)..(('pgtvkhjglmnbqrzdfwxs'):sub(('bcdfghjklmnpqrstvwxz'):find(a:sub(1,1)))..b):rep(2))

Edición 1: se eliminaron 7 bytes buscando cualquier carácter después de las consonantes (ver expresiones regulares)

Pruébalo en línea!

Este programa toma una cadena en el argumento CLI e imprime su versión codificada.

Esta es mi primera presentación a un código de golf! No verifiqué los otros en detalle, por lo que podría haber perdido algunas optimizaciones comunes (y caer en algunas trampas). Usé Lua porque me ha gustado este pequeño lenguaje e intenté encontrar una expresión regular que se adaptara a mis necesidades.

Aquí hay una versión más limpia, usando una función (¡pretendía usar una, pero las palabras clave en Lua son demasiado largas!):

function covfefy(word)
  i, j, a, b = word:find('[aeiouy]+([^aeiouy]+)(.)')

  -- 'a' is one or several consonants following the first vowel, b is the first vowel after that
  -- 'i' is the index of the beginning of 'a', 'j' the index of 'b'

  cov = word:sub(1, j - #a)

  -- Look for the first letter of 'a' in the voiced/voiceless table
  f = ('pgtvkhjglmnbqrzdfwxs'):sub(('bcdfghjklmnpqrstvwxz'):find(a:sub(1, 1)))

  return cov .. (f .. b):rep(2)
end

Siéntase libre de dar algunos comentarios :)

Nota: Si se lo pregunta, ¡tiene 149 bytes de largo con MoonScript!

JavaScript (ES5), 237 229 bytes

function(s){r=['aeiouy','bcdfgkpstvz','pgtvkgbzdfs']i=0,p=''while(p+=s[i],r[0].indexOf(s[i++])<0);while(p+=s[i],~r[0].indexOf(s[i++]));b=s[i-1];while(r[0].indexOf(s[i++])<0);c=r[1].indexOf(b)d=((~c)?r[2][c]:b)+s[i-1]return p+d+d}

Pruébalo en línea!

Probablemente no sea el más golfista, pero es ES5.

Recientemente arreglado un error. Salida de ejemplo:

creation->creatdidi
coverage->covfefe
example->exxaxa
programming->progkaka
code->codtete
president->preszizi

sed, 106 (105 + 1) bytes

Esto se deposita con la -Ebandera, que aparentemente cuenta con un byte.

s/([aoeuiy][^aoeuiy])[^aoeuiy]*(.).*/\1\2/
h
s/.*(..)/\1\1/
y/bcdfgkpstvz/pgtvkgbzdfs/
x
s/.$//
G
s/\n//g

Pruébalo en línea!

C #, 584 581 bytes

-3 bytes gracias a Destructible Lemon

Esta es mi primera presentación en Code Golf y en Stack Exchange en general. Sé que C # no es un gran lenguaje de golf y esto probablemente no está completamente optimizado, pero quería darle una oportunidad: p. Cualquier consejo es bienvenido!

Versión de golf:

namespace System{class B{static void Main(string[]args){var s="creation";var t="aeiou";int i=0,j=0,l=s.Length;char c=' ',f=' ';for(int x=0;x++<l;){if(t.IndexOf(s[x])>=0){i=x;break;}}for(int x=i;x++<l;){if(!(t.IndexOf(s[x])>=0)){j=x;c=s[x];for(int y=x;y++<l;){if (t.IndexOf(s[y])>=0){f=s[y];goto W;}}}}W:switch(c){case'b':c='p';break;case'c':c='g';break;case'd':c='t';break;case'f':c='v';break;case'g':c='k';break;case'k':c='j';break;case'p':c='b';break;case's':c='z';break;case't':c='d';break;case'v':c='f';break;case'z':c='s';break;}Console.Write(s.Substring(0,l-i-1)+c+f+c+f);}}}

Versión legible:

namespace System
{
    class B
    {
        static void Main(string[] args)
        {
            var s = "creation";
            var t = "aeiou";
            int i = 0, j = 0, l = s.Length;
            char c = ' ', f = ' ';
            for (int x = 0; x++ < l; )
            {
                if (t.IndexOf(s[x]) >= 0)
                {
                    i = x; break;
                }
            }
            for (int x = i; x++ < l;)
            {
                if (!(t.IndexOf(s[x]) >= 0))
                {
                    j = x; c = s[x];
                    for (int y = x; y++ < l;)
                    {
                        if (t.IndexOf(s[y]) >= 0)
                        {
                            f = s[y];
                            break;
                        }
                    }
                }
            }
            switch (c)
            {
                case 'b': c = 'p';
                    break;
                case 'c': c = 'g';
                    break;
                case 'd': c = 't';
                    break;
                case 'f': c = 'v';
                    break;
                case 'g': c = 'k';
                    break;
                case 'k': c = 'j';
                    break;
                case 'p': c = 'b';
                    break;
                case 's': c = 'z';
                    break;
                case 't': c = 'd';
                    break;
                case 'v': c = 'f';
                    break;
                case 'z': c = 's';
                    break;
            }
            Console.Write(s.Substring(0, l - i - 1) + c + f + c + f);
        }
    }
}

SmileBASIC 3, 195 bytes

Muy tarde a esta pregunta, pero ¿cómo podría resistir un buen desafío para SmileBASIC 3? Las características como iterar sobre una secuencia o manipular una cadena no son tan robustas como otros lenguajes, por lo que es un poco difícil hacerlo lo más pequeño posible. Asume que las palabras son MAYÚSCULAS.

V$="AEIOUY
LINPUT W$REPEAT I=I+1UNTIL.<=INSTR(V$,W$[I-1])&&.>INSTR(V$,W$[I])J=I
WHILE.>INSTR(V$,W$[J])J=J+1WEND?LEFT$(W$,I+1)+("PGTVKHJGLMNBQRZDFWXS"[INSTR("BCDFGHJKLMNPQRSTVWXZ",W$[I])]+W$[J])*2

Explicación detallada aquí!

05AB1E , 55 bytes

η.ΔžOSåàyžPSÅ¿à*}ÐIsKžOÃнsθU.•gÍĆdQ¸G•SDXåiÂXQÏθë\X}ìDJ

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

η                        # 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"
  U                      # Pop and store it in variable `X`
   .•gÍĆdQ¸G•            # Push string "bcdfkszgvtgp"
             S           # Convert to list of characters: ["b","c","d","f","k","s","z","g","v","t","g","p"]
              D          # Duplicate it
               Xåi       # If `X` is in this string:
                  Â      #  Bifurcate the list (short for Duplicate & Reverse copy)
                         #   i.e. ["b","c","d","f","k","s","z","g","v","t","g","p"]
                         #   → ["p","g","t","v","g","z","s","k","f","d","c","b"]
                   XQ    #  Check if they're equal to variable `X`
                         #   i.e. `X` = "t" → [0,0,1,0,0,0,0,0,0,0,0,0]
                     Ï   #  Only keep the truthy values
                         #   i.e. ["b","c",...,"g","p"] and [0,0,1,0,0,0,0,0,0,0,0,0]
                         #    → ["d"]
                      θ  #  Pop and push the last one
                         #   i.e. ["d"] → "d"
                 ë       # Else:
                  \      #  Discard the duplicate list from the stack
                   X     #  And push variable `X` again
                 }       # Close the if-else
                  ì      # 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"

Vea estos consejos míos 05AB1E (sección ¿Cómo comprimir cadenas que no forman parte del diccionario? ) Para comprender por qué lo .•gÍĆdQ¸G•es "bcdfkszgvtgp".