내가 미래에 여행하는 동안, 나는 2275 년경 아이들 사이에서 재미있는 게임을 발견했습니다. 그들이 위대한 부모님이 그들의 말을 이해하기를 원하지 않을 때, 그들은 BIBABOBU 발언 을 사용합니다 . 분명히, 나는 사이보그 이전 시대의 두뇌로 아무것도 이해할 수 없었고 나는 정말로 어리석은 것을 느꼈다 (또는 기술적으로 : 나는 느낄 것이다 ). 그래서 다음 방문에는 디코더가 필요합니다.

비바 보부?

오랫동안 더 이상 사용되지 않지만 ASCII는 2275의 대중 문화에서 여전히 일반적으로 사용되며이 언어는이를 기반으로합니다.

문자열은 다음과 같이 BIBABOBU로 인코딩됩니다.

• 모든 문자를 ASCII 코드로 변환하십시오.

• 각 코드의 2 자리 16 진수 표현을 가져 와서 다음 표를 사용하여 변환하십시오.

  0: BI  4: BIDI  8: BADI  C: BODI
  1: BA  5: BIDA  9: BADA  D: BODA
  2: BO  6: BIDO  A: BADO  E: BODO
  3: BU  7: BIDU  B: BADU  F: BODU
  

예

"Hello!" → 48 65 6C 6C 6F 21 → "BIDIBADI BIDOBIDA BIDOBODI BIDOBODI BIDOBODU BOBA"

그러나 어린이가 임플란트없이 이해하기 어렵게하기 위해 사용하는 단조로운 억양을 모방 할 수있는 공간없이 해당 입력 이 제공됩니다.

"BIDIBADIBIDOBIDABIDOBODIBIDOBODIBIDOBODUBOBA"

설명 및 규칙

• 인코더가 아닌 디코더 가 필요하다는 것을 기억하십시오 .
• 디코딩 된 문자는 [32 ... 126] 범위에 있어야합니다 .
• 입력에는 짝수의 BIBABOBU 인코딩 16 진수가 포함됩니다.
• 소문자 또는 대문자로 입력 할 수 있습니다. 혼합 사례는 허용되지 않습니다.
• 비트 플립은 시간 이동 중에 매우 일반적이므로 위험을 최소화하기 위해 코드 골프 입니다.

테스트 사례

주의 : 아래의 줄 바꿈은 서식 지정 목적으로 만 사용됩니다. 당신은 그들을 처리 해서는 안됩니다 .

Input:
BIDABIDIBIDOBIDABIDUBUBIDUBIDI

Output:
Test

Input:
BIDABIDUBIDOBIDABIDOBODIBIDOBUBIDOBODUBIDOBODABIDOBIDABOBIBIDUBIDIBIDOBODUBOBIBUBOBUBOBUBI
DUBUBIDABOBA

Output:
Welcome to 2275!

Input:
BIDIBADIBIDOBIDABIDOBODIBIDOBODIBIDOBODUBOBODIBOBIBIDABIDIBIDOBADABIDOBODABIDOBIDABOBIBIDA
BIDIBIDUBOBIDOBABIDUBIDOBIDOBIDABIDOBODIBIDOBIDABIDUBOBOBABOBIBIDABADABIDOBODUBIDUBIDABOBI
BIDOBODIBIDOBODUBIDOBODUBIDOBADUBOBIBIDUBUBIDOBODUBOBIBIDOBIDOBIDUBIDABIDOBODOBIDOBODOBIDU
BADABOBA

Output:
Hello, Time Traveler! You look so funny!

Input:
BIDIBABIDOBODOBIDOBIDIBOBIBIDUBADABIDOBODUBIDUBIDABOBIBIDOBIDIBIDOBODUBIDOBODOBOBIDUBIDUBI
DIBOBIBIDUBIDABIDOBODOBIDOBIDIBIDOBIDABIDUBOBIDUBUBIDUBIDIBIDOBABIDOBODOBIDOBIDIBOBIBIDUBI
DUBIDOBADIBIDOBABIDUBIDIBOBIBIDIBADABOBIDUBIDOBODABOBIBIDUBUBIDOBABIDUBADABIDOBADABIDOBODO
BIDOBIDUBOBODIBOBIBIDOBIDIBIDOBODUBOBIBIDUBADABIDOBODUBIDUBIDABUBODUBOBIBIDIBADIBIDOBABOBI
BIDOBADIBIDOBABOBIBIDOBADIBIDOBABOBA

