මෙම අභියෝගයේදී, ඔබ රීජෙක්ස් වලට ගැලපෙන නූලක් ^[a-zA-Z]+$හෝ සාධාරණ දෙයක් ගත යුතුය (ඔබට අවශ්‍ය නම් ලොකු අකුරු හෝ සිම්පල් අකුරු සලකා බැලිය යුතු නැත) (ඔබට අවශ්‍ය නම් නූල දිග ප්‍රමාණවත් යැයි සිතිය හැකි අතර සියල්ලටම නිවැරදි ව්‍යුහයක් ඇත. මෙහෙයුම්), සහ තවත් නූලක් ප්‍රතිදානය කිරීම, පොටස් ( "Despite the constant negative press covfefe") විසින් මෑතකදී කරන ලද ඩැඩිස්ට් ට්වීට් එකක් අවසානයේ වචනයට සමානව නිපදවන ලදි .

නූලක් covfefify කරන්නේ කෙසේද:

පළමුව, පළමු ශබ්ද කණ්ඩායම ලබා ගන්න (පාරිභාෂිතය සෑදී ඇත).

ඔබ මෙය කරන්නේ කෙසේද? හොඳින්:

• පළමු ස්වරය සොයා ගන්න (ස්වරයක් yද වේ)

    v
  creation
  

• ඊට පසු පළමු ව්යාංජනාක්ෂරය සොයා ගන්න

      v
  creation
  

• ඉතිරි නූල් ඉවත් කරන්න

  creat
  

එය ඔබේ පළමු ශබ්ද කණ්ඩායමයි.

ඊළඟ පියවර:

ශබ්ද කණ්ඩායමේ අවසාන ව්‍යාංජනාක්‍ෂරය ලබා ගන්න

t

හ o හෝ හ less නැති අනුවාදය සමඟ එය ප්‍රතිස්ථාපනය කරන්න. මෙය සිදු කිරීම සඳහා, මෙම වගුවේ ඇති ලිපිය සොයා ගන්න. දී ඇති ලිපිය සමඟ ප්‍රතිස්ථාපනය කරන්න (එය එකම අකුර විය හැකිය)

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

ඉතින්, අපට ලැබෙනවා

d

ඉන්පසු එම ව්‍යාංජනාක්‍ෂරයෙන් පසු ඊළඟ ස්වරය ගන්න. මෙම ව්‍යාංජනාක්‍ෂරය නූල් අවසානයේ නොමැති බව ඔබට උපකල්පනය කළ හැකිය. මේ දෙක එකට එකතු කරන්න, ඉන්පසු එය දෙවරක් නැවත කරන්න:

didi

පළමු ශබ්ද කණ්ඩායමට මෙය සංයුක්ත කරන්න:

creatdidi

ඔබ ඉවරයි: නූල covfefified, ඔබට දැන් එය ප්‍රතිදානය කළ හැකිය.

පරීක්ෂණ අවස්ථා:

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

මෙය කේත ගොල්ෆ් වේ , එබැවින් කරුණාකර ඔබේ වැඩසටහන හැකි තරම් කෙටි කරන්න!

ජෙලි , බයිට්  58  57

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

කුඩා අකුරු ලැයිස්තුවක් පිළිගෙන ප්‍රති .ලය මුද්‍රණය කරන සම්පූර්ණ වැඩසටහනකි.

එය මාර්ගගතව උත්සාහ කරන්න!

කොහොමද?

<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

GOTO 0 ට ස්තූතියි බයිට් 4 ක් ඉතිරි කර ඇත

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

පරීක්ෂණ අවස්ථා

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

ජෙලි , බයිට් 45 39

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

එය මාර්ගගතව උත්සාහ කරන්න!

එය ක්‍රියාත්මක වන ආකාරය

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.

සී ජෑම් , 59 58 57 56 බයිට්

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

එය මාර්ගගතව උත්සාහ කරන්න!

පැහැදිලි කිරීම

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.

