Mientras viajaba en el futuro, noté un juego divertido entre los niños alrededor del año 2275. Cuando no quieren que sus tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-tatara-, tatara-tatara-tatara-tatara tienen para hablar lo que están diciendo, usan el discurso BIBABOBU . Obviamente, tampoco podía entender nada con mi cerebro de la era anterior al cyborg y me sentí (o técnicamente: me sentiré ) realmente tonto. Entonces, necesitaría un decodificador para mi próxima visita.

BIBABOBU?

Si bien ha quedado en desuso durante mucho tiempo, ASCII todavía se usa comúnmente en la cultura pop de 2275 y este lenguaje se basa en él.

Una cadena está codificada en BIBABOBU de esa manera:

• Convierta todos los caracteres a sus códigos ASCII.

• Tome la representación hexadecimal de 2 dígitos de cada código y conviértalos usando la siguiente tabla:

  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
  

Ejemplo

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

Sin embargo, la entrada correspondiente se daría sin espacio para imitar la entonación monótona que los niños están usando para hacer esto aún más difícil de entender sin implantes:

"BIDIBADIBIDOBIDABIDOBODIBIDOBODIBIDOBODUBOBA"

Aclaraciones y reglas.

• Recuerda que necesito un decodificador , no un codificador.
• Los caracteres decodificados están garantizados para estar en el rango [32 ... 126] .
• Se garantiza que la entrada contiene un número par de dígitos hexadecimales codificados con BIBABOBU.
• Puede tomar la entrada en minúsculas o mayúsculas. No se permiten casos mixtos.
• Debido a que los cambios de bit son bastante comunes durante un viaje en el tiempo, este es un código de golf para minimizar los riesgos.

Casos de prueba

Nota: los avances de línea se utilizan a continuación solo con fines de formateo. Se supone que no debes manejarlos.

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 bytes

Guardado 1 byte gracias a Mr.Xcoder
Guardado 2 bytes gracias a KevinCruijssen

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

Pruébalo en línea! o como un conjunto de pruebas

Explicación

ć©¡                                 # 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

Gelatina , 26 24 23 22 20 17 15 bytes

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

Pruébalo en línea!

Cómo funciona

ṣḢ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.

Perl 6 , 58 bytes

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

Pruébalo en línea!

Muy inspirado por la solución Jelly de Dennis. Utiliza una función mágica diferente x³ % 87 % 4que también asigna los códigos ASCII de IAOUBDa 012302.

Versión alternativa de 75 74 bytes

-1 byte gracias a Jo King

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

Pruébalo en línea!

Versión alternativa de 85 bytes

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

Pruébalo en línea!

Python 2 , 100 97 96 95 bytes

^{-1 byte gracias a ovs
-1 byte gracias a GB}

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

Pruébalo en línea!

Perl 5 -p, 67 bytes

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

Pruébalo en línea!

05AB1E (heredado), 68 65 60 59 bytes

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

La entrada está en minúsculas.

-3 bytes implícitamente gracias a @Emigna cambiando 'b¡εg>}s£a 'b©¡®ì.

Pruébelo en línea o verifique todos los casos de prueba .

Además, definitivamente se puede jugar con algo más inteligente que las enormes cuerdas comprimidas. Echaremos otro vistazo más adelante. Respuesta más corta ya proporcionada por @Emigna , ¡así que asegúrese de votarlo!

Explicación:

.•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!"

Perl 6 , 88 86 84 bytes

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

Pruébalo en línea!

R , 141 135 bytes

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

Pruébalo en línea!

¡Gracias a JayCe por guardar 6 bytes!

Es probable que usar algo de magia modular sea más corto, pero estoy bastante contento con esto como un primer paso ingenuo.

Japt, 43 29 28 bytes

Como era de esperar, un puerto de la solución Jelly de Dennis funciona mucho más corto.

Emite una matriz de caracteres.

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

Intentalo

Original, 42 bytes

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

Intentalo

Explicación

Å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 bytes

¡Esperemos que haya un compilador de C en el futuro para compilar esto! :-)

Gracias a Max Yekhlakov y ceilingcat por las sugerencias.

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

Pruébalo en línea!

En caso de que el compilador C del futuro solo comprenda ASCII BIBABOBU-ified :-)

