Pendant que je voyageais dans le futur, j'ai remarqué un jeu amusant parmi les enfants vers 2275. Lorsqu'ils ne veulent pas que leurs arrière-arrière-arrière-arrière-arrière-petits-parents comprennent ce qu'ils disent, ils utilisent le langage BIBABOBU . De toute évidence, je ne pouvais rien comprendre non plus avec mon cerveau d'avant l'ère cyborg et je me sentais (ou techniquement: je vais me sentir ) vraiment stupide. Donc, il me faudrait un décodeur pour ma prochaine visite.

BIBABOBU?

Bien qu'il soit obsolète depuis longtemps, l'ASCII est encore couramment utilisé dans la culture pop de 2275 et ce langage est basé sur celui-ci.

Une chaîne est codée BIBABOBU de cette façon:

• Convertir tous les caractères en leurs codes ASCII.

• Prenez la représentation hexadécimale à 2 chiffres de chaque code et convertissez-les en utilisant le tableau suivant:

  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
  

Exemple

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

Cependant, l' entrée correspondante serait donnée sans aucun espace pour imiter l'intonation monotone que les enfants utilisent pour rendre cela encore plus difficile à comprendre sans implants:

"BIDIBADIBIDOBIDABIDOBODIBIDOBODIBIDOBODUBOBA"

Clarifications et règles

• Rappelez-vous que j'ai besoin d'un décodeur , pas d'un encodeur.
• Les caractères décodés sont assurés d'être dans la plage [32 ... 126] .
• Il est garanti que l’entrée contient un nombre pair de chiffres hexadécimaux codés par BIBABOBU.
• Vous pouvez entrer des entrées en minuscules ou en majuscules. Les cas mixtes ne sont pas autorisés.
• Parce que les bits sont très fréquents lors d’un voyage dans le temps, il s'agit de code-golf afin de minimiser les risques.

Cas de test

NB: Les sauts de ligne sont utilisés ci-dessous uniquement à des fins de formatage. Vous n'êtes pas censé les gérer.

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 octets

Sauvé 1 octet grâce à Mr.Xcoder
Sauvé 2 octets grâce à KevinCruijssen

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

Essayez-le en ligne! ou en tant que suite de tests

Explication

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

Jelly , 26 24 23 22 20 17 15 octets

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

Essayez-le en ligne!

Comment ça fonctionne

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

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

Essayez-le en ligne!

Fortement inspiré par la solution Jelly de Dennis. Utilise une fonction différente et magique x³ % 87 % 4qui associe également les codes ASCII IAOUBDà 012302.

Version alternative 75 de 74 octets

-1 octet grâce à Jo King

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

Essayez-le en ligne!

Version alternative de 85 octets

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

Essayez-le en ligne!

Python 2 , 100 97 96 95 octets

^{-1 octet grâce à ovs
-1 octet grâce à GB}

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

Essayez-le en ligne!

Perl 5 -p, 67 octets

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

Essayez-le en ligne!

05AB1E (héritage), 68 65 60 59 octets

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

La saisie est en minuscule.

-3 octets implicitement grâce à @Emigna changer 'b¡εg>}s£à 'b©¡®ì.

Essayez-le en ligne ou vérifiez tous les cas de test .

En outre, peut certainement être joué avec quelque chose de plus intelligent que les énormes chaînes compressées. Je reviendrai plus tard. Réponse plus courte déjà fournie par @Emigna , alors assurez-vous de le réévaluer!

Explication:

.•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 octets

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

Essayez-le en ligne!

R , 141 135 octets

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

Essayez-le en ligne!

Merci à JayCe d' avoir sauvé 6 octets!

L'utilisation de la magie modulaire sera probablement plus courte, mais je suis assez content de cela comme d'une première passe naïve.

Japt, 43 29 28 octets

Sans surprise, la solution Jelly de Dennis au port est beaucoup plus courte.

Sort un tableau de caractères.

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

L'essayer

Original, 42 octets

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

L'essayer

Explication

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

Espérons qu’il y aura un compilateur C à l’avenir pour compiler cela! :-)

Merci à Max Yekhlakov et ceilingcat pour les suggestions.

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

Essayez-le en ligne!

Au cas où le compilateur C du futur ne comprend que l'ASCII BIBABOBU-ified :-)

