Covfefify一个字符串


371

在此挑战中,您必须采用与正则表达式匹配的字符串^[a-zA-Z]+$或任何合理的字符串(如果需要,您不必考虑大写或小写字母)(您可以假设字符串足够长,并且对于所有字符串都具有正确的结构操作),并输出另一个字符串,该字符串与POTUS("Despite the constant negative press covfefe")在最近的dadaist推文末尾产生的单词类似。

如何对字符串进行coffefify:

首先,获得第一个声音组(组成的术语)。

你怎么做到这一点?好:

  • 查找第一个元音(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

这是,所以请使您的程序尽可能短!


7
技术上,“ x”应映射到“ gz”。“ qu”应映射到“ gw”。
史蒂夫·本内特

2
这指定了一个coffefification概念,但是我一直觉得,引用Douglas Hofstadter(和Melanie Mitchell)的字符串转换类比的著作,例如在Fluid Concepts中似乎是适当的。
火星

58
超过140个字符的答案应该被取消资格
桑迪·吉福德

12
不幸的是,这不可能在TrumpScript中完成:(

4
@ThePlasmaRailgun这是个玩笑,因为tweets的长度不得超过140个字符。
硕果累累

Answers:


91

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

13
这真是太神奇了……
克朗根

难以置信的工作。
JF,它

9
我是果冻。已投票。
DeepS1X

6
这是我见过的最奇怪的编程语言。
Ryan

@Ryan专为打高尔夫球而设计。
硕果累累

61

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

测试用例


6
您可以像这样保存一些字节:s=>([,a,b,c]=s.match`(.*?[aeiouy]+(.)).*?([aeiouy])`,a+(b=(a="bcdfgszkvtgp")[11-a.search(b)]||b)+c+b+c)
GOTO 0

@ GOTO0谢谢,更新。
Arnauld

49

果冻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.

4
抱歉,哥们,您好像错过了超级果冻代表
Destructible Lemon

tfw答案看似过于简单,但实际上确实很棒……简单而美丽
Erik the Outgolfer

31

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

2
果酱能打果冻吗?:O(至少,它击败了果冻的回答,每个人似乎都对此表示反对。)
Esolanging Fruit

29

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

在线尝试!


* p = putchar是否作为第一行?
k_g

4
对不起,取消比赛资格。无法加入推文。
caird coinheringaahing

@cairdcoinheringaahing您的先生不正确(我知道您写这封信的时候是140)
Stan Strum,


1
通过将#defines和函数替换为预处理器标志(-D...),可以减少大约12个字节。


18

PHP,121字节

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

在线尝试!


3
-2个字节:echo$t[1],$z=strtr($t[2].$t[3],bcdfgkpstvz,pgtvkgbzdfs),$z;
Titus

@Titus我没有考虑过。谢谢你
约尔格Hülsermann

为什么不重命名$argn为更短的名称?$a,例如-这是-3字节
泰勒塞巴斯蒂安

@TylerSebastian我必须有一个存在的输入变量。是的,我可以创造一个功能,但如果我这样做,它提升的字节数更是使用三个字节
约尔格Hülsermann

嗯,很抱歉,我忘记了PHP如何做命令行参数-我刚刚看到您已经在标头部分中定义了它,但是未能意识到它是一个保留变量。
泰勒·塞巴斯蒂安

15

Pyth,54个字节

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

这定义了一个函数y,需要一个字符串。在线试用:测试套件


14

Python 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áborFekete删除了1个字节


2
您可以创建一个具有值的变量'aeiouy]',也许可以节省一些字节。您也可以从替换字符串中删除一些字符,因为它们相同。
加博尔·费克特(GáborFekete)

2
我无法从替换字符串中删除相同的字符,因为那将是一个IndexError,并且保存aeiouy])不会保存任何字节。
L3viathan '17

