(Artinya: Konversi Bahasa Inggris ke Bleet)

Kami telah memuji kambing sebagai dewa selama bertahun-tahun sekarang.

Tetapi jika kita tidak dapat menerjemahkan bahasa Inggris ke 'Bleet', bahasa Goat God, kita tidak dapat berkomunikasi dengan mereka.

Jadi, untuk berkomunikasi dengan mereka, kami telah meneliti aktivitas kambing, dan mengambil pola ini, yang merupakan inti dari bahasa tersebut.

Ucapkan 'Bleet' untuk panjang setiap kata. Itu berarti jumlah 'e' harus (panjang-3) untuk kata-kata yang lebih panjang dari 3 huruf. Anda harus mengurangi 'Bleet' untuk kata-kata yang lebih pendek dari 'Blt'. Misalnya, 'menjadi' menjadi 'bl', tetapi 'kucing' dan 'kapal' menjadi 'blt' dan 'blet'.

Sepertinya, mereka tidak benar-benar mengubah karakter non-alfabet menjadi 'Bleet'. Penelitian kami menunjukkan bahwa 'Halo, Dunia!' untuk Bleet adalah 'Bleet, Bleet!' bukan 'Bleeet Bleeet'. Juga, Kambing tidak begitu cerdas (jangan tersinggung), sehingga mereka tampaknya tidak mengerti karakter atau diakritik non-ascii sama sekali.

Sekarang, saatnya membuat penerjemah untuk berkomunikasi dengan para dewa kambing.

Bleeeeet (Artinya: Contoh)

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

Retina , 31 byte

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

Cobalah online!

Penjelasan

T`lL`e

Ubah semua huruf menjadi es.

(?<!e)e
B

Ubah yang pertama edi setiap lari ke B.

Be
Bl

Berubah Bemenjadi Bl.

e(?!e)
t

Ubah yang terakhir edi setiap run menjadi t.

JavaScript (ES6), 79 77 74 byte

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

Pendekatan alternatif, saat ini 83 78 byte:

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

Yang terbaik yang bisa saya lakukan secara rekursif adalah 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 dengan array (membutuhkan PHP 5.4 atau yang lebih baru)

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

Jalankan dengan echo '<string>' | php -nR '<code>'atau coba online .

kerusakan

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

Revisi 5: disimpan 9 byte dengan rantai regex Martin Ender .
^{(Itu juga memperbaiki kasus dengan karakter kata non-alfabet = digit / garis bawah.)}

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

Cobalah online! Penggunaan (""!) $ "some string". Tanpa regex, ini ternyata cukup panjang, mungkin beberapa pendekatan lain lebih pendek. Sunting: Disimpan 7 byte berkat @nimi!

Perl 5 , 47 byte

Disimpan 15 byte dengan menggunakan teknik yang sama seperti jawaban Retina Martin Ender . (Jawaban ini pada dasarnya adalah port dari jawabannya sekarang)

46 byte kode + -pbendera.

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

Cobalah online!

Versi yang lebih lama: 62 byte:

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

Dan 68 byte:

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

PHP, 84 Bytes

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

PHP, 117 Bytes

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

Bekerja untuk "Ini uji coba 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];);}

Outputnya sekarang merupakan efek samping dengan menghancurkan string asli.

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

Saya pikir itu setidaknya benar sekarang

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

Hanya sebuah re.subrantai

Selangkah demi selangkah

Input contoh: " Kami memuji Dewa Kambing! "

Sub alias sehingga kami dapat menyimpan byte pada panggilan berulang

import re
s=re.sub

Ganti semua karakter kata dengan "e"

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

Keluaran: ee eeeeee eee eeee eee!

Ganti semua "e" yang diawali dengan batas kata (Awal kata) dengan "B"

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

Keluaran: Be Beeeee Bee Beee Bee!

Ganti semua "Jadilah" dengan "Bl"

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

Keluaran: Bl Bleeee Ble Blee Ble!

Ganti semua "e" yang diikuti oleh batas kata dengan "t"

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

Keluaran: Bl Bleeet Blt Blet Blt!

Pip , 28 byte

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

Mengambil input sebagai argumen baris perintah. Cobalah online!

Penjelasan

Ini menyenangkan - saya harus menggunakan pengubah regex dan interpolasi string.

                              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

Saya sadar bahwa ini agak panjang dan saya menyambut saran tentang cara mengurangi panjangnya.

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)

ditumpuk , 57 byte

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

Cobalah online! Mengambil input dari atas tumpukan.

Biarkan a ( n ) = A136412 ( n - 2) = (5 × 4 ^{n - 2} + 1) ÷ 3. Konversi a ( n ) menjadi basis 4 menghasilkan:

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

Memetakan indeks 0..3 ke string Blet, kita mendapatkan:

a (3) = lt
a (4) = biarkan
a (5) = leet
a (6) = leeet
...

Sekarang, mengawali Bmemberi kita string yang diinginkan, mengingat panjangnya. Kebanyakan. Satu hanya perlu menangani kasus khusus untuk n ≤ 2. Dalam kasus saya, ini diselesaikan dengan mengurangi ( n - 2 <1) sebagai boolean numerik (1 untuk "benar" dan 0 untuk "salah").

Adapun spesifik dari jawabannya:

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

Cobalah online!

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

Tidak benar-benar senang dengan itu, dan tentu saja bisa bermain golf lagi ..

Penjelasan:

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

Kode uji:

Coba di sini.

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

Keluaran:

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

Cobalah online! atau sebagai Test suite

Penjelasan

Siapkan input:

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

Ini membuat daftar seperti ['hello', ', ', 'world', '!'] untuk inputHello, World!

Iterate over list:

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