La lingua: opposizione

Una lingua divertente da parlare viene creata applicando il seguente processo a ogni parola:

Posto opdopo ogni consonante. Così Codediventa Copodope.

Sì è quello. Ai fini di questa sfida, yè sempre una consonante.

La sfida: disopposizione

Data una parola opposta, restituisce la parola originale. L'input conterrà solo lettere. La prima lettera può essere in maiuscolo. La parola originale non sarà mai vuota e conterrà sempre una vocale.

Casi 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
fonte

8

Nessuno dei tuoi casi di test contiene una vocale seguita da op, quindi una risposta lungo la linea di replace(/(.)op/, '\1')non fallirà nessuno di essi. Ti suggerisco di aggiungere una parola simile hoopo loopedai casi di test.

— Maniglia della porta

@ mbomb007 Ho aggiunto alcuni casi di test più complicati.

— xnor

La risposta deve funzionare solo per input pre-appaiati o tutti gli input?

— Calcolatrice

@CalculatorFeline "Dato un termine opposto"

— mbomb007,

2

Possiamo aggiungere "mopmopmopbopopop" come test case? :)

— user2390246

10

V , 12 , 5 byte

Í.“op

Provalo online!

00000000: cd2e 936f 70                             ...op

Risparmio di 7 byte grazie alla realizzazione di @ Xnor che poiché l'input deve essere sempre contrastato, non dobbiamo controllare le vocali.

— DJMcMayhem
fonte

Hmm, sembra così difficile da battere ...

— Erik the Outgolfer,

4

La discarica esadecimale: ...op mi sta facendo ridere molto più forte di quanto dovrebbe

— nmjcman101

12

Retina , 9 byte

(?!\G)op

Provalo online!

Invece di verificare che il carattere precedente sia una consonante, ci assicuriamo solo che la corrente opnon sia adiacente all'inizio della stringa o alla corrispondenza precedente. L'unico caso in cui potremmo trovare una corrispondenza errata opè se la stringa originale conteneva un op(risultante opop). Ma in quel caso rimuoveremo solo il primo opanziché il secondo e il risultato sarà lo stesso.

— Martin Ender
fonte

Questo non darebbe una risposta errata per un input simile loop?

— Leo,

4

@Leo loopnon è un input valido perché non è possibile ottenerlo dall'opporsi ad un'altra parola.

— Martin Ender,

@MartinEnder Ma lopoop(la versione opposta di loop) è valida e non viene annullata loop.

— Imus,

@Imus no, la versione opposta di loopè lopoopop.

— Martin Ender,

capito anche il mio errore poco dopo averlo pubblicato :) era troppo lento nell'eliminazione. Buon punto.

— Imus,

10

Python , 42 byte

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

Provalo online!

Se non sbaglio, si può semplicemente sostituire tutte ?opcon ?senza preoccuparsi vocali. Se la stringa originale contiene op, allora si oppone opope la sostituzione la restituisce ope non oltre. Questo perché lo schema corrispondente a ?opnon può sovrapporsi, quindi ne opviene rimosso solo uno .

Una soluzione non regex è più lunga di 5 byte.

Python , 47 byte

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

Provalo online

— XNOR
fonte

3

Puoi importarlo re dopo averlo fatto riferimento‽

— Adám,

4

@Adám Python non lo valuta quando viene definita la funzione, solo quando viene chiamata.

— xnor

4

Wow, è da un po 'che non vedo nessuno usare un interrobang. Immagino sia un modo per aggiungere un po 'di golf al tuo commento.

— Baldrickk,

1

@Baldrickk Ma in byte , l'interrobang ha> = byte rispetto alla sola stringa "?!"

— MilkyWay90,

5

Perl 5 , 10 + 1 = 11 byte

s/.\Kop//g

Provalo online!

Esegui con -p(penalità di 1 byte); le lingue del golf potrebbero fare automaticamente l'I / O implicito, ma Perl ha bisogno di un'opzione per farlo.