2
如果你掏出类似的东西s='aeiouy])',你可以用b,c,v=re.findall('(.*?[%s([^%s.*?([%s'%(s,s,s)。它并不短,但可能会导致整体上缩短它的方法。
杰里米·维里希


3
使用F-字符串将节省1个字节:k='aeiouy])'f'(.*?[{k}([^{k}.*?([{k}'
的Gabor菲克特

14

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

13

Haskell中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]

在线尝试!


1
太棒了!替换nx为一个字母将节省2个字节。
tomsmeding

z外部声明f并切换到警卫而不是a let可以节省另外两个字节:在线尝试!
Laikoni

2
和另外两个通过合并(s,v)<-break z i,(m,c:x)<-span z v(s,(m,c:x))<-span z<$>break z i
Laikoni

将圆括号放在旁边可以再剃掉一个let,谢谢!
bartavelle

@Laikoni我不明白有关移动部分z出来的f
bartavelle

10

Python,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分钟时间,再花一个小时去打高尔夫球。

它可能比整个python标准库具有更多的列表理解能力,主要是因为我不知道regex ...

在线尝试!(带有测试用例)


8

红宝石,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

8

Python 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

2
欢迎光临本站!我看到您尝试使用制表符进行缩进。如果将每个选项卡用单个空格替换,则它在功能上是相同的,并且实际上会正确显示,而不是显示为多余的字节
Destructible Lemon 2015年

4
尽管Destructible Lemon所说的是正确的,但您可以通过在代码的第一级缩进一个空格,在第二级缩进一个制表符,来在源代码中节省更多的字节,这会使显示起来有些困难,但是会为您节省5个字节。
精神主义主义的O'Zaic,2015年

1
第4行结尾的分号是否必要?
Hubert Grzeskowiak

1
@WaitndSee我认为您可以缩短一些条件。第一:你可以改变not nn<12个字节,因为你知道n永远都不会是负的。您也可以更改n==3为,n>2因为您知道n永远不会大于3。你也可以使用Python的技巧条件语句缩短第一和倒数第二更进一步:n=[n,1][i in w and n<1]; r+=[0,r][n<2]
musicman523

1
您可以更改r,v,c=('',)*3r=v=c='',因为字符串是不可变的。我尝试了许多其他巧妙的技巧,但令人沮丧的是它们的长度完全一样。另外,可能值得添加在线试用!链接到您的帖子
musicman523 '17

7

红宝石175个 141 110字节

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

在线尝试!

不打高尔夫球

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

4
-34个字节,带有Hash[*"bpcgdtfvgkkgpbsztdvfzs".chars]
Eric Duminil,

1
由于输入似乎保证全部为字母字符,因此输入要c=[^aeiou]短一些。让每个变量的第一个插值同时为-2个字节分配:/^(.*?${v='[aeiou]'}+(#{c='[^aeiou]})).../。最后,$2.tr("b-z","pgtevkhijgl-obqrzdufwxys")代替哈希解决方案。
价值墨水

您可以使用子表达式(\g<n>)而不是插值来保存14个字节,再使用@ValueInk的[^aeiou]建议再保存14个字节s=~/^(.*?([aeiouy])+([^aeiou]))\g<3>*(\g<2>)/
乔丹

实际上,programming-> 有一个错误progkaka,我不太清楚。
约旦

不幸的是,@ Jordan的子表达式调用会\g<3>更新$ 3的值,因此我们不能使用此快捷方式。
sudee

6

水晶,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]

我想你可以失去周围的括号c=vo+=<...>
Cyoce

5

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)进行减法,而是通过aMATLAB(1)而不是0开始对索引进行 减法。我们'a'的ASCII码为97。
  8. m(1:i)=0;:采用布尔掩码并将元音后从第一个位置到第一个辅音的输入字符串中的所有字符设置为false。
  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

当您点击顶部的“执行”按钮时,请稍等片刻,然后输入所需的字符串。缓慢输入字符串,因为在输入文本时似乎会有延迟。


5

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

返回的序列 ((\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=\sn=\i

或为“榜样”这是s=[]m=(\e)c=\xn=\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]))))

