（含义：将英语转换为Bleet）

多年来，我们一直称赞山羊为神。

但是，如果我们无法将英语翻译为山羊神的语言“ Bleet”，我们将无法与他们交流。

因此，为了与他们交流，我们研究了山羊的活动，并检索了这种模式，这是该语言的核心。

对每个单词的长度说“ Bleet”。这意味着对于大于3个字母的单词，``e''的数量应为（length-3）。对于小于``Blt''的单词，应减少``Bleet''的数量。例如，“ be”变成“ bl”，但是“ cat”和“ boat”变成“ blt”和“ blet”。

看起来，他们实际上并没有将非字母字符更改为“ Bleet”。我们的研究表明，“世界，您好！” 对Bleet来说是“ Bleet，Bleet！” 不是“ Bleeet Bleeet”。另外，山羊也不是那么聪明（没有冒犯性），所以他们似乎根本不懂非ASCII字符或变音符号。

现在，是时候让翻译与山羊神交流了。

Bleeeeet（含义：示例）

Hello, World! => Bleet, Bleet!
lorem ipsum dolor sit amet. => Bleet Bleet Bleet Blt Blet.
We praise the Goat God! => Bl Bleeet Blt Blet Blt!
I have a pen => B Blet B Blt
0123456789_ => 0123456789_
0te_st1 => 0Bl_Bl1

视网膜，31字节

T`lL`e
(?<!e)e
B
Be
Bl
e(?!e)
t

在线尝试！

说明

T`lL`e

将所有字母都变成es。

(?<!e)e
B

将e每次运行的第一个转换为B。

Be
Bl

转Be进Bl。

e(?!e)
t

将e每次运行中的最后一个变为t。

JavaScript（ES6），79 77 74字节

s=>s.replace(/[A-Z]+/gi,x=>x.replace(/./g,(_,i)=>'Bl'[i]||'et'[+!x[i+1]]))

替代方法，当前为83 78字节：

s=>s.replace(/[A-Z]+/gi,x=>`Bl${'e'.repeat((l=x.length)>3&&l-3)}t`.slice(0,l))

我可以递归执行的最佳操作是88个字节：

f=([c,...s],i=0,q=/^[A-Z]/i)=>c?q.test(c)?('Bl'[i]||'te'[+q.test(s)])+f(s,i+1):c+f(s):''

PHP，115 88 86 77 75字节

preg_replace 带数组（需要PHP 5.4或更高版本）

echo preg_replace(["#[a-z]#i","#(?<!e)e#",_Be_,"#e(?!e)#"],[e,B,Bl,t],$argn);

在线运行echo '<string>' | php -nR '<code>'或对其进行测试。

分解

SEARCH      EXPLANATION             REPLACE     EXAMPLE
            original string                     Hello
[a-z]       every letter            e           eeeee
(?<!e)e     first letter            B           Beeee
Be          first two letters       Bl          Bleee
e(?!e)      last letter if still e  t           Bleet

修订版5：使用Martin Ender的正则表达式链保存了9个字节。
^{（这也解决了非字母文字字符=数字/下划线的情况。）}

Haskell中，135个 128字节

b"e"="B"
b"ee"="Bl"
b('e':_:_:e)="Bl"++e++"t"
b e=e
e!(l:t)|elem l$['a'..'z']++['A'..'Z']=('e':e)!t|1<3=b e++l:""!t
e!_=[]
(""!)

在线尝试！用法(""!) $ "some string"。如果没有正则表达式，这会很长，也许其他一些方法会更短。编辑：感谢@nimi，节省了7个字节！

Perl 5，47个字节

使用与Martin Ender的Retina answer相同的技术，节省了15个字节。（这个答案现在基本上是他的答案的一部分）

46个字节的代码+ -p标志。

s/\pl/e/g;s/(?<!e)e/B/g;s/Be/Bl/g;s/e(?!e)/t/g

在线尝试！

旧版本：62个字节：

s/\pl+/$l=length$&;$_=Bl.e x($l-3).t;chop while$l<y%%%c;$_/ge

和68个字节：

s%\pl+%$_=$&;s/./B/;s/.\K./l/;s/(?<=..).(?=.)/e/g;s/..\K.$/t/;$_%ge

PHP，84字节

