(Ý nghĩa: Chuyển đổi tiếng Anh sang Bleet)

Chúng tôi đã ca ngợi dê là thần trong nhiều năm nay.

Nhưng nếu chúng ta không thể dịch tiếng Anh sang 'Bleet', ngôn ngữ của Dê, chúng ta không thể giao tiếp với họ.

Vì vậy, để giao tiếp với chúng, chúng tôi đã nghiên cứu các hoạt động của dê và lấy ra mô hình này, đó là cốt lõi của ngôn ngữ.

Nói 'Bleet' cho độ dài của mỗi từ. Điều đó có nghĩa là số lượng 'e nên là (độ dài 3) cho các từ dài hơn 3 chữ cái. Bạn sẽ cắt giảm' Bleet 'cho các từ ngắn hơn' Blt '. Ví dụ: 'trở thành' trở thành 'bl', nhưng 'mèo' và 'thuyền' trở thành 'blt' và 'blet'.

Có vẻ như, họ không thực sự thay đổi các ký tự không phải là bảng chữ cái thành 'Bleet'. Nghiên cứu của chúng tôi cho thấy 'Xin chào, Thế giới!' với Bleet là 'Bleet, Bleet!' không phải 'Bleeet Bleeet'. Ngoài ra, những con dê không quá thông minh (không có hành vi phạm tội), vì vậy chúng dường như không hiểu các ký tự không phải là ascii hoặc dấu phụ.

Bây giờ, đã đến lúc làm một dịch giả để giao tiếp với các vị thần dê.

Bleeeeet (Ý nghĩa: Ví dụ)

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

Võng mạc , 31 byte

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

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

Giải trình

T`lL`e

Biến tất cả các chữ cái thành es.

(?<!e)e
B

Lần đầu tiên etrong mỗi lần chạy vào B.

Be
Bl

Biến Bethành Bl.

e(?!e)
t

Biến cuối cùng etrong mỗi lần chạy vào t.

JavaScript (ES6), 79 77 74 byte

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

Cách tiếp cận thay thế, hiện 83 83 byte:

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

Điều tốt nhất tôi có thể làm đệ quy là 88 byte:

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 byte

preg_replace với các mảng (yêu cầu PHP 5.4 trở lên)

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

Chạy với echo '<string>' | php -nR '<code>'hoặc kiểm tra nó trực tuyến .

phá vỡ

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

Bản sửa đổi 5: đã lưu 9 byte với chuỗi regex Martin Ender hungs .
^{(Đó cũng là trường hợp cố định với các ký tự từ không phải là chữ cái = chữ số / dấu gạch dưới.)}

Haskell , 135 128 byte

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!_=[]
(""!)

Hãy thử trực tuyến! Cách sử dụng (""!) $ "some string". Không có regex, điều này hóa ra khá dài, có thể một số cách tiếp cận khác ngắn hơn. Chỉnh sửa: Đã lưu 7 byte nhờ @nimi!

Perl 5 , 47 byte

Đã lưu 15 byte bằng cách sử dụng kỹ thuật tương tự như của Martin Ender câu trả lời Retina . (Câu trả lời này về cơ bản là một cổng câu trả lời của anh ấy)

46 byte mã + -pcờ.

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

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

Các phiên bản cũ hơn: 62 byte:

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

Và 68 byte:

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

PHP, 84 byte

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

PHP, 117 byte

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

Hoạt động cho "Đó là bài kiểm tra của Jimmy" -> 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];);}

Đầu ra bây giờ là một tác dụng phụ bằng cách phá hủy chuỗi gốc.

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

Tôi nghĩ rằng nó ít nhất là đúng

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 byte

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

Chỉ một re.sub chuỗi

Từng bước một

Ví dụ đầu vào: " Chúng tôi ca ngợi Thần dê! "

Bí danh phụ để chúng tôi có thể lưu byte trên các cuộc gọi lặp lại

import re
s=re.sub

Thay thế tất cả các ký tự từ bằng "e"

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

Đầu ra: ee eeeeee eee eeee eee!

Thay thế tất cả các "e" được đi trước bởi một ranh giới từ (Bắt đầu từ) bằng "B"

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

Đầu ra: Be Beeeee Bee Beee Bee!

Thay thế tất cả "Be" bằng "Bl"

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

Đầu ra: Bl Bleeee Ble Blee Ble!

Thay thế tất cả các "e" được theo sau bởi một ranh giới từ bằng "t"

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

Đầu ra: Bl Bleeet Blt Blet Blt!

Pip , 28 byte

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

Đưa đầu vào làm đối số dòng lệnh. Hãy thử trực tuyến!

Giải trình

Điều này thật thú vị - Tôi đã sử dụng các công cụ sửa đổi regex và nội suy chuỗi.

                              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 byte

Tôi biết rằng điều này khá dài và tôi hoan nghênh các đề xuất về cách giảm chiều dài.

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)

xếp chồng lên nhau , 57 byte

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

Hãy thử trực tuyến!Lấy đầu vào từ đầu ngăn xếp.

Đặt a ( n ) = A136412 ( n - 2) = (5 × 4 ^{n - 2} + 1) 3. Chuyển đổi a ( n ) thành cơ sở 4 mang lại:

a (3) = 13 4 
a (4) = 123 4 
a (5) = 1223 4 
a (6) = 12223 4
...

Ánh xạ các chỉ số 0..3 vào chuỗi Blet, chúng ta nhận được:

a (3) = lt
a (4) = hãy
a (5) = leet
a (6) = leeet
...

Bây giờ, việc chuẩn bị Bcho chúng ta chuỗi mong muốn, với độ dài. Hầu hết. Người ta chỉ cần xử lý các trường hợp đặc biệt cho n ≤ 2. Trong trường hợp của tôi, điều này được giải quyết bằng cách trừ ( n - 2 <1) dưới dạng boolean số (1 cho "true" và 0 cho "false").

Đối với các chi tiết cụ thể của câu trả lời:

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

Python 2 , 137 114 byte

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

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

Java 7, 201 byte

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

Không thực sự hài lòng với nó, và chắc chắn có thể chơi gôn thêm ..

Giải trình:

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

Mã kiểm tra:

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

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

Đầu ra:

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

05AB1E , 36 byte

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

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

Chuẩn bị đầu vào:

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

Điều này tạo ra một danh sách như ['hello', ', ', 'world', '!'] cho đầu vàoHello, World!

Lặp lại danh sách:

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