Cofectar una cadena

371

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 , ¡así que haga su programa lo más corto posible!

Limón Destructible
fuente
77
"x" debería mapearse técnicamente en "gz". "qu" debería mapearse en "gw".
Steve Bennett
2
Esto especifica un concepto de codificación, pero sigo sintiendo que una referencia al trabajo de Douglas Hofstadter (y Melanie Mitchell) sobre analogías de conversión de cadenas, por ejemplo, en Fluid Concepts parece apropiado.
Marte
6060
Las respuestas de más de 140 caracteres deben ser descalificadas
Sandy Gifford
12
Desafortunadamente, es imposible hacer esto en TrumpScript :(
44
@ThePlasmaRailgun Fue una broma, ya que los tweets tienen que tener 140 caracteres o menos.
Esolanging Fruit

Respuestas:

91

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
Jonathan Allan
fuente
13
Esto es increíble ...
Klangen
Increíble trabajo.
JF es el
99
Soy gelatina Votado.
DeepS1X
66
Este es el lenguaje de programación más extraño que he visto.
Ryan
@ Ryan está destinado al golf.
Esolanging Fruit
61

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

Arnauld
fuente
66
Puede guardar algunos bytes como este:s=>([,a,b,c]=s.match`(.*?[aeiouy]+(.)).*?([aeiouy])`,a+(b=(a="bcdfgszkvtgp")[11-a.search(b)]||b)+c+b+c)
GOTO 0
@ GOTO0 Gracias, actualizado.
Arnauld
49

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.
Dennis
fuente
44
lo siento amigo, parece que te perdiste el representante de la mega gelatina
Destructible Lemon
TFW una respuesta parece demasiado simplista, pero es, de hecho, realmente maravilloso ... simple es hermoso
Erik el Outgolfer
31

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.
Gato de negocios
fuente
2
¿CJam le gana a Jelly? : O (al menos, supera la respuesta de Jelly que todo el mundo parece estar votando).
Esolanging Fruit
29

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!

Betseg
fuente
¿* P = putchar funciona como la primera línea?
k_g
44
Lo siento descalificado. No cabe en un tweet.
caird coinheringaahing
@cairdcoinheringaahing, señor, usted es incorrecto (sé que era 140 cuando escribió eso)
Stan Strum
1
171 bytes
ceilingcat el
1
Se pueden eliminar aproximadamente 12 bytes reemplazando #definesy la función con banderas de preprocesador ( -D...).
23

Perl 5 , 81 72 bytes

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

Pruébalo en línea!

Mugriento
fuente
Tu y yo tuvimos la misma idea \K, pero lo hiciste 9 bytes mejor que yo. ¡Buena respuesta!
Silvio Mayolo
18

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!

Jörg Hülsermann
fuente
3
-2 bytes:echo$t[1],$z=strtr($t[2].$t[3],bcdfgkpstvz,pgtvkgbzdfs),$z;
Titus
@Titus No he pensado en eso. Gracias
Jörg Hülsermann 01 de
¿Por qué no renombrar $argna algo más corto? $a, por ejemplo, eso es -3 bytes
Tyler Sebastian
@ TylerSebastian Debo tener una variable de entrada que exista. Sí, puedo crear una función, pero si lo hago,
aumenta
ah ok lo siento, olvidé cómo PHP hace los argumentos de la línea de comandos: acabo de ver que lo había definido en la sección del encabezado pero no me di cuenta de que era una variable reservada.
Tyler Sebastian
15

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

Jakube
fuente
14

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

L3viatán
fuente
2
Podría crear una variable que tenga el valor 'aeiouy]', tal vez eso ahorrará algunos bytes. También puede eliminar algunos caracteres de las cadenas de reemplazo, ya que son los mismos.
Gábor Fekete
2
No puedo eliminar los caracteres idénticos de la cadena de reemplazo, porque eso sería un IndexError, y guardar aeiouy])no guarda ningún byte.
L3viathan
2
si sacas algo como s='aeiouy])', podrías usarlo b,c,v=re.findall('(.*?[%s([^%s.*?([%s'%(s,s,s). No es más corto, pero podría conducir a una forma de acortarlo en general.
Jeremy Weirich
3
El uso de cadenas f ahorrará 1 byte: k='aeiouy])'yf'(.*?[{k}([^{k}.*?([{k}'
Gábor Fekete
14

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
Kevin Cruijssen
fuente
13

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!

bartavelle
fuente
1
¡Increíble! Reemplazar nxcon algo de una letra ahorrará 2 bytes.
tomsmeding 01 de
declarar zfuera fy cambiar a guardias en lugar de letguardar otros dos bytes: ¡ Pruébelo en línea!
Laikoni
2
Y dos más al combinar (s,v)<-break z i,(m,c:x)<-span z ven (s,(m,c:x))<-span z<$>break z i.
Laikoni 01 de
Podría afeitarse uno más colocando el paréntesis de apertura al lado del let, ¡gracias!
bartavelle 01 de
@Laikoni No entiendo la parte de movimiento zde f?
bartavelle 01 de
10

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)

