Bu zorlamada, regex ile eşleşen ^[a-zA-Z]+$veya makul olan ne olursa olsun eşleşen bir dize almalısınız (isterseniz büyük veya küçük harfleri düşünmeniz gerekmez) (dizgenin yeterince uzun olduğunu ve tüm için doğru yapıya sahip olduğunu varsayabilirsiniz. işlemler) ve POTUS ( "Despite the constant negative press covfefe") tarafından yazılan bir son tweet'in sonunda, kelimeye benzer şekilde üretilen başka bir dizge çıktılar .

Bir dize covfefify nasıl:

İlk olarak, ilk ses grubunu edinin (terminolojiden oluşur).

Bunu nasıl yapıyorsun? İyi:

• İlk ünlü kelimeyi bul ( yayrıca ünlü)

    v
  creation
  

• Bundan sonra ilk ünsüz bul

      v
  creation
  

• Dizenin geri kalanını çıkarın

  creat
  

Bu senin ilk ses grubun.

Sonraki adım:

Ses grubunun son ünsüzünü al

t

ve sesli veya sesli sürümüyle değiştirin. Bunu yapmak için, bu tablodaki mektubu bulun. Verilen harfle değiştirin (aynı harf olabilir)

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

yani, anlıyoruz

d

Ardından, o ünsüzden sonra bir sonraki ünlü harfleri alın. Bu ünsüzün dizenin sonunda olmadığını varsayabilirsiniz. Bu ikisine birlikte katılın, sonra iki kez tekrarlayın:

didi

Bunu ilk ses grubuyla birleştir:

creatdidi

Bitirdiniz: dize birlikte tanımlanmış ve şimdi çıktısını alabilirsiniz.

Test durumları:

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

Bu kod-golf , bu nedenle lütfen programınızı mümkün olduğunca kısa tutun!

Jöle ,  58  57 bayt

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

Küçük harfli karakterlerin listesini kabul eden ve sonucu basan tam bir program.

Çevrimiçi deneyin!

Nasıl?

<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

JavaScript (ES6), 107 103 bayt

GOTO 0 sayesinde 4 bayt kaydedildi

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

Test durumları

let f =

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

console.log(f("creation"))
console.log(f("coverage"))
console.log(f("example"))
console.log(f("programming"))
console.log(f("president"))

Jöle , 45 39 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

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.

CJam , 59 58 57 56 bayt

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

Çevrimiçi deneyin!

açıklama

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.

C, 219 213 206 179 175 bayt

#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);}

Çevrimiçi deneyin!

Perl 5 , 81 72 bayt

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

Çevrimiçi deneyin!

PHP, 121 Bayt

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

Çevrimiçi deneyin!

Pyth, 54 bayt

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

Bu, ybir dize bekleyen bir işlevi tanımlar . Çevrimiçi deneyin: Test Paketi

Python 3, 155 139 bayt

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

@ovs sayesinde 16 bayt kaldırıldı

Gábor Fekete sayesinde 1 bayt kaldırıldı

Java 8, 243 236 222 bayt

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;}

.replaceAllİstemediğimiz parçaları filtrelemek için yakalama gruplarıyla regex'ler kullanır .

Açıklama:

Burada dene.

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

Haskell , 143 141 138 137 136 bayt

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]

Çevrimiçi deneyin!

Python, 261 260 bayt

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

Regex olmayan, ezoterik olmayan bir çözelti. Golf yapmak için yaklaşık 20 dakika ve bir saat daha sürdü.

Muhtemelen tüm python standart kütüphanesinden daha fazla liste kavramasına sahiptir, çünkü çoğunlukla regex bilmiyorum ...

Çevrimiçi deneyin! (Testcases ile)

Yakut , 90 bayt

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

Çevrimiçi deneyin!

Biraz ungolfing, biz eşdeğer bir şey var:

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

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

İlk başvuru burada.

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

Çevrimiçi deneyin!

Bana yardımcı olan golfçüler:

 Destructible Lemon / Wheat Wizard - 5 bytes
 Hubert Grzeskowiak - 1 byte
 musicman523 - 16 bytes

Ruby , 175 141 110 bayt

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

Çevrimiçi deneyin!

• Eric Duminil sayesinde 34 bayt kaydedildi
• Value Ink + optimize edilmiş trargümanlar sayesinde 31 bayt kurtarıldı

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}"
}

Kristal, 203 194 187 186 184 163 bayt

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]

MATLAB / Octave - 159 158 bayt

Girdi dizgisinin tümü küçük harf olduğu varsayılarak aşağıdaki çalışmalar.

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]

açıklama