සී, 219 213 206 179 175 බයිට්

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

එය මාර්ගගතව උත්සාහ කරන්න!

පර්ල් 5 , 81 72 බයිට්

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

එය මාර්ගගතව උත්සාහ කරන්න!

PHP, බයිට් 121

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

එය මාර්ගගතව උත්සාහ කරන්න!

පයිත්, බයිට් 54 යි

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

මෙය ශ්‍රිතයක් අර්ථ දක්වයි y, එය නූලක් අපේක්ෂා කරයි. එය මාර්ගගතව උත්සාහ කරන්න: පරීක්ෂණ කට්ටලය

පයිතන් 3, 155 139 බයිට්

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

බයිට් 16 ක් ඉවත් කර ඇත

ගොබෝර් ෆීකෙට ස්තූතියි බයිට් 1 ක් ඉවත් කළා

ජාවා 8, 243 236 222 බයිට්

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අපට අවශ්‍ය නොවන කොටස් පෙරීමට ග්‍රහණ කණ්ඩායම් සමඟ රීජෙක්ස් භාවිතා කරයි.

පැහැදිලි කිරීම:

එය මෙහි උත්සාහ කරන්න.

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

හස්කල් , 143 141 138 137 136 බයිට්

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]

එය මාර්ගගතව උත්සාහ කරන්න!

පයිතන්, බයිට් 261 260

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

රීජෙක්ස් නොවන, එසෝටරික් විසඳුමක් නොවේ. සෑදීමට මිනිත්තු 20 ක් පමණ ගත වූ අතර ගොල්ෆ් ක්‍රීඩාවට තවත් පැයක් පමණ ගත විය.

එය බොහෝ විට සමස්ත පයිතන් සම්මත පුස්තකාලයට වඩා ලැයිස්තු අවබෝධයක් ඇති, බොහෝ දුරට මම රීජෙක්ස් නොදන්නා නිසා ...

එය මාර්ගගතව උත්සාහ කරන්න! (ටෙස්ට් කේස් සමඟ)

රූබි , බයිට් 90 යි

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

එය මාර්ගගතව උත්සාහ කරන්න!

එය මඳක් ඉවත් කිරීම, අපට සමාන දෙයක් තිබේ:

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

පයිතන් 2, 251 246 245 239 237 234 229 211 බයිට්

පළමු ඉදිරිපත් කිරීම මෙහි.

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

එය මාර්ගගතව උත්සාහ කරන්න!

මට උදව් කළ සෙසු ගොල්ෆ් ක්‍රීඩකයින්:

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

රූබි , 175 141 110 බයිට්

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

එය මාර්ගගතව උත්සාහ කරන්න!

• ස්තූතියි බයිට් 34 ක් ඉතිරි කළා එරික් ඩුමිනිල්ට
• අගය තීන්ත + ප්‍රශස්තිකරණය කළ යෝජිත trතර්ක වලට ස්තූතියි බයිට් 31 ක් ඉතිරි කර ඇත

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

ක්‍රිස්ටල්, 203 194 187 186 184 163 බයිට්

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

ආදාන නූල සියල්ලම කුඩා අකුරු යැයි උපකල්පනය කරමින් පහත ක්‍රියා කරයි.

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]

පැහැදිලි කිරීම

