(Significado: convertir inglés a bleet)

Hemos alabado a las cabras como dios desde hace años.

Pero si no podemos traducir el inglés al 'Bleet', el idioma de Dios de la cabra, no podemos comunicarnos con ellos.

Entonces, para comunicarnos con ellos, hemos investigado las actividades de las cabras y recuperamos este patrón, que es el núcleo del lenguaje.

Di 'Bleet' por la longitud de cada palabra. Eso significa que la cantidad de 'e' debe ser (longitud-3) para palabras más largas que 3 letras. Deberá reducir 'Bleet' para palabras más cortas que 'Blt'. Por ejemplo, 'be' se convierte en 'bl', pero 'cat' y 'boat' se convierten en 'blt' y 'blet'.

Como parece, en realidad no cambian los caracteres que no son del alfabeto a 'Bleet'. Nuestra investigación mostró que '¡Hola, mundo!' Bleet es '¡Bleet, Bleet!' no 'Bleeet Bleeet'. Además, las cabras no son tan inteligentes (sin ofender), por lo que no parecen entender a los personajes no ascii o diacríticos.

Ahora, es hora de hacer un traductor para comunicarse con los dioses de las cabras.

Bleeeeet (Significado: Ejemplos)

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

Pruébalo en línea!

Explicación

T`lL`e

Convierte todas las letras en es.

(?<!e)e
B

Convierte el primero een cada carrera B.

Be
Bl

Conviértete Been Bl.

e(?!e)
t

Convierte el último een cada carrera t.

JavaScript (ES6), 79 77 74 bytes

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

Enfoque alternativo, actualmente 83 78 bytes:

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

Lo mejor que pude hacer recursivamente fue 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 con matrices (requiere PHP 5.4 o posterior)

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

Ejecutar echo '<string>' | php -nR '<code>'o probarlo en línea .

Descompostura

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ón 5: guardado 9 bytes con la cadena de expresiones regulares de Martin Ender .
^{(Eso también solucionó casos con caracteres de palabras no alfabéticos = dígitos / guiones bajos).}

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

Pruébalo en línea! Uso (""!) $ "some string". Sin expresiones regulares, esto resultó ser bastante largo, tal vez algún otro enfoque es más corto. Editar: ¡Guardado 7 bytes gracias a @nimi!

Perl 5 , 47 bytes

Ahorró 15 bytes usando la misma técnica que la respuesta Retina de Martin Ender . (Esta respuesta es básicamente un puerto de su respuesta ahora)

46 bytes de código + -pbandera.

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

Pruébalo en línea!

Versiones anteriores: 62 bytes:

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

Y 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

Trabajando para "Es la prueba 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];);}

La salida ahora es un efecto secundario al destruir la cadena 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);
}

Creo que es correcto al menos ahora

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

Solo un re.sub cadena

Paso a paso

Entrada de ejemplo: " Alabamos al Dios de la cabra! "

Sub alias para que podamos guardar bytes en llamadas repetidas

import re
s=re.sub

Reemplace todos los caracteres de palabras con "e"

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

Salida: ee eeeeee eee eeee eee!

Reemplace todas las "e" que están precedidas por un límite de palabra (Comienzo de palabra) con "B"

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

Salida: Be Beeeee Bee Beee Bee!

Reemplace todo "Be" con "Bl"

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

Salida: Bl Bleeee Ble Blee Ble!

Reemplace todas las "e" s seguidas de un límite de palabra con "t"

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

Salida: Bl Bleeet Blt Blet Blt!

Pip , 28 bytes

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

Toma entrada como argumento de línea de comando. Pruébalo en línea!

Explicación

Esto fue divertido: pude usar modificadores de expresiones regulares e interpolación de cadenas.

                              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

Soy consciente de que esto es bastante largo y agradezco las sugerencias sobre cómo reducir la longitud.

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)

apilado , 57 bytes

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

Pruébalo en línea! Toma información desde la parte superior de la pila.

Deje a ( n ) = A136412 ( n - 2) = (5 × 4 ^{n - 2} + 1) ÷ 3. La conversión de a ( n ) en la base 4 produce:

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

Al asignar índices 0..3 a la cadena Blet, obtenemos:

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

Ahora, anteponer Bnos da la cadena deseada, dada la longitud. Principalmente. Uno solo necesita manejar los casos especiales para n ≤ 2. En mi caso, esto se resuelve restando ( n - 2 <1) como un booleano numérico (1 para "verdadero" y 0 para "falso").

En cuanto a los detalles de la respuesta:

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

Python 2 , 137114 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

Pruébalo en línea!

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

No estoy muy contento con él, y ciertamente se puede jugar un poco más.

Explicación:

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 de prueba:

Pruébalo aquí

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

Salida:

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

Pruébalo en línea! o como un conjunto de pruebas

Explicación

Preparar 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

Esto crea una lista como ['hello', ', ', 'world', '!'] para la entradaHello, World!

Iterar sobre la 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