(Significado: converter inglês para Bleet)

Louvamos as cabras como deus há anos.

Mas se não podemos traduzir o inglês para 'Bleet', a língua de Deus dos bodes, não podemos nos comunicar com eles.

Portanto, para nos comunicarmos com eles, pesquisamos as atividades das cabras e recuperamos esse padrão, que é o cerne da linguagem.

Diga 'Bleet' pelo comprimento de cada palavra. Isso significa que a quantidade de 'e's deve ser (comprimento-3) para palavras com mais de 3 letras. Por exemplo, 'be' se torna 'bl', mas 'cat' e 'boat' se tornam 'blt' e 'blet'.

Como parece, eles não alteram caracteres não alfabéticos para 'Bleet'. Nossa pesquisa mostrou que 'Olá, mundo!' para Bleet é 'Bleet, Bleet!' não 'Bleeet Bleeet'. Além disso, as cabras não são tão inteligentes (sem ofensas), por isso não parecem entender caracteres não-ascii ou diacríticos.

Agora, é hora de fazer um tradutor para se comunicar com os deuses das cabras.

Bleeeeet (Significado: Exemplos)

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 bytes

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

Experimente online!

Explicação

T`lL`e

Transforme todas as letras em es.

(?<!e)e
B

Transforme a primeira eem cada corrida B.

Be
Bl

Transformar Beem Bl.

e(?!e)
t

Transforme o último eem cada corrida t.

JavaScript (ES6), 79 77 74 bytes

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

Abordagem alternativa, atualmente 83 78 bytes:

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

O melhor que pude fazer recursivamente foi 88 bytes:

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 bytes

preg_replace com matrizes (requer PHP 5.4 ou posterior)

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

Execute echo '<string>' | php -nR '<code>'ou teste on-line .

demolir

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

Revisão 5: salvou 9 bytes com a cadeia regex de Martin Ender .
^{(Isso também corrigia casos com caracteres de palavra não alfabéticos = dígitos / sublinhados.)}

Haskell , 135 128 bytes

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

Experimente online! Uso (""!) $ "some string". Sem regexes, isso acabou sendo bastante longo, talvez alguma outra abordagem seja mais curta. Editar: salvou 7 bytes graças a @nimi!

Perl 5 , 47 bytes

Economizou 15 bytes usando a mesma técnica da resposta Retina de Martin Ender . (Esta resposta é basicamente uma porta de sua resposta agora)

46 bytes de código + -psinalizador.

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

Experimente online!

Versões anteriores: 62 bytes:

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

E 68 bytes:

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

Trabalhando para "É o teste de 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];);}

A saída agora é um efeito colateral, destruindo a string original.

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

Eu acho que está correto pelo menos agora

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 bytes

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

Apenas uma re.subcorrente

Passo a passo

Exemplo de entrada: " Louvamos ao Deus dos bodes! "

Alias ​​sub para que possamos salvar bytes em chamadas repetidas

import re
s=re.sub

Substitua todos os caracteres de palavra por "e"

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

Resultado: ee eeeeee eee eeee eee!

Substitua todos os "e" s precedidos por um limite de palavras (início da palavra) por "B"

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

Resultado: Be Beeeee Bee Beee Bee!

Substitua todos os "Be" por "Bl"

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

Resultado: Bl Bleeee Ble Blee Ble!

Substitua todos os "e" s que são seguidos por um limite de palavra por "t"

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

Resultado: Bl Bleeet Blt Blet Blt!

Pip , 28 bytes

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

Recebe entrada como um argumento de linha de comando. Experimente online!

Explicação

Foi divertido - usei modificadores de regex e interpolação de strings.

                              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 bytes

Estou ciente de que isso é bastante longo e aceito sugestões de como reduzir o comprimento.

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)

empilhados , 57 bytes

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

Experimente online! Recebe entrada do topo da pilha.

Seja a ( n ) = A136412 ( n - 2) = (5 × 4 ^{n - 2} + 1) ÷ 3. A conversão de a ( n ) na base 4 produz:

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

Mapeando índices 0..3 para a string Blet, obtemos:

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

Agora, o prefixo Bfornece a string desejada, considerando o comprimento. Na maioria das vezes. Basta lidar com os casos especiais para n ≤ 2. No meu caso, isso é resolvido subtraindo ( n - 2 <1) como um booleano numérico (1 para "true" e 0 para "false").

Quanto aos detalhes da resposta:

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

Python 2 , 137 114 bytes

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

Experimente online!

Java 7, 201 bytes

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

Não é realmente feliz com isso, e certamente pode ser jogado um pouco mais ..

Explicação:

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

Código do teste:

Experimente aqui.

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

Resultado:

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

05AB1E , 36 bytes

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

Experimente online! ou como um conjunto de testes

Explicação

Prepare a entrada:

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

Isso cria uma lista como ['hello', ', ', 'world', '!'] para a entradaHello, World!

Repita a lista:

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