1. a = input('','s');: STDIN වෙතින් නූලක් ලබා ගෙන එය විචල්‍යයට ගබඩා කරයි a .
2. m=ismember(a,'aeiouy');: aස්වර පිහිටා ඇති ස්ථානය තීරණය කරන නූලට සමාන ප්‍රමාණයේ බූලියන් අරාවක් ලබා දෙයි
3. s='pgt vkh jglmn bqrzd fwx s';මෙම covfefeවැලක් ලෙස ව්යාංජනාක්ෂර සිතියම්ගත කරණය. මෙම නූල අක්ෂර 25 ක් දිග වන අතර ස්වර අතහැර දමයි. ස්වරයේ පළමු ස්ථානය'a' ඉවත් කළ යුතු ඉවත් කරන අතර ස්වර පිහිටා ඇති අනෙක් ස්ථාන ව්‍යාජ අවකාශ අනුලකුණක් සහිතව තබා ඇත. මෙය එසේ වන්නේ ස්වරයෙන් පසුව දිස්වන පළමු ව්යාංජනාක්ෂරය තීරණය කළ විට, පරිවර්තනය කළ වචනයේ පළමු අංගය තීරණය කිරීම සඳහා අපි ව්යාංජනාක්ෂරය මෙම නූලෙහි අක්ෂරයකට ප්රවේශ විය හැකි ස්ථානයකට පරිවර්තනය කරමු.
4. m(1:find(m,1))=1: බූලියන් අරාවේ පළමු ස්ථානය සියලු ස්වර ලෙස අප පළමු ස්වරය සොයාගත් ස්ථානය දක්වා සකසයි. මෙය එසේ වන්නේ පළමු ස්වරයෙන් පසුව ඇති ඊළඟ ව්‍යාංජනාක්‍ෂරය සෙවීමේදී අපි මෙම අක්ෂර නොසලකා හරිනු ඇත.
5. i=find(~m,1);: පළමු ස්වරයෙන් පසුව ව්‍යාංජනාක්‍ෂරයක් වන නූලෙහි පළමු ස්ථානය සොයා ගනී.
6. f=a(1:i): ස්වරයෙන් පසුව එන පළමු ව්‍යාංජනාක්‍ෂරයෙන් පසුව නූල ඉවත් කරයි. අපි සරලවම නූල් වල පළමු ස්ථානයේ සිට මේ දක්වා නියැදි කරමු.
7. d=s(f(end)-97);: ඉතිරිව ඇති නූලෙහි අවසාන අක්‍ෂරය ගෙන අපට බැලීමේ නූලෙන් නියැදිය යුතු ස්ථානය සොයාගෙන එම චරිතය ලබා ගනී. මැට්ලැබ් හෝ ඔක්ටේව් හි අක්ෂරයක් සහ අංකයක් අඩු කිරීමෙන් අක්ෂරයක් එහි ASCII කේතය බවට පරිවර්තනය කිරීමෙන් පූර්ණ සංඛ්‍යාවක් සෑදේ. මෙම අවස්ථාවේ දී, අපි අක්ෂර මාලාවේ ආරම්භයේ ඇති අක්‍ෂරයෙන් අන්තිම අක්‍ෂරය අඩු කර ආරම්භයට සාපේක්ෂව අපට පිහිටීම ලබා දෙමු. කෙසේ වෙතත්, b(98) මගින් අඩු කිරීම වෙනුවට , අපි aMATLAB 0 වෙනුවට සුචිගත කිරීම ආරම්භ කරන විට අඩු කරමු 'a'. ASCII කේතය 97 වේ.
8. m(1:i)=0;: බූලියන් ආවරණ ගෙන ආදාන නූලෙහි ඇති සියලුම අක්ෂර පළමු ස්ථානයේ සිට පළමු ව්යාංජනාක්ෂරය දක්වා ස්වර ස්වරයෙන් පසුව අසත්ය ලෙස සකසයි.
9. v=a(find(m,1));: ආදාන නූලෙන් පළමු ව්යාංජනාක්ෂරයට පසුව එන ඊළඟ ස්වරය සොයා ගනී.
10. [f d v d v]: අපේ 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]
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

එය මාර්ගගතව උත්සාහ කරන්න!

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

ඔබ ඉහළින් ක්‍රියාත්මක කරන්න බොත්තම එබූ විට, මොහොතකට රැඳී සිටින්න, පසුව අපේක්ෂිත නූල ඇතුළත් කරන්න. පෙළ ඇතුළත් කිරීමේදී ප්‍රමාදයක් ඇති බව පෙනෙන පරිදි නූල සෙමින් ඇතුළත් කරන්න.

