Covfefify uma string

371

Nesse desafio, você deve usar uma string que corresponda ao regex ^[a-zA-Z]+$ou o que for razoável (não é necessário considerar letras maiúsculas ou minúsculas, se quiser) (você pode assumir que a string é longa o suficiente e tem a estrutura correta para todas as operações) e produziu outra string, produzida de maneira semelhante à palavra no final de um recente tweet dadaísta do POTUS ( "Despite the constant negative press covfefe").

Como ocultar uma string:

Primeiro, obtenha o primeiro grupo de sons (terminologia composta).

Como você faz isso? Bem:

  • Encontre a primeira vogal ( ytambém é vogal)

      v
    creation
    
  • Encontre a primeira consoante depois disso

        v
    creation
    
  • Remova o restante da string

    creat
    

Esse é o seu primeiro grupo de som.

Próxima Etapa:

Obter a última consoante do grupo de sons

t

e substitua-o pela versão com ou sem voz. Para fazer isso, encontre a letra nesta tabela. Substitua pela letra fornecida (que pode ser a mesma letra)

b: p
c: g
d: t
f: v
g: k
h: h
j: j
k: g
l: l
m: m
n: n
p: b
q: q
r: r
s: z
t: d
v: f
w: w
x: x
z: s

então, nós temos

d

Em seguida, faça a próxima vogal depois dessa consoante. Você pode assumir que essa consoante não está no final da sequência. Junte esses dois e repita-o duas vezes:

didi

Concatene isso para o primeiro grupo de sons:

creatdidi

Você está pronto: a string é cefefificada e agora você pode produzi-la.

Casos de teste:

coverage: covfefe

example: exxaxa

programming: progkaka (the a is the first vowel after the g, even though it is not immediately after)
code: codtete

president: preszizi

Isso é , então faça seu programa o mais curto possível!

