Bibi-binary is a numeric system invented by Boby Lapointe in order to represent numbers in letters which pronunciation seems funny.

Your task is to convert decimal numbers into Bibi-binary!


A number is converted to base 16 (hexadecimal) and each character is replaced by its Bibi-binary name:

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

Let N be a positive integer (between 1 -> 2^31-1). For every character in the hexadecimal representation of N, replace the character by its according Bibi-binary pair (the table above contains all the pairs).


  • N = 156
  • H = (hexadecimal representation of N) --> 9C
  • 9 --> KA, C --> DO

Thus the output is KADO.

Input & output

You will receive an positive 32-bit integer N, which you will have to turn into Bibi-binary.

You may (return, print, etc...) in any convenient format, but the pairs have to be connected! So KA DO wouldn't be okay, but KADO would.

Both, lowercase and uppercase are allowed.


  • No loopholes.
  • This is code-golf, so the shortest code wins.


2048 -> KOHOHO
156 -> KADO
10000 -> HEBIHAHO
12 -> DO
  • \$\begingroup\$ The spec seems to say that the input will be non-negative in one section and positive in another - could you please clarify which one is intended? \$\endgroup\$
    – Sp3000
    Commented Sep 3, 2016 at 14:13
  • \$\begingroup\$ @Sp3000 positive is intended. I'll edit that in, thanks! \$\endgroup\$
    – Yytsi
    Commented Sep 3, 2016 at 14:19
  • \$\begingroup\$ Your spec still says between 0 -> 2^31-1, but 0 isn't positive (in English). \$\endgroup\$
    – Dennis
    Commented Sep 3, 2016 at 17:55
  • \$\begingroup\$ @Dennis I treated 0 as positive. I'll edit that out. Thanks for the mention! \$\endgroup\$
    – Yytsi
    Commented Sep 3, 2016 at 18:00
  • \$\begingroup\$ @TuukkaX 0 is precisely the distinction between positive and non-negative. \$\endgroup\$ Commented Sep 5, 2016 at 7:26

24 Answers 24


05AB1E, 20 18 16 bytes



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

Try it online!

Saved 2 bytes thanks to Adnan

  • \$\begingroup\$ …Âkd is a compressed version of "hbkd" :). \$\endgroup\$
    – Adnan
    Commented Sep 3, 2016 at 18:51
  • \$\begingroup\$ Also, I'm not sure if it's possible but H also converts a hexadecimal number to base 10. \$\endgroup\$
    – Adnan
    Commented Sep 3, 2016 at 18:57

Python 2, 58 bytes

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

A recursive solution. Try it on Ideone.

  • 2
    \$\begingroup\$ f=lambda n:n*'_'and f(n/16)+"HBKD"[n/4%4]+"OAEI"[n%4] saves 5 bytes. \$\endgroup\$
    – Dennis
    Commented Sep 3, 2016 at 17:51
  • \$\begingroup\$ I undeleted my comment. The OP clarified and input 0 is invalid. \$\endgroup\$
    – Dennis
    Commented Sep 3, 2016 at 18:02

Python 2, 81 76 bytes

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

Chooses the bibi-digit to represent each hex digit based on the patterns in the bibi-digits.


Jelly, 17 bytes


Try it online! or verify all test cases.

How it works

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

Javascript (ES6), 58 53 43 bytes


Saved 10 bytes (no support for n = 0 anymore)


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

  • \$\begingroup\$ Can you shorten this now that zero is no longer a requirement? \$\endgroup\$
    – Neil
    Commented Sep 4, 2016 at 13:45

Pyth, 28 bytes


Defines a function y. Basically the same algorithm as my Python answer.


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.

Try it here! (The extra two chars at the end is just to call the function)


Ruby, 55 51 bytes

A recursive anonymous function:


Call it for example with f[156] and it returns "KADO"


J, 35 33 bytes


Generates the table of bibi-binary values for integers [0, 16), then converts the input n to a list of base 16 digits and selects the corresponding bibi-binary name for each hex digit.

Saved 2 bytes thanks to @randomra.