ක්ලෝජුර්, අක්ෂර 182 156

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

එය ක්‍රියාත්මක වන ආකාරය

(partition-by v "president")

හි අනුපිළිවෙලක් ලබා දෙයි ((\p \r) (\e) (\s) (\i) (\d) (\e) (\n \t))

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

බවට මහලේකම් පා Destructures s=(\p \r), m=(\e), c=\s,n=\i .

හෝ "උදාහරණයක්" සඳහා ඒක s=[], m=(\e), c=\x, n=\a.

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

කෑලි එකට එකතු කර එය තද කිරීමෙන් ප්‍රතිදාන නූල ලබා දෙයි.

ඊටපස්සේ මම සම්පාදනය කරන අතරතුර මට හැකි තරම් සුදු අවකාශය ඉවත් කළා.

අවලස්සන:

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

ආර්, අක්ෂර 341

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

බිහිසුණු R උත්සාහය, ඇයි නූල් මෙතරම් අමාරු?

කියවිය හැකි අනුවාදය:

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

රෙටිනා , බයිට් 68 යි

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

එය මාර්ගගතව උත්සාහ කරන්න!

බ්ලිට්ස්මැක්ස්, බයිට් 190 යි

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 වෙතින් වචනයක් ගෙන එහි ප්‍රති result ලය stdout වෙත මුද්‍රණය කරයි. ආදාන වචනය කුඩා අකුරු ලෙස උපකල්පනය කර ඇති අතර අවම වශයෙන් එක් ස්වරයක් හෝ ව්‍යාංජනාක්‍ෂරයක් අඩංගු වේ.

ආකෘතිකරණය සහ විචල්‍ය ප්‍රකාශන සහිත ප්‍රෝගම් හි වඩාත් කියවිය හැකි අනුවාදය:

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

එය ක්‍රියාත්මක වන ආකාරය:

බ්ලිට්ස්මැක්ස් සතුව කිසිදු බිල්ඩින් රීජෙක්ස් ක්‍රියාකාරිත්වයක් හෝ ඊට සමාන නොවේ, එබැවින් ස්වරයක් සොයා ගන්නා තෙක් ආදාන වචනයේ අක්ෂරවලට වඩා පුනරාවර්තනය කිරීම සඳහා ලූපයක් භාවිතා කරයි. විචල්ය c එම ව්යාංජනාක්ෂරයේ අන්තිම ස්ථානය, v ස්වරයේ පිහිටීම ගබඩා කරයි. දාමයෙන් පසුව තවත් ස්වරයක් තිබේදැයි බැලීමට ලූපය දිගටම පවතින අතර එසේ නම් v ඒ අනුව යාවත්කාලීන වේ. C හි ඇති ව්‍යාංජනාක්‍ෂරය ආදේශන වගුවක් ලෙස ක්‍රියා කරන "bpdtfvgkcgsz" නූලෙන් සොයා ගනී. ව්යාංජනාක්ෂරය කිසියම් ස්ථානයක වගුවේ තිබේ නම්, එම ස්ථානය 1 සමඟ XOR-ed වන අතර එහි ප්රති ing ලයක් ලෙස ඇති අක්ෂරය එහි ප්රතිස්ථාපනය ලෙස භාවිතා වේ. XOR මෙහෙයුම 0, 1, 2, 3, 4, 5 බවට පරිවර්තනය වේ. අනෙක් අතට b, p, d සමඟ t සමඟ මාරු වේ. අවසාන වශයෙන්, මුල් නූල c දක්වා,

උදාහරණ ප්‍රති results ල:

ආවරණ covfefe

නිර්මානය

ක්‍රමලේඛන ප්‍රොග්කාකා

මෝඩ මෝඩකම

blah blahhaha

පර්ල්, බයිට් 71 යි

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

