A Língua: Oppificação

Um idioma engraçado para falar é criado aplicando o seguinte processo a cada palavra:

1. Coloque opapós cada consoante. Assim Codese torna Copodope.

Sim é isso. Para o propósito deste desafio, yé sempre uma consoante.

O desafio: desoplificação

Dada uma palavra oprificada, retorne a palavra original. A entrada conterá apenas letras. A primeira letra pode ser maiúscula. A palavra original nunca estará vazia e sempre conterá uma vogal.

Casos de teste:

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

Experimente online!

00000000: cd2e 936f 70                             ...op

Salvamos 7 bytes graças à percepção do @ Xnor de que, como a entrada sempre deve ser ativada, não precisamos verificar vogais.

Retina , 9 bytes

(?!\G)op

Experimente online!

Em vez de verificar se o caractere anterior é uma consoante, apenas garantimos que a corrente opnão seja adjacente ao início da string ou à correspondência anterior. O único caso em que poderíamos corresponder a um incorreto opé se a string original contiver um op(resultando em opop). Mas nesse caso, apenas removeremos o primeiro em opvez do segundo e o resultado será o mesmo.

Python , 42 bytes

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

Experimente online!

Se não me engano, você pode simplesmente substituir todos ?opcom ?sem se preocupar com vogais. Se a string original contiver op, ela será ativada opope a substituição a retornará ope não mais. Isso ocorre porque o padrão corresponde a ?opnão pode se sobrepor, portanto, apenas um opé removido.

Uma solução não regex tem 5 bytes a mais.

Python , 47 bytes

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

Experimente online

Perl 5 , 10 + 1 = 11 bytes

s/.\Kop//g

Experimente online!

Corra com -p(penalidade de 1 byte); idiomas de golfe podem executar E / S implícita automaticamente, mas o Perl precisa de uma opção para isso.

Quando vi a resposta do @ xnor , percebi que ela poderia ser melhorada usando um recurso regex específico do Perl; s/a\Kb/c/gé equivalente a s/ab/ac/g(em outras palavras, o s///único substitui as coisas após o primeiro \K). Então, veja como fica no Perl.

Retina , 15 8 bytes

(.)op
$1

Experimente online!

-7 bytes graças a Kevin Cruijssen

Go , 103 92 bytes

Deve ... compilar ... As funções internas do Go têm nomes estranhos. : P

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

Experimente online!

Haskell (93 62 61 bytes)

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

graças às sugestões @nimi nos comentários!

PHP , 36 bytes

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

Experimente online!

Japonês , 9 bytes

r"%Vop"_g

Experimente online

JavaScript (ES6), 35 bytes

Adicione f=no início e chame like f(arg).

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

Estou surpreso que ninguém postou uma solução JavaScript ainda ...

Snippet de teste

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

Experimente online!

/// , 18 bytes

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

Experimente online!

Observe que esse snippet deseja substituir oppor a ., mas mais tarde há uma substituição definida onde opestá sendo colocada de volta na string. Essa segunda instrução opsubstitui a por a .(e, portanto, insere a .no resultado final), então usei a \entre the oe ppara quebrar o padrão.

APL (Dyalog) , 13 bytes

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

Experimente online!

Simplesmente PCRE R moran Jr. qualquer caractere seguido por "op" com o próprio caráter.

Cristal, 39 bytes

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

Como funciona

Ele simplesmente procura cada consoante, seguido pela sequência op. Se assim for, substituir essa seqüência somente com a consoante encontrado antes: ([^aeiou]).

Experimente online

Java 8, 36 26 bytes

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

-10 bytes substituindo [^aeiou]por ., graças à explicação de @xnor em sua resposta em Python .

Experimente aqui.

Ruby , 34 27 22 + 1 = 23 bytes

-4 bytes graças ao RJHunter.

+1 byte para o -psinalizador.

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

Experimente online!

sed, 22 bytes

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

Lê de STDIN até EOF e gera string desaprovada
Utiliza a mesma técnica de redução de comprimento da resposta Python do @ xnor

R , 29 bytes

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

Experimente online!

Muito parecido com a maioria das outras soluções aqui, captura o caractere seguido por op e o substitui pelo próprio caractere.