(Znaczenie: Konwertuj angielski na Bleet)

Od lat chwalimy kozy za boga.

Ale jeśli nie potrafimy przetłumaczyć angielskiego na „Bleet”, język koziego Boga, nie możemy się z nimi porozumieć.

Aby więc się z nimi komunikować, zbadaliśmy działalność kóz i znaleźliśmy ten wzór, który jest rdzeniem języka.

Powiedz „Bleet” na długość każdego słowa. Oznacza to, że liczba „e” powinna wynosić (długość-3) dla słów dłuższych niż 3 litery. Powinieneś zmniejszyć „Bleet” dla słów krótszych niż „Blt”. Na przykład „be” staje się „bl”, ale „cat” i „boat” stają się „blt” i „blet”.

Wygląda na to, że tak naprawdę nie zmieniają znaków innych niż alfabet na „Bleet”. Nasze badania wykazały, że „Witaj, świecie!” Bleet to „Bleet, Bleet!” nie „Bleeet Bleeet”. Ponadto kozy nie są tak inteligentne (bez obrazy), więc wydaje się, że w ogóle nie rozumieją postaci innych niż ascii ani znaków diakrytycznych.

Teraz czas na tłumacza, by komunikował się z kozimi bogami.

Bleeeeet (znaczenie: przykłady)

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 bajtów

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

Wypróbuj online!

Wyjaśnienie

T`lL`e

Zamień wszystkie litery na es.

(?<!e)e
B

Włącz pierwszy ew każdym biegu B.

Be
Bl

Zamień się Bew Bl.

e(?!e)
t

Zmień ostatni ew każdym biegu t.

JavaScript (ES6), 79 77 74 bajtów

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

Alternatywne podejście, obecnie 83 78 bajtów:

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

Najlepsze, co mogłem zrobić rekurencyjnie, to 88 bajtów:

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 bajtów

preg_replace z tablicami (wymaga PHP 5.4 lub nowszego)

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

Uruchom go echo '<string>' | php -nR '<code>'lub przetestuj online .

awaria

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

Wersja 5: zapisano 9 bajtów za pomocą łańcucha wyrażeń regularnych Martina Endera .
^{(To także naprawiło przypadki z nie alfabetycznymi znakami słów = cyfry / podkreślenia.)}

Haskell , 135 128 bajtów

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

Wypróbuj online! Wykorzystanie (""!) $ "some string". Bez wyrażeń regularnych okazało się to dość długie, może inne podejście jest krótsze. Edycja: Zapisano 7 bajtów dzięki @nimi!

Perl 5 , 47 bajtów

Zaoszczędzono 15 bajtów, stosując tę ​​samą technikę, co odpowiedź Retina Martina Endera . (Ta odpowiedź jest teraz w zasadzie częścią jego odpowiedzi)

46 bajtów kodu + -pflaga.

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

Wypróbuj online!

Starsze wersje: 62 bajty:

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

I 68 bajtów:

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

PHP, 84 bajtów

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

PHP, 117 bajtów

<?=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 Bajtów

Praca dla „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];);}

Wynik jest teraz efektem ubocznym poprzez zniszczenie oryginalnego łańcucha.

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

Myślę, że to jest poprawne przynajmniej teraz

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 bajtów

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

Po prostu re.subłańcuch

Krok po kroku

Przykładowe dane wejściowe: „ Chwalimy boga kozła! ”

Alias ​​sub, dzięki czemu możemy zaoszczędzić bajty na powtarzanych połączeniach

import re
s=re.sub

Zamień wszystkie znaki słów na „e”

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

Wynik: ee eeeeee eee eeee eee!

Zamień wszystkie litery „e” poprzedzone granicą wyrazów (początek słowa) na „B”

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

Wynik: Be Beeeee Bee Beee Bee!

Zamień wszystkie „Be” na „Bl”

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

Wynik: Bl Bleeee Ble Blee Ble!

Zamień wszystkie „e”, po których następuje granica słowa na „t”

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

Wynik: Bl Bleeet Blt Blet Blt!

Pip , 28 bajtów

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

Pobiera dane wejściowe jako argument wiersza polecenia. Wypróbuj online!

Wyjaśnienie

To była świetna zabawa - musiałem używać modyfikatorów wyrażeń regularnych i interpolacji ciągów.

                              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 bajtów

Zdaję sobie sprawę, że jest to dość długa i cieszę się z sugestii dotyczących skrócenia długości.

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)

ułożone , 57 bajtów

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

Wypróbuj online! Pobiera dane wejściowe z góry stosu.

Niech a ( n ) = A136412 ( n - 2) = (5 × 4 ^{n - 2} + 1) ÷ 3. Przekształcenie a ( n ) na podstawę 4 daje:

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

Odwzorowując indeksy 0..3 na ciąg Blet, otrzymujemy:

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

Teraz prepending Bdaje nam pożądany ciąg, biorąc pod uwagę długość. Przeważnie. Wystarczy zająć się przypadkami specjalnymi dla n ≤ 2. W moim przypadku jest to rozwiązane przez odjęcie ( n - 2 <1) jako liczbową wartość logiczną (1 dla „true” i 0 dla „false”).

Jeśli chodzi o szczegóły odpowiedzi:

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

Python 2 , 137 114 bajtów

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

Wypróbuj online!

Java 7, 201 bajtów

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

Nie bardzo z tego zadowolony, a na pewno można jeszcze zagrać w golfa ..

Wyjaśnienie:

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

Kod testowy:

Wypróbuj tutaj.

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

Wynik:

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

05AB1E , 36 bajtów

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

Wypróbuj online! lub jako pakiet testowy

Wyjaśnienie

Przygotuj dane wejściowe:

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

Spowoduje to utworzenie listy, takiej jak ['hello', ', ', 'world', '!'] dane wejścioweHello, World!

Iterate over list:

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