(의미 : 영어를 Bleet로 변환)

우리는 염소를 신으로 칭찬 해 왔습니다.

그러나 우리가 영어를 염소 신의 언어 인 '블리트 (Bleet)'로 번역 할 수 없다면, 그들과 의사 소통 할 수 없습니다.

그래서 그들과 의사 소통하기 위해 염소의 활동을 조사하고 언어의 핵심 인이 패턴을 검색했습니다.

각 단어의 길이에 대해 'Bleet'이라고 말하십시오. 즉, 3 글자보다 긴 단어의 경우 'e'의 양은 (길이 -3)이어야합니다. 'Blt'보다 짧은 단어의 경우 'Bleet'을 줄이십시오. 예를 들어 'be'는 'bl'이되지만 'cat'과 'boat'는 'blt'와 'blet'이됩니다.

보이는 것처럼 알파벳이 아닌 문자를 실제로 'Bleet'로 변경하지는 않습니다. 우리의 연구는 'Hello, World!' 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

모든 글자를 es 로 바꿉니다.

(?<!e)e
B

e각 런 의 첫 번째 를로 바꿉니다 B.

Be
Bl

돌려 Be으로 Bl.

e(?!e)
t

e각 런 의 마지막 을로 바꿉니다 t.

자바 스크립트 (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 : Martin Ender의 정규식 체인으로 9 바이트를 절약했습니다 .
^{(알파벳이 아닌 단어 문자 = 숫자 / 밑줄이있는 경우도 수정되었습니다.)}

하스켈 , 135128 바이트

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". 정규 표현식이 없으면 이것은 상당히 길다는 것이 밝혀졌습니다. 어쩌면 다른 접근법은 더 짧을 수도 있습니다. 편집 : @nimi 덕분에 7 바이트가 절약되었습니다!

펄 5 , 47 바이트

Martin Ender의 Retina answer 와 동일한 기술을 사용하여 15 바이트를 절약했습니다 . (이 답변은 기본적으로 그의 답변의 포트입니다)

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 바이트

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

출력은 이제 원래 문자열을 파괴함으로써 부작용입니다.

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_

파이썬 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!

단어 경계 앞에 나오는 모든 "e"(단어 시작)를 "B"로 바꿉니다.

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

파이썬 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

온라인으로 사용해보십시오! 스택 맨 위에서 입력을받습니다.

하자 ( N ) = A136412 ( N - 2) = (5 × 4 ^{N - 2} + 1) ÷ 3. 변환 ( 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) = leeet
...

이제 prepending B은 길이에 따라 원하는 문자열을 제공합니다. 대개. 하나의 경우 n ≤ 2 의 특수한 경우 만 처리하면됩니다 . 제 경우에는 ( n -2 <1)를 숫자 부울로 빼서 ( "true"의 경우 1, "false"의 경우 0) 해결합니다.

답변의 세부 사항은 다음과 같습니다.

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

파이썬 2 , 137114 바이트

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

온라인으로 사용해보십시오!

자바 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