Bahasa: Oppifikasi

Bahasa yang lucu untuk diucapkan dibuat dengan menerapkan proses berikut untuk setiap kata:

1. Tempatkan opsetelah setiap konsonan. Jadi CodemenjadiCopodope .

Ya itu saja. Untuk tujuan tantangan ini,y selalu merupakan konsonan.

The Challenge: De-oppification

Diberi kata menentang, kembalikan kata aslinya. Input hanya akan berisi huruf. Huruf pertama dapat ditulis dengan huruf besar. Kata aslinya tidak akan pernah kosong dan akan selalu berisi vokal.

Kasus uji:

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 byte

Í.“op

Cobalah online!

00000000: cd2e 936f 70                             ...op

Disimpan 7 byte berkat realisasi @ Xnor bahwa karena input harus selalu di-opped, kita tidak perlu memeriksa vokal.

Retina , 9 byte

(?!\G)op

Cobalah online!

Alih-alih memeriksa bahwa karakter sebelumnya adalah konsonan, kami hanya memastikan bahwa arus optidak berdekatan dengan awal string atau kecocokan sebelumnya. Satu-satunya kasus di mana kami dapat mencocokkan yang salah opadalah jika string asli berisi op(menghasilkan opop). Tetapi dalam hal ini kami hanya akan menghapus yang pertama, opbukan yang kedua dan hasilnya akan sama.

Python , 42 byte

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

Cobalah online!

Jika saya tidak salah, Anda bisa mengganti semuanya ?opdengan ?tanpa peduli dengan vokal. Jika string asli berisi op, maka itu dilawan opop, dan penggantian mengembalikannya opdan tidak lebih lanjut. Ini karena pola yang cocok untuk ?optidak dapat tumpang tindih, jadi hanya satuop yang dihapus.

Solusi non-regex lebih panjang 5 byte.

Python , 47 byte

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

Cobalah online

Perl 5 , 10 + 1 = 11 byte

s/.\Kop//g

Cobalah online!

Jalankan dengan -p (penalti 1 byte); bahasa golf mungkin melakukan I / O implisit secara otomatis, tetapi Perl membutuhkan opsi untuk itu.

Ketika saya melihat jawaban @ xnor , saya menyadari bahwa ini dapat ditingkatkan menggunakan fitur regex khusus Perl; s/a\Kb/c/gsetara dengan s/ab/ac/g(dengan kata lain, s///satu - satunya menggantikan hal-hal setelah yang pertama \K). Jadi begini tampilannya di Perl.

Retina , 15 8 byte

(.)op
$1

Cobalah online!

-7 byte terima kasih kepada Kevin Cruijssen

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!

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!

PHP, 36 bytes

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

Try it online!

Japt, 9 bytes

r"%Vop"_g

Try it online

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

C (gcc), 83 bytes

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

Try it online!

///, 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.

APL (Dyalog), 13 bytes

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

Try it online!

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

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

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.

Ruby, 34 27 22 + 1 = 23 bytes

-4 bytes thanks to RJHunter.

+1 byte for the -p flag.

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

Try it online!

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

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.