Limão destrutível
fonte
7
"x" deve mapear tecnicamente para "gz". "qu" deve mapear para "gw".
Steve Bennett
2
Isso especifica um conceito de covfefification, mas continuo achando que uma referência ao trabalho de Douglas Hofstadter (e de Melanie Mitchell) sobre analogias de conversão de strings, por exemplo, em Fluid Concepts, parece apropriada.
Mars
59
Respostas mais de 140 caracteres deve ser desqualificado
Sandy Gifford
12
Infelizmente, é impossível fazer isso no TrumpScript :(
4
@ThePlasmaRailgun Era uma piada, já que os tweets precisam ter 140 caracteres ou menos.
Esolanging Fruit

Respostas:

91

Geléia ,  58  57 bytes

<TḢị
e€Øyµ¬TĖEÐḟḢṪ;ç¥T
ḣÇḢ⁸ÇịµḢØYiị“ßȷ%Hẹrȧq’œ?ØY¤⁾cgy;ẋ2

Um programa completo que aceita uma lista de caracteres minúsculos e imprime o resultado.

Experimente online!

Quão?

<TḢị - Link 1, extract first value from y not less than x: number, x; list of numbers, y
     -                                                     e.g. 5, [3,4,7]
<    - x less than vectorised across y                             [0,0,1]
 T   - truthy indices                                              [    3]
  Ḣ  - head                                                             3
   ị - index into y                                                     7

e€Øyµ¬TĖEÐḟḢṪ;ç¥T - Link 2, indices of the letters to manipulate: list of characters, w
  Øy              - vowel+ yield = "AEIOUYaeiouy"                 e.g.  "smouching" 
e€                - exists in for €ach letter in w                       001100100
    µ             - monadic chain separation, call that v
     ¬            - not vectorised across v                              110011011
      T           - truthy indices                                       12  56 89
       Ė          - enumerate                      [[1,1],[2,2],[3,5],[4,6],[5,8],[6,9]]
         Ðḟ       - filter discard if:
        E         -   elements are equal                       [[3,5],[4,6],[5,8],[6,9]]
           Ḣ      - head                                        [3,5]
            Ṫ     - tail                                           5
                T - truthy indices of v                                    34  7
               ¥  - last 2 links as a dyad
              ç   -   call last link (1) as a dyad                         7
             ;    -   concatenate                                     5,7
                  -                                    ...i.e the indexes of 'c' and 'i'

ḣÇḢ⁸ÇịµḢØYiị“ßȷ%Hẹrȧq’œ?ØY¤⁾cgy;ẋ2 - Main link: list of characters, w
                                   -                             e.g.  "smouching"
 Ç                                 - call the last link (2) as a monad    [5,7]
ḣ                                  - head to index (vectorises)      ["smouc","smouchi"]
  Ḣ                                - head                             "smouc"
                                   -   implicit print due to below leading constant chain
   ⁸                               - link's left argument, w
    Ç                              - call the last link (2) as a monad    [5,7]
     ị                             - index into w                         "ci"
      µ                            - monadic chain separation, call that p
       Ḣ                           - head p                               'c'
        ØY                         - consonant- yield = "BCDFGHJKLMNPQRSTVWXZbcdfghjklmnpqrstvwxz"
          i                        - first index                          22
                          ¤        - nilad followed by link(s) as a nilad:
            “ßȷ%Hẹrȧq’             -   base 250 number = 1349402632272870364
                        ØY         -   consonant- yield = "BCDFGHJKLMNPQRSTVWXZbcdfghjklmnpqrstvwxz"
                      œ?           -   nth permutation  = "BCDFGHJKLMNPQRSTVWXZpctvkhjglmnbqrzdfwxs"
           ị                       - index into         (special case ->) 'c'
                           ⁾cg     - literal ['c','g']
                              y    - translate (change 'c's to 'g's)      'g'
                               ;   - concatenate with the headed p        "gi"
                                ẋ2 - repeat list twice                    "gigi"
                                   - implicit print ...along with earlier = smoucgigi
Jonathan Allan
fonte
13
Isto é incrível ...
Klangen
Trabalho incrível.
você
9
Eu sou geléia. Votado.
DeepS1X 5/06
6
Essa é a linguagem de programação mais estranha que eu já vi.
21719 Ryan
@ Ryan é destinado ao golfe.
Esolanging Fruit
61

JavaScript (ES6), 107 103 bytes

Guardado 4 bytes graças a GOTO 0

s=>([,a,b,c]=s.match`(.*?[aeiouy]+(.)).*?([aeiouy])`,a+(b=(a="bcdfgszkvtgp")[11-a.search(b)]||b)+c+b+c)

Casos de teste

Arnauld
fonte
6
Você pode salvar alguns bytes como este:s=>([,a,b,c]=s.match`(.*?[aeiouy]+(.)).*?([aeiouy])`,a+(b=(a="bcdfgszkvtgp")[11-a.search(b)]||b)+c+b+c)
GOTO 0
@ GOTO0 Obrigado, atualizado.
Arnauld
49

Geléia , 45 39 bytes

Øa“œṣ$b|0Ḃ’ṃ,Ṛ$yṫµfØyḢṭḢẋ2
e€ØyIi-‘ɓḣ;ç

Experimente online!

Como funciona

e€ØyIi-‘ɓḣ;ç                Main link. Argument: s (string)

  Øy                        Vowels with y; yield "AEIOUYaeiouy".
e€                          Test each character in s for membership.
    I                       Increments; compute the forward differences of the
                            resulting array of Booleans.
     i-                     Find the first index of -1.
       ‘                    Increment this index to find the index of the first
                            consonant that follows a vowel.
                            Let's call this index j.
        ɓ                   Begin a new chain. Left argument: s. Right argument: j
         ḣ                  Head; yield the first j characters of s.
           ç                Call the helper link with arguments s and j.
          ;                 Concatenate the results to both sides.
Øa“œṣ$b|0Ḃ’ṃ,Ṛ$yṫµfØyḢṭḢẋ2  Helper link. Left argument: s. Right argument: j

Øa                          Alphabet; set the return value to “abc...xyz”.
  “œṣ$b|0Ḃ’                 Yield 7787255460949942. This is a numeric literal in
                            bijective base 250. The value of each digit matches its
                            1-based index in Jelly's code page.
           ṃ                Convert 7787255460949942 to base 26, using the digts
                            a = 0, b = 1, ..., z = 25.
                            This yields "bcdfkszgvtgp".
            ,Ṛ$             Pair the result with its reverse, yielding
                            ["bcdfkszgvtgp", "pgtvgzskfdcb"].
                ṫ           Call tail with arguments s and j, yielding the j-th and
                            all following characters of s.
               y            Translate the result to the right according to the
                            mapping to the left, i.e., replace 'b' with 'p', 'c'
                            with 'g', etc. 'g' appears twice in the first string
                            of the mapping; only the first occurrence counts.
                            Let's call the resulting string r.
                 µ          Begin a new chain. Argument: r
                  fØy       Filter; remove non-vowels from r.
                     Ḣ      Head; take the first vowel.
                       Ḣ    Head; take the first character/consonant of r.
                      ṭ     Tack; append vowel to the consonant.
                        ẋ2  Repeat the resulting string twice.
Dennis
fonte
4
Desculpe, amigo, parece que você perdeu a rep geléia de mega
Destrutível Lemon
tfw uma resposta parece simplista demais, mas na verdade é realmente maravilhosa ... simples é linda
Erik the Outgolfer
31

CJam , 59 58 57 56 bytes

q_{"aeiouy":V&,_T|:T^}#)/(_W>"cbdfkszgvtpg"_W%er@sV&0=+_

Experimente online!

Explicação

q_                   e# Read the input and copy it.
{                    e# Find the index of the first char for which the following is true:
 "aeiouy":V          e#  Push "aeiouy" and store it in V.
 &,                  e#  Check if the current char is in the vowel string (0 or 1).
 _T|:T               e#  Copy the result and OR with T (T is initially 0), storing back in T.
 ^                   e#  XOR with the original result. This will be 1 for the first 
                     e#  consonant appearing after a vowel.
}#                   e# (end find)
)/                   e# Increment the index and split the string into chunks of that size.
(                    e# Pull out the first chunk.
_W>                  e# Copy it and get the last character (the consonant).
"cbdfkszgvtpg"_W%er  e# Transliterate the consonant to voiced/voiceless alternative.
@s                   e# Bring all the other split chunks to the top and join them together.
V&0=                 e# First char of the set intersection of that and the vowels.
                     e# (i.e. the first vowel in the second half)
+                    e# Concatenate the new consonant and the vowel.
_                    e# Duplicate the result of that.
                     e# Implicit output of stack contents.
Gato de negócios
fonte
2
CJam vence Jelly? : O (pelo menos, é melhor do que a resposta da geléia que todo mundo parece estar votando.) #
Esolanging Fruit
29

C, 219 213 206 179 175 bytes

#define p putchar
#define q(a)for(;a strchr("aeiouy",*s);p(*s++));
f(s,c,h)char*s;{q(!)q()p(*s);p(c="pgt vkh jglmn bqrzd fwx s"[*s-98]);p(h=s[strcspn(s,"aeiouy")]);p(c);p(h);}

Experimente online!

betseg
fonte
* P = putchar funciona como a primeira linha?
k_g
4
Desculpe desqualificado. Não pode caber em um tweet.
caird coinheringaahing
@cairdcoinheringaahing você senhor é incorreta (eu sei que era 140 quando você escreveu isso)
Stan Strum
1
171 bytes
ceilingcat 30/11/18
1
12 bytes ou mais podem ser eliminados substituindo se #definea função por sinalizadores de pré-processador ( -D...).
23

Perl 5 , 81 72 bytes

s![aeiouy]+(.)\K.*!($1=~y/bcdfgkpstvz/pgtvkgbzdfs/r.$&x/[aeiouy]/g)x2!ge

Experimente online!

Sujo
fonte
Você e eu tivemos a mesma idéia \K, mas você fez 9 bytes melhor do que eu. Boa resposta!
Silvio Mayolo
18

PHP, 121 bytes

$v=aeiouy;preg_match("#(.*?[$v]+([^$v])).*?([$v])#",$argn,$t);echo$t[1],$z=strtr($t[2].$t[3],bcdfgkpstvz,pgtvkgbzdfs),$z;

Experimente online!

Jörg Hülsermann
fonte
3
-2 bytes:echo$t[1],$z=strtr($t[2].$t[3],bcdfgkpstvz,pgtvkgbzdfs),$z;
Titus
@ Titus Eu não penso nisso. Obrigado
Jörg Hülsermann
por que não renomear $argnpara algo mais curto? $a, por exemplo - isso é -3 bytes
Tyler Sebastian
@TylerSebastian Devo ter uma variável de entrada que exista. Sim, eu posso criar uma função, mas se eu fizer isso ele levantar a contagem de bytes mais como usar os três bytes
Jörg Hülsermann
ah ok desculpe, esqueci como o PHP faz argumentos de linha de comando - acabei de ver que você o definiu na seção de cabeçalho, mas não percebeu que era uma variável reservada.
Tyler Sebastian
15

Pitão, 54 bytes

L+hb?>F}RJ"aeiouy"<b2+hKtb*2+XhK"cgdsfbpvztkg")h@JKytb