<?=preg_replace(["#[a-z]#i","#(?<!l)l#","#(?<=l)l#","#e(?!e)#"],[l,B,e,t],$argv[1]);

PHP，117字节

<?=preg_replace_callback("#[a-z]+#i",function($m){return substr(str_pad(Bl,-1+$l=strlen($m[0]),e).t,0,$l);},$argv[1]);

C，120 151 140 111 108 105 104 92 90个字节

为“这是吉米的考试”工作-> Bl'B Bleet'B Blet

j;f(char*m){for(;*m=!isalpha(*m++)?j=0,*(m-1):"*Blet"[isalpha(*m)?j^3?++j:j:j>1?4:++j];);}

现在，输出会破坏原始字符串，从而产生副作用。

main(c,v)char**v;{
    char test[] = "The End is near Fellows!";
    f(test);puts(test);
    char test2[] = "We praise the Goat God!";
    f(test2);puts(test2);
    char test3[] = "It's Jimmy's test";
    f(test3);puts(test3);
    char test4[] = "0te_st1";
    f(test4);puts(test4);
    char test5[] = "I have a pen";
    f(test5);puts(test5);
    char test6[] = "_0123456789_";
    f(test6);puts(test6);
}

我认为至少现在是正确的

Blt Blt Bl Blet Bleeeet!
Bl Bleeet Blt Blet Blt!
Bl'B Bleet'B Blet
0Bl_Bl1
B Blet B Blt
_012345678_

Python 2.7版，129 118 114 109 95个 91个 88字节

import re
s=re.sub
def f(i):print s(r"e\b","t",s("Be","Bl",s(r"\be","B",s("\w","e",i))))

只是一条re.sub链

一步步

输入示例：“ 我们赞美山羊神！ ”

别名子，这样我们可以节省重复调用的字节

import re
s=re.sub

将所有单词字符替换为“ e”

s("\w","e",i)

输出： ee eeeeee eee eeee eee!

将所有以单词边界（单词开头）开头的“ e”替换为“ B”

s(r"\be","B",s("\w","e",i))

输出： Be Beeeee Bee Beee Bee!

将所有“ Be”替换为“ Bl”

s("Be","Bl",s(r"\be","B",s("\w","e",i)))

输出： Bl Bleeee Ble Blee Ble!

将所有带有单词边界的“ e”替换为“ t”

s(r"e\b","t",s("Be","Bl",s(r"\be","B",s("\w","e",i))))

输出： Bl Bleeet Blt Blet Blt!

点，28字节