Output:
And you don't understand what I'm saying, do you? Ha ha ha!

05AB1E , 36 35 33 바이트

Mr.Xcoder 덕분에 1 바이트 절약 KevinCruijssen 덕분에
2 바이트 절약

ć©¡®ì®D…IAO©â'D«‚˜®'U«âJskh2ôJHçJ

온라인으로 사용해보십시오! 또는 테스트 스위트

설명

ć©¡                                 # extract the head ("B") and split input on it
   ®ì                              # prepend "B" to each
     ®D                            # push 2 copies of "B"
       …IAO©â                      # cartesian product with "IAO"
             'D«                   # append "D" to each
                ‚˜                 # add the leftover "B" to the list
                  ®'U«â            # cartesian product with "IAOU"
                       J           # join each to string
                        sk         # get the index of each word of the input in this list
                          h        # convert each to hex
                           2ôJ     # format as pairs of chars
                              H    # convert to int
                               çJ  # convert from ascii-codes to string

젤리 , 26 24 23 22 20 17 15 바이트

ṣḢO^1%9%4Ḅḅ⁴b⁹Ọ

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

작동 원리

ṣḢO^1%9%4Ḅḅ⁴b⁹Ọ  Main link. Argument: s (string)

 Ḣ               Head; remove and yield the first character of s.
ṣ                Split s at occurrences of the result ('B').
  O              Ordinal; map "IAOUD" to A1 := [73, 65, 79, 85, 68].
   ^1            Bitwise XOR 1; map A1 to A2 := [72, 64, 78, 84, 69].
     %9          Modulo 9; map A2 to A3 := [0, 1, 6, 3, 6].
       %4        Modulo 4; map A3 to A4 := [0, 1, 2, 3, 2].
                 So far, we've mapped "BX" to [x] and "BXDY" to [x, 2, y],
                 where x/y = 0, 1, 2, 3 when X/Y = I, A, O, U.
         Ḅ       Unbinary; map [x] to x and [x, 2, y] to 4x + 2×2 + y = 4(x + 1) + y.
          ḅ⁴     Convert the resulting array from base 16 to integer.
            b⁹   Convert the resulting integer to base 256.
              Ọ  Unordinal; replace code points with their characters.

펄 6 , 58 바이트

{S:g{(B.[D.]?)**2}=chr :16[$0».&{:2[.ords»³X%87 X%4]}]}

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

Dennis 'Jelly 솔루션에 큰 영향을 받았습니다. 다른 마법 기능 사용 x³ % 87 % 4도의 ASCII 코드 매핑 IAOUBD에를 012302.

대체 75 74 바이트 버전

Jo King 덕분에 -1 바이트

{pack('H',.trans((<B BID BAD BOD>X~ <I A O U>)=>(^16)».base(16))).decode}

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

대체 85 바이트 버전

{S:g[....]=chr :4(~$/)*2+|221+^:4(~$/)+^238}o{TR:d/UIAOBD/0123/}o{S:g[B.<![D]>]=0~$/}

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

파이썬 2 , 100 97 96 95 바이트

^{ovs 덕분에
-1 바이트 GB 덕분에 -1 바이트}

lambda w:''.join(' 1023546798abdcef'[int(c,35)/7%77%18]for c in w.split('B')[1:]).decode("hex")

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

Perl 5 -p, 67 바이트

for$p(<{B,0D,1D,2D}{I,A,O,U}>){s/$p/chr$i+48/ge;$i++}$_=pack'H*',$_

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

05AB1E (레거시), 68 65 60 59 바이트

