# Convert to Bibi-binary

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

## Conversion

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

## Example

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

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

## Rules

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

## Testcases

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

• 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? Sep 3, 2016 at 14:13
• @Sp3000 positive is intended. I'll edit that in, thanks! Sep 3, 2016 at 14:19
• Your spec still says between 0 -> 2^31-1, but 0 isn't positive (in English). Sep 3, 2016 at 17:55
• @Dennis I treated 0 as positive. I'll edit that out. Thanks for the mention! Sep 3, 2016 at 18:00
• @TuukkaX 0 is precisely the distinction between positive and non-negative. Sep 5, 2016 at 7:26

# 05AB1E, 2018 16 bytes

hv…Ã‚kdžM¨ÁâyHèJ


Explanation

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

• …Ã‚kd is a compressed version of "hbkd" :). Sep 3, 2016 at 18:51
• Also, I'm not sure if it's possible but H also converts a hexadecimal number to base 10. 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.

• f=lambda n:n*'_'and f(n/16)+"HBKD"[n/4%4]+"OAEI"[n%4] saves 5 bytes. Sep 3, 2016 at 17:51
• I undeleted my comment. The OP clarified and input 0 is invalid. 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

b⁴d4ị"€“BKDH“AEIO


### 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), 5853 43 bytes

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


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

### Demo

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

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

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

# Pyth, 28 bytes

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


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

Explanation:

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:

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


Call it for example with f and it returns "KADO"

# J, 35 33 bytes

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


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.

## Usage

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


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
KOHOHO


## Explanation

,/'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

• 'HBKDOAEI'{~[:(+0 4$~$)4#.inv] Feb 10, 2018 at 22:06

# Perl, 52 51 bytes

Includes +1 for -p

Run with the number on STDIN

bibi.pl <<< 156


bibi.pl:

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


# PHP ,63 Bytes

contribution by @Titus Thank You

for($n=$argv;$n;$n>>=4)$r=HBKD[$n/4&3].OAEI[$n&3].$r;echo$r;  72 Bytes works also with zero do$r=OAEIHBKD[$t*4+($n=&$argv)%4].$r;while(($t=!$t)|$n=$n>>2);echo$r;  76 Bytes alternative Version for($i=2*strlen(dechex($n=$argv));$i;)echo HBKDOAEI[$i%2*4+$n/4**--$i%4];

• Try this one: for($n=$argv;$n;$n>>=2)$r=HBKDOAEI[$n%4+4*$t=!$t].$r;echo$r; Sep 15, 2016 at 18:19
• Also: You forgot to golf the curlys from your first version. Sep 15, 2016 at 18:20
• for($n=$argv;$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]:'';} Sep 15, 2016 at 18:31
• @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 Sep 15, 2016 at 19:11
• yup, just noticed. it doesnt print the H in first place. Take the second one. Sep 15, 2016 at 19:15

# Ruby, 85 83 bytes

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


Just a quick and simple solution without encoding the string.

# Pyth, 21 bytes

sm@*"HBKD""OAEI"djQ16


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

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


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

qiGb"HBKD""OAEI"m*f=


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

### Explanation

qi      e# Read input and convert to integer.
"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.

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


∊ 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

⊢ of

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

(until(\x->x<="HO"||x>="HP")(drop 2)mapmapM 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.

• Since the challenge says that the input is positive, it looks like you don't have to special-case 0.
– xnor
Nov 1, 2020 at 15:10
• 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)
– Lynn
Nov 1, 2020 at 17:41
• 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.
– xnor
Nov 1, 2020 at 20:37

# Japt, 13 bytes

s"HBKD"ï"OAEI


Try it

Or, with string compression:

sbakió rï


Try it

• what is this sorcery Nov 1, 2020 at 13:47
• Just a straightforward custom base conversion, @Razetime. Nov 1, 2020 at 14:12

# K (ngn/k), 30 27 bytes

,/(,/"HBKD",/:\:"OAEI")@16\


Try it online!

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

(l!!)
l=[]:tail[x++[a,b]|x<-l,a<-"HBKD",b<-"OAEI"]


Try it online!

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

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!

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


Try it online!

# Chip, 174 bytes

 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]'


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

#include<stdio.h>
#include<unistd.h>


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

int a=0;char c;                                                                                                                                               // declares accumilator and input char
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!

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

# Husk, 20 bytes

ṁ!ṙ1*"HBKD""OAEI"B16


Try it online!

ṁz!e"BKDH""AEIO"m‰4B16
`