A Língua: Oppificação

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

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

code-golf string natural-language

— mbomb007
fonte

8

Nenhum de seus casos de teste contém uma vogal seguida por op, portanto, uma resposta semelhante replace(/(.)op/, '\1')não falhará em nenhum deles. Sugiro que você adicione uma palavra como hoopou loopednos casos de teste.

— Maçaneta

@ mbomb007 Adicionei alguns casos de teste mais complicados.

— Xnor

A resposta precisa funcionar apenas para entradas pré-aprovadas ou para todas as entradas?

— CalculatorFeline

@CalculatorFeline "Dada uma palavra oprimida"

— mbomb007 06/06

2

Podemos adicionar "mopmopmopbopopop" como um caso de teste? :)

— user2390246

10

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.

— DJMcMayhem
fonte

Hmm, isso parece tão difícil de bater ...

— Erik o Outgolfer

4

O despejo hex: ...op Está me fazendo rir maneira mais difícil do que deveria

— nmjcman101

12

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.

— Martin Ender
fonte

Isso não daria uma resposta incorreta para uma entrada como loop?

— Leo

4

@Leo loopnão é uma entrada válida porque você não pode obtê-la ao oprimir outra palavra.

— Martin Ender

@MartinEnder Mas lopoop(a versão opcificada de loop) é válida e não é desopilada loop.

— Imus

@ Não, a versão oppificada de loopé lopoopop.

— Martin Ender

percebi o meu erro também logo após publicá-lo :) foi muito lento na exclusão. Bom ponto.

— Imus

10

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

— xnor
fonte

3

Você pode importar re depois de referenciá-lo‽

— Adám

4

@ Adám Python não avalia quando a função é definida, apenas quando é chamada.

— Xnor

4

Uau, já faz um tempo desde que eu vi alguém usar um interrobelo. Eu acho que é uma maneira de jogar um pouco o seu comentário.

— precisa

1

@ Baldrickk Mas em bytes , o interrobang tem> = bytes do que apenas a string "?!"

— precisa

5

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.

5

Retina , 15 8 bytes

(.)op
$1

Experimente online!

-7 bytes graças a Kevin Cruijssen

— Ninguém está aqui
fonte

2

Você pode salvar 7 bytes substituindo [^aeiou]por .. Veja a explicação de @xnor em sua resposta em Python .

— Kevin Cruijssen 06/06/19

3

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!

— totalmente humano
fonte

3

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!

— Davide Spataro
fonte

2

Algumas dicas: enquanto você estiver usando ve oapenas uma vez, é possível incorporá-lo. notElemé mais curto que not(...elem...). Você pode substituir o &&em uma proteção por a ,. O último caso para apode ser escrito como a x=x. Não há necessidade de ()nos x:(a r).

— N

1

... oh, e o teste para =="op"pode ser substituído por uma correspondência literal de padrão:a(x:'o':'p':r)|notElem x"aeiouAEIOU"=x:a r

— nimi 5/17

Atualizada. Obrigado @nimi

— Davide Spataro

1

Mais um byte para economizar: você pode omitir o espaço entre xe ".

— N

3

PHP , 36 bytes

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

Experimente online!

— Jörg Hülsermann
fonte

Como isso deve ser executado?

— Titus

Falha nos dois primeiros casos de teste. Use preg_replacepara consertar.

— Titus

Você pode salvar 3 bytes, renomeando a variável a qualquer caractere único, $ a, por exemplo

— junkfoodjunkie

@junkfoodjunkie $argné uma variável reservada que é availbale quando o PHP é executado com a -Ropção da linha de comando

— Jörg Hülsermann

Ah, tudo bem, não sabia disso. O testador online não responde por isso. :-)

— junkfoodjunkie 7/17

2

Japonês , 9 bytes

r"%Vop"_g

Experimente online

— Shaggy
fonte

1

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

Expandir snippet

— Arjun
fonte

1

C (gcc) , 83 bytes

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

Experimente online!

— cleblanc
fonte

0

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

— steenbergh
fonte

0

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.

— Adão
fonte

0

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

— Domii
fonte

0

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.

— Kevin Cruijssen
fonte

0

Ruby , 34 27 22 + 1 = 23 bytes

-4 bytes graças ao RJHunter.

+1 byte para o -psinalizador.

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

Experimente online!

— totalmente humano
fonte

Usar a -popção Ruby custará um byte, mas permitirá que seu script inicie diretamente gsub.

— RJHunter

0

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

— Arc676
fonte

0

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.

— Sumner18
fonte

Copodope Gopolopfop

A Língua: Oppificação

O desafio: desoplificação

Casos de teste:

V , 12 , 5 bytes

Retina , 9 bytes

Python , 42 bytes

Perl 5 , 10 + 1 = 11 bytes

Retina , 15 8 bytes

Go , 103 92 bytes

Haskell (93 62 61 bytes)

PHP , 36 bytes

Japonês , 9 bytes

JavaScript (ES6), 35 bytes

Snippet de teste

C (gcc) , 83 bytes

/// , 18 bytes

APL (Dyalog) , 13 bytes

Cristal, 39 bytes

Como funciona

Java 8, 36 26 bytes

Ruby , 34 27 22 + 1 = 23 bytes

sed, 22 bytes

R , 29 bytes