.•5Ç¿ÆΓ•2ô.•1ÒKá ¸ΓìŸÆt`ô_zTºγ„KRI‰ι놽òι•4ô«I¬©¡®ìkh2ôJHçJ

입력이 소문자입니다.

@Emigna가로 변경 'b¡εg>}s£되어 암시 적으로 -3 바이트 'b©¡®ì.

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

또한 거대한 압축 줄보다 더 똑똑한 것으로 골프를 칠 수 있습니다. 나중에 다시 살펴볼 것입니다. @Emigna가 이미 제공 한 짧은 답변 이므로 그를 투표 해야합니다!

설명:

.•5Ç¿ÆΓ•      # Compressed string "bibabobu"
        2ô    # Split in parts of 2
              #  → ["bi","ba","bo","bu"]
.•1ÒKá ¸ΓìŸÆt`ô_zTºγ„KRI‰ι놽òι•
              # Compressed string "bidibidabidobidubadibadabadobadubodibodabodobodu"
        4ô    # Split in parts of 4
              #  → ["bidi","bida","bido","bidu","badi","bada","bado","badu","bodi","boda","bodo","bodu"]
«             # Merge both lists together
              #  → ["bi","ba","bo","bu","bidi","bida","bido","bidu","badi","bada","bado","badu","bodi","boda","bodo","bodu"]
I¬©¡          # Take the input and split on the head (always 'b')
              #  i.e. "bidibadibidobidabidobodibidobodibidoboduboba"
              #   → ["idi","adi","ido","ida","ido","odi","ido","odi","ido","odu","o","a"]
    ®ì        # And prepend a 'b' to each item again
              #  i.e. ["idi","adi","ido","ida","ido","odi","ido","odi","ido","odu","o","a"] 
              #   → ["bidi","badi","bido","bida","bido","bodi","bido","bodi","bido","bodu","bo","ba"]
k             # Map each item to the index of the first list
              #   i.e. ["bidi","badi","bido","bida","bido","bodi","bido","bodi","bido","bodu","bo","ba"]
              #    → [4,8,6,5,6,12,6,12,6,15,2,1]
 h            # Convert everything to hexadecimal
              #  i.e. [4,8,6,5,6,12,6,12,6,15,2,1]
              #   → ["4","8","6","5","6","C","6","C","6","F","2","1"]
  2ôJ         # Split it in parts of 2 and join them together
              #  i.e. ["4","8","6","5","6","C","6","C","6","F","2","1"]
              #   → ["48","65","6C","6C","6F","21"]
     H        # Convert that from hexadecimal to an integer
              #  i.e. ["48","65","6C","6C","6F","21"] → [72,101,108,108,111,33]
      ç       # And take its ASCII value
              #  i.e. [72,101,108,108,111,33] → ["H","e","l","l","o","!"]
       J      # Then join everything together (and output implicitly)
              #  i.e. ["H","e","l","l","o","!"] → "Hello!"

펄 6 , 88 86 84 바이트

{S:g{B(.*?)B(.D.|.)}=chr :16[$/.map:{first :k,~$_,("",|<ID AD OD UD>X~ <I A O U>)}]}

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

R , 141135 바이트

function(x,y="I":"A":"O")intToUtf8(matrix(match(el(strsplit(gsub("D","",x),"B"))[-1],paste0(rep("":y,e=4),y:"U"))-1,,2,T)%*%16:1)
":"=c

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

6 바이트를 절약 한 JayCe 에게 감사 합니다!

일부 모듈 식 마술을 사용하는 것이 더 짧을 수도 있지만 순진한 첫 번째 패스로 이것에 매우 만족합니다.

apt, 43 29 28 바이트

의심 할 여지없이 Dennis 'Jelly 솔루션 포트는 훨씬 짧습니다.

문자 배열을 출력합니다.

Åqbu)®¬®c ^1 %9%4Ãì2Ãò ®ìG d

시도 해봐

원본, 42 바이트

Åqb £`bbidbad¾d`ò3n)ï`ia`q)m¬bXibÃò ®ìG d

시도 해봐

설명

