(Bedeutung: Englisch in Bleet umrechnen)

Wir preisen seit Jahren Ziegen als Gott.

Aber wenn wir Englisch nicht in Bleet, die Sprache des Ziegengottes, übersetzen können, können wir nicht mit ihnen kommunizieren.

Um mit ihnen zu kommunizieren, haben wir die Aktivitäten von Ziegen untersucht und dieses Muster gefunden, das den Kern der Sprache darstellt.

Sagen Sie "Bleet" für die Länge der einzelnen Wörter. Das bedeutet, dass die Anzahl der "e" (Länge-3) für Wörter länger als 3 Buchstaben sein sollte. Sie müssen "Bleet" für Wörter kürzer als "Blt" kürzen. Zum Beispiel wird 'be' zu 'bl', aber 'cat' und 'boat' werden zu 'blt' und 'blet'.

Offenbar ändern sie nicht-alphabetische Zeichen nicht in "Bleet". Unsere Untersuchung ergab, dass "Hallo, Welt!" Bleet heißt Bleet, Bleet! nicht "Bleeet Bleeet". Außerdem sind die Ziegen nicht so intelligent (keine Beleidigung), sodass sie anscheinend überhaupt keine Nicht-Ascii-Charaktere oder Diakritika verstehen.

Jetzt ist es an der Zeit, einen Übersetzer mit den Ziegengöttern zu kommunizieren.

Bleeeeet (Bedeutung: Beispiele)

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

Probieren Sie es online!

Erläuterung

T`lL`e

Verwandle alle Buchstaben in es.

(?<!e)e
B

Schalten Sie die erste ein jedem Lauf in B.

Be
Bl

Biegen Sie Bein Bl.

e(?!e)
t

Schalten Sie die letzte ein jedem Lauf in t.

JavaScript (ES6), 79 77 74 Byte

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

Alternativer Ansatz, derzeit 83 bis 78 Bytes:

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

Das Beste, was ich rekursiv machen konnte, waren 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 mit Arrays (benötigt PHP 5.4 oder neuer)

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

Laufen Sie mit echo '<string>' | php -nR '<code>'oder testen Sie es online .

Nervenzusammenbruch

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

Revision 5: 9 Bytes mit der Regex-Kette von Martin Ender gespeichert .
^{(Das hat auch Fälle mit nicht-alphabetischen Wortzeichen = Ziffern / Unterstrichen behoben.)}

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

Probieren Sie es online! Verwendung (""!) $ "some string". Ohne reguläre Ausdrücke erwies sich dies als ziemlich langwierig, vielleicht ist ein anderer Ansatz kürzer. Bearbeiten: 7 Bytes dank @nimi gespeichert!

Perl 5 , 47 Bytes

Mit derselben Technik wie bei Martin Enders Retina-Antwort wurden 15 Byte gespeichert . (Diese Antwort ist im Grunde genommen ein Teil seiner Antwort.)

46 Byte Code + -pFlag.

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

Probieren Sie es online!

Ältere Versionen: 62 Bytes:

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

Und 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

Arbeiten für "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];);}

Die Ausgabe ist jetzt ein Nebeneffekt, indem die ursprüngliche Zeichenfolge zerstört wird.

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

Ich denke, es ist zumindest jetzt richtig

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

Nur eine re.subKette

Schritt für Schritt

Eingabebeispiel: " Wir preisen den Ziegengott! "

Alias ​​Sub, damit wir bei wiederholten Aufrufen Bytes sparen können

import re
s=re.sub

Ersetzen Sie alle Wortzeichen durch "e"

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

Ausgabe: ee eeeeee eee eeee eee!

Ersetzen Sie alle "e", denen eine Wortgrenze (Wortanfang) vorausgeht, durch "B".

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

Ausgabe: Be Beeeee Bee Beee Bee!

Ersetze alles "Be" durch "Bl"

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

Ausgabe: Bl Bleeee Ble Blee Ble!

Ersetzen Sie alle "e", denen eine Wortgrenze folgt, durch "t".

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

Ausgabe: Bl Bleeet Blt Blet Blt!

Pip , 28 Bytes

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

Übernimmt die Eingabe als Befehlszeilenargument. Probieren Sie es online!

Erläuterung

Das hat Spaß gemacht - ich musste Regex-Modifikatoren und String-Interpolation verwenden.

                              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

Mir ist bewusst, dass dies ziemlich lang ist, und ich begrüße Vorschläge zur Verkürzung der Länge.

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)

gestapelt , 57 Bytes

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

Probieren Sie es online! Nimmt die Eingabe vom oberen Rand des Stapels auf.

Sei a ( n ) = A136412 ( n - 2) = (5 × 4 ^{n - 2} + 1) ÷ 3. Die Umwandlung von a ( n ) in die Base 4 ergibt:

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

Wenn Bletwir die Indizes 0..3 dem String zuordnen , erhalten wir:

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

Wenn Sie jetzt voranstellen B, erhalten Sie die gewünschte Zeichenfolge in der angegebenen Länge. Meistens. Man muss nur die Sonderfälle für n ≤ 2 behandeln. In meinem Fall wird dies durch Subtrahieren ( n - 2 <1) als numerischer Boolescher Wert (1 für "wahr" und 0 für "falsch") gelöst .

Zu den Einzelheiten der Antwort:

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

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

Ich bin nicht wirklich glücklich damit und kann sicherlich noch mehr golfen.

Erläuterung:

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

Testcode:

Probieren Sie es hier aus.

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

Ausgabe:

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

Probieren Sie es online! oder als Testsuite

Erläuterung

Eingabe vorbereiten:

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

Dadurch wird eine Liste erstellt, beispielsweise ['hello', ', ', 'world', '!'] für die EingabeHello, World!

Liste durchlaufen:

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