සමඟ දුවන්න perl -pe. පෙර පර්ල් විසඳුමට වඩා බයිට් කිහිපයක් අඩුය. එහි සිට මට යම් ආශ්වාදයක් ලැබුණු බව පිළිගත යුතුය.

05AB1E , 101 104 88 බයිට්

-16 බයිට් ඔක්ස්ට ස්තූතියි

මෙය කළ හැක්කේ මා කෙසේ හෝ බලාපොරොත්තු මාර්ගය වඩාත් කාර්යක්ෂමව.

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

එය මාර්ගගතව උත්සාහ කරන්න!

පැහැදිලි කිරීම

                  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

05AB1E , බයිට් 55 42

η.ΔžOSåàyžPSÅ¿à*}ÐIsKžOÃнsθ.•gÍĆdQ¸G•Â‡ìDJ

-13 ග්‍රයිට් වලට ස්තූතියි -13 බයිට් .

එය මාර්ගගතව උත්සාහ කරන්න හෝ සියලු පරීක්ෂණ අවස්ථා සත්‍යාපනය කරන්න .

පැහැදිලි කිරීම:

η                # 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"
  .•gÍĆdQ¸G•     # Push string "bcdfkszgvtgp"
            Â    # Bifurcate it (short for Duplicate & Reverse copy): "pgtvgzskfdcb"
             ‡   # Transliterate the character of "bcdfkszgvtgp" to the same index in "pgtvgzskfdcb"
              ì  # 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"

මගේ මේ 05AB1E ඉඟි බලන්න (පනතේ සංකෝචනය වන ශබ්ද කෝෂය කොටසක් නොවේ නූල් කෙසේද? ) ඇයි තේරුම් ගැනීමට .•gÍĆdQ¸G•ය "bcdfkszgvtgp".

පයිතන් 3.8 (පූර්ව මුදා හැරීම) , බයිට් 142

s=input()
g=lambda i,f='aeiuoy':i if s[i]in f else g(i+1,f)
q=g(g(0),c:='pgtcvkh jglmn bqrzd fwx s')
exit(s[:-~q]+(c[ord(s[q])-98]+s[g(q)])*2)

එය මාර්ගගතව උත්සාහ කරන්න!

සාදයට ටිකක් ප්‍රමාදයි, නමුත් මෙන්න තවත් රීජෙක්ස් නොවන පයිතන් පිළිතුරක්! STDERR වෙත මුද්‍රණය කිරීමට බයිට් ( exit/ print) ඉතිරි කරන නීති රීති මම අර්ථකථනය කළෙමි . පයිතන් 3.8 ට වැඩි 3 <= 3.7 භාවිතා කිරීමෙන් මට වොල්රස් ක්‍රියාකරු සමඟ බයිට් 1 ක් ඉතිරි වේ.c විචල්යය වෙනත් තැනක .

උදව් සඳහා පෝස්ට් රොක් ගාර්ෆ් හන්ටර් (බයිට් -21) ට බොහොම ස්තූතියි!

ක්‍රිස්ටල්, බයිට් 130 යි

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

එය ක්‍රියාත්මක වන ආකාරය

c = /[aeiouy]/

පළමු ස්වරය සෙවීම සඳහා රීජෙක්ස් ගබඩා කරන්න c.

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

පළමු තර්කය කොටස් තුනකට බෙදන්න {"", පළමු ස්වරයෙන් පසු පළමු ව්‍යාංජනාක්‍ෂරයට පෙර එක් අක්‍ෂරයක් තෙක් නූල්, ඉතිරි නූල්} සහ එක් එක් මූලද්‍රව්‍ය x, y සහ z ලෙස ගබඩා කරන්න.

k = z[0]

පළමු අක්ෂර, අදාළ ව්‍යාංජනාක්‍ෂරය ලබා ගන්න.

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

වම් නූල් තුළ ව්යාංජනාක්ෂරයේ දර්ශකය ලබා ගන්න හෝ nil.

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

