이 도전에서는 정규식 ^[a-zA-Z]+$과 일치 하거나 합리적 인 문자열을 사용해야합니다 (원하는 경우 대문자 또는 소문자를 고려할 필요가 없습니다) (문자열이 충분히 길고 모든 것을위한 올바른 구조를 가지고 있다고 가정 할 수 있음) POTUS ( "Despite the constant negative press covfefe") 의 최근 dadaist 트윗 끝에 단어와 유사하게 생성 된 다른 문자열을 출력합니다 .

문자열을 covfefify하는 방법 :

먼저, 첫 번째 사운드 그룹 (용어 구성)을 가져옵니다.

어떻게합니까? 잘:

• 첫 번째 모음 찾기 (모음 y이기도 함)

    v
  creation
  

• 그 후 첫 번째 자음 찾기

      v
  creation
  

• 문자열의 나머지 부분을 제거

  creat
  

이것이 첫 번째 사운드 그룹입니다.

다음 단계:

사운드 그룹의 마지막 자음을 얻으십시오

t

음성 또는 무성 버전으로 교체하십시오. 이렇게하려면이 표에서 문자를 찾으십시오. 주어진 문자로 교체하십시오 (동일한 문자 일 수 있음)

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

자바 스크립트 (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.

CJam , 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.

C, 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;

온라인으로 사용해보십시오!

Pyth, 54 바이트

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

이것은 y문자열을 기대 하는 함수를 정의 합니다. 온라인으로 사용해보십시오 : Test Suite

파이썬 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

@ovs 덕분에 16 바이트가 제거되었습니다.

Gábor Fekete 덕분에 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]

온라인으로 사용해보십시오!

파이썬, 261260 바이트

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 분, 골프에 1 시간 더 걸렸습니다.

아마도 정규 표현식을 모르기 때문에 전체 파이썬 표준 라이브러리보다 더 많은 목록 이해력을 가지고 있습니다 ...

온라인으로 사용해보십시오! (테스트 케이스 포함)

루비 , 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}"}

온라인으로 사용해보십시오!

• Eric Duminil 덕분에 34 바이트 절약
• Value Ink + 최적화 된 제안 tr인수 덕분에 31 바이트 절약

언 골프

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 / 옥타브 - 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);: 남아있는 문자열의 마지막 문자를 가져 와서 조회 문자열에서 샘플링해야하는 위치를 찾아 해당 문자를 가져옵니다. MATLAB 또는 Octave에서 문자와 숫자를 빼면 문자를 ASCII 코드로 변환하여 정수를 형성합니다. 이 경우, 알파벳의 시작 부분에있는 문자를 사용하여 마지막 문자를 빼서 시작과 관련된 위치를 제공합니다. 그러나 b(98)을 빼는 a대신 MATLAB이 0 대신 1 씩 색인을 생성하기 시작합니다 'a'. ASCII 코드는 97입니다.
8. m(1:i)=0;: 부울 마스크를 가져 와서 입력 문자열의 모든 문자를 모음 다음에있는 첫 번째 위치에서 첫 번째 자음으로 설정하여 false로 설정합니다.
9. v=a(find(m,1));: 입력 문자열에서 첫 번째 자음을 따르는 다음 모음을 찾습니다.
10. [f d v d v]: covfefeied 문자열을 출력 합니다.

예제 실행

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

상단의 실행 버튼을 누르면 잠시 기다린 다음 원하는 문자열을 입력하십시오. 텍스트를 입력 할 때 지연되는 것처럼 문자열을 천천히 입력하십시오.

클로저, 182156 자

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

의 seq를 반환 ((\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]))))

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

블리츠 맥스, 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에서 단어를 가져 와서 결과를 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

작동 방식 :

BlitzMax에는 내장 정규식 기능 또는 이와 유사한 기능이 없으므로, 모음을 찾은 다음 하나 이상의 자음 체인이있을 때까지 입력 단어의 문자를 반복하는 데 루프가 사용됩니다. 변수 c는 모음의 마지막 자음 v의 위치를 ​​저장합니다. 루프는 체인 다음에 또 다른 모음이 있는지 계속 확인하고, 그렇다면 v가 그에 따라 업데이트됩니다. 그런 다음 c의 자음을 문자열 "bpdtfvgkcgsz"에서 찾아 보면 대체 테이블 역할을합니다. 자음이 테이블에서 임의의 위치에있는 경우 해당 위치는 1과 XOR되며 결과 위치의 문자가 대체로 사용됩니다. XOR 연산은 0을 1로, 2를 3으로, 4를 5로 등으로 바꿉니다. 그 반대로 b는 p, d는 t 등으로 교체됩니다. 마지막으로 원래 문자열은 c까지

결과 예 :

커버리지 코브 페

창조 creatdidi

프로그래밍 progkaka

어리 석음 스투 비비

ㅋㅋ ㅋㅋㅋ

펄, 71 바이트

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

로 실행하십시오 perl -pe. 이전 Perl 솔루션보다 몇 바이트 더 적습니다. 분명히 나는 ​​거기에서도 약간의 영감을 얻었다.

05AB1E , 101 (104) 88 바이트

Okx 덕분에 -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

수정, 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.

온라인으로 사용해보십시오 .

레티 나 , 68 바이트

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

온라인으로 사용해보십시오!

루아, 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 인수로 문자열을 가져 와서 해당 버전을 인쇄합니다.

이것은 코드 골프에 대한 첫 번째 제출입니다! 나는 다른 것들을 자세히 확인하지 않았기 때문에 일반적인 최적화를 놓쳤을 수도 있습니다 (일부 함정에 빠졌습니다). 나는이 작은 언어를 좋아하기 때문에 Lua를 사용했고 내 요구에 맞는 정규식을 찾으려고 노력했습니다.

다음은 함수를 사용하는 더 깨끗한 버전입니다 (하나를 사용하려고했지만 Lua의 키워드가 너무 깁니다!).

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

의견을 주시기 바랍니다 :)

참고 : 궁금한 점이 있다면 MoonScript를 사용하는 길이는 149 바이트입니다!

자바 스크립트 (ES5), 237229 바이트

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플래그 와 함께 sed이며 , 분명히 1 바이트로 계산됩니다.

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

온라인으로 사용해보십시오!

C #, 584 581 바이트

Destructible Lemon 덕분에 -3 바이트

이것은 Code Golf 및 Stack Exchange에 대한 첫 번째 제출물입니다. 나는 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);
        }
    }
}

SmileBASIC 3, 195 바이트

이 질문에 매우 늦었지만 SmileBASIC 3의 좋은 도전에 어떻게 저항 할 수 있습니까? 시퀀스를 반복하거나 문자열을 조작하는 것과 같은 기능은 다른 언어만큼 강력하지 않으므로 가능한 한 작게 만드는 것이 약간의 과제입니다. 단어가 대문자라고 가정합니다.

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

자세한 설명은 여기!

05AB1E , 55 바이트

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

온라인으로 사용해보십시오 하거나 모든 테스트 사례를 확인하십시오 .

설명:

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

내이 05AB1E 팁을 참조하십시오 (부분 문자열 사전의 일부를 압축하는 방법을? ) 이유를 이해하는 .•gÍĆdQ¸G•것입니다 "bcdfkszgvtgp".