(Significato: converti l'inglese in bleet)

Ormai da anni lodiamo le capre come dio.

Ma se non possiamo tradurre l'inglese in 'Bleet', la lingua di Dio della Capra, non possiamo comunicare con loro.

Quindi, per comunicare con loro, abbiamo studiato le attività delle capre e recuperato questo modello, che è il nucleo della lingua.

Pronuncia "Bleet" per la lunghezza di ogni parola. Ciò significa che la quantità di "e" dovrebbe essere (lunghezza-3) per le parole più lunghe di 3 lettere. Dovresti ridurre "Bleet" per le parole più brevi di "Blt". Ad esempio, "be" diventa "bl", ma "cat" e "boat" diventano "blt" e "blet".

A quanto pare, in realtà non cambiano i caratteri non alfabetici in "Bleet". La nostra ricerca ha dimostrato che "Ciao, mondo!" Bleet è "Bleet, Bleet!" non "Bleeet Bleeet". Inoltre, le capre non sono così intelligenti (senza offesa), quindi non sembrano affatto comprendere caratteri non ascii o segni diacritici.

Ora, è tempo di fare un traduttore per comunicare con gli dei caprini.

Bleeeeet (Significato: esempi)

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

Provalo online!

Spiegazione

T`lL`e

Trasforma tutte le lettere in es.

(?<!e)e
B

Trasforma il primo ein ogni corsa in B.

Be
Bl

Trasforma Bein Bl.

e(?!e)
t

Trasforma l'ultimo ein ogni corsa 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]]))

Approccio alternativo, attualmente 83 78 byte:

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

Il meglio che ho potuto fare ricorsivamente è stato di 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 con array (richiede PHP 5.4 o successivo)

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

Esegui echo '<string>' | php -nR '<code>'o prova online .

abbattersi

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

Revisione 5: salvati 9 byte con la catena regex di Martin Ender .
^{(Ciò ha risolto anche i casi con caratteri non alfabetici = cifre / caratteri di sottolineatura.)}

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

Provalo online! Utilizzo (""!) $ "some string". Senza regex, questo si è rivelato piuttosto lungo, forse un altro approccio è più breve. Modifica: salvato 7 byte grazie a @nimi!

Perl 5 , 47 byte

Hai salvato 15 byte usando la stessa tecnica della risposta Retina di Martin Ender . (Questa risposta è sostanzialmente una porta della sua risposta ora)

46 byte di codice + -pflag.

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

Provalo online!

Versioni precedenti: 62 byte:

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

E 68 byte:

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

PHP, 84 byte

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

PHP, 117 byte

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

Lavora per "È il test di 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];);}

L'output ora è un effetto collaterale distruggendo la stringa originale.

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

Penso che sia corretto almeno ora

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

Solo un re.sub catena

Passo dopo passo

Esempio di input: " Lodiamo Dio capra! "

Alias ​​sub in modo da poter salvare byte su chiamate ripetute

import re
s=re.sub

Sostituisci tutti i caratteri di parole con "e"

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

Produzione: ee eeeeee eee eeee eee!

Sostituisci tutte le "e" che sono precedute da un limite di parole (Inizio della parola) con "B"

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

Produzione: Be Beeeee Bee Beee Bee!

Sostituisci tutto "Be" con "Bl"

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

Produzione: Bl Bleeee Ble Blee Ble!

Sostituisci tutte le "e" che sono seguite da un limite di parole con "t"

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

Produzione: Bl Bleeet Blt Blet Blt!

Pip , 28 byte

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

Accetta input come argomento della riga di comando. Provalo online!

Spiegazione

È stato divertente - ho usato i modificatori regex e l'interpolazione di stringhe.

                              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

Sono consapevole che questo è piuttosto lungo e accolgo con favore suggerimenti su come ridurre la lunghezza.

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)

impilato , 57 byte

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

Provalo online! Riceve input dalla cima dello stack.

Sia a ( n ) = A136412 ( n - 2) = (5 × 4 ^{n - 2} + 1) ÷ 3. Conversione di a ( n ) in base 4 rese:

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

Mappando gli indici 0..3 sulla stringa Blet, otteniamo:

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

Ora, anteponendoci Bci dà la stringa desiderata, data la lunghezza. Soprattutto. Uno deve solo gestire i casi speciali per n ≤ 2. Nel mio caso, questo viene risolto sottraendo ( n - 2 <1) come un valore booleano numerico (1 per "vero" e 0 per "falso").

Per quanto riguarda le specifiche della risposta:

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

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

Non ne sono davvero contento, e sicuramente si può giocare ancora un po 'a golf ..

Spiegazione:

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

Codice di prova:

Provalo qui.

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

Produzione:

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

Provalo online! o come una suite di test

Spiegazione

Prepara 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

Questo crea un elenco come ['hello', ', ', 'world', '!'] per l'inputHello, World!

Scorrere l'elenco:

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