1. a = input('','s');: Bir dizgiyi STDIN'den alır ve değişkene kaydeder a.
2. m=ismember(a,'aeiouy');: Ünlülerin anerede olduğunu belirleyen dizeyle aynı boyutta bir Boolean dizisi döndürür
3. s='pgt vkh jglmn bqrzd fwx s';covfefeBir dize olarak ünsüzlerin haritalama. Bu dize 25 karakter uzunluğundadır ve sesli harfleri atlar. Ünlü harflerin bulunduğu ilk konum 'a', ünlülerin bulunduğu diğer konumlar boş alan karakteriyle yerleştirilirken kaldırılır. Bu, sesli harften sonra görünen ilk ünsüz harfini belirlediğimizde, ünsüzü dönüştürülen kelimenin ilk bileşenini belirlemek için bu dizgede bir karaktere erişmek için bir konuma çeviririz.
4. m(1:find(m,1))=1: Boolean dizisinin ilk konumunu, ilk sesli harfleri tüm ünlüler olarak bulduğumuz noktaya kadar ayarlar. Bu, ilk sesli harfleri takip eden bir sonraki ünsüz'ü aradığımızda, bu karakterleri görmezden geleceğimizden olacaktır.
5. i=find(~m,1);: İlk ünlüden sonra dizenin ünsüz olan ilk konumunu bulur.
6. f=a(1:i): Ünlü harfini izleyen ilk ünsüzden sonra dizeyi kaldırır. Sadece dizenin ilk konumundan bu noktaya kadar örnek alıyoruz.
7. d=s(f(end)-97);: Kalan dizgenin son karakterini alın ve arama dizgisinden örnekleme yapmamız gereken yeri bulur ve bu karakteri alır. Bir karakter ve sayıyı MATLAB veya Octave'de çıkarmak, karakteri ASCII koduna dönüştürerek bir tam sayı oluşturmak için birleşir. Bu durumda, son karakteri alfabenin başındaki karakterden çıkartarak bize başlangıcına göre konum verelim. Bununla birlikte, b(98) ile çıkartmak yerine, aMATLAB 0 yerine 1 ile indekslemeye başladığında çıkar 'a'. ASCII kodu 97'dir.
8. m(1:i)=0;: Boolean maskesini alır ve giriş dizesindeki tüm karakterleri ilk harflerden ilk ünsüze doğru bir sesli harf yanlıştan sonra ayarlar.
9. v=a(find(m,1));: Giriş dizesinden ilk ünsüz harfini takip eden bir sonraki ünlü harfini bulur.
10. [f d v d v]: Bizim covfefeied dizgimizi çıktı .

Örnek Çalıştırmalar

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

Çevrimiçi deneyin!

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

Üstte Yürüt düğmesine bastığınızda, birkaç dakika bekleyin, ardından istediğiniz dizeyi girin. Metin girerken bir gecikme göründüğü için dizgiyi yavaşça girin.

Clojure, 182 156 karakter

#(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)))

Nasıl çalışır

(partition-by v "president")

Bir sıra döndürür ((\p \r) (\e) (\s) (\i) (\d) (\e) (\n \t))

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

İçine seq Destructures s=(\p \r), m=(\e), c=\s, n=\i.

Veya "Örneğin" için bu kadar s=[], m=(\e), c=\x, n=\a.

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

Parçaları bir araya getirip ve onu sıralayarak çıktı dizisini döndürür.

Sonra derlemeye devam ederken alabildiğim kadar boşluk bıraktım.

De-uglified:

(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]))))

R, 341 karakter

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="")}

Korkunç R girişimi, neden dizeleri bu kadar zor

Okunabilir sürüm:

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 = "")
}

BlitzMax, 190 bayt

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

Stdin'den bir kelime alır ve sonucu stdout'a yazdırır. Giriş sözcüğünün küçük harf olduğu ve en az bir ünlü harf ve ardından bir ünsüz içerdiği varsayılır.

Biçimlendirme ve değişken bildirimleriyle programın daha okunaklı bir sürümü:

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

Nasıl çalışır:

BlitzMax herhangi bir yerleşik regex işlevine ya da benzerine sahip değildir, bu nedenle en az bir ünsüz zincirini takip eden bir sesli harf bulana kadar girilen kelimenin karakterlerini yinelemek için bir döngü kullanılır. C değişkeni, ünsüzlerin sonuncusu, v ile ünlü olanın konumunu saklar. Döngü zincirden sonra başka bir ünlü olup olmadığını görmeye devam eder ve eğer öyleyse, v buna göre güncellenir. Sonra c deki ünsüzü, yedek tablo görevi gören "bpdtfvgkcgsz" dizgisinde aranır. Ünsüz tabloda herhangi bir pozisyonda bulunursa, o zaman bu pozisyon 1 ile XOR-ed ve sonuçtaki karakter yerine onun yerine kullanılır. XOR işlemi 0, 1, 2, 3, 4, 5 vb. Olur ve tam tersi olur, böylece b, p, d ve t ile değiştirilir. Sonunda, orijinal dize c kadar

