Trong thử thách này, bạn phải lấy một chuỗi khớp với biểu thức chính quy ^[a-zA-Z]+$hoặc bất cứ điều gì hợp lý (bạn không phải xem xét chữ hoa hoặc chữ thường nếu bạn muốn) (bạn có thể giả sử chuỗi đó đủ dài và có cấu trúc phù hợp cho tất cả các hoạt động) và xuất ra một chuỗi khác, được tạo ra tương tự như từ ở cuối một tweet dadaist gần đây của POTUS ( "Despite the constant negative press covfefe").

Làm thế nào để xác định một chuỗi:

Đầu tiên, có được nhóm âm thanh đầu tiên (thuật ngữ tạo thành).

Làm thế nào để bạn làm điều này? Tốt:

• Tìm nguyên âm đầu tiên ( ycũng là nguyên âm)

    v
  creation
  

• Tìm phụ âm đầu tiên sau đó

      v
  creation
  

• Loại bỏ phần còn lại của chuỗi

  creat
  

Đó là nhóm âm thanh đầu tiên của bạn.

Bước tiếp theo:

Lấy phụ âm cuối của nhóm âm thanh

t

và thay thế nó bằng phiên bản có tiếng hoặc không có tiếng. Để làm điều này, tìm chữ cái trong bảng này. Thay thế bằng chữ cái đã cho (có thể là cùng một chữ cái)

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

vì vậy, chúng tôi nhận được

d

Sau đó, lấy nguyên âm tiếp theo sau phụ âm đó. Bạn có thể giả sử rằng phụ âm này không nằm ở cuối chuỗi. Nối hai cái này lại với nhau, sau đó lặp lại hai lần:

didi

Kết hợp điều này với nhóm âm thanh đầu tiên:

creatdidi

Bạn đã hoàn thành: chuỗi đã được xác thực và bây giờ bạn có thể xuất chuỗi đó.

Các trường hợp thử nghiệm:

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

Đây là môn đánh gôn , vì vậy hãy làm cho chương trình của bạn ngắn nhất có thể!

Thạch ,  58  57 byte

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

Một chương trình đầy đủ chấp nhận một danh sách các ký tự chữ thường và in kết quả.

Hãy thử trực tuyến!

Làm sao?

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

Đã lưu 4 byte nhờ GOTO 0

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

Các trường hợp thử nghiệm

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

Thạch , 45 39 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

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

Hãy thử trực tuyến!

Giải trình

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 byte

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

Hãy thử trực tuyến!

Perl 5 , 81 72 byte

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

Hãy thử trực tuyến!

PHP, 121 byte

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

Hãy thử trực tuyến!

Bình thường, 54 byte

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

Điều này xác định một hàm y, mong đợi một chuỗi. Dùng thử trực tuyến: Test Suite

Python 3, 155 139 byte

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

đã xóa 16 byte nhờ @ovs

xóa 1 byte nhờ Gábor Fekete

Java 8, 243 236 222 byte

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

Sử dụng .replaceAllregex với các nhóm chụp để lọc ra những phần chúng ta không muốn.

Giải trình:

Hãy thử nó ở đây.

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 byte

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]

Hãy thử trực tuyến!

Python, 261 260 byte

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

Một giải pháp phi regex, không bí truyền. Mất khoảng 20 phút để thực hiện, và thêm một giờ để chơi gôn.

Nó có thể có nhiều khả năng hiểu danh sách hơn toàn bộ thư viện chuẩn python, chủ yếu là vì tôi không biết regex ...

Hãy thử trực tuyến! (Có tủ thử)

Ruby , 90 byte

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

Hãy thử trực tuyến!

Ủng hộ nó một chút, chúng ta có một cái gì đó tương đương với:

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 byte

Trình đầu tiên ở đây.

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

Hãy thử trực tuyến!

Các golf thủ đã giúp tôi:

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

Ruby , 175 141 110 byte

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

Hãy thử trực tuyến!

• Đã lưu 34 byte nhờ Eric Duminil
• Đã lưu 31 byte nhờ Value Ink + các trđối số được đề xuất tối ưu hóa

Ung dung

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

Pha lê, 203 194 187 186 184 163 byte

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 byte

Các công việc sau đây giả sử chuỗi đầu vào là tất cả chữ thường.

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]

Giải trình