aR+XA{Y'eX#a-3\"Bl\yt\"@<#a}

将输入作为命令行参数。在线尝试！

说明

这很有趣-我必须使用正则表达式修饰符和字符串插值。

                              a is 1st cmdline arg; XA is the regex `[A-Za-z]` (implicit)
aR                            In a, replace
   XA                          the regex XA
  +                            wrapped in (?:  )+
     {                     }  with this callback function:
          #a-3                 Length of argument - 3
       'eX                     Repeat e that many times (empty string if #a-3 is negative)
      Y                        Yank that string into the y variable
              \"Bl\yt\"        An escaped string, which interpolates the value of y
                       @<#a    Take first len(a) characters
                              After the replacement, the string is autoprinted

Python 3，271个字节

我知道这是很长的时间，我欢迎有关如何减少长度的建议。

def f(s):
 b=[];t='';f=[];a=list.append
 for c in s:
  if c.isalpha():t+='e'
  else:
   if t:a(b,t);t=''
    a(b,c)
 if t:a(b,t)
 for i in b:
  i=[*i]
  if i[0]=='e':
   i[0]='B';i[-1]=[i[-1],'t'][len(i)>2]
   if len(i)>2:i[1]='l'
  a(f,''.join(i))
 return ''.join(f)

堆叠式，57字节

'\l+'{!n size 2-:4\^5*1+3/\1<-4 tb 0\,'Blet'\#''join}repl

在线尝试！从堆栈的顶部获取输入。

令a（n）= A136412（n -2）=（5×4 ^{n -2} +1）÷3。将a（n）转换为以4为底的整数：

a（3）= 13 4 
a（4）= 123 4 
a（5）= 1223 4 
a（6）= 12223 4
...

将索引0..3映射到字符串Blet，我们得到：

a（3）= lt
a（4）=让
a（5）= et
a（6）= lee
...

现在，B在给定长度的情况下，前置将为我们提供所需的字符串。大多。一个只需要办理特殊情况ñ ≤2。在我的情况下，这是通过从（解决ñ - 2 <1）作为数字布尔（1“真”，0为“假”）。

至于答案的细节：

'\l+'{! ... }repl
             repl    replace all
'\l+'                alphanumeric strings ("letters")
     {!     }        applying this function to the result.

Python 2中，137个 114字节

def f(s,r='',l=-3):
 for c in s+'\0':
	if c.isalpha():l+=1
	else:r+=('Bl%st'%('e'*l))[:l+3*(l>=0)]+c;l=-3
 print r

在线尝试！

Java 7，201字节

String c(String s){String r="",z="e([^e]|$)";char p=0;int x;for(char c:s.toCharArray()){x=c&~32;p=x>64&x<91?p==66?'l':p>100&p<109?'e':66:c;r+=p;}return r.replaceAll("l"+z,"lt$1").replaceAll(z,"et$1");}

对它不是很满意，当然可以再打些高尔夫球。

说明：

String c(String s){               // Method with String parameter and String return-type
  String r="",                    //  The return-String
         z="e([^e]|$)";           //  Partial regex String that's used twice ('e' followed by non-'e' or nothing)
  char p=0;                       //  The previous character
  int x;                          //  Another temp value
  for(char c : s.toCharArray()){  //  Loop over the characters of the input String
    x = c&~32;                    //   Make every lowercase character uppercase (this returns an integer, hence the integer temp value, which is shorter than a cast to char)
    p = x>64 & x<91 ?             //   If the current character is a letter:
         p == 66 ?                //    And if the previous character is 'B':
          'l'                     //     Set the character value to 'l'
         : p>100&p<109 ?          //    Else if the previous character is either an 'e' or 'l':
            'e'                   //     Set the character value to 'e'
           :                      //    Else:
            66                    //     Set the character value to 'B'
         :                        //   Else (not a letter):
          c;                      //    Set the character to the current character
    r += p;                       //   Append the result-String with this character
  }                               //  End loop
  return r                        //  Return the result-String
    .replaceAll("l"+z,"lt$1")     //   After we've replaced all occurrences of "le." with "lt." (where "." can be anything else, including nothing at the end of a line)
    .replaceAll(z,"et$1")         //   And also replaced all occurrences of "ee." with "et." (where "." can again be anything else)
}                                 // End of method

测试代码：

在这里尝试。

class M{
  static String c(String s){String r="",z="e([^e]|$)";char p=0;int x;for(char c:s.toCharArray()){x=c&~32;p=x>64&x<91?p==66?'l':p>100&p<109?'e':66:c;r+=p;}return r.replaceAll("l"+z,"lt$1").replaceAll(z,"et$1");}

  public static void main(String[] a){
    System.out.println(c("Hello, World!"));
    System.out.println(c("lorem ipsum dolor sit amet."));
    System.out.println(c("We praise the Goat God!"));
    System.out.println(c("I have a pen"));
    System.out.println(c("0123456789_"));
    System.out.println(c("0te_st1"));
  }
}

输出：

Bleeet, Bleeet!
Bleeet Bleeet Bleeet Blt Bleet.
Bl Bleeeet Blt Bleet Blt!
B Bleet B Blt
0123456789_
0Bl_Bl1

05AB1E，36个字节

lDAsSå.¡€g£vyAySåPigÍ<'e×"Blÿt"yg£}J

在线尝试！ 或作为测试套件

说明

准备输入：

lD                                    # convert input to lower-case and duplicate
  As                                  # push lower-case alphabet and swap input to the top
    Så                                # check each char in input for 
                                      # membership in the alphabet
      .¡                              # split into chunks of equal elements
        €g                            # get length of each chunk
          £                           # split input into chunks of those lengths

这['hello', ', ', 'world', '!'] 将为输入创建一个列表Hello, World!

遍历列表：

v                          # for each element in the list
 y                         # push current element
  AySåPi               }   # if all members of current element are letters
        gÍ<'e×             # repeat string "e" len(element)-3 times
              "Blÿt"       # replace "ÿ" with the e's in the string "Blÿt"
                    yg£    # take the first len(element) chars of the string
                        J  # join to string