La langue: l'opposition

Une langue amusante à parler est créée en appliquant le processus suivant à chaque mot:

Placez opaprès chaque consonne. Devient Codeainsi Copodope.

Oui c'est ça. Aux fins de ce défi, yest toujours une consonne.

Le défi: la désoppification

Étant donné un mot oppified, renvoyez le mot d'origine. L'entrée ne contiendra que des lettres. La première lettre peut être en majuscule. Le mot d'origine ne sera jamais vide et contiendra toujours une voyelle.

Cas de test:

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
source

8

Aucun de vos cas de test ne contient de voyelle suivie de op, donc une réponse dans le sens de replace(/(.)op/, '\1')n'échouera aucun d'entre eux. Je vous suggère d'ajouter un mot comme hoopou loopedaux cas de test.

— Poignée de porte

@ mbomb007 J'ai ajouté des cas de test plus délicats.

— xnor

La réponse ne doit-elle fonctionner que pour les entrées préopérées ou toutes les entrées?

— CalculatorFeline

@CalculatorFeline "Étant donné un mot oppifié"

— mbomb007

2

Peut-on ajouter "mopmopmopbopopop" comme cas de test? :)

— user2390246

10

V , 12 , 5 octets

Í.“op

Essayez-le en ligne!

00000000: cd2e 936f 70                             ...op

Sauvegardé 7 octets grâce à la réalisation de @ Xnor que puisque l'entrée doit toujours être oppée, nous n'avons pas à vérifier les voyelles.

— DJMcMayhem
source

Hmm, cela semble si difficile à battre ...

— Erik the Outgolfer

4

Le vidage hexadécimal: ...op me fait rire beaucoup plus fort qu'il ne le devrait

— nmjcman101

12

Rétine , 9 octets

(?!\G)op

Essayez-le en ligne!

Au lieu de vérifier que le caractère précédent est une consonne, nous nous assurons simplement que le courant opn'est pas adjacent au début de la chaîne ou à la correspondance précédente. Le seul cas où nous pourrions faire correspondre un incorrect opest si la chaîne d'origine contenait un op(résultant en opop). Mais dans ce cas, nous allons simplement supprimer le premier opau lieu du second et le résultat sera le même.

— Martin Ender
source

Cela ne donnerait-il pas une réponse incorrecte pour une entrée comme loop?

— Leo

4

@Leo loopn'est pas une entrée valide car vous ne pouvez pas l'obtenir en oppifiant un autre mot.

— Martin Ender

@MartinEnder Mais lopoop(la version oppifiée de loop) est valide et n'est pas désopposée loop.

— Imus

@Imus non, la version oppifiée de loopis lopoopop.

— Martin Ender

réalisé mon erreur aussi peu de temps après l'avoir posté :) était trop lent à supprimer. Bon point.

— Imus

10

Python , 42 octets

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

Essayez-le en ligne!

Si je ne me trompe pas, vous pouvez simplement remplacer tout ?oppar ?sans vous soucier des voyelles. Si la chaîne d'origine contient op, alors elle est oppifiée opopet le remplaçant la renvoie opet pas plus loin. En effet, le motif correspondant à ?opne peut pas se chevaucher, donc un seul opest supprimé.

Une solution non regex est plus longue de 5 octets.

Python , 47 octets

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

Essayez-le en ligne

— xnor
source

3

Vous pouvez importer re après l'avoir référencé‽

— Adám

4

@ Adám Python ne l'évalue pas lorsque la fonction est définie, uniquement lorsqu'elle est appelée.

— xnor

4

Wow, ça fait un moment que je n'ai vu personne utiliser un interrobang. Je suppose que c'est une façon de jouer un peu à votre commentaire.

— Baldrickk

1

@Baldrickk Mais en octets , l'interrobang a> = octets que juste la chaîne "?!"

— MilkyWay90

5

Perl 5 , 10 + 1 = 11 octets

s/.\Kop//g

Essayez-le en ligne!

Courir avec -p (1 octet de pénalité); les langages de golf peuvent faire des E / S implicites automatiquement, mais Perl a besoin d'une option pour cela.

Quand j'ai vu la réponse de @ xnor , je me suis rendu compte qu'elle pouvait être améliorée en utilisant une fonction d'expression régulière spécifique à Perl; s/a\Kb/c/gest équivalent à s/ab/ac/g(en d'autres termes, le s///seul remplace les choses après le premier \K). Voici donc à quoi cela ressemble en Perl.

5

Rétine , 15 8 octets

(.)op
$1

Essayez-le en ligne!

-7 octets grâce à Kevin Cruijssen

— Il n'y a personne
source

2

Vous pouvez économiser 7 octets en remplaçant [^aeiou]par .. Voir l'explication de @xnor dans sa réponse Python .

