Le bibi-binaire est un système numérique inventé par Boby Lapointe afin de représenter des nombres en lettres dont la prononciation semble amusante.

Votre tâche consiste à convertir des nombres décimaux en Bibi-binaire!

Conversion

Un nombre est converti en base 16 (hexadécimal) et chaque caractère est remplacé par son nom bibi-binaire:

0 = HO
1 = HA
2 = HE
3 = HI
4 = BO
5 = BA
6 = BE
7 = BI
8 = KO
9 = KA
A = KE
B = KI
C = DO
D = DA
E = DE
F = DI

Soit Nun entier positif (entre 1 -> 2 ^ 31-1). Pour chaque caractère dans la représentation hexadécimale de N, remplacez le caractère par sa paire bibi-binaire correspondante (le tableau ci-dessus contient toutes les paires).

Exemple

• N = 156
• H= (représentation hexadécimale de N) -> 9C
• 9 -> KA, C -> DO

Ainsi, la sortie est KADO.

Entrée sortie

Vous recevrez un entier 32 bits positif N, que vous devrez transformer en bibi-binaire.

Vous pouvez (retourner, imprimer, etc ...) dans n'importe quel format pratique, mais les paires doivent être connectées ! Donc KA DOça ne serait pas bien, mais ça le KADOserait.

Les majuscules et les minuscules sont autorisés.

Règles

• Pas de failles.
• C'est le code-golf, donc le code le plus court l'emporte.

Cas de test

2048 -> KOHOHO
156 -> KADO
10000 -> HEBIHAHO
12 -> DO

05AB1E , 20 18 16 octets

hv…ÂkdžM¨ÁâyHèJ

Explication

h                     # convert input to hex
 v                    # for each
  …Âkd               # string of the possible first Bibi-binary letters
       žM¨Á           # string of the possible second Bibi-binary letters
           â          # cartesian product to produce list of Bibi-binary pairs
            yH        # convert hex char to base 10
              è       # use this to index into the list
               J      # join

Essayez-le en ligne!

Enregistré 2 octets grâce à Adnan

Python 2, 58 octets

f=lambda n:(n>15and f(n/16)or"")+"HBKD"[n/4%4]+"OAEI"[n%4]

Une solution récursive. Essayez-le sur Ideone .

Python 2, 81 76 octets

lambda n:''.join('HBKD'[int(x,16)/4]+'OAEI'[int(x,16)%4]for x in hex(n)[2:])

Choisit le chiffre bibi pour représenter chaque chiffre hexadécimal en fonction des motifs dans les chiffres bibi.

Javascript (ES6), 58 53 43 octets

f=n=>n?f(n>>4)+'HBKD'[n/4&3]+'OAEI'[n&3]:''

10 octets enregistrés (plus de support pour n = 0)

Démo

var f=n=>n?f(n>>4)+'HBKD'[n/4&3]+'OAEI'[n&3]:''

console.log(f(2048));   // -> KOHOHO
console.log(f(156));    // -> KADO
console.log(f(10000));  // -> HEBIHAHO
console.log(f(12));     // -> DO

Pyth, 28 octets

L+?>b15y/b16k@*"HBKD""OAEI"b

Définit une fonction y. Fondamentalement, le même algorithme que ma réponse Python .

Explication:

L                            # Define a function, y, with an argument, b.
  ?>b15                      # If b > 15, then:
       y/b16                 # Call y with b / 16, else:
            k                # The empty string.
 +                           # Append with
              *"HBKD""OAEI"  # The Cartesian product of "HBKD" and "OAEI". Gives all the letter pairs in order
             @             b # Get the b'th number from that list. Because @ in Pyth is modular, we don't need to take b % 16.

Essayez-le ici! (Les deux caractères supplémentaires à la fin sont juste pour appeler la fonction)

Gelée , 17 octets

b⁴d4ị"€“BKDH“AEIO

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

Comment ça marche

b⁴d4ị"€“BKDH“AEIO  Main link. Argument: n

b⁴                 Convert n to base 16.
  d4               Divmod 4; map each base-16 digit k to [k / 4, k % 4].
       “BKDH“AEIO  Yield ["BKDH", "AEIO"].
      €            For each quotient-remainder pair [q, r]:
    ị"               Yield "BKDH"[q] and "AEIO"[r] (1-based indexing).

Rubis, 55 51 octets

Une fonction anonyme récursive:

f=->i{(i>15?f[i/16]:'')+'HBKD'[i%16/4]+'OAEI'[i%4]}

Appelez-le par exemple avec f[156]et il revient"KADO"

J, 35 33 octets