Isso define uma função yque espera uma string. Experimente on-line: Test Suite

Jakube
fonte
14

Python 3, 155 139 bytes

import re
def f(x,k='aeiouy])'):b,c,v=re.findall(f'(.*?[{k}([^{k}.*?([{k}',x)[0];return b+c+(('bcdfgkpstvz'+c)['pgtvkgbzdfs'.find(c)]+v)*2

removeu 16 bytes graças a @ovs

removido 1 byte graças a Gábor Fekete

L3viathan
fonte
2
Você pode criar uma variável que tenha o valor 'aeiouy]', talvez isso economize alguns bytes. Além disso, você pode remover alguns caracteres das cadeias de substituição, pois são iguais.
Gábor Fekete
2
Não consigo remover os caracteres idênticos da sequência de substituição, porque isso seria um IndexErrore salvar aeiouy])não salva nenhum bytes.
L3viathan
2
se você puxar algo assim s='aeiouy])', você poderia usar b,c,v=re.findall('(.*?[%s([^%s.*?([%s'%(s,s,s). Não é mais curto, mas pode levar a uma maneira de reduzi-lo em geral.
Jeremy Weirich
3
O uso de strings f salvará 1 byte: k='aeiouy])'ef'(.*?[{k}([^{k}.*?([{k}'
Gábor Fekete
14

Java 8, 243 236 222 bytes

s->{String q="[a-z&&[^aeiouy]]",a=s.replaceAll("(^"+q+"*[aeiouy]+"+q+").*","$1"),b="pgtvkhjglmnbqrzdfwxs".charAt("bcdfghjklmnpqrstvwxz".indexOf(a.charAt(a.length()-1)))+s.replaceAll(a+q+"*([aeiouy]).*","$1");return a+b+b;}

Usa .replaceAllexpressões regulares com grupos de captura para filtrar as partes que não queremos.

Explicação:

Experimente aqui.

s->{ // Method with String parameter and String return-type
  // Temp String we use multiple times:
  String q="[a-z&&[^aeiouy]]",
   // Regex to get the first part (i.e. `creation` -> `creat` / `example` -> `ex`)
   a=s.replaceAll("(^"+q+"*[aeiouy]+"+q+").*","$1"), 
   // Get the trailing consonant and convert it
   b="pgtvkhjglmnbqrzdfwxs".charAt("bcdfghjklmnpqrstvwxz".indexOf(a.charAt(a.length()-1)))
   // Get the next vowel after the previous consonant from the input-String
    +s.replaceAll(a+q+"*([aeiouy]).*","$1");
  // Return the result:
  return a+b+b;
} // End of method
Kevin Cruijssen
fonte
13

Haskell , 143 141 138 138 137 136 bytes

z h=elem h"aeiouy"
f i|(s,(m,c:x))<-span z<$>break z i,j:_<-filter z x,d<-"pgt.vkh.jglmn.bqrzd.fwx.s"!!(fromEnum c-98)=s++m++[c,d,j,d,j]

Experimente online!

bartavelle
fonte
1
Impressionante! Substituir nxpor algo com uma letra economizará 2 bytes.
tomsmeding 01/06/19
declarar zfora fe alternar para guardas em vez de letsalvar outros dois bytes: Experimente on-line!
Laikoni
2
E mais dois combinando (s,v)<-break z i,(m,c:x)<-span z vem (s,(m,c:x))<-span z<$>break z i.
Laikoni
Poderia fazer a barba mais uma vez, colocando o parêntese de abertura ao lado do let, obrigado!
#
@Laikoni Eu não entendo a parte de zsair de f?
#
10

Python, 261 260 bytes

def c(s,t='bpcgdtfvgksz'):
 q,r,t='aeiouy',range(len(s)),t+t[::-1]
 c=[i for i in r if i>[j for j in r if s[j]in q][0]and s[i]not in q][0]
 C=([t[2*i+1]for i in range(12)if s[c]==t[i*2]]or s[c])[0]
 return s[:c+1]+(C+s[[i for i in r if i>c and s[i]in q][0]])*2

Uma solução não regular, não esotérica. Demorou cerca de 20 minutos para fazer e mais uma hora para jogar golfe.

Provavelmente tem mais compreensão da lista do que toda a biblioteca padrão do python, principalmente porque eu não sei regex ...

Experimente online! (Com caixas de teste)

sagiksp
fonte
8

Ruby , 90 bytes

->x{x[/(.*?#{$v='[aeiouy]'}+.).*?(#$v)/];$1+($1[-1].tr('bcdfgkpstvz','pgtvkgbzdfs')+$2)*2}

Experimente online!

Desprezando um pouco, temos algo equivalente a:

def covfefefify(x)
  v = '[aeiouy]'
  # Match x to a regular expression capturing:
  # Group 1:
  #  some characters (non-greedy)
  #  followed by some (greedy) non-zero number of vowels
  #  followed by exactly one character
  # Ungrouped:
  #  Some more (non-greedy) characters
  # Group 2
  #  Exactly one other vowel
  # By switching between greedy and non-greedy matches, we can capture longest and shortest vowel/consonant sequences without writing out all the consonants
  x[/(.*?#{v}+.).*?(#{v})/]
  # Glue it back together, replace the necessary consonants, duplicate where needed
  $1+($1[-1].tr('bcdfgkpstvz','pgtvkgbzdfs')+$2)*2
end
ymbirtt
fonte
8

Python 2, 251 246 245 239 237 234 229 211 bytes

Primeira submissão aqui.

def f(s):
  r=c='';n=0;w='aeiouy';a='bcdfghjklmnpqrstvwxz'
  for i in s:
    if n<2:r+=i
    if n<1and i in w:n=1
    if n==1and i in a:c='pgtvkhjglmnbqrzdfwxs'[a.index(i)];n=2
    if n==2and i in w:r+=c+i+c+i;break
  return r

Experimente online!

Companheiros de golfe que me ajudaram:

 Destructible Lemon / Wheat Wizard - 5 bytes
 Hubert Grzeskowiak - 1 byte
 musicman523 - 16 bytes
WaitndSee
fonte
2
Bem vindo ao site! Vejo que você tentou usar guias para recuar. Se você substituir cada guia com um único espaço, é funcionalmente idêntica e realmente mostra-se adequadamente em vez de bytes como extras
Destrutível Lemon
4
Enquanto o que o Destructible Lemon disse está correto, você pode salvar ainda mais bytes na fonte, recuando o primeiro nível do seu código com um único espaço e o segundo nível com uma única guia, isso dificultará a exibição, mas facilitará a exibição. economize 5 bytes.
Sriotchilism O'Zaic
1
O ponto e vírgula no final da linha 4 é necessário?
Hubert Grzeskowiak 3/17/17
1
@WaitndSee Acho que você pode reduzir alguns de seus condicionais. Primeiro: você pode mudar not na n<1para 2 bytes, desde que você sabe nnunca será negativo. Você também pode mudar n==3para, n>2pois sabe nque nunca será maior que 3. Você também pode usar os truques Python para condicionais para encurtar o primeiro e penúltimo ainda mais longe: n=[n,1][i in w and n<1]; r+=[0,r][n<2]
musicman523
1
Você pode mudar r,v,c=('',)*3para r=v=c='', pois as strings são imutáveis. Eu tentei vários outros truques inteligentes, mas frustrantemente eles são exatamente o mesmo tempo. Também pode valer a pena adicionar um Experimente-o online! link para sua publicação
musicman523
7

Rubi , 175 141 110 bytes

->s{s=~/(.*?#{v='[aeiouy]'}+(#{c='[^aeiouy]'}))#{c}*(#{v})/;"#$1#{($2.tr('bcdfgkpstvz','pgtvkgbzdfs')+$3)*2}"}

Experimente online!

  • Economizou 34 bytes graças a Eric Duminil
  • Economizou 31 bytes graças aos argumentos sugeridos pelo Value Ink +tr

Ungolfed

covfefify = -> (s) {
    from = 'bcdfgkpstvz'
    to   = 'pgtvkgbzdfs'

    vowels = "[aeiouy]"
    consonants = "[^aeiouy]"

    s.match(/(.*?#{vowels}+(#{consonants}))#{consonants}*(#{vowels})/)
    d = ($2.tr(from, to) + $3) * 2
    "#$1#{d}"
}
sudee
fonte
4
-34 bytes comHash[*"bpcgdtfvgkkgpbsztdvfzs".chars]
Eric Duminil
1
Como a entrada parece ter todos os caracteres alfabéticos, c=[^aeiou]é mais curta. Tem o primeiro interpolação para cada variável atribuí-lo simultaneamente para -2 bytes: /^(.*?${v='[aeiou]'}+(#{c='[^aeiou]})).../. Finalmente, em $2.tr("b-z","pgtevkhijgl-obqrzdufwxys")vez da solução Hash.
Value Ink
Você pode economizar 14 bytes usando subexpressions ( \g<n>) em vez de interpolação, além de outros 14 utilizando @ de ValueInk [^aeiou]sugestão: s=~/^(.*?([aeiouy])+([^aeiou]))\g<3>*(\g<2>)/.
Jordan
Na verdade, isso tem um bug com programming-> progkaka, que não consigo entender.
Jordânia
@ Jordânia, infelizmente, a chamada de subexpressão \g<3>atualiza o valor de US $ 3, portanto não podemos usar esse atalho.
Sudee
6

Cristal, 203 194 187 186 184 163 bytes

o=""
ARGV[v=c=0].each_char{|a|r=/#{a}/
"aeiouy"=~r&&(v=x=1)||(c=v)
o+=a if c<2||x
c>0&&(x&&break||(o+=(i="pgtvkgbqrzdfs"=~r)?"bcdfgkpqrstvz"[i]: a))}
p o+o[-2..-1]
reitermarkus
fonte
Eu acho que você pode perder as parênteses ao redor c=veo+=<...>
Cyoce
5

MATLAB / Oitava - 159 158 bytes

Os trabalhos a seguir assumindo que a sequência de entrada esteja em minúscula.

a=input('','s');m=ismember(a,'aeiouy');s='pgt vkh jglmn bqrzd fwx s';m(1:find(m,1))=1;i=find(~m,1);f=a(1:i);d=s(f(end)-97);m(1:i)=0;v=a(find(m,1));[f d v d v]

Explicação

  1. a = input('','s');: Obtém uma seqüência de STDIN e armazena-o na variável a.
  2. m=ismember(a,'aeiouy');: Retorna uma matriz booleana que é do mesmo tamanho que a sequência que adetermina onde as vogais estão localizadas
  3. s='pgt vkh jglmn bqrzd fwx s';O covfefemapeamento de consoantes como uma sequência. Essa cadeia tem 25 caracteres e omite as vogais. A primeira posição em que a vogal 'a'deve estar é removida, enquanto as outras posições em que as vogais estão localizadas são colocadas com um caractere de espaço simulado. Isso é feito para que, quando determinarmos a primeira consoante que aparece após a vogal, converteremos a consoante em uma posição para acessar um caractere nessa cadeia de caracteres para determinar o primeiro componente da palavra convertida.
  4. m(1:find(m,1))=1: Define a primeira posição da matriz booleana até onde encontramos a primeira vogal como todas as vogais. Isso será feito para que, quando procurarmos a próxima consoante que segue a primeira vogal, ignoraremos esses caracteres.
  5. i=find(~m,1);: Localiza a primeira posição da string que é uma consoante após a primeira vogal.
  6. f=a(1:i): Remove a string após a primeira consoante que segue a vogal. Simplesmente amostramos da primeira posição da string até este ponto.
  7. d=s(f(end)-97);: Pegue o último caractere da string restante e encontre onde precisamos obter amostras da string de pesquisa e obtenha esse caractere. Subtrair um caractere e um número em MATLAB ou Octave coalesces para formar um número inteiro convertendo o caractere em seu código ASCII. Nesse caso, subtraímos o último caractere pelo caractere no início do alfabeto para nos dar a posição relativa ao início. No entanto, em vez de subtrair por b(98), subtraímos aquando o MATLAB inicia a indexação por 1 em vez do 'a'código ASCII do 0. é 97.
  8. m(1:i)=0;: Pega a máscara booleana e define todos os caracteres na sequência de entrada da primeira posição para a primeira consoante após uma vogal como false.
  9. v=a(find(m,1));: Localiza a próxima vogal que segue a primeira consoante da sequência de entrada.
  10. [f d v d v]: Saída nossa covfefestring ied.

Execuções de exemplo

>> a=input('','s');m=ismember(a,'aeiouy');s='pgt vkh jglmn bqrzd fwx s';m(1:find(m,1))=1;i=find(~m,1);f=a(1:i);d=s(f(end)-97);m(1:i)=0;v=a(find(m,1));[f d v d v]
coverage

ans =

covfefe

>> a=input('','s');m=ismember(a,'aeiouy');s='pgt vkh jglmn bqrzd fwx s';m(1:find(m,1))=1;i=find(~m,1);f=a(1:i);d=s(f(end)-97);m(1:i)=0;v=a(find(m,1));[f d v d v]
example

ans =

exxaxa

>> a=input('','s');m=ismember(a,'aeiouy');s='pgt vkh jglmn bqrzd fwx s';m(1:find(m,1))=1;i=find(~m,1);f=a(1:i);d=s(f(end)-97);m(1:i)=0;v=a(find(m,1));[f d v d v]
programming

ans =

progkaka

>> a=input('','s');m=ismember(a,'aeiouy');s='pgt vkh jglmn bqrzd fwx s';m(1:find(m,1))=1;i=find(~m,1);f=a(1:i);d=s(f(end)-97);m(1:i)=0;v=a(find(m,1));[f d v d v]
code

ans =

codtete

>> a=input('','s');m=ismember(a,'aeiouy');s='pgt vkh jglmn bqrzd fwx s';m(1:find(m,1))=1;i=find(~m,1);f=a(1:i);d=s(f(end)-97);m(1:i)=0;v=a(find(m,1));[f d v d v]
president

ans =

preszizi

Experimente online!

http://www.tutorialspoint.com/execute_octave_online.php?PID=0Bw_CjBb95KQMdjROYVR0aFNrWXM

Quando você pressiona o botão Executar na parte superior, aguarde alguns instantes e digite a sequência desejada. Digite a sequência lentamente, pois parece haver um atraso ao digitar o texto.

rayryeng
fonte
5

Clojure, 182 156 caracteres

#(let[v #{\a\e\i\o\u\y}p(partition-by v %)[s m[c][n]](if(v(first %))(cons[]p)p)z[(or((zipmap"bcdfgkpstvz""pgtvkgbzdfs")c)c)n]](apply str(concat s m[c]z z)))

Como funciona

(partition-by v "president")

Retorna uma seq de ((\p \r) (\e) (\s) (\i) (\d) (\e) (\n \t))

[s m [c] [n]] (if (v (first x)) (cons [] p) p)

Desestrutura a seq em s=(\p \r), m=(\e), c=\s, n=\i.

Ou de "exemplo" é s=[], m=(\e), c=\x, n=\a.

(apply str (concat s m [c] [(l c) n] [(l c) n]))

Retorna a sequência de saída concatenando as partes juntas e as especificando.

E então eu apenas removi o máximo de espaço em branco possível enquanto ainda o compilava.

Desglomerado:

(defn covfefify [x]
  (let [vowel? #{\a\e\i\o\u\y}
        parts (partition-by vowel? x)
        [start mid [consonant] [last-vowel]] (if (vowel? (first x)) (cons [] parts) parts)
        lookup #(or ((zipmap "bcdfgkpstvz" "pgtvkgbzdfs") %) %)]
    (apply str (concat start mid [consonant] [(lookup consonant) last-vowel] [(lookup consonant) last-vowel]))))
Brian Baritonehands Gregg
fonte
Bem-vindo ao PPCG, e ótima primeira resposta! Esperamos que você fique e se divirta participando de mais desafios. :-)
ETHproductions
Se você estiver definindo uma função, seu nome provavelmente deve ser o mais curto possível. Você poderia simplesmente chamar a função principal c, por exemplo. (Também permitimos funções anônimas, que são mais curtas em muitos idiomas; não tenho certeza se elas estão no Clojure). Vejo que você já fez essa melhoria no interior do seu código, portanto, provavelmente não precisa mudar muito aqui.
5

R, 341 caracteres

f=function(x){g=function(x,y)el(strsplit(x,y));a=g(x,'');v=g('aeiouy','');n=letters[-c(1,5,9,15,21,25)];l=data.frame(n,g('pgtvkhjglmnbqrzdfwxs',''));y=min(match(n,a)[which(match(n,a)>min(match(v,a),na.rm=T))]);m=l[which(l$n==a[y]),2];e<-a[-c(1:y)][min(match(v,a[-c(1:y)]),na.rm=T)];paste0(paste0(a[c(1:y)],collapse=''),m,e,m,e,collapse="")}

Horrenda tentativa R, por que as cordas são tão difíceis?

Versão legível:

f = function(x) {
  g = function(x, y)el(strsplit(x, y))
  a = g(x, '')
  v = g('aeiouy', '')
  n = letters[-c(1, 5, 9, 15, 21, 25)]
  l = data.frame(n, g('pgtvkhjglmnbqrzdfwxs', ''))
  y = min(match(n, a)[which(match(n, a) > min(match(v, a), na.rm = T))])
  m = l[which(l$n == a[y]), 2]
  e <-a[-c(1:y)][min(match(v, a[-c(1:y)]), na.rm = T)]
  paste0(paste0(a[c(1:y)], collapse = ''), m, e, m, e, collapse = "")
}
Andrew Haynes
fonte
Acredito que sua contagem é off - Conto 340 bytes
Taylor Scott
4

BlitzMax, 190 bytes

s$=Input()For i=1To s.Length
f="aeiouy".Contains(s[i-1..i])If f v=i If c Exit
If v And c|f=0c=i
Next
t$="bpdtfvgkcgsz"x$=s[c-1..c]r=t.Find(x)~1If r>=0x=t[r..r+1]
x:+s[v-1..v]Print s[..c]+x+x

Retira uma palavra de stdin e imprime o resultado em stdout. A palavra de entrada é assumida como minúscula e contém pelo menos uma vogal seguida por uma consoante.

Uma versão mais legível do programa com formatação e declarações de variáveis:

SuperStrict
Framework BRL.StandardIO

Local s:String = Input()
Local v:Int
Local c:Int

For Local i:Int = 1 To s.Length
    Local f:Int = "aeiouy".Contains(s[i - 1..i])
    If f Then
        v = i
        If c Then Exit
    End If
    If v And c | f = 0 Then c = i
Next

Local t:String = "bpdtfvgkcgsz"
Local x:String = s[c-1..c]
Local r:Int = t.Find(x) ~ 1
If r >= 0 Then x = t[r..r + 1]
x :+ s[v - 1..v]
Print s[..c] + x + x

Como funciona:

O BlitzMax não possui nenhuma funcionalidade regular de regex ou similar; portanto, um loop é usado para iterar os caracteres da palavra de entrada até encontrar uma vogal seguida por uma cadeia de pelo menos uma consoante. A variável c armazena a posição da última dessas consoantes, v da vogal. O loop continua para ver se há outra vogal após a cadeia e, se houver, v é atualizado de acordo. Em seguida, a consoante em c é pesquisada na cadeia "bpdtfvgkcgsz", que atua como uma tabela de substituição. Se a consoante for encontrada na tabela em qualquer posição, essa posição será XOR-ed com 1 e o caractere na posição resultante será usado como substituto. A operação XOR transforma 0 em 1, 2 em 3, 4 em 5 etc. e vice-versa, para que b seja trocado por p, d com te assim por diante. Por fim, a sequência original até c,

Resultados de exemplo:

cobertura covfefe

criação creatdidi

progkaka de programação

estupidez stupbibi

blá bláá

Bola de fogo
fonte
link para o repo blitzmax?
Destructible Lemon
O @DestructibleLemon BlitzMax foi criado como uma linguagem principalmente para o desenvolvimento de jogos amadores e com um compilador proprietário vendido por dinheiro. Embora agora seja gratuito e disponível a partir daqui , acredito que o compilador ainda não seja de código aberto. Existe uma implementação alternativa (repo aqui , constrói aqui ), que, no entanto, executará apenas a versão não destruída do código acima devido à falta de uma configuração "não estrita" que permita omitir declarações de variáveis.
FireballStarfish
Uso inteligente de XOR no índice - provavelmente usarei isso algum dia. Obrigado.
AI Breveleri
4

Perl, 71 bytes

s#[aeiouy]+(.)\K.*?([aeiouy]).*#"$1$2"=~y/bcdfgkpstvz/pgtvkgbzdfs/rx2#e

Também corra com perl -pe. Alguns bytes a menos que a solução Perl anterior. É certo que também obtive alguma inspiração de lá.

SomeDude
fonte
4

05AB1E , 101 104 88 bytes

-16 bytes graças a Okx

De alguma forma, espero que isso possa ser feito de maneira mais eficiente.

žOÃćIsk>[DIs£¤žPså#\>]s[DIsèDžOså#\>]ŠŠ"bpcgdtfvgkhhjjkgllmmnnpbqqrrsztdvfwwxxzs"S2ôDí«ø`Šs¤sŠksŠèsŠì2׫

Experimente online!

Explicação

                  Argument: s
žOÃ0èk            Get index of first vowel in s
>[DIs£¤žPså#\>]   Increment index and split s until last character of substring is a consonant
s[DIsèDžOså#\>]   Increment index an get character at index in s until character is a vowel
ŠŠ                Rearrange stack
.•7¶ëÒ—Öb´ƒ≠Ä“šʒƵJ^ÝV“Îpи•S2ôDí«ø`   Prepare character substitution map
Šs                Rearrange stack
¤                 Last character of substring
sŠ                Rearrange stack (yes, again)
k                 Index of last character in substitution key list
sŠ                Rearrange stack (it won't stop)
è                 Character at index in character substitution value list
sŠ                Rearrange stack (ONE LAST TIME)
ì2׫              Prepend substitution consonant before vowel, duplcicate and concatenate with the substring from the very beginning
kalsowerus
fonte
Você pode substituir "bpcgdtfvgkhhjjkgllmmnnpbqqrrsztdvfwwxxzs"por .•7¶ëÒ—Öb´ƒ≠Ä“šʒƵJ^ÝV“Îpи•para salvar 15 bytes
Okx
Você também pode substituir žOÃćIskpor žOÃ0èkpara salvar outro byte.
Okx,
@ Ok, acho que realmente preciso aprender algumas técnicas de compressão de cordas. Obrigado!
kalsowerus
@kalsowerus Eu sei que já faz um tempo, mas você pode obter 8 bytes de sua resposta da seguinte maneira: žOÃнk>[DIs£¤žPså#\>]©s[DIsèDžOså#\>]s\.•7¶ëÒ—Öb´ƒ≠Ä“šʒƵJ^ÝV“Îpи•S2ôDí«ø`®θkèìDJ Experimente online. Eu me livrei principalmente de todos os swaps e swaps triplos usando uma variável. E pode ser н, e eu substituí 2׫por DJpara juntar a pilha inteira. PS: Também publiquei uma resposta 05AB1E de 55 bytes usando uma técnica diferente. (Que também inclui um link para entender melhor compressão em 05AB1E:. D)
Kevin Cruijssen
3

Cristal, 130 bytes

c=/[aeiouy]/
x,y,z=ARGV[0].partition /[^aeiouy]*#{c}*/
k=z[0]
b=((i="pgtvkgbqrzdfs"=~/#{k}/)?"bcdfgkpqrstvz"[i]: k)+z[c]
p y+k+b*2

Como funciona

c = /[aeiouy]/

armazene um regex para pesquisar a primeira vogal para c.

x, y, z = ARGV[0].partition /[^aeiouy]*#{c}*/

divida o primeiro argumento em três partes {"", String até um caractere antes da primeira consoante após a primeira vogal, restante da string} e armazene cada um dos elementos em x, ye z.

k = z[0]

obtenha o primeiro caractere, a consoante relevante.

i = "pgtvkgbqrzdfs" =~ /#{k}/

obtenha o índice da consoante dentro da string esquerda ou nil.

b = ((i = ...) ? "bcdfgkpqrstvz"[i] : k) + z[c]

caso icontrário nil, use esse índice para a segunda sequência (tipo um hash de golfe).

se ifor nil, use o caractere original.

Em seguida, acrescente a primeira vogal de z.

p y + k + (b * 2)

finalmente, imprima a primeira parte do primeiro regex y, a primeira consoante ke duas vezes a string calculada anterior b.

Experimente online .

Domii
fonte
2

Lua, 164 157 bytes

w=arg[1]
i,j,a,b=w:find('[aeiouy]+([^aeiouy]+)(.)')
print(w:sub(1,j-#a)..(('pgtvkhjglmnbqrzdfwxs'):sub(('bcdfghjklmnpqrstvwxz'):find(a:sub(1,1)))..b):rep(2))

Editar 1: foram removidos 7 bytes procurando qualquer caractere após as consoantes (consulte regex)

Experimente online!

Este programa pega uma string no argumento da CLI e imprime sua versão protegida.

Esta é a minha primeira submissão a um código de golfe! Eu não verifiquei os outros em detalhes, por isso poderia ter perdido algumas otimizações comuns (e caído em algumas armadilhas). Eu usei Lua porque passei a gostar dessa pequena linguagem e tentei encontrar um regex que atendesse às minhas necessidades.

Aqui está uma versão mais limpa, usando uma função (eu pretendia usar uma, mas as palavras-chave em Lua são muito longas!):

function covfefy(word)
  i, j, a, b = word:find('[aeiouy]+([^aeiouy]+)(.)')

  -- 'a' is one or several consonants following the first vowel, b is the first vowel after that
  -- 'i' is the index of the beginning of 'a', 'j' the index of 'b'

  cov = word:sub(1, j - #a)

  -- Look for the first letter of 'a' in the voiced/voiceless table
  f = ('pgtvkhjglmnbqrzdfwxs'):sub(('bcdfghjklmnpqrstvwxz'):find(a:sub(1, 1)))

  return cov .. (f .. b):rep(2)
end

Sinta-se livre para dar um feedback :)

Nota: Se você está se perguntando, é de 149 bytes usando o MoonScript!

Kyrio
fonte
2

JavaScript (ES5), 237 229 bytes

function(s){r=['aeiouy','bcdfgkpstvz','pgtvkgbzdfs']i=0,p=''while(p+=s[i],r[0].indexOf(s[i++])<0);while(p+=s[i],~r[0].indexOf(s[i++]));b=s[i-1];while(r[0].indexOf(s[i++])<0);c=r[1].indexOf(b)d=((~c)?r[2][c]:b)+s[i-1]return p+d+d}

Experimente online!

Provavelmente não é o mais golfista, mas é o ES5.

Corrigido recentemente um erro. Exemplo de saída:

creation->creatdidi
coverage->covfefe
example->exxaxa
programming->progkaka
code->codtete
president->preszizi
Polvo
fonte
2

sed, 106 (105 + 1) bytes

Isso é sed com a -Ebandeira, que aparentemente conta com um byte.

s/([aoeuiy][^aoeuiy])[^aoeuiy]*(.).*/\1\2/
h
s/.*(..)/\1\1/
y/bcdfgkpstvz/pgtvkgbzdfs/
x
s/.$//
G
s/\n//g

Experimente online!

zgrep
fonte
2

C #, 584 581 bytes

-3 bytes graças ao limão destrutível

Esta é a minha primeira submissão no Code Golf e no Stack Exchange em geral. Eu sei que o C # não é uma ótima linguagem para o golfe e isso provavelmente não está completamente otimizado, mas eu queria tentar: p. Todas as dicas são bem-vindas!

Versão Golfed:

namespace System{class B{static void Main(string[]args){var s="creation";var t="aeiou";int i=0,j=0,l=s.Length;char c=' ',f=' ';for(int x=0;x++<l;){if(t.IndexOf(s[x])>=0){i=x;break;}}for(int x=i;x++<l;){if(!(t.IndexOf(s[x])>=0)){j=x;c=s[x];for(int y=x;y++<l;){if (t.IndexOf(s[y])>=0){f=s[y];goto W;}}}}W:switch(c){case'b':c='p';break;case'c':c='g';break;case'd':c='t';break;case'f':c='v';break;case'g':c='k';break;case'k':c='j';break;case'p':c='b';break;case's':c='z';break;case't':c='d';break;case'v':c='f';break;case'z':c='s';break;}Console.Write(s.Substring(0,l-i-1)+c+f+c+f);}}}

Versão legível:

namespace System
{
    class B
    {
        static void Main(string[] args)
        {
            var s = "creation";
            var t = "aeiou";
            int i = 0, j = 0, l = s.Length;
            char c = ' ', f = ' ';
            for (int x = 0; x++ < l; )
            {
                if (t.IndexOf(s[x]) >= 0)
                {
                    i = x; break;
                }
            }
            for (int x = i; x++ < l;)
            {
                if (!(t.IndexOf(s[x]) >= 0))
                {
                    j = x; c = s[x];
                    for (int y = x; y++ < l;)
                    {
                        if (t.IndexOf(s[y]) >= 0)
                        {
                            f = s[y];
                            break;
                        }
                    }
                }
            }
            switch (c)
            {
                case 'b': c = 'p';
                    break;
                case 'c': c = 'g';
                    break;
                case 'd': c = 't';
                    break;
                case 'f': c = 'v';
                    break;
                case 'g': c = 'k';
                    break;
                case 'k': c = 'j';
                    break;
                case 'p': c = 'b';
                    break;
                case 's': c = 'z';
                    break;
                case 't': c = 'd';
                    break;
                case 'v': c = 'f';
                    break;
                case 'z': c = 's';
                    break;
            }
            Console.Write(s.Substring(0, l - i - 1) + c + f + c + f);
        }
    }
}
Brandon Hao
fonte
1
Não sou especialista, mas acho que você pode adicionar o incremento ao comparador no loop for x++ < l, ou seja , ou algo assim (talvez l > x++se o primeiro não funcionar). Não tenho certeza, porém,
Destructible Lemon
@DestructibleLemon Obrigado pela dica!
Brandon Hao
2

SmileBASIC 3, 195 bytes

Muito tarde para essa pergunta, mas como resistir a um bom desafio para o SmileBASIC 3? Recursos como iterar sobre uma sequência ou manipular uma sequência de caracteres não são tão robustos quanto em outros idiomas; portanto, é um desafio fazer o menor possível. Assume que as palavras estão em MAIÚSCULAS.

V$="AEIOUY
LINPUT W$REPEAT I=I+1UNTIL.<=INSTR(V$,W$[I-1])&&.>INSTR(V$,W$[I])J=I
WHILE.>INSTR(V$,W$[J])J=J+1WEND?LEFT$(W$,I+1)+("PGTVKHJGLMNBQRZDFWXS"[INSTR("BCDFGHJKLMNPQRSTVWXZ",W$[I])]+W$[J])*2

Explicação detalhada aqui!

Caracol_
fonte
2

05AB1E , 55 bytes

η.ΔžOSåàyžPSÅ¿à*}ÐIsKžOÃнsθU.•gÍĆdQ¸G•SDXåiÂXQÏθë\X}ìDJ

Experimente online ou verifique todos os casos de teste .

Explicação:

η                        # Suffixes of the (implicit) input
                         #  i.e. "creation" → ["c","cr","cre","crea","creat","creati","creato","creatio","creation"]
        }              # Find the first for which the following is truthy:
   žO                    #  Push vowels (including y): "aeiouy"
     S                   #  Convert it to a list of characters: ["a","e","i","o","u","y"]
      å                  #  Check for each if they're in the current (implicit) suffix
                         #   i.e. "creat" → [1,1,0,0,0,0]
       à                 #  Pop and push the max (basically check if any are truthy)
                         #   i.e. [1,1,0,0,0,0] → 1
   y                     #  Push the suffix again
    žP                   #  Push the consonants (excluding y): "bcdfghjklmnpqrstvwxz"
      S                  #  Convert to a list of characters: ["b","c","d","f","g","h","j","k","l","m","n","p","q","r","s","t","v","w","x","z"]
       Å¿                #  Check for each if the suffix ends with it
                         #   i.e. "creat" → [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0]
         à               #  Pop and push the max (basically check if any are truthy)
                         #   i.e. [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0] → 1
   *                     #  Check if both are truthy
                         #   i.e. 1 and 1 → 1
           Ð             # Triplicate the found suffix
            I            # Push the input
             s           # Swap the top two items on the stack
                         #  i.e. stack contains now: "creat","creat","creation","creat"
K                        # Remove the suffix from the input
                         #  i.e. "creation" and "creat" → "ion"
 žOÃ                     # Only leave the vowels
                         #  i.e. "ion" → "io"
    н                    # Pop and push the first character
                         #  i.e. "io" → "i"
s                        # Swap again so the prefix is a the top of the stack again
 θ                       # Pop and push the last character
                         #  i.e. "creat" → "t"
  U                      # Pop and store it in variable `X`
   .•gÍĆdQ¸G            # Push string "bcdfkszgvtgp"
             S           # Convert to list of characters: ["b","c","d","f","k","s","z","g","v","t","g","p"]
              D          # Duplicate it
               Xåi       # If `X` is in this string:
                  Â      #  Bifurcate the list (short for Duplicate & Reverse copy)
                         #   i.e. ["b","c","d","f","k","s","z","g","v","t","g","p"]
                         #   → ["p","g","t","v","g","z","s","k","f","d","c","b"]
                   XQ    #  Check if they're equal to variable `X`
                         #   i.e. `X` = "t" → [0,0,1,0,0,0,0,0,0,0,0,0]
                     Ï   #  Only keep the truthy values
                         #   i.e. ["b","c",...,"g","p"] and [0,0,1,0,0,0,0,0,0,0,0,0]
                         #    → ["d"]
                      θ  #  Pop and push the last one
                         #   i.e. ["d"] → "d"
                 ë       # Else:
                  \      #  Discard the duplicate list from the stack
                   X     #  And push variable `X` again
                 }       # Close the if-else
                  ì      # Prepend the second character in front of the first
                         #  i.e. "d" and "i" → "di"
                   D     # Duplicate it
J                        # Join the stack together (and output implicitly)
                         #  i.e. "creat" and "di" and "di" → "creatdidi"

Veja esta dicas 05AB1E da mina (seção Como comprimir cordas não fazem parte do dicionário? ) Para entender por que .•gÍĆdQ¸G•é "bcdfkszgvtgp".

Kevin Cruijssen
fonte