— Kevin Cruijssen

3

Allez , 103 92 octets

Doit ... compiler ... Go Les fonctions intégrées ont des noms étranges. : P

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

Essayez-le en ligne!

— totalement humain
source

3

Haskell (93 62 61 octets)

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

merci aux suggestions @nimi dans les commentaires!

— Davide Spataro
source

2

Quelques conseils: comme vous l'utilisez vet oune seule fois, vous pouvez l'intégrer. notElemest plus court que not(...elem...). Vous pouvez remplacer le &&dans un garde par un ,. Le dernier cas pour apeut s'écrire a x=x. Pas besoin d' ()en x:(a r).

— nimi

1

... oh, et le test pour =="op"peut être remplacé par une correspondance de motif littéral:a(x:'o':'p':r)|notElem x"aeiouAEIOU"=x:a r

— nimi

Mis à jour. merci @nimi

— Davide Spataro

1

Un octet de plus à enregistrer: vous pouvez omettre l'espace entre x et ".

— nimi

3

PHP , 36 octets

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

Essayez-le en ligne!

— Jörg Hülsermann
source

Comment est-ce censé être exécuté?

— Titus

Il échoue pour les deux premiers cas de test. Utilisez preg_replacepour corriger.

— Titus

Vous pouvez économiser 3 octets en renommant la variable en n'importe quel caractère, $ a par exemple

— junkfoodjunkie

@junkfoodjunkie $argnest une variable réservée qui est disponible lorsque PHP est exécuté avec l' -Roption depuis la ligne de commande

— Jörg Hülsermann

Ah, d'accord, je ne savais pas ça. Le testeur en ligne n'en tient pas compte. :-)

— junkfoodjunkie

2

Japt , 9 octets

r"%Vop"_g

Essayez-le en ligne

— Hirsute
source

1

JavaScript (ES6), 35 octets

Ajoutez f=au début et invoquez comme f(arg).

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

Je suis surpris que personne n'ait encore publié de solution JavaScript ....

Extrait de test

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

Développer l'extrait

— Arjun
source

1

C (gcc) , 83 octets

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

Essayez-le en ligne!

— cleblanc
source

0

/// , 18 octets

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

Essayez-le en ligne!

Notez que cet extrait de code veut remplacer oppar un ., mais plus tard il y a un remplacement défini où opest remis dans la chaîne. Cette deuxième instruction devrait être opremplacée par un .(et donc insérer un .dans le résultat final), j'ai donc utilisé un \entre le oet ppour briser le motif.

— steenbergh
source

0

APL (Dyalog) , 13 octets

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

Essayez-le en ligne!

Il suffit de PCRE R eplace un caractère suivi de « op » avec le caractère lui - même.

— Adam
source

0

Cristal, 39 octets

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

Comment ça fonctionne

Il recherche simplement chaque consonne, suivi de la séquence op. Si oui, remplacez cette séquence uniquement par la consonne trouvée avant:([^aeiou]) .

Essayez-le en ligne

— Domii
source

0

Java 8, 36 26 octets

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

-10 octets en remplaçant [^aeiou]par ., grâce à l' explication de @xnor dans sa réponse Python .

Essayez-le ici.

— Kevin Cruijssen
source

0

Rubis , 34 27 22 + 1 = 23 octets

-4 octets grâce à RJHunter.

+1 octet pour le -pdrapeau.

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

Essayez-le en ligne!

— totalement humain
source

L'utilisation de l' -poption Ruby coûtera un octet mais permettra à votre script de démarrer directement gsub.

— RJHunter

0

sed, 22 octets

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

Lit de STDIN jusqu'à EOF et sort une chaîne désoppée
Utilise la même technique de réduction de longueur que la réponse Python de @ xnor

— Arc676
source

0

R , 29 octets

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

Essayez-le en ligne!

Tout comme la plupart des autres solutions ici, capture le caractère suivi de op, le remplace par le caractère lui-même.

— Sumner18
source

Copodope Gopolopfop

La langue: l'opposition

Le défi: la désoppification

Cas de test:

V , 12 , 5 octets

Rétine , 9 octets

Python , 42 octets

Perl 5 , 10 + 1 = 11 octets

Rétine , 15 8 octets

Allez , 103 92 octets

Haskell (93 62 61 octets)

PHP , 36 octets

Japt , 9 octets

JavaScript (ES6), 35 octets

Extrait de test

C (gcc) , 83 octets

/// , 18 octets

APL (Dyalog) , 13 octets

Cristal, 39 octets

Comment ça fonctionne

Java 8, 36 26 octets

Rubis , 34 27 22 + 1 = 23 octets

sed, 22 octets

R , 29 octets