Örnek sonuçlar:

kapsama alanı

oluşturma creatdidi

programlama progkaka

aptallık stupbibi

falan filan

Perl, 71 bayt

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

Ayrıca ile çalıştırın perl -pe. Önceki Perl çözümünden birkaç bayt daha az. Kuşkusuz oradan da biraz ilham aldım.

05AB1E , 101 104 88 bayt

Okx sayesinde -16 bayt

Her nasılsa bu yapılabilir umut yolu daha verimli.

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

Çevrimiçi deneyin!

açıklama

                  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

Kristal, 130 Bayt

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

Nasıl çalışır

c = /[aeiouy]/

ilk sesli harf aramak için bir regex saklayın c.

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

ilk argümanı üç bölüme ayırın {"", String, ilk ünlüden sonra ilk ünsüzden önce bir karakter olana kadar, string} 'in geri kalanı ve her bir öğeyi x, y ve z' de saklayın.

k = z[0]

ilk karakter, ilgili ünsüz olsun.

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

Sol dizge içindeki ünsüz dizini ya da almak nil.

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

değilse i, nilbu dizgiyi ikinci string için kullanın (bir golf karması türü).

eğer öyleyse i, nilorijinal karakteri kullanın.

daha sonra, ilk harfini ekleyin z.

p y + k + (b * 2)

Son olarak, ilk kısmı ilk regex'ten y, ilk ünsüzden kve önceki hesaplanan dizenin iki katından yazdır b.

Çevrimiçi deneyin .

Retina , 68 bayt

r`\B(?>([^aeiouy])+)([aeiouy]).*
$1$1$2$1$2
T-5>`fs\dbgcgk\ptzv`Ro`.

Çevrimiçi deneyin!

Lua, 164 157 bayt

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

Düzenleme 1: Ünsüzlerden sonra herhangi bir karakteri arayarak 7 bayt kaldırıldı (bkz. Regex)

Çevrimiçi deneyin!

Bu program CLI bağımsız değişkeninde bir dize alır ve covfefied sürümünü yazdırır.

Bu benim ilk golf koduna gönderme! Diğerlerini ayrıntılı olarak kontrol etmedim, bu yüzden bazı genel optimizasyonları kaçırmış olabilirim (ve bazı tuzaklara düştüm). Lua'yı kullandım, çünkü bu küçük dili sevdim ve ihtiyaçlarıma uygun bir regex bulmaya çalıştım.

İşte bir fonksiyon kullanarak daha temiz bir versiyon (Bir tanesini kullanmak istedim, fakat Lua'daki anahtar kelimeler çok uzun!):

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

Bazı geribildirim vermek için çekinmeyin :)

Not: Merak ediyorsanız, MoonScript!

JavaScript (ES5), 237 229 bayt

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}

Çevrimiçi deneyin!

Muhtemelen en golfçü değil, ama ES5.

Son zamanlarda bir hata düzeltildi. Örnek çıktı:

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

sed, 106 (105 + 1) bayt

Bu, -Egörünüşe göre bir bayt için önemli olan bayrakla doludur.

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

Çevrimiçi deneyin!

C #, 584 581 bayt

Yıkılabilir Limon sayesinde -3 bayt

Bu benim Code Golf ve genel olarak Stack Exchange'deki ilk başvurum. C # 'nın harika bir golf dili olmadığını ve muhtemelen tamamen optimize edilmediğini biliyorum ama bir şans vermek istedim: p. Herhangi bir ipucu bekliyoruz!

Golf Sürümü:

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

Okunabilir sürüm:

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

SmileBASIC 3, 195 bayt

Bu soruya çok geç kaldım ancak SmileBASIC 3 için iyi bir mücadeleye nasıl karşı koyabilirim? Bir diziyi yinelemek veya bir dizgiyi değiştirmek gibi özellikler diğer diller kadar sağlam değildir, bu yüzden bunu mümkün olduğunca küçük yapmak biraz zor. Kelimelerin UPPERCASE olduğunu varsayar.

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

Ayrıntılı açıklama burada!

05AB1E , 55 bayt

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

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

η                        # 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"

Bunun 05AB1E ipuçlarına bakın (bölüm sözlükte yer almayan dizeleri nasıl sıkıştırmalı? ) Nedenini anlamak .•gÍĆdQ¸G•için "bcdfkszgvtgp".