This part generates a 16 x 2 array of characters for the bibi-binary name of each hex digit.

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


  '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
  • \$\begingroup\$ 'HBKDOAEI'{~[:(+0 4$~$)4#.inv] \$\endgroup\$
    – FrownyFrog
    Commented Feb 10, 2018 at 22:06

Perl, 52 51 bytes

Includes +1 for -p

Run with the number on STDIN

bibi.pl <<< 156


#!/usr/bin/perl -p

PHP ,63 Bytes

contribution by @Titus Thank You


72 Bytes works also with zero


76 Bytes alternative Version

for($i=2*strlen(dechex($n=$argv[1]));$i;)echo HBKDOAEI[$i%2*4+$n/4**--$i%4];
  • \$\begingroup\$ Try this one: for($n=$argv[1];$n;$n>>=2)$r=HBKDOAEI[$n%4+4*$t=!$t].$r;echo$r; \$\endgroup\$
    – Titus
    Commented Sep 15, 2016 at 18:19
  • 1
    \$\begingroup\$ Also: You forgot to golf the curlys from your first version. \$\endgroup\$
    – Titus
    Commented Sep 15, 2016 at 18:20
  • \$\begingroup\$ for($n=$argv[1];$n;$n>>=4)$r=HBKD[$n/4&3].OAEI[$n&3].$r;echo$r; for also 63 bytes or a port of Arnauld´s answer for 61: function f($n){return$n?f($n>>4).HBKD[$n/4&3].OAEI[$n&3]:'';} \$\endgroup\$
    – Titus
    Commented Sep 15, 2016 at 18:31
  • \$\begingroup\$ @Titus your first version works not correctly by an input of 1 or 16. Nice I have not realize that zero as input is not longer allowed \$\endgroup\$ Commented Sep 15, 2016 at 19:11
  • \$\begingroup\$ yup, just noticed. it doesnt print the H in first place. Take the second one. \$\endgroup\$
    – Titus
    Commented Sep 15, 2016 at 19:15

Ruby, 85 83 bytes


Just a quick and simple solution without encoding the string.


Pyth, 21 bytes


A program that takes input of an integer from STDIN and prints the result.

Try it online

How it works

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 bytes


This basically leverages the integrated hexadecimal functions and a little trick in the while statement to save on curly braces.


Java, 224 bytes

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

Using some lookup table trickery Usage of Long type was to shave off a few bytes compared to Integer


CJam, 20 bytes


Try it online! (As a linefeed-separated test suite.)


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 bytes

Requires ⎕IO←0 which is default on many systems.


enlist (make completely flat)


, the raveled

'HBKD'∘.,'OAEI' concatenation table (i.e. all combos)

)[ indexed by...

16⊥⍣¯1 the inverse of base-16 to base 10 (i.e. base-10 to base 16) representation


the numeric input


TryAPL online!


Lua, 196 Bytes

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 is annoying for this sort of a task, as it doesn't per default contain a hex or binary conversion method. Most of the flesh is converting it to base 4. After that we force a 0 behind it if we need to using s=("0"):rep(#s%2), then we using gsub replace all the didgets with with their BIBI counterpart.


Haskell, 76 bytes

(until(\x->x<="HO"||x>="HP")(drop 2)`map`mapM id([1..8]>>["HBKD","OAEI"])!!)

Try it online!

Since the input is guaranteed to fit in 32 bits, we can generate a list of all \$16^8 = 2^{32}\$ strings and index into it, after removing HO (zeroes) from the start.

(Haskell's Prelude has no good tools for base conversion, but Cartesian products are real easy with mapM.)

To strip superfluous HOs from the start of each string, we drop 2 characters from the front until the string either equals HO (0), or does not start with HO.

The obvious way to write this is x=="HO"||take 2x/="HO", but x<="HO"||x>="HP" is a little shorter.

  • \$\begingroup\$ Since the challenge says that the input is positive, it looks like you don't have to special-case 0. \$\endgroup\$
    – xnor
    Commented Nov 1, 2020 at 15:10
  • \$\begingroup\$ Hmm, I'll leave it as is, because some of the other answers go out of their way to handle 0, and it seemed to have been unclear at some point in the history of the challenge looking at the comment; and I like my <= >= trick better than I like saving some bytes with until((/="HO").take 2) \$\endgroup\$
    – lynn
    Commented Nov 1, 2020 at 17:41
  • \$\begingroup\$ Here's a way to handle the HO-removal by defining it as a separate function: TIO It may be possible to shorten the first line here, perhaps by reordering it to avoid the map. Though now that I think about it, it might be best to just calculate how many characters to drop from the size-16 string based on n, without looking at the resulting string. \$\endgroup\$
    – xnor
    Commented Nov 1, 2020 at 20:37

Japt, 13 bytes


Try it

Or, with string compression:

s`baki`ó rï

Try it

  • \$\begingroup\$ what is this sorcery \$\endgroup\$
    – Razetime
    Commented Nov 1, 2020 at 13:47
  • \$\begingroup\$ Just a straightforward custom base conversion, @Razetime. \$\endgroup\$
    – Shaggy
    Commented Nov 1, 2020 at 14:12

K (ngn/k), 30 27 bytes


Try it online!

Quite similar to the J solution by @miles and the APL solution by @adám.


Haskell, 50 bytes


Try it online!

Recursively defines the infinite list l of all encoded numbers starting from 0.

Haskell, 54 bytes

f n=mapM id([1|i<-[0..8],16^i<=n]>>["HBKD","OAEI"])!!n

Try it online!

Based off of Lynn's solution. The new idea is to avoid leading "zeroes" (HO's) by predicting the number of digits in advance and only generating that many copies for mapM. A number has one digit in base 16 for each number in 1,16,256,4096,... that is no greater than it. This gives the empty string for zero, but we could change it to HO like this:

56 bytes

f n=mapM id(0:[1|i<-[1..8],16^i<=n]>>["HBKD","OAEI"])!!n

Try it online!

A variant where we compute the number of digits directly:

60 bytes

f n=mapM id([0..until(\i->16^i>n)(+1)0]>>["HBKD","OAEI"])!!n

Try it online!

Haskell, 54 bytes

f 0=""
f n=f(div n 16)++mapM id[cycle"HBKD","OAEI"]!!n

Try it online!


Chip, 174 bytes

Ex]xx' ,x]/b

Try it online! TIO includes a Bash wrapper that converts an integer string to an actual 32-bit integer value.

The top half prints out the letters corresponding to the binary data, once the bottom half has detected that we've reached the interesting data (in other words, we skip leading zeroes. To print all leading zeroes, remove the second line that starts with A and down.


C (gcc), 206 bytes

int main(){int a=0;char c;while(read(0,&c,1)){a*=10;a+=c-'0';}c=8;while(c--)if(a&15<<c*4)break;if(c!=7)c++;while(c--)printf("%c%c","HBKD"[a>>c*4+2&3],"OAEI"[a>>c*4&3]);}

Uses as requested input, no check done on read return.

int a=0;char c;                                                                                                                                               // declares accumilator and input char
               while(read(0,&c,1)){a*=10;a+=c-'0';}                                                                                                           // read input in accumulator
                                                   c=8;while(c--)if(a&15<<c*4)break;if(c!=7)c++;                                                              // goto first not null byte
                                                                                                while(c--)printf("%c%c",                                      // print for each byte
                                                                                                                        "HBKD"[a>>c*4+2&3],                   // fetching right consonant
                                                                                                                                           "OAEI"[a>>c*4&3]); // fetching right vowel

Try it online!

  • \$\begingroup\$ Hi ceilingcat, what a good idea, I'll integrate it soon ;-) \$\endgroup\$ Commented Nov 2, 2020 at 12:07
  • \$\begingroup\$ 137 bytes \$\endgroup\$
    – ceilingcat
    Commented Nov 4, 2020 at 3:27

Husk, 20 bytes


Try it online!

Similiar to the APL answer.

Husk, 22 bytes


Try it online!

Idea from Dennis' answer.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.