(Signification: convertir l'anglais en Bleet)

Nous louons les chèvres comme dieu depuis des années maintenant.

Mais si nous ne pouvons pas traduire l'anglais en «Bleet», la langue du Dieu bouc, nous ne pouvons pas communiquer avec eux.

Donc, pour communiquer avec eux, nous avons recherché les activités des chèvres et récupéré ce modèle, qui est au cœur de la langue.

Dites «Bleet» pour la longueur de chaque mot. Cela signifie que le nombre de «e» doit être (longueur-3) pour les mots de plus de 3 lettres. Vous devez réduire «Bleet» pour les mots plus courts que «Blt». Par exemple, «be» devient «bl», mais «cat» et «boat» devient «blt» et «blet».

Comme il semble, ils ne changent pas réellement les caractères non alphabétiques en «Bleet». Nos recherches ont montré que "Bonjour, monde!" pour Bleet, c'est «Bleet, Bleet! pas «Bleeet Bleeet». De plus, les chèvres ne sont pas si intelligentes (sans offense), donc elles ne semblent pas comprendre du tout les caractères non-ascii ou les signes diacritiques.

Maintenant, il est temps de faire un traducteur pour communiquer avec les dieux de chèvre.

Bleeeeet (Signification: exemples)

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

Rétine , 31 octets

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

Essayez-le en ligne!

Explication

T`lL`e

Transformez toutes les lettres en eart.

(?<!e)e
B

Transformez le premier ede chaque manche en B.

Be
Bl

Transformez Been Bl.

e(?!e)
t

Transformez le dernier ede chaque manche en t.

JavaScript (ES6), 79 77 74 octets

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

Approche alternative, actuellement 83 78 octets:

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

Le mieux que j'ai pu faire récursivement était de 88 octets:

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 octets

preg_replace avec des tableaux (nécessite PHP 5.4 ou version ultérieure)

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

Exécutez-le echo '<string>' | php -nR '<code>'ou testez-le en ligne .

panne

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

Révision 5: sauvegarde de 9 octets avec la chaîne d'expression régulière de Martin Ender .
^{(Cela a également corrigé les cas avec des caractères de mots non alphabétiques = chiffres / traits de soulignement.)}

Haskell , 135 128 octets

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

Essayez-le en ligne! Utilisation (""!) $ "some string". Sans regex, cela s'est avéré être assez long, peut-être qu'une autre approche est plus courte. Edit: 7 octets enregistrés grâce à @nimi!

Perl 5 , 47 octets

15 octets enregistrés en utilisant la même technique que la réponse Retina de Martin Ender . (Cette réponse est essentiellement un portage de sa réponse maintenant)

46 octets de code + -pindicateur.

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

Essayez-le en ligne!

Versions antérieures: 62 octets:

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

Et 68 octets:

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

PHP, 84 octets

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

PHP, 117 octets

<?=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 104 92 90 octets

Travailler pour "It's Jimmy's test" -> 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 sortie est maintenant un effet secondaire en détruisant la chaîne d'origine.

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

Je pense que c'est correct au moins maintenant

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 octets

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

Juste une re.subchaîne

Pas à pas

Exemple d'entrée: " Nous louons le Dieu bouc! "

Sous-alias afin que nous puissions économiser des octets sur les appels répétés

import re
s=re.sub

Remplacez tous les caractères du mot par "e"

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

Production: ee eeeeee eee eeee eee!

Remplacez tous les «e» précédés d'une limite de mot (début du mot) par «B»

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

Production: Be Beeeee Bee Beee Bee!

Remplacez tous "Be" par "Bl"

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

Production: Bl Bleeee Ble Blee Ble!

Remplacez tous les «e» qui sont suivis d'une limite de mot par «t»

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

Production: Bl Bleeet Blt Blet Blt!

Pip , 28 octets

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

Prend l'entrée comme argument de ligne de commande. Essayez-le en ligne!

Explication

C'était amusant - j'ai pu utiliser des modificateurs d'expression régulière et l'interpolation de chaînes.

                              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 octets

Je sais que c'est assez long et j'accueille favorablement les suggestions sur la façon de réduire la longueur.

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)

empilés , 57 octets

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

Essayez-le en ligne!Prend l'entrée du haut de la pile.

Soit a ( n ) = A136412 ( n - 2) = (5 × 4 ^{n - 2} + 1) ÷ 3. Conversion de a ( n ) en base 4 donne:

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

Mappage des indices 0..3 à la chaîne Blet , nous obtenons:

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

Maintenant, le préfixe Bnous donne la chaîne souhaitée, compte tenu de la longueur. La plupart. Il suffit de gérer les cas spéciaux pour n ≤ 2. Dans mon cas, cela est résolu en soustrayant ( n - 2 <1) comme un booléen numérique (1 pour "vrai" et 0 pour "faux").

Quant aux détails de la réponse:

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

Python 2 , 137 114 octets

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

Essayez-le en ligne!

Java 7, 201 octets

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

Pas vraiment content, et peut certainement être joué au golf encore plus ..

Explication:

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

Code de test:

Essayez-le ici.

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

Production:

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

05AB1E , 36 octets

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

Essayez-le en ligne! ou comme suite de tests

Explication

Préparez l'entrée:

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

Cela crée une liste telle que ['hello', ', ', 'world', '!'] pour l'entréeHello, World!

Itérer sur la liste:

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