El lenguaje: oppificación

Se crea un lenguaje divertido para hablar aplicando el siguiente proceso a cada palabra:

1. Colocar opdespués de cada consonante. Así se Codeconvierte Copodope.

Si eso es. A los efectos de este desafío, ysiempre es una consonante.

El desafío: desaptación

Dada una palabra oppified, devuelve la palabra original. La entrada solo contendrá letras. La primera letra puede estar en mayúscula. La palabra original nunca estará vacía y siempre contendrá una vocal.

Casos de prueba:

Oppified      ->         Original 
a                        a
I                        I
itop                     it
opop                     op
Opop                     Op
popopop                  pop
Copopop                  Cop
opopopop                 opop
Kopicopkop               Kick
Asopia                   Asia
soptopopop               stop
hopoopopsop              hoops
hopoopopedop             hooped
ooooohop                 oooooh
aaaopopaaa               aaaopaaa
Popopopsopicoplope       Popsicle
gopaloplopopopinopgop    galloping
aopopbopopopcopopop      aopbopcop

V , 12 , 5 bytes

Í.“op

Pruébalo en línea!

00000000: cd2e 936f 70                             ...op

Ahorré 7 bytes gracias a la comprensión de @ Xnor de que, dado que la entrada siempre debe ser activada, no tenemos que verificar las vocales.

Retina , 9 bytes

(?!\G)op

Pruébalo en línea!

En lugar de verificar que el carácter anterior es una consonante, solo nos aseguramos de que la corriente opno sea adyacente ni al comienzo de la cadena ni a la coincidencia anterior. El único caso en el que podríamos coincidir con un incorrecto opes si la cadena original contenía un op(que resulta en opop). Pero en ese caso, eliminaremos el primero en oplugar del segundo y el resultado será el mismo.

Python , 42 bytes

lambda s:re.sub('(.)op',r'\1',s)
import re

Pruébalo en línea!

Si no me equivoco, sólo puede sustituir todo ?opcon ?y sin preocuparse por las vocales. Si la cadena original contiene op, entonces está oppified opop, y el reemplazo la devuelve opy no más. Esto se debe a que las coincidencias de patrones para ?opno se pueden superponer, por lo que solo opse elimina una.

Una solución no regex es 5 bytes más larga.

Python , 47 bytes

f=lambda s:s and s[0]+f(s[1+2*(s[1:3]=='op'):])

Pruébalo en línea

Perl 5 , 10 + 1 = 11 bytes

s/.\Kop//g

Pruébalo en línea!

Ejecutar con -p(penalización de 1 byte); los lenguajes de golf pueden hacer E / S implícitas automáticamente, pero Perl necesita una opción para ello.

Cuando vi la respuesta de @ xnor , me di cuenta de que podría mejorarse usando una función de expresión regular específica de Perl; s/a\Kb/c/ges equivalente a s/ab/ac/g(en otras palabras, el s///único reemplaza las cosas después del primero \K). Así es como se ve en Perl.

Retina , 15 8 bytes

(.)op
$1

Pruébalo en línea!

-7 bytes gracias a Kevin Cruijssen

Go , 103 92 bytes

Debe ... compilar ... Ir Las funciones incorporadas tienen nombres extraños. :PAG

import."regexp"
func f(s string)string{return MustCompile("(.)op").ReplaceAllString(s,"$1")}

Pruébalo en línea!

Haskell93 62 61 bytes)

a(x:'o':'p':r)|notElem x"aeiouAEIOU"=x:a r
a(x:r)=x:a r
a x=x

gracias a @nimi sugerencias en los comentarios!

PHP , 36 bytes

<?=preg_replace("#.\Kop#","",$argn);

Pruébalo en línea!

Japt , 9 bytes

r"%Vop"_g

Pruébalo en línea

JavaScript (ES6), 35 bytes

Agregue f=al principio e invoque como f(arg).

s=>s.replace(/([^aeiou])op/gi,"$1")

Me sorprende que nadie haya publicado una solución de JavaScript todavía ...

Fragmento de prueba

let f=
s=>s.replace(/([^aeiou])op/gi,"$1")

console.log("a" + " -> " + f("a"));
console.log("I" + " -> " + f("I"));
console.log("itop" + " -> " + f("itop"));
console.log("opop" + " -> " + f("opop"));
console.log("Opop" + " -> " + f("Opop"));
console.log("popopop" + " -> " + f("popopop"));
console.log("Copopop" + " -> " + f("Copopop"));
console.log("opopopop" + " -> " + f("opopopop"));
console.log("Kopicopkop" + " -> " + f("Kopicopkop"));
console.log("Asopia" + " -> " + f("Asopia"));
console.log("soptopopop" + " -> " + f("soptopopop"));
console.log("hopoopopsop" + " -> " + f("hopoopopsop"));
console.log("hopoopopedop" + " -> " + f("hopoopopedop"));
console.log("ooooohop" + " -> " + f("ooooohop"));
console.log("aaaopopaaa" + " -> " + f("aaaopopaaa"));
console.log("Popopopsopicoplope" + " -> " + f("Popopopsopicoplope"));
console.log("gopaloplopopopinopgop" + " -> " + f("gopaloplopopopinopgop"));
console.log("aopopbopopopcopopop" + " -> " + f("aopopbopopopcopopop"));

C (gcc) , 83 bytes

main(c,v)char**v;{for(;*v[1];strchr("aAeEiIoOuU",putchar(*v[1]++))?:printf("op"));}

Pruébalo en línea!

/// , 18 bytes

/op/.//../o\p//.//

Pruébalo en línea!

Tenga en cuenta que este fragmento quiere reemplazar opcon un ., pero más adelante hay un reemplazo definido donde opse vuelve a colocar en la cadena. Esa segunda instrucción tendría el opreemplazado por a .(y, por lo tanto, inserte un .en el resultado final), por lo que he usado un \entre oy ppara romper el patrón.

APL (Dyalog) , 13 bytes

'(.)op'⎕R'\1'

Pruébalo en línea!

Simplemente PCRE R eplace cualquier carácter seguido de "OP" con el personaje en sí.

Cristal, 39 bytes

def o(s)s.gsub(/([^aeiou])op/,"\\1")end

Cómo funciona

Simplemente busca cada consonante, seguido de la secuencia op. Si es así, sustituya esa secuencia única con la consonante encuentra antes: ([^aeiou]).

Pruébalo en línea

Java 8, 36 26 bytes

s->s.replaceAll("(.)op","$1")

-10 bytes reemplazando [^aeiou]con ., gracias a la explicación de @xnor en su respuesta de Python .

Pruébalo aquí.

Rubí , 34 27 22 + 1 = 23 bytes

-4 bytes gracias a RJHunter.

+1 byte para la -pbandera.

$_.gsub!(/(.)op/,'\1')

Pruébalo en línea!

sed, 22 bytes

sed -E 's/(.)op/\1/g'

Lee desde STDIN hasta EOF y emite una cadena desaplicada
Usa la misma técnica de reducción de longitud de la respuesta Python de @ xnor

R , 29 bytes

gsub("(.)op","\\1",scan(,''))

Pruébalo en línea!

Al igual que la mayoría de las otras soluciones aquí, captura el personaje seguido de op, lo reemplaza con el personaje en sí.