[:,(,/'HBKD',"0/'OAEI'){~16#.inv]

Génère la table des valeurs bibi-binaires pour les entiers [0, 16), puis convertit l'entrée n en une liste de 16 chiffres de base et sélectionne le nom bibi-binaire correspondant pour chaque chiffre hexadécimal.

Enregistré 2 octets grâce à @randomra.

Usage

   ,/'HBKD',"0/'OAEI'
HO
HA
HE
HI
BO
BA
BE
BI
KO
KA
KE
KI
DO
DA
DE
DI

Cette partie génère un tableau 16 x 2 de caractères pour le nom bibi-binaire de chaque chiffre hexadécimal.

   f =: [:,(,/'HBKD',."0 1'OAEI'){~16#.inv]
   f 156
KADO
   f 2048
KOHOHO

Explication

,/'HBKD',"0/'OAEI'
  'HBKD'    'OAEI'  Constant char arrays
        ,"0/        Form the table of joining each char with the other
,/                  Join the rows of that table

[:,(,/'HBKD',."0 1'OAEI'){~16#.inv]  Input: n
                                  ]  Identity function, get n
                           16#.inv   Performs the inverse of converting an array of
                                     hex digits meaning it converts a value to a list of
                                     hex digits
   (,/'HBKD',."0 1'OAEI')            Create the bibi-binary names of each hex digit
                         {~          For each hex digit, select its bibi-binary name
[:,                                  Join the names to form a single string and return

Perl, 52 51 octets

Comprend +1 pour -p

Courir avec le numéro sur STDIN

bibi.pl <<< 156

bibi.pl:

#!/usr/bin/perl -p
1while$\=(<{H,B,K,D}{O,A,E,I}>)[$_%16].$\,$_>>=4}{

PHP, 63 octets

contribution de @Titus Merci

for($n=$argv[1];$n;$n>>=4)$r=HBKD[$n/4&3].OAEI[$n&3].$r;echo$r;

72 octets fonctionne également avec zéro

do$r=OAEIHBKD[$t*4+($n=&$argv[1])%4].$r;while(($t=!$t)|$n=$n>>2);echo$r;

Version alternative à 76 octets

for($i=2*strlen(dechex($n=$argv[1]));$i;)echo HBKDOAEI[$i%2*4+$n/4**--$i%4];

Rubis, 85 83 octets

->x{x.to_s(16).chars.map{|d|"HOHAHEHIBOBABEBIKOKAKEKIDODADEDI"[2*d.to_i(16),2]}*''}

Juste une solution rapide et simple sans encoder la chaîne.

Pyth, 21 octets

sm@*"HBKD""OAEI"djQ16

Un programme qui prend l'entrée d'un entier de STDIN et imprime le résultat.

Essayez-le en ligne

Comment ça marche

sm@*"HBKD""OAEI"djQ16  Program. Input: Q
                 jQ16  Yield decimal digits of the base-16 representation of Q as a list
    "HBKD"              Possible first letters
          "OAEI"        Possible second letters
   *                    Cartesian product of those two strings
  @                     Index into the above
 m              d      Map that across the digits list
s                      Concatenate
                       Implicitly print

PHP, 93 octets

$a=HBKDOAEI;$h=dechex($argv[1]);while($h{$i}!=''|$c=hexdec($h{$i++}))echo$a{$c/4}.$a{4+$c%4};

Cela utilise essentiellement les fonctions hexadécimales intégrées et une petite astuce dans l'instruction while pour économiser sur les accolades.

Java, 224 octets

class N{public static void main(String[]a){String x="0HO1HA2HE3HI4BO5BA6BE7BI8KO9KAaKEbKIcDOdDAeDEfDI";for(int c:Long.toHexString(Long.valueOf(a[0])).toCharArray()){c=x.indexOf(c)+1;System.out.print(x.substring(c++,++c));}}}

Utilisation d'une astuce de table de recherche L'utilisation du type Long consistait à raser quelques octets par rapport à Integer

CJam , 20 octets

qiGb"HBKD""OAEI"m*f=

Essayez-le en ligne!(En tant que suite de tests séparés par des sauts de ligne.)

Explication

qi      e# Read input and convert to integer.
Gb      e# Get hexadecimal digits.
"HBKD"  e# Push this string.
"OAEI"  e# Push this string.
m*      e# Cartesian product, yields ["HO" "HA" "HE" "HI" "BO" ... "DE" "DI"].
f=      e# For each digit, select the corresponding syllable.

Dyalog APL , 19 octets

Requiert ⎕IO←0ce qui est par défaut sur de nombreux systèmes.

∊(,'HBKD'∘.,'OAEI')[16⊥⍣¯1⊢⎕]

∊ enrôler (rendre complètement plat)

(...

 , le ravelé

 'HBKD'∘.,'OAEI' table de concaténation (c'est-à-dire tous les combos)

)[ indexé par ...

 16⊥⍣¯1 l'inverse de la représentation de la base 16 à la base 10 (c'est-à-dire de la base 10 à la base 16)

 ⊢ de

 ⎕ l'entrée numérique

]

TryAPL en ligne!

Lua, 196 octets

function(n)s=""t={"H","B","K","D"}p={"O","A","E","I"}while n>0 do s=n%4 ..s n=math.floor(n/4)end s=("0"):rep(#s%2)..s o=nil return s:gsub(".",function(s)o=not o return o and t[s+1]or p[s+1]end)end

Lua est ennuyeux pour ce genre de tâche, car il ne contient pas par défaut une méthode de conversion hexadécimale ou binaire. La plupart de la chair le convertit en base 4. Après cela s=("0"):rep(#s%2), nous forçons un 0 derrière si nous devons l'utiliser , puis nous utilisons gsub pour remplacer tous les didgets par leur homologue BIBI.

Puce , 174 octets

 z---.
!+ZZZ^~s
Axxx])~-vv/c
Ex]xx' ,x]/b
Bxxx])~^}~/d
Fx]xx'g*-}^a
Cxx])v]--/c
G]xx'>x~v/d
Dxx])x+-]/a
H]xx'`}--/b
 )x)-----'
Axx].zv~S
Bxx]+^'
Cxx]<
Dxx]<
E]v-'
F]<
G]<
H]'

Essayez-le en ligne!TIO comprend un wrapper Bash qui convertit une chaîne entière en une valeur entière réelle de 32 bits.

La moitié supérieure imprime les lettres correspondant aux données binaires, une fois que la moitié inférieure a détecté que nous avons atteint les données intéressantes (en d'autres termes, nous ignorons les zéros de tête. Pour imprimer tous les zéros de tête, supprimez la deuxième ligne qui commence par Aet en bas.