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

Мы восхваляли коз как бога уже много лет.

Но если мы не можем перевести английский на «Bleet», язык козьего бога, мы не сможем с ними общаться.

Итак, чтобы общаться с ними, мы исследовали деятельность коз и извлекли эту модель, которая является ядром языка.

Скажите «Bleet» для длины каждого слова. Это означает, что количество «е» должно быть (длина-3) для слов длиннее 3 букв. Вы должны сократить «Bleet» для слов короче «Blt». Например, «be» становится «bl», а «cat» и «boat» становятся «blt» и «blet».

Похоже, что они на самом деле не меняют не алфавитные символы на «Bleet». Наше исследование показало, что «Привет, мир!» Bleet это "Bleet, Bleet!" не Bleeet Bleeet. Кроме того, козлы не такие умные (без обид), поэтому они, похоже, совсем не понимают не-ascii персонажей или диакритических знаков.

Теперь пришло время заставить переводчика общаться с богами козлов.

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

Превратить все буквы в eс.

(?<!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]);

С 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

Заменить все символы слова на «е»

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

Выход: ee eeeeee eee eeee eee!

Заменить все «е», которым предшествует граница слова (начало слова), буквой «В»

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

Выход: Be Beeeee Bee Beee Bee!

Заменить все "Be" на "Bl"

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

Выход: Bl Bleeee Ble Blee Ble!

Заменить все буквы "e", за которыми следует граница слова, буквой "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

Python 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
а (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.

Python 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