Copodope Gopolopfop

Question

The Language: Oppification

A funny language to speak is created by applying the following process to each word:

1. Place op after each consonant. So Code becomes Copodope.

Yes, that's it. For the purpose of this challenge, y is always a consonant.

The Challenge: De-oppification

Given an oppified word, return the original word. Input will only contain letters. The first letter may be capitalized. The original word will never be empty and will always contain a vowel.

Test Cases:

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

Answer 1

Retina, 9 bytes

(?!\G)op

Try it online!

Instead of checking that the preceding character is a consonant, we just make sure that the current op is not adjacent to either the beginning of the string or the previous match. The only case where we could match an incorrect op is if the original string contained an op (resulting in opop). But in that case we'll just remove the first op instead of the second and the result will be the same.

Answer 2

V, 12, 5 bytes

Í.“op

Try it online!

00000000: cd2e 936f 70                             ...op

Saved 7 bytes thanks to @Xnor's realization that since the input must always be opped, we don't have to check for vowels.

Answer 3

Python, 42 bytes

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

Try it online!

If I'm not mistaken, you can just substitute all ?op with ? without caring about vowels. If the original string contains op, then it's oppified to opop, and the replacement returns it to op and no further. This is because the pattern matches for ?op cannot overlap, so only one op is removed.

A non-regex solution is 5 bytes longer.

Python, 47 bytes

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

Try it online

Answer 4

Perl 5, 10 + 1 = 11 bytes

s/.\Kop//g

Try it online!

Run with -p (1 byte penalty); golfing languages might do implicit I/O automatically, but Perl needs an option for it.

When I saw @xnor's answer, I realised it could be improved using a Perl-specific regex feature; s/a\Kb/c/g is equivalent to s/ab/ac/g (in other words, the s/// only replaces the things after the first \K). So here's how it looks in Perl.

Answer 5

Retina, 15 8 bytes

(.)op
$1

Try it online!

-7 bytes thanks to Kevin Cruijssen

Answer 6

Go, 103 92 bytes

Must... compile... Go built-in functions have weird names. :P

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

Try it online!

Answer 7

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

thanks to @nimi suggestions in comments!

Answer 8

PHP, 36 bytes

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

Try it online!

Answer 9

Japt, 9 bytes

r"%Vop"_g

Try it online

Answer 10

JavaScript (ES6), 35 bytes

Add f= at beginning and invoke like f(arg).

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

I am surprised no one posted a JavaScript solution yet....

Test Snippet

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

Answer 11

C (gcc), 83 bytes

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

Try it online!

Answer 12

///, 18 bytes

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

Try it online!

Note that this snippet wants to replace op with a ., but later on there is a replacement defined where op is being put back into the string. That second instruction would have the op replaced by a . (and thus insert a . into the end result), so I've used a \ between the o and p to break the pattern.

Answer 13

APL (Dyalog), 13 bytes

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

Try it online!

Simply PCRE Replace any character followed by "op" with the character itself.

Answer 14

Crystal, 39 Bytes

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

How it works

It simply searches for each consonant, followed by the sequence op. If so, replace that sequence only with the consonant found before: ([^aeiou]).

Try it online

Answer 15

Java 8, 36 26 bytes

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

-10 bytes by replacing [^aeiou] with ., thanks to @xnor's explanation in his Python answer.

Try it here.

Answer 16

Ruby, 34 27 22 + 1 = 23 bytes

-4 bytes thanks to RJHunter.

+1 byte for the -p flag.

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

Try it online!

Answer 17

sed, 22 bytes

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

Reads from STDIN until EOF and outputs de-oppified string
Uses same length reduction technique from @xnor's Python answer

Answer 18

R, 29 bytes

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

Try it online!

Much like most other solutions here, captures character followed by op, replaces it with character itself.