එසේ iනොවේ නම් nil, දෙවන දර්ශකය සඳහා මෙම දර්ශකය භාවිතා කරන්න (ගොල්ෆ් කළ හැෂ් වර්ගයක්).

එසේ iනම් nil, මුල් අක්‍ෂරය භාවිතා කරන්න.

ඊළඟට, පළමු ස්වරය එකතු කරන්න z.

p y + k + (b * 2)

අවසාන වශයෙන්, පළමු රීජෙක්ස් වෙතින් පළමු කොටස මුද්‍රණය කරන්න y, පළමු ව්යාංජනාක්ෂරය kසහ කලින් ගණනය කළ නූල මෙන් දෙගුණයක්b .

එය මාර්ගගතව උත්සාහ කරන්න .

ලුවා, බයිට් 164 157

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

සංස්කරණය 1: ව්‍යාංජනාක්‍ෂරයෙන් පසුව ඕනෑම අක්ෂරයක් සොයමින් බයිට් 7 ක් ඉවත් කරන ලදි (රීජෙක්ස් බලන්න)

එය මාර්ගගතව උත්සාහ කරන්න!

මෙම වැඩසටහන CLI තර්කයේ නූලක් ගෙන එහි covfefied අනුවාදය මුද්‍රණය කරයි.

කේත ගොල්ෆ් ක්‍රීඩාවකට මගේ පළමු ඉදිරිපත් කිරීම මෙයයි! මම අනෙක් ඒවා විස්තරාත්මකව පරික්ෂා නොකළ නිසා මට පොදු ප්‍රශස්තිකරණ කිහිපයක් මග හැරී යන්නට ඇත (සමහර උගුල් වලට වැටුණි). මම ලුවා භාවිතා කළේ මම මේ කුඩා භාෂාවට කැමති තරමට වැඩී ඇති නිසා සහ මගේ අවශ්‍යතාවන්ට ගැලපෙන රීජෙක්ස් එකක් සොයා ගැනීමට උත්සාහ කළෙමි.

මෙන්න පිරිසිදු අනුවාදයක්, ශ්‍රිතයක් භාවිතා කරමින් (මම එකක් භාවිතා කිරීමට අදහස් කළෙමි, නමුත් ලුවා හි මූල පද දිගු වේ!):

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

යම් ප්‍රතිපෝෂණයක් දීමට නිදහස් වන්න :)

සටහන: ඔබ පුදුම වන්නේ නම්, එය මූන් ස්ක්‍රිප්ට් භාවිතා කරමින් බයිට් 149 ක් දිගයි!

JavaScript (ES5), බයිට් 237 229

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}

එය මාර්ගගතව උත්සාහ කරන්න!

බොහෝ විට ගොල්ෆ් නොවේ, නමුත් එය ES5 වේ.

මෑතකදී දෝෂයක් නිවැරදි කරන ලදි. උදාහරණ ප්‍රතිදානය:

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

sed, 106 (105 + 1) බයිට්

මෙය -Eධජය සමඟ බැඳී ඇති අතර පෙනෙන ආකාරයට එය එක් බයිටයක් සඳහා ගණන් ගනී.

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

එය මාර්ගගතව උත්සාහ කරන්න!

සී #, බයිට් 584 581

විනාශකාරී ලෙමන් වලට ස්තූතියි බයිට් -3

කෝඩ් ගොල්ෆ් සහ පොදුවේ ස්ටැක් එක්ස්චේන්ජ් පිළිබඳ මගේ පළමු ඉදිරිපත් කිරීම මෙයයි. C # විශිෂ්ට ගොල්ෆ් ක්‍රීඩාවක් නොවන බව මම දනිමි. මෙය සම්පුර්ණයෙන්ම ප්‍රශස්තිකරණය කර නැති නමුත් මට එය ලබා දීමට අවශ්‍ය විය: p. ඕනෑම ඉඟි සාදරයෙන් පිළිගනිමු!

ගොල්ෆ් අනුවාදය:

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

කියවිය හැකි අනුවාදය:

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