Quando ho visto la risposta di @ xnor , mi sono reso conto che poteva essere migliorato usando una funzione regex specifica di Perl; s/a\Kb/c/gè equivalente a s/ab/ac/g(in altre parole, l' s///unica rimpiazza le cose dopo la prima \K). Quindi ecco come appare in Perl.

5

Retina , 15 8 byte

(.)op
$1

Provalo online!

-7 byte grazie a Kevin Cruijssen

— Qui non c'e `Nessuno
fonte

2

È possibile salvare 7 byte sostituendo [^aeiou]con .. Vedi la spiegazione di @xnor nella sua risposta Python .

— Kevin Cruijssen,

3

Vai , 103 92 byte

Deve ... compilare ... Le funzioni integrate di Go hanno nomi strani. : P

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

Provalo online!

— totallyhuman
fonte

3

Haskell (93 62 61 byte)

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

grazie ai suggerimenti di @nimi nei commenti!

— Davide Spataro
fonte

2

Alcuni consigli: mentre stai usando ve osolo una volta, puoi integrarlo. notElemè più corto di not(...elem...). È possibile sostituire &&in una guardia con a ,. L'ultimo caso per apuò essere scritto come a x=x. Non c'è bisogno di ()dentro x:(a r).

— nimi,

1

... oh, e il test per =="op"può essere sostituito con una corrispondenza letterale:a(x:'o':'p':r)|notElem x"aeiouAEIOU"=x:a r

— nimi

Aggiornato. grazie @nimi

— Davide Spataro il

1

Ancora un byte da salvare: puoi omettere lo spazio tra xe ".

— nimi,

3

PHP , 36 byte

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

Provalo online!

— Jörg Hülsermann
fonte

Come dovrebbe essere gestito?

— Tito,

Non riesce per i primi due casi di test. Utilizzare preg_replaceper risolvere.

— Tito,

Puoi salvare 3 byte rinominando la variabile in un singolo carattere, ad esempio $ a

— junkfoodjunkie

@junkfoodjunkie $argnè una variabile riservata che è disponibile quando PHP viene eseguito con l' -Ropzione dalla riga di comando

— Jörg Hülsermann

Ah, okay, non lo sapevo. Il tester online non lo tiene conto. :-)

— junkfoodjunkie

2

Japt , 9 byte

r"%Vop"_g

Provalo online

— ispido
fonte

1

JavaScript (ES6), 35 byte

Aggiungi f=all'inizio e invoca like f(arg).

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

Sono sorpreso che nessuno abbia ancora pubblicato una soluzione JavaScript ....

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

Espandi frammento

— Arjun
fonte

1

C (gcc) , 83 byte

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

Provalo online!

— cleblanc
fonte

0

/// , 18 byte

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

Provalo online!

Nota che questo snippet vuole sostituire opcon a ., ma in seguito è stata definita una sostituzione in cui opviene reinserita nella stringa. Quella seconda istruzione dovrebbe essere opsostituita da un .(e quindi inserire una .nel risultato finale), quindi ho usato una \tra la oe pper interrompere il modello.

— steenbergh
fonte

0

APL (Dyalog) , 13 byte

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

Provalo online!

Semplicemente PCRE R eplace qualsiasi carattere seguito da "op" con il carattere stesso.

— Adamo
fonte

0

Cristallo, 39 byte

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

Come funziona

Cerca semplicemente ciascuna consonante, seguita dalla sequenza op. In tal caso, sostituire quella sequenza soltanto con la consonante trovato prima: ([^aeiou]).

Provalo online

— Domii
fonte

0

Java 8, 36 26 byte

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

-10 byte sostituendo [^aeiou]con ., grazie alla spiegazione di @xnor nella sua risposta Python .

Provalo qui.

— Kevin Cruijssen
fonte

0

Rubino , 34 27 22 + 1 = 23 byte

-4 byte grazie a RJHunter.

+1 byte per la -pbandiera.

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

Provalo online!

— totallyhuman
fonte

L'uso -pdell'opzione di Ruby avrà un costo di un byte ma consentirà di avviare direttamente lo script gsub.

— RJHunter,

0

sed, 22 byte

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

Legge da STDIN fino a EOF e genera una stringa non opposta
Utilizza la stessa tecnica di riduzione della lunghezza dalla risposta Python di @ xnor

— Arc676
fonte

0

R , 29 byte

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

Provalo online!

Proprio come la maggior parte delle altre soluzioni qui, cattura il personaggio seguito da op, lo sostituisce con il personaggio stesso.

— Sumner18
fonte

Copodope Gopolopfop

La lingua: opposizione

La sfida: disopposizione

Casi test:

V , 12 , 5 byte

Retina , 9 byte

Python , 42 byte

Perl 5 , 10 + 1 = 11 byte

Retina , 15 8 byte

Vai , 103 92 byte

Haskell (93 62 61 byte)

PHP , 36 byte

Japt , 9 byte

JavaScript (ES6), 35 byte

Test snippet

C (gcc) , 83 byte

/// , 18 byte

APL (Dyalog) , 13 byte

Cristallo, 39 byte

Come funziona

Java 8, 36 26 byte

Rubino , 34 27 22 + 1 = 23 byte

sed, 22 byte

R , 29 byte