sagiksp
fuente
8

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
ymbirtt
fuente
8

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
WaitndVer
fuente
2
Bienvenido al sitio! Veo que intentaste usar pestañas para sangrar. Si reemplaza cada pestaña con un solo espacio, es funcionalmente idéntico y en realidad se muestra correctamente en lugar de bytes adicionales
Destructible Lemon
44
Si bien lo que dijo Destructible Lemon es correcto, puede guardar aún más bytes en su fuente al sangrar el primer nivel de su código con un solo espacio y el segundo nivel con una sola pestaña, esto hará que sea un poco difícil de mostrar, pero ahorrarte 5 bytes.
Sriotchilism O'Zaic
1
¿Es necesario el punto y coma al final de la línea 4?
Hubert Grzeskowiak
1
@WaitndSee Creo que puedes acortar algunos de tus condicionales. Primero: se puede cambiar not na n<1de 2 bytes, ya que usted sabe nque nunca será negativo. También puede cambiar n==3a n>2ya que sabe nque nunca será mayor que 3. También puede utilizar los trucos Python para los condicionales para acortar la primera y segunda pasada aún más: n=[n,1][i in w and n<1]; r+=[0,r][n<2]
musicman523
1
Puede cambiar r,v,c=('',)*3a r=v=c='', ya que las cadenas son inmutables. He intentado muchos otros trucos inteligentes, pero frustrantemente son exactamente igual de largos. También puede valer la pena agregar un ¡ Pruébelo en línea! enlace a su publicación
musicman523
7

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}"
}
sudee
fuente
44
-34 bytes conHash[*"bpcgdtfvgkkgpbsztdvfzs".chars]
Eric Duminil
1
Dado que la entrada parece estar garantizada con todos los caracteres alfabéticos, c=[^aeiou]es más corta. Tiene la primera interpolación para cada variable se asigna simultáneamente durante -2 bytes: /^(.*?${v='[aeiou]'}+(#{c='[^aeiou]})).../. Finalmente, en $2.tr("b-z","pgtevkhijgl-obqrzdufwxys")lugar de la solución Hash.
Value Ink
Puede guardar 14 bytes mediante el uso de subexpresiones ( \g<n>) en lugar de la interpolación, más otros 14 usando @ de ValueInk [^aeiou]sugerencia: s=~/^(.*?([aeiouy])+([^aeiou]))\g<3>*(\g<2>)/.
Jordania
En realidad, eso tiene un error con programming-> progkaka, que no puedo entender.
Jordania
@Jordan desafortunadamente, la llamada de subexpresión \g<3>actualiza el valor de $ 3, por lo que no podemos usar este acceso directo.
sudee
6

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]
reitermarkus
fuente
Creo que puedes perder a los c=vo+=<...>
padres
5

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.

rayryeng
fuente
5

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]))))
Brian Baritonehands Gregg
fuente
¡Bienvenido a PPCG, y una excelente primera respuesta! Esperamos que te quedes y te diviertas participando en más desafíos. :-)
ETHproductions
Si está definiendo una función, su nombre probablemente debería ser lo más corto posible. Podría llamar a la función principal c, por ejemplo. (También permitimos funciones anónimas, que son más cortas en muchos idiomas; no estoy seguro de si están en Clojure). Sin embargo, veo que ya ha realizado esa mejora en el interior de su código, por lo que probablemente no sea necesario cambiar mucho aquí.
5

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 = "")
}
Andrew Haynes
fuente
Creo que tu cuenta está apagada - Cuento 340 bytes
Taylor Scott
4

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

Bola De FuegoEstrella De Mar
fuente
enlace al repositorio de blitzmax?
Destructible Lemon
@DestructibleLemon BlitzMax fue creado como un lenguaje principalmente para el desarrollo de juegos de aficionados y con un compilador propietario vendido por dinero. Si bien ahora es gratuito y está disponible desde aquí , creo que el compilador aún no es de código abierto. Existe una implementación alternativa (repositorio aquí , compilaciones aquí ), que sin embargo solo ejecutará la versión no codificada del código anterior debido a la falta de una configuración "no estricta" que permita omitir declaraciones variables.
FireballStarfish
Uso inteligente de XOR en el índice: probablemente lo usaré algún día. Gracias.
AI Breveleri
4

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.

SomeDude
fuente
4

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
kalsowerus
fuente
Puede reemplazar "bpcgdtfvgkhhjjkgllmmnnpbqqrrsztdvfwwxxzs"con .•7¶ëÒ—Öb´ƒ≠Ä“šʒƵJ^ÝV“Îpи•para guardar 15 bytes
Okx
También puede reemplazar žOÃćIskcon žOÃ0èkpara guardar otro byte.
Okx
@Okx Creo que realmente necesito aprender algunas técnicas de compresión de cadenas. ¡Gracias!
kalsowerus
@kalsowerus Sé que ha pasado un tiempo, pero puedes jugar 8 bytes de tu respuesta de esta manera: žOÃнk>[DIs£¤žPså#\>]©s[DIsèDžOså#\>]s\.•7¶ëÒ—Öb´ƒ≠Ä“šʒƵJ^ÝV“Îpи•S2ôDí«ø`®θkèìDJ Pruébalo en línea. Principalmente eliminé todos los intercambios y triples intercambios utilizando una variable en su lugar. Y puede ser н, y he reemplazado 2׫con DJunirse a toda la pila juntos. PD: También publiqué una respuesta 05AB1E de 55 bytes usando una técnica diferente. (Que también incluye un enlace para comprender mejor la compresión en 05AB1E.: D)
Kevin Cruijssen
3

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 .

Domii
fuente
2

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!

Kyrio
fuente
2

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
Pulpo
fuente
2

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!

zgrep
fuente
2

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);
        }
    }
}
Brandon Hao
fuente
1
No soy un experto, pero creo que puede agregar el incremento al comparador en el ciclo for, es decir x++ < l, o algo (tal vez l > x++si el primero no funciona). aunque no estoy seguro
Destructible Lemon
@DestructibleLemon ¡Gracias por la sugerencia!
Brandon Hao
2

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

caracol_
fuente
2

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

Kevin Cruijssen
fuente