Åqb £`bbidbad¾d`ò3n)ï`ia`q)m¬bXibÃò ®ìG d
Å                                              :Slice off the first character
 qb                                            :Split on "b"
    £                                          :Map
     `bbidbad¾d`                               :  Compressed string "bbidbadbod"
                ò3n)                           :  Partition at every 3rd character from the end (["b","bid","bad","bod"])
                    ï                          :  Cartesian product
                     `ia`                      :   Compressed string "iaou"
                          q                    :   Split
                           )                   :  End Cartesian product
                            m                  :  Map
                             ¬                 :   Join
                              b                :  Index of
                               X               :   Current element
                                ib             :   Prepend "b"
                                  Ã            :End map
                                   ò           :Partition at every second element
                                     ®         :Map
                                      ìG       :  Convert from base-16 digit array to base-10 integer
                                         d     :  Get the character at that codepoint

C (GCC) , 181 (138) 136 바이트

이 컴파일을 위해 앞으로 C 컴파일러가 있기를 바랍니다. :-)

Max Yekhlakov와 ceilingcat에게 감사의 말을 전합니다.

v,t,c,d;f(char*s){for(v=t=c=0;d=*s++;)t+=d==66?v=v*16+t,++c>2?v=!putchar(v),c=1:0,-t:d-65?d-79?d-68?d-85?0:3:4+t*3:2:1;putchar(v*16+t);}

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

미래의 C 컴파일러가 BIBABOBU-ified ASCII 만 이해하는 경우 :-)

BIDUBIDOBOBODIBIDUBIDIBOBODIBIDOBUBUBADUBIDOBIDOBOBADIBIDOBUBIDOBADIBIDOBABIDUBOBOBADOBIDUBUBOBADABIDUBADUBIDOBIDOBIDOBODUBIDUBOBOBADIBIDUBIDOBUBODABIDUBIDIBUBODABIDOBUBUBODABUBIBUBADUBOBADOBIDUBUBUBADUBIDUBUBOBADUBOBADUBOBADABIDUBIDIBOBADUBUBODABOBADOBIDUBUBUBODABUBODABUBIDOBUBIDOBUBODUBIDUBIDOBUBODABIDUBIDOBOBADOBUBABUBIDOBOBADUBIDUBIDIBOBODIBOBADUBOBADUBIDOBUBUBODOBUBOBUBODUBIDUBIDOBUBODABOBABIDUBIBIDUBIDABIDUBIDIBIDOBUBIDOBADIBIDOBABIDUBOBOBADIBIDUBIDOBOBADABOBODIBIDOBUBUBODABUBABUBADOBUBIBOBODIBOBODABIDUBIDIBUBADOBOBADOBIDUBUBOBODABUBIDOBUBIDABUBODUBOBADOBIDUBUBOBODABUBIDUBUBADABUBODUBOBADOBIDUBUBOBODABUBIDOBUBADIBUBODUBOBADOBIDUBUBOBODABUBADIBUBIDABUBODUBUBIBUBADOBUBUBUBADOBUBIDIBOBADUBIDUBIDIBOBADOBUBUBUBADOBUBOBUBADOBUBABUBADUBIDUBIBIDUBIDABIDUBIDIBIDOBUBIDOBADIBIDOBABIDUBOBOBADIBIDUBIDOBOBADOBUBABUBIDOBOBADUBIDUBIDIBOBADABUBADUBIDUBODA

(엔코더 온라인 시도! )

자바 스크립트 (Node.js를) , (131) 128 바이트

s=>unescape(s.replace(/B.(D.)?/g,(f,s)=>(-~g(f[1])*4*!!s+g((s||f)[1])).toString(16),g=c=>'IAOU'.search(c)).replace(/../g,'%$&'))

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다. 대체 버전, 131 바이트 :

s=>unescape(s.replace(/B.(D.)?/g,s=>(-~g(s[1])*4*!!s[3]+g(s[3]||s[1])).toString(16),g=c=>'IAOU'.search(c)).replace(/../g,'%$&'))

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다. 편집 : @Shaggy 덕분에 3 바이트를 절약합니다.

Bash + 공통 Linux 유틸리티, 75 바이트

sed $(printf `printf %s s/{B{O,A,I}D,B}{U,O,A,I}/%x/g\;` {15..0})|xxd -r -p

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

스칼라 , 305 바이트

글쎄, 나는 이것이 골프를 칠 수 있다고 확신한다. 그러나 여전히 존재합니다. 소문자를 입력합니다. fstdout에 결과를 인쇄합니다.