欢迎使用PPCG,这是一个很好的第一答案!我们希望您能留下来并享受参与更多挑战的乐趣。:-)
ETHproductions '17

如果要定义一个函数,则其名称应尽可能短。例如,您可以只调用main函数c。(我们还允许匿名函数,在许多语言中匿名函数都较短;我不确定它们是否在Clojure中)。不过,我看到您已经在代码内部进行了改进,因此在这里可能没有太多需要更改。

5

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

我相信你算它关闭-我算340个字节
泰勒·斯科特


4

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

从标准输入中取一个单词并将结果打印到标准输出。假设输入单词是小写字母,并且包含至少一个元音,后跟辅音。

带有格式和变量声明的程序的可读性更高的版本:

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将相应更新。然后,在字符串“ bpdtfvgkcgsz”中查找c处的辅音,该字符串充当替换表。如果在表中的任何位置找到辅音,则将该位置与1进行XOR运算,并将所得位置处的字符用作其替换字符。XOR运算将0变成1、2变成3、4变成5等,反之亦然,因此b与p交换,d与t交换,依此类推。最后,原始字符串最多为c,

结果示例:

覆盖率

创作creatdidi

编程progkaka

愚蠢的愚蠢

等等等等


链接到blitzmax回购?
破坏的柠檬

@DestructibleLemon BlitzMax被创建为主要用于业余游戏开发的语言,并出售了专有的编译器。虽然它现在是免费的,并且可以从此处获得,但我相信编译器仍不是开源的。(回购存在一个备选实现这里,构建在这里),这将仅然而运行的上面的代码ungolfed版本由于缺乏,允许省略变量声明“非严格”设置的。
FireballStarfish

在索引上巧妙地使用XOR-有一天我可能会使用。谢谢。
AI Breveleri

4

Perl,71个字节

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

也可以使用perl -pe。比以前的Perl解决方案少几个字节。诚然,我从那里也得到了一些启发。


4

05AB1E101个 104 88字节

-16字节归功于Okx

我莫名其妙地希望这是可以做到的方式更有效。

ž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

您可以替换"bpcgdtfvgkhhjjkgllmmnnpbqqrrsztdvfwwxxzs".•7¶ëÒ—Öb´ƒ≠Ä“šʒƵJ^ÝV“Îpи•以保存15个字节
-Okx

您也可以替换žOÃćIskžOÃ0èk以保存另一个字节。
Okx

@Okx我想我真的需要学习一些String压缩技术。谢谢!
kalsowerus

@kalsowerus我知道已经有一段时间了,但是您可以从答案中得到8个字节,例如:žOÃнk>[DIs£¤žPså#\>]©s[DIsèDžOså#\>]s\.•7¶ëÒ—Öb´ƒ≠Ä“šʒƵJ^ÝV“Îpи•S2ôDí«ø`®θkèìDJ 在线尝试。我主要通过使用变量来摆脱所有交换和三重掉期。并且可以н,我把它换成2׫DJ加入整个堆叠在一起。PS:我还使用其他技术发布了55字节的05AB1E答案。(其中还包含一个链接,可以更好地理解05AB1E中的压缩。:D)
Kevin Cruijssen

3

水晶,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,则将此索引用于第二个字符串(打高尔夫球的哈希值)。

如果inil,则使用原始字符。

接下来,附加的第一个元音z

p y + k + (b * 2)

最后,打印第一个正则表达式的第一部分,第y一个辅音k和先前计算的字符串的两倍b

在线尝试



2

Lua中,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字节!


2

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

2

sed,106(105 + 1)字节

这与-E标志一起使用,该标志显然占一个字节。

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

在线尝试!


2

C#,584581字节

-3个字节归功于Destructible Lemon

这是我第一次在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);
        }
    }
}

1
我不是专家,但是我认为您可以在for循环中的比较器中添加增量,即x++ < l,或类似的东西(l > x++如果第一个不起作用)。虽然不确定
破坏的柠檬

@DestructibleLemon感谢您的提示!
布兰登·郝

2

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

详细说明在这里!


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"

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.