BIDUBIDOBOBODIBIDUBIDIBOBODIBIDOBUBUBADUBIDOBIDOBOBADIBIDOBUBIDOBADIBIDOBABIDUBOBOBADOBIDUBUBOBADABIDUBADUBIDOBIDOBIDOBODUBIDUBOBOBADIBIDUBIDOBUBODABIDUBIDIBUBODABIDOBUBUBODABUBIBUBADUBOBADOBIDUBUBUBADUBIDUBUBOBADUBOBADUBOBADABIDUBIDIBOBADUBUBODABOBADOBIDUBUBUBODABUBODABUBIDOBUBIDOBUBODUBIDUBIDOBUBODABIDUBIDOBOBADOBUBABUBIDOBOBADUBIDUBIDIBOBODIBOBADUBOBADUBIDOBUBUBODOBUBOBUBODUBIDUBIDOBUBODABOBABIDUBIBIDUBIDABIDUBIDIBIDOBUBIDOBADIBIDOBABIDUBOBOBADIBIDUBIDOBOBADABOBODIBIDOBUBUBODABUBABUBADOBUBIBOBODIBOBODABIDUBIDIBUBADOBOBADOBIDUBUBOBODABUBIDOBUBIDABUBODUBOBADOBIDUBUBOBODABUBIDUBUBADABUBODUBOBADOBIDUBUBOBODABUBIDOBUBADIBUBODUBOBADOBIDUBUBOBODABUBADIBUBIDABUBODUBUBIBUBADOBUBUBUBADOBUBIDIBOBADUBIDUBIDIBOBADOBUBUBUBADOBUBOBUBADOBUBABUBADUBIDUBIBIDUBIDABIDUBIDIBIDOBUBIDOBADIBIDOBABIDUBOBOBADIBIDUBIDOBOBADOBUBABUBIDOBOBADUBIDUBIDIBOBADABUBADUBIDUBODA

(Codificador ¡ Pruébelo en línea! )

JavaScript (Node.js) , 131128 bytes

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,'%$&'))

Pruébalo en línea! El enlace incluye casos de prueba. Versión alternativa, también 131 bytes:

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,'%$&'))

Pruébalo en línea! El enlace incluye casos de prueba. Editar: ahorra 3 bytes gracias a @Shaggy.

Bash + utilidades comunes de Linux, 75 bytes

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

Pruébalo en línea!

Scala , 305 bytes

Bueno, estoy bastante seguro de que esto se puede jugar. Pero aún así, existe. Toma la entrada en minúscula. fimprime el resultado en stdout.

EDITAR: -8 caracteres gracias a que ya no soy tonto (espacios); -13 caracteres gracias a crater2150

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

Pruébalo en línea!

Python 2 , 142 139 127 118 bytes

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

Pruébalo en línea!

Python 2 , 93 bytes

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

Pruébalo en línea!

Ruby , 86 75 bytes

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

Pruébalo en línea!

Dyalog APL, 74 72 bytes

Solución de nivel principiante en Dyalog APL (¡recién comencé a aprender esto hace un par de días!). Define un dfn que toma un argumento correcto (la entrada). 72 caracteres, 72 bytes cuando se usa la codificación dyalog. Basado en la solución de Emigna en 05AB1E.

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

Jalea , 39 bytes

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

Pruébalo en línea!

La técnica utilizada es muy similar a la de Emigna . Voy a jugar al golf más pronto, con suerte.

Brain-Flak , 178 bytes

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

Pruébalo en línea!

Explicación

# 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 bytes

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

Puerto de la respuesta de jalea loca de @Dennis (solo con incorporaciones menos convenientes). ¡Así que asegúrate de votarlo!

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

ć¡             # 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 bytes

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

Pruébalo en línea!

Créditos

• -2 bytes gracias a Arnauld

VBA (Excel), con un increíble 322 244 bytes

Sí, y ME ENCANTA el hexadecimal. (Todavía no hay una fuente de sarcasmo, por lo que estoy usando cursiva por ahora) Agregaré comentarios si alguien quiere, pero creo que se explica por sí mismo. El golf sucedió.

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

Con comentarios:

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

Realmente intenté poner esto en la Ventana Inmediata de VB, pero no parece funcionar allí ... creo que cortaría 11 caracteres. También quería poner la declaración Match entre paréntesis, pero eso causa un error silencioso cada vez. Se agradece la ayuda: D

Haxe , 228 bytes

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

No es el mejor, los nombres de función de biblioteca estándar son demasiado grandes :(

Pruébalo en línea!

Pyth, 35 bytes

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

Salidas como una lista de caracteres.
Pruébalo aquí

Explicación

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.

Carbón , 36 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

ＦＳ≡ι

Pase sobre cada carácter de entrada y cambie.

B⊞υ⁰

Si es un, Bentonces empuje 0a la lista vacía predefinida.

D⊞υ×⁴⊕⊟υ

Si es un a Dcontinuación, haga estallar el último valor, increméntelo, multiplique por 4y empújelo nuevamente.

⊞υ⁺⊟υ⊕⌕AOUι

De lo contrario, busque el índice en la cadena AOU, increméntelo y agréguelo al último valor.

⭆⪪υ²℅↨ι¹⁶

Divida la lista en pares de valores, decodifique como base 16, convierta a ASCII e imprima implícitamente.

Limpio , 145134 bytes

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

Pruébalo en línea!

Explicado:

PHP, 119 bytes

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;

asume una entrada en mayúscula. Ejecutar como tubería -nRo probarlo en línea .

requiere PHP 7.1
para PHP anterior, use substr($m,-3,1)y en substr($m,-1)lugar de $m[-<x>](+16 bytes);
para los más pequeños PHP, put B, XIAOy IAOUentre comillas para evitar mensajes de advertencia (+10 bytes).

05AB1E , 40 bytes

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

Pruébalo en línea!

PHP, 163 bytes

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

Llame f(string $s)con la cadena apropiada de caracteres codificados con bibabobu, e imprimirá la cadena decodificada.

Python 3, 199 bytes

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

No es el más corto pero sin bucles.