편집 : 더 이상 바보하지 않습니다 덕분에 -8 문자 (공백); 분화구 덕분에 -13 문자

var k=Seq("bi","ba","bo","bu")
k++=k.init.flatMap(a=>Seq("di","da","do","du").map(a+_))//Putting "bu" here instead of at line 1, and in place of using init, would be interesting... if it did not cause a typing problem
var m=Seq[String]()
def g(a:Seq[String],b:Int)=k.indexOf(a(b)).toHexString
def f(a:String){a.split('b').drop(1).foreach(x=>m:+="b"+x)
var i=0
while(i<m.length){print(Integer.parseInt(g(m,i)+g(m,i+1),16).toChar)
i+=2}}

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

파이썬 (2) , 142 (139) 127 118 바이트

lambda s:''.join(chr(16*a+b)for a,b in zip(*[iter(4*F(l[:-2])+F(l[-1])-1for l in s.split('B')[1:])]*2));F=' IAOU'.find

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

파이썬 2 , 93 바이트

lambda w:''.join('c60238e4d1_b7f95a'[hash(x)%3046%17]for x in w.split('B')[1:]).decode('hex')

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

루비 , 86 75 바이트

->s{[s.gsub(/B[^B]+/){|x|"546798ABDCEF1023"[x.to_i(31)/7%38%20]}].pack'H*'}

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

Dyalog APL, 74 72 바이트

Dyalog APL의 초보자 수준 솔루션 (방금 며칠 전에 이것을 배우기 시작했습니다!). 하나의 올바른 인수 (입력)를 취하는 dfn을 정의합니다. dyalog 인코딩 사용시 72 자, 72 바이트 05AB1E의 Emigna 솔루션을 기반으로합니다.

{⎕UCS 16⊥¨(1 0⍴⍨≢t)⊂1-⍨(,('B',('B'∘.,'IAO'),¨'D')∘.,'IAOU')⍳t←('B'⍷⍵)⊂⍵}

젤리 , 39 바이트

®+“IAO”+”D®;p“IAOU”Ẏ€
=”B©œṗµḊ¢iⱮ’s2ḅ⁴Ọ

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

사용 된 기술은 Emigna 와 매우 유사합니다 . 나는 이것을 더 빨리 골프 할 것입니다.

Brain-Flak , 178 바이트

{(([((((()()()()){}){}){}()){}]{}){{}<>(({}){}){}(<>)}{}<({}(<>))(<>)((()()()())({})()){{(({})){({}[()])<>}{}}<>({}<>)<>{}}{}><>{}{})<>}<>([]){{}({}(((({}){}){}){}){}<>)<>([])}<>

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

설명

# Step 1: convert to hex.
# For each pair of letters in the input:
{

  (

    # Compare first letter to B
    ([((((()()()()){}){}){}()){}]{})

    # If not B, pop previous output, multiply by 4, and put on third stack.
    # 4 is added automatically from pushing/popping the difference
    # between the letters B and D.
    {{}<>(({}){}){}(<>)}{}

    <

      # Push second letter in pair to other stack
      ({}(<>))

      # Push 4 and 9
      (<>)((()()()())({})())

      # Compute 3-((8-(n mod 9)) mod 4)
      # (same as (n-1) mod 9 mod 4)
      {{(({})){({}[()])<>}{}}<>({}<>)<>{}}{}

    >

    # Add result to third stack (either 0 or 4*previous+4)
    <>{}{}

  # Push onto second stack
  )

<>}

# Step 2: Pair up hex digits.
# While digits remain on right stack:
<>([]){{}

  # Push top of stack + 16*second on stack to left stack
  ({}(((({}){}){}){}){}<>)<>

([])}

# Switch to left stack for output.
<>

05AB1E , 30 바이트

ć¡Ç1^9%4%εDg≠i421øP]€OžvβžzвçJ

@Dennis 포트 '미친 젤리 답변 (편리한 내장으로). 따라서 그를 찬성해야합니다!

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