1. a = input('','s');: Nhận một chuỗi từ STDIN và lưu nó vào biến a.
2. m=ismember(a,'aeiouy');: Trả về một mảng Boolean có cùng kích thước với chuỗi axác định vị trí nguyên âm nằm ở đâu
3. s='pgt vkh jglmn bqrzd fwx s';Việc covfefeánh xạ các phụ âm dưới dạng một chuỗi. Chuỗi này dài 25 ký tự và bỏ qua các nguyên âm. Vị trí đầu tiên mà nguyên âm 'a'được cho là bị loại bỏ trong khi các vị trí khác nơi đặt nguyên âm được đặt với một ký tự không gian giả. Điều này là để khi chúng tôi xác định phụ âm đầu tiên xuất hiện sau nguyên âm, chúng tôi sẽ chuyển đổi phụ âm sang vị trí để truy cập một ký tự trong chuỗi này để xác định thành phần đầu tiên của từ được chuyển đổi.
4. m(1:find(m,1))=1: Đặt vị trí đầu tiên của mảng Boolean đến nơi chúng tôi đã tìm thấy nguyên âm đầu tiên là tất cả các nguyên âm. Điều này sẽ là để khi chúng ta tìm kiếm phụ âm tiếp theo sau nguyên âm đầu tiên, chúng ta sẽ bỏ qua các ký tự này.
5. i=find(~m,1);: Tìm vị trí đầu tiên của chuỗi là phụ âm sau nguyên âm đầu tiên.
6. f=a(1:i): Loại bỏ chuỗi sau phụ âm đầu tiên theo sau nguyên âm. Chúng tôi chỉ đơn giản lấy mẫu từ vị trí đầu tiên của chuỗi cho đến thời điểm này.
7. d=s(f(end)-97);: Lấy ký tự cuối cùng của chuỗi còn lại và tìm nơi chúng ta cần lấy mẫu từ chuỗi tra cứu và nhận ký tự đó. Trừ một ký tự và một số trong MATLAB hoặc Octave hợp lại để tạo thành một số nguyên bằng cách chuyển đổi ký tự thành mã ASCII của nó. Trong trường hợp này, chúng tôi trừ ký tự cuối cùng của ký tự ở đầu bảng chữ cái để cung cấp cho chúng tôi vị trí so với đầu. Tuy nhiên, thay vì trừ đi b(98), chúng tôi trừ đi akhi MATLAB bắt đầu lập chỉ mục bằng 1 thay vì 'a'mã ASCII của 0. là 97.
8. m(1:i)=0;: Đưa mặt nạ Boolean và đặt tất cả các ký tự trong chuỗi đầu vào từ vị trí đầu tiên thành phụ âm đầu tiên sau nguyên âm thành sai.
9. v=a(find(m,1));: Tìm nguyên âm tiếp theo theo sau phụ âm đầu tiên từ chuỗi đầu vào.
10. [f d v d v]: Xuất covfefechuỗi ied của chúng tôi .

Chạy ví dụ

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

Hãy thử trực tuyến!

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

Khi bạn nhấn nút Thực thi ở trên cùng, hãy đợi một lát, sau đó nhập chuỗi mong muốn. Nhập chuỗi chậm vì dường như có độ trễ khi nhập văn bản.

Clojure, 182 156 ký tự

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

Làm thế nào nó hoạt động

(partition-by v "president")

Trả về một seq của ((\p \r) (\e) (\s) (\i) (\d) (\e) (\n \t))

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

Destructures các seq vào s=(\p \r), m=(\e), c=\s, n=\i.

Hoặc cho "ví dụ" nó s=[], m=(\e), c=\x, n=\a.

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

Trả về chuỗi đầu ra bằng cách nối các mảnh lại với nhau và xâu chuỗi nó lại.

Và sau đó tôi chỉ cần loại bỏ càng nhiều khoảng trắng càng tốt trong khi vẫn làm cho nó biên dịch.

Khử nhiễu:

