(Значення: Перетворити англійську на Bleet)

Ми вже багато років славимо козлів як бога.

Але якщо ми не можемо перекласти англійську мову на «Bleet», мову Божої Кози, ми не можемо з ними спілкуватися.

Отже, для спілкування з ними ми дослідили діяльність козлів та знайшли цю закономірність, яка є ядром мови.

Скажіть "Bleet" для довжини кожного слова. Це означає, що кількість слів має бути (довжина-3) для слів, що перевищують три літери. Вимкніть "Bleet" для слів, коротших за "Blt". Наприклад, "бути" стає "бл", але "кішка" і "човен" стає "блит" і "блет".

Як здається, вони насправді не змінюють символи, що не містять алфавіту, на "Bleet". Наше дослідження показало, що "Привіт, світ!" до Bleet - це "Bleet, Bleet!" не "Bleeet Bleeet". Крім того, Кози не такі розумні (без образи), тому, схоже, вони взагалі не розуміють символів чи діакритики.

Тепер саме час зробити перекладача для спілкування з козячими богами.

Bleeeeet (Значення: Приклади)

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

Сітківка , 31 байт

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

Спробуйте в Інтернеті!

Пояснення

T`lL`e

Перетворіть усі літери в es.

(?<!e)e
B

Перетворіть перших eу кожному циклі B.

Be
Bl

Перетвориться Beна Bl.

e(?!e)
t

Перетворіть останню eв кожному циклі t.

JavaScript (ES6), 79 77 74 байт

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

Альтернативний підхід, наразі 83 78 байт:

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

Найкраще, що я міг зробити рекурсивно, було 88 байт:

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 байт

preg_replace з масивами (потрібен PHP 5.4 або пізнішої версії)

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

Запустіть echo '<string>' | php -nR '<code>'або випробуйте його в Інтернеті .

зламатися

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

Версія 5: збережено 9 байт за допомогою ланцюга регулярних виразів Мартіна Ендера .
^{(Це також виправлено випадки з символами слова, що не містять алфавіту = цифри / підкреслення.)}

Haskell , 135 128 байт

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

Спробуйте в Інтернеті! Використання (""!) $ "some string". Без регулярних виразів це виявилося досить довгим, можливо, якийсь інший підхід коротший. Редагувати: Збережено 7 байт завдяки @nimi!

Perl 5 , 47 байт

Збережено 15 байт, використовуючи ту саму техніку, що і відповідь Мартіна Ендера на retina . (Ця відповідь - це в основному портрет його відповіді зараз)

46 байт коду + -pпрапор.

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

Спробуйте в Інтернеті!

Старіші версії: 62 байти:

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

І 68 байт:

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

PHP, 84 байт

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

PHP, 117 байт

<?=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 Байт

Робота над "Це тест Джиммі" -> 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];);}

Вихід тепер є побічним ефектом, знищуючи початковий рядок.

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

Я думаю, що це принаймні зараз

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 байт

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

Просто re.subланцюжок

Крок за кроком

Приклад введення: " Ми хвалимо Козла Бога! "

Псевдонім псевдонім, щоб ми могли зберігати байти при повторних дзвінках

import re
s=re.sub

Замініть усі символи слова на "e"

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

Вихід: ee eeeeee eee eeee eee!

Замініть всі "е", які передують межі слова (Початок слова) на "В"

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

Вихід: Be Beeeee Bee Beee Bee!

Замініть все "Бути" на "Бл"

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

Вихід: Bl Bleeee Ble Blee Ble!

Замініть всі "e" s, за якими межує слово, на "t"

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

Вихід: Bl Bleeet Blt Blet Blt!

Піп , 28 байт

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

Вводиться як аргумент командного рядка. Спробуйте в Інтернеті!

Пояснення

Це було весело - я мав використовувати модифікатори регулярних виразів та рядкову інтерполяцію.

                              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

Пітон 3, 271 байт

Я знаю, що це досить довго, і я вітаю пропозиції щодо зменшення довжини.

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)

складений , 57 байт

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

Спробуйте в Інтернеті! Здійснює введення з верхньої частини стека.

Нехай a ( n ) = A136412 ( n - 2) = (5 × 4 ^{n - 2} + 1) ÷ 3. Перетворення a ( n ) в основу 4 виходить:

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

Зіставивши індекси 0..3 у рядок Blet, отримаємо:

a (3) = lt
a (4) = нехай
a (5) = leet
a (6) = ліє
...

Тепер, попереднє додавання Bдає нам бажану рядок, враховуючи довжину. Переважно. Потрібно просто обробити особливі випадки для n ≤ 2. У моєму випадку це вирішується відніманням ( n - 2 <1) як числовим булевим (1 для "true" і 0 для "false").

Що стосується специфіки відповіді:

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

Пітон 2 , 137 114 байт

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

Спробуйте в Інтернеті!

Java 7, 201 байт

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

Не дуже задоволений цим, і, безумовно, можна пограти ще трохи ..

Пояснення:

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

Код тесту:

Спробуйте тут.

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

Вихід:

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

05AB1E , 36 байт

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

Спробуйте в Інтернеті! або як тестовий набір

Пояснення

Підготуйте вхід:

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

Це створює такий список, як ['hello', ', ', 'world', '!'] для введенняHello, World!

Повторити список:

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