ć¡             # Split the input-string on its first character ('B')
               #  i.e. "BIDABIDIBIDOBIDABIDUBUBIDUBIDI"
               #   → ["IDA","IDI","IDO","IDA","IDU","U","IDU","IDI"]
  Ç            # Convert each character to it's ordinal value
               #  → [[73,68,65],[73,68,73],[73,68,79],[73,68,65],[73,68,85],85,[73,68,85],[73,68,73]]
   1^          # XOR it by 1
               #  → [[72,69,64],[72,69,72],[72,69,78],[72,69,64],[72,69,84],84,[72,69,84],[72,69,72]]
     9%        # Take modulo-9
               #  → [[0,6,1],[0,6,0],[0,6,6],[0,6,1],[0,6,3],3,[0,6,3],[0,6,0]]
       4%      # Take Modulo-4
               #  → [[0,2,1],[0,2,0],[0,2,2],[0,2,1],[0,2,3],3,[0,2,3],[0,2,0]]
ε         ]    # Now map it to:
 Dg≠i          # If the length is not 1:
               #  i.e. [0,2,1] → 3 → 1 (truthy)
               #  i.e. 3 → 1 → 0 (falsey)
     421øP     # Multiply the first number by 4, second by 2, and third by 1
               #  i.e. [0,2,1] and [4,2,1] → [[0,4],[2,2],[1,1]] → [0,4,1]
           €O  # Then sum every inner list
               #  [[0,4,1],[0,4,0],[0,4,2],[0,4,1],[0,4,3],3,[0,4,3],[0,4,0]]
               #   → [5,4,6,5,7,3,7,4]
žvβ            # Convert this list from base-16 to base-10
               #  → 1415934836
   žzв         # Convert this integer from base-10 to base-256
               #  → [84,101,115,116]
      ç        # Convert this number to ASCII characters
               #  → ["T","e","s","t"]
       J       # Join the characters together (and output implicitly)
               #  → "Test"

Java (JDK 10) , 199 바이트

s->{var z="";for(var x:s.substring(1).split("B")){int d=-1;for(var y:x.split("D"))d=-~d*4+"IAOU".indexOf(y);z+=(char)(d>9?d+55:d+48);}return new String(new java.math.BigInteger(z,16).toByteArray());}

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

크레딧

• Arnauld 덕분에 -2 바이트

와 VBA (엑셀), 놀라운 322 244 바이트

그래, 나는 사랑 16 진수. (sarcasm 글꼴은 아직 없기 때문에 지금은 기울임 꼴을 사용하고 있습니다.) 누군가 원한다면 주석을 추가 할 것이지만 설명이 필요하다고 생각합니다. 골프가 발생했습니다.

Sub b(s)
For Each c In Split(Replace(s,"D",""),"B")
c=Application.Match(c,Array("I","A","O","U","II","IA","IO","IU","AI","AA","AO","AU","IO","OA","OO","OU"),0)
If Not IsError(c)Then d=d &c-1:If Len(d)=2Then e=e &Chr("&h"&d):d=""
Next
Debug.?e
End Sub

의견 :

Sub b(s)
  'For each string between B's (Remove the D's first)
  For Each c In Split(Replace(s,"D",""),"B")
    'Get the index of the element in the array (Can cause error if empty)
    c = Application.Match (c,Array("I","A","O","U","II","IA","IO","IU","AI","AA","AO","AU","IO","OA","OO","OU"),0)
    'If c isn't an error
    If Not IsError(c) Then
      'Subtract 1 from c and add to d  --> Array index is 1 based
      d = d & (c-1)
      'If d is 2 characters
      If Len(d)=2 Then
        'Add the char from the hex value of d   --> &h forces Hex
        e = e & Chr("&h" & d)
        'Reset d
        d = ""
      End if
    End if
  Next
  'Print the output
  Debug.Print e
End Sub

나는 이것을 VB Immediate Window로 가져 오려고 시도했지만 거기에서 작동하지 않는 것 같습니다. 또한 Match 문을 괄호 안에 넣고 싶었지만 매번 자동 오류가 발생합니다. 도움에 감사드립니다 : D

Haxe , 228 바이트

s->{var l=(u,i)->((i=u.charCodeAt(i))&8==8?0:1)|((i>>1)&2),p=s.split("B"),i=-1,q,o;[while((i+=2)<p.length)String.fromCharCode(l(q=p[i+1],o=q.length-1)+((o>1?l(q,0)+1:0)+((l(q=p[i],o=q.length-1)+o*(l(q,0)+1)*2)*4))*4)].join("");}

최고는 아니지만 표준 라이브러리 함수 이름이 너무 큽니다. (

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

Pyth, 35 바이트

mCid16cm+4imx"IAOU"k.[N2d4tc-Q\D\B2

문자 목록으로 출력합니다.
여기 사용해보십시오

설명

mCid16cm+4imx"IAOU"k.[N2d4tc-Q\D\B2
                          tc-Q\D\B   Get the vowels associated with each digit.
       m            .[N2d            Pad with a quote.
           mx"IAOU"k                 Find each character's position.
        +4i              4           Convert to base 4 and add 4.
      c                           2  Split the result into pairs.
mCid16                               Get the associated ASCII characters.

숯 , 36 바이트

ＦＳ≡ιB⊞υ⁰D⊞υ×⁴⊕⊟υ⊞υ⁺⊟υ⊕⌕AOUι⭆⪪υ²℅↨ι¹⁶

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

ＦＳ≡ι

각 입력 문자를 반복하고 전환하십시오.

B⊞υ⁰

이 경우 사전 정의 된 빈 목록으로 B푸시 0하십시오.

D⊞υ×⁴⊕⊟υ

이 경우 D마지막 값을 팝하고 값을 곱한 4다음 다시 곱 하십시오.

⊞υ⁺⊟υ⊕⌕AOUι

그렇지 않으면 string에서 색인을 찾아서 AOU증가시킨 후 마지막 값에 추가하십시오.

⭆⪪υ²℅↨ι¹⁶

목록을 값 쌍으로 나누고 16 진수로 디코딩하고 ASCII로 변환 한 후 암시 적으로 인쇄합니다.

클린 , 145134 바이트

import StdEnv                   // import things like addition and comparison
?c=(743rem(toInt c))/16         // magical formula that maps ['IAOU'] to [0,1,2,3]
@[_,b,'D',d:t]=[?d+ ?b*4+4: @t] // convert B#D#
@[_,b:t]=[?b: @t]               // convert "B#"
@_=[]                           // handle base case
$[u,v:t]=[u<<4+v: $t]           // turn the digits into 2-digit numbers
$e=e                            // handle base case

toString o$o@                   // convert to string (make numbers (make digits))

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

설명 :

PHP, 119 바이트

foreach(explode(B,$argn)as$i=>$m)($v=$v*16+4*strpos(XIAO,$m[-3]?:B)+strpos(IAOU,$m[-1]?:B))?$i&1||print chr($v&=255):0;

대문자 입력을 가정합니다. 파이프로 실행 -nR하거나 온라인으로 사용해보십시오 .

PHP 7.1을 필요로
오래된 PHP, 사용 substr($m,-3,1)및 substr($m,-1)대신 $m[-<x>](16 바이트);
젊은 PHP를 들어, 넣어 B, XIAO그리고 IAOU따옴표로 경고 메시지 (10 바이트)를 방지하기 위해.

05AB1E , 40 바이트

'B"IAOU"©âÐUs'D®ââJ)˜sXíDεSðý}:#khJ2ôHçJ

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

PHP, 163 바이트

function f($s){$t=[I=>0,A=>1,O=>2,U=>3];for($q=explode(B,$s);$a=&$q[++$i];){$a=($a[1]?($t[$a[0]]+1)*4:0)+$t[$a[2*($a[1]==D)]];$i%2?:print(chr(($q[$i-1]<<4)+$a));}}

f(string $s)적절한 바이 바보 부로 인코딩 된 문자열을 호출 하면 디코딩 된 문자열이 인쇄됩니다.

파이썬 3, 199 바이트

import re
lambda s:''.join(eval(re.sub(r'(\d+), (\d+)',r'chr(16*\1+\2)',str(eval(s.replace('I','1').replace('A','2').replace('O','3').replace('U','4').replace('B',',-1+').replace('D','*4+')[1:])))))

가장 짧지는 않지만 루프가 없습니다.