(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 ký tự

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

Nỗ lực R khủng khiếp, tại sao các chuỗi rất khó khăn

Phiên bản dễ đọc:

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 byte

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

Lấy một từ từ stdin và in kết quả ra thiết bị xuất chuẩn. Từ đầu vào được giả sử là chữ thường và chứa ít nhất một nguyên âm theo sau là phụ âm.

Một phiên bản dễ đọc hơn của progam với định dạng và khai báo biến:

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

Làm thế nào nó hoạt động:

BlitzMax không có bất kỳ chức năng regex dựng sẵn nào hoặc tương tự, do đó, một vòng lặp được sử dụng để lặp lại các ký tự của từ đầu vào cho đến khi nó tìm thấy một nguyên âm theo sau là một chuỗi ít nhất một phụ âm. Biến c lưu vị trí cuối cùng của các phụ âm đó, v là nguyên âm. Vòng lặp tiếp tục để xem nếu có một nguyên âm khác sau chuỗi và nếu vậy, v được cập nhật tương ứng. Sau đó, phụ âm tại c được tra cứu trong chuỗi "bpdtfvgkcgsz", hoạt động như một bảng thay thế. Nếu phụ âm được tìm thấy trong bảng ở bất kỳ vị trí nào, thì vị trí đó là XOR-ed với 1 và ký tự ở vị trí kết quả sẽ được sử dụng làm thay thế. Thao tác XOR biến 0 thành 1, 2 thành 3, 4 thành 5, v.v. và ngược lại, để b được hoán đổi với p, d với t và cứ thế. Cuối cùng, chuỗi gốc lên đến c,

Kết quả ví dụ:

bảo hiểm covfefe

sáng tạo creatdidi

chương trình progkaka

ngu ngốc ngu ngốc

blah blahhaha

Perl, 71 byte

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

Cũng chạy với perl -pe. Ít hơn một vài byte so với giải pháp Perl trước đó. Phải thừa nhận rằng tôi cũng có một số cảm hứng từ đó.

05AB1E , 101 104 88 byte

-16 byte nhờ Okx

Tôi bằng cách nào đó hy vọng điều này có thể được thực hiện cách hiệu quả hơn.

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

Hãy thử trực tuyến!

Giải trình

                  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

Pha lê, 130 byte

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

Làm thế nào nó hoạt động

c = /[aeiouy]/

lưu trữ một regex để tìm kiếm nguyên âm đầu tiên c.

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

chia đối số đầu tiên thành ba phần {"", Chuỗi cho đến khi một ký tự đứng trước phụ âm đầu tiên sau nguyên âm đầu tiên, phần còn lại của chuỗi} và lưu trữ từng phần tử vào x, y và z.

k = z[0]

có được ký tự đầu tiên, phụ âm có liên quan.

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

lấy chỉ số của phụ âm bên trong chuỗi bên trái hoặc nil.

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

nếu ikhông nil, sử dụng chỉ số này cho chuỗi thứ hai (loại băm được đánh gôn).

nếu ilà nil, sử dụng ký tự gốc.

tiếp theo, nối nguyên âm đầu tiên của z.

p y + k + (b * 2)

cuối cùng, in phần đầu tiên từ regex đầu tiên y, phụ âm đầu tiên kvà hai lần chuỗi tính toán trước đó b.

Hãy thử trực tuyến .

Võng mạc , 68 byte

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

Hãy thử trực tuyến!

Lua, 164 157 byte

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

Chỉnh sửa 1: Đã xóa 7 byte bằng cách tìm kiếm bất kỳ ký tự nào sau các phụ âm (xem regex)

Hãy thử trực tuyến!

Chương trình này lấy một chuỗi trong đối số CLI và in phiên bản đồng biến của nó.

Đây là lần đầu tiên tôi gửi đến một mã golf! Tôi đã không kiểm tra chi tiết những cái khác vì vậy tôi có thể đã bỏ lỡ một số tối ưu hóa phổ biến (và rơi vào một số bẫy). Tôi đã sử dụng Lua vì tôi đã thích ngôn ngữ nhỏ này và tôi đã cố gắng tìm một regex phù hợp với nhu cầu của mình.

Đây là phiên bản sạch hơn, sử dụng một chức năng (tôi dự định sử dụng một chức năng, nhưng các từ khóa trong Lua quá dài!):

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

Hãy đưa ra một số phản hồi :)

Lưu ý: Nếu bạn đang tự hỏi, nó dài 149 byte khi sử dụng MoonScript!

JavaScript (ES5), 237 229 byte

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}

Hãy thử trực tuyến!

Có lẽ không phải là golf nhất, nhưng đó là ES5.

Gần đây đã sửa một lỗi. Ví dụ đầu ra:

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

sed, 106 (105 + 1) byte

Đây là sed với -Ecờ, dường như được tính cho một byte.

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

Hãy thử trực tuyến!

C #, 584 581 byte

-3 byte nhờ Dest Destible Lemon

Đây là lần gửi đầu tiên của tôi về Code Golf và trên Stack Exchange nói chung. Tôi biết rằng C # không phải là một ngôn ngữ chơi golf tuyệt vời và điều này có lẽ không được tối ưu hóa hoàn toàn nhưng tôi muốn cho nó một cú đánh: p. Bất kỳ lời khuyên đều được chào đón!

Phiên bản chơi gôn:

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

Phiên bản dễ đọc:

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 byte

Rất muộn với câu hỏi này, nhưng làm thế nào tôi có thể chống lại một thử thách tốt cho SmileBASIC 3? Các tính năng như lặp lại một chuỗi hoặc thao tác một chuỗi không mạnh mẽ như các ngôn ngữ khác, vì vậy đây là một thách thức để làm điều đó nhỏ nhất có thể. Giả sử các từ là LỚN.

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

Giải thích chi tiết tại đây!

05AB1E , 55 byte

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

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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

Xem 05AB1E này lời khuyên của tôi (phần Làm thế nào để nén chuỗi không nằm trong từ điển? ) Để hiểu tại sao .•gÍĆdQ¸G•là "bcdfkszgvtgp".