BIDUBIDOBOBODIBIDUBIDIBOBODIBIDOBUBUBADUBIDOBIDOBOBADIBIDOBUBIDOBADIBIDOBABIDUBOBOBADOBIDUBUBOBADABIDUBADUBIDOBIDOBIDOBODUBIDUBOBOBADIBIDUBIDOBUBODABIDUBIDIBUBODABIDOBUBUBODABUBIBUBADUBOBADOBIDUBUBUBADUBIDUBUBOBADUBOBADUBOBADABIDUBIDIBOBADUBUBODABOBADOBIDUBUBUBODABUBODABUBIDOBUBIDOBUBODUBIDUBIDOBUBODABIDUBIDOBOBADOBUBABUBIDOBOBADUBIDUBIDIBOBODIBOBADUBOBADUBIDOBUBUBODOBUBOBUBODUBIDUBIDOBUBODABOBABIDUBIBIDUBIDABIDUBIDIBIDOBUBIDOBADIBIDOBABIDUBOBOBADIBIDUBIDOBOBADABOBODIBIDOBUBUBODABUBABUBADOBUBIBOBODIBOBODABIDUBIDIBUBADOBOBADOBIDUBUBOBODABUBIDOBUBIDABUBODUBOBADOBIDUBUBOBODABUBIDUBUBADABUBODUBOBADOBIDUBUBOBODABUBIDOBUBADIBUBODUBOBADOBIDUBUBOBODABUBADIBUBIDABUBODUBUBIBUBADOBUBUBUBADOBUBIDIBOBADUBIDUBIDIBOBADOBUBUBUBADOBUBOBUBADOBUBABUBADUBIDUBIBIDUBIDABIDUBIDIBIDOBUBIDOBADIBIDOBABIDUBOBOBADIBIDUBIDOBOBADOBUBABUBIDOBOBADUBIDUBIDIBOBADABUBADUBIDUBODA

(Encoder Essayez-le en ligne! )

JavaScript (Node.js) , 131 128 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Version alternative, également 131 octets:

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

Essayez-le en ligne! Le lien inclut des cas de test. Edit: enregistre 3 octets grâce à @Shaggy.

Bash + utilitaires Linux courants, 75 octets

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

Essayez-le en ligne!

Scala , 305 octets

Eh bien, je suis à peu près sûr que cela peut être joué au golf. Mais encore, ça existe. Prend la saisie en minuscule. faffiche le résultat en stdout.

EDIT: -8 caractères grâce à moi de ne plus être muet (espaces); -13 caractères grâce à 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}}

Essayez-le en ligne!

Python 2 , 142 139 127 118 octets

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

Essayez-le en ligne!

Python 2 , 93 octets

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

Essayez-le en ligne!

Ruby , 86 75 octets

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

Essayez-le en ligne!

Dyalog APL, 74 72 octets

Solution de niveau débutant dans Dyalog APL (cela ne fait que l’apprendre il ya quelques jours!). Définit un dfn qui prend un argument correct (l’entrée). 72 caractères, 72 octets lors de l’utilisation du codage dyalog. Basé sur la solution d'Emigna dans 05AB1E.

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

Gelée , 39 octets

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

Essayez-le en ligne!

La technique utilisée est très similaire à celle d' Emigna . Je vais jouer au golf plus tard, avec un peu de chance.

Brain-Flak , 178 octets

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

Essayez-le en ligne!

Explication

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

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

La réponse insensée de Jelly du port de @Dennis (avec des commandes moins pratiques). Alors assurez-vous de le revivre!

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

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

Essayez-le en ligne!

Crédits

• -2 octets grâce à Arnauld

VBA (Excel), avec un incroyable 322 244 octets

Oui, et j'adore hexadécimal. (Il n'y a pas encore de police sarcasme, donc j'utilise l'italique pour le moment) Je vais ajouter des commentaires si quelqu'un le souhaite, mais je pense que cela va de soi. Le golf est arrivé.

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

Avec commentaires:

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

J'ai vraiment essayé de faire entrer cela dans la fenêtre Immédiate de VB, mais cela ne semble pas fonctionner là-bas ... cela réduirait 11 caractères, je pense. Je voulais également mettre l'instruction Match entre crochets, mais cela provoque une erreur silencieuse à chaque fois. L'aide est appréciée: D

Haxe , 228 octets

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

Pas le meilleur, les noms de fonction de bibliothèque standard sont trop grands :(

Essayez-le en ligne!

Pyth, 35 octets

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

Affiche une liste de caractères.
Essayez-le ici

Explication

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.

Charbon de bois , 36 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

ＦＳ≡ι

Boucle sur chaque caractère d'entrée et commutateur.

B⊞υ⁰

Si c'est un Bpuis appuyez 0sur la liste vide prédéfinie.

D⊞υ×⁴⊕⊟υ

Si c'est un Dpuis pop la dernière valeur, incrémentez-le, multipliez par 4, et appuyez à nouveau.

⊞υ⁺⊟υ⊕⌕AOUι

Sinon, recherchez l'index dans la chaîne AOU, incrémentez-le et ajoutez-le à la dernière valeur.

⭆⪪υ²℅↨ι¹⁶

Divisez la liste en paires de valeurs, décodez-la en base 16, convertissez-la en ASCII et imprimez-la de manière implicite.

Propre , 145 134 octets

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

Essayez-le en ligne!

A expliqué:

PHP, 119 octets

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;

suppose une entrée en majuscule. Exécuter en pipe -nRou essayer en ligne .

nécessite PHP 7.1
pour les anciens PHP, utilisez substr($m,-3,1)et substr($m,-1)au lieu de $m[-<x>](+16 octets);
pour PHP plus jeune, mettre B, XIAOet IAOUentre guillemets pour éviter les messages d' avertissement (+ 10 octets).

05AB1E , 40 octets

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

Essayez-le en ligne!

PHP, 163 octets

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

Appelez f(string $s)avec la chaîne appropriée de caractères encodés en bibabobu, et la chaîne décodée sera imprimée.

Python 3, 199 octets

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

Pas le plus court mais sans boucles.