27
\$\begingroup\$

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!

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

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.

Rules

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

Testcases

2048 -> KOHOHO
156 -> KADO
10000 -> HEBIHAHO
12 -> DO
\$\endgroup\$
5
  • \$\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 Sep 3 '16 at 14:13
  • \$\begingroup\$ @Sp3000 positive is intended. I'll edit that in, thanks! \$\endgroup\$ – Yytsi Sep 3 '16 at 14:19
  • \$\begingroup\$ Your spec still says between 0 -> 2^31-1, but 0 isn't positive (in English). \$\endgroup\$ – Dennis Sep 3 '16 at 17:55
  • \$\begingroup\$ @Dennis I treated 0 as positive. I'll edit that out. Thanks for the mention! \$\endgroup\$ – Yytsi Sep 3 '16 at 18:00
  • \$\begingroup\$ @TuukkaX 0 is precisely the distinction between positive and non-negative. \$\endgroup\$ – Angew is no longer proud of SO Sep 5 '16 at 7:26

24 Answers 24

11
\$\begingroup\$

05AB1E, 20 18 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

\$\endgroup\$
2
  • \$\begingroup\$ …Âkd is a compressed version of "hbkd" :). \$\endgroup\$ – Adnan Sep 3 '16 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 Sep 3 '16 at 18:57
12
\$\begingroup\$

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.

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

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.

\$\endgroup\$
4
\$\begingroup\$

Jelly, 17 bytes

b⁴d4ị"€“BKDH“AEIO

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).
\$\endgroup\$
4
\$\begingroup\$

Javascript (ES6), 58 53 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(156));    // -> KADO
console.log(f(10000));  // -> HEBIHAHO
console.log(f(12));     // -> DO

\$\endgroup\$
1
  • \$\begingroup\$ Can you shorten this now that zero is no longer a requirement? \$\endgroup\$ – Neil Sep 4 '16 at 13:45
3
\$\begingroup\$

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)

\$\endgroup\$
3
\$\begingroup\$

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[156] and it returns "KADO"

\$\endgroup\$
3
\$\begingroup\$

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

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}{
\$\endgroup\$
3
\$\begingroup\$

PHP ,63 Bytes

contribution by @Titus Thank You

for($n=$argv[1];$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[1])%4].$r;while(($t=!$t)|$n=$n>>2);echo$r;

76 Bytes alternative Version

for($i=2*strlen(dechex($n=$argv[1]));$i;)echo HBKDOAEI[$i%2*4+$n/4**--$i%4];
\$\endgroup\$
5
  • \$\begingroup\$ Try this one: for($n=$argv[1];$n;$n>>=2)$r=HBKDOAEI[$n%4+4*$t=!$t].$r;echo$r; \$\endgroup\$ – Titus Sep 15 '16 at 18:19
  • 1
    \$\begingroup\$ Also: You forgot to golf the curlys from your first version. \$\endgroup\$ – Titus Sep 15 '16 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 Sep 15 '16 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\$ – Jörg Hülsermann Sep 15 '16 at 19:11
  • \$\begingroup\$ yup, just noticed. it doesnt print the H in first place. Take the second one. \$\endgroup\$ – Titus Sep 15 '16 at 19:15
2
\$\begingroup\$

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.

\$\endgroup\$
2
\$\begingroup\$

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
\$\endgroup\$
2
\$\begingroup\$

PHP, 93 bytes

$a=HBKDOAEI;$h=dechex($argv[1]);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.

\$\endgroup\$
2
\$\begingroup\$

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

\$\endgroup\$
2
\$\begingroup\$

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.
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.
\$\endgroup\$
2
\$\begingroup\$

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!

\$\endgroup\$
1
\$\begingroup\$

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.

\$\endgroup\$
1
\$\begingroup\$

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.

\$\endgroup\$
3
  • \$\begingroup\$ Since the challenge says that the input is positive, it looks like you don't have to special-case 0. \$\endgroup\$ – xnor Nov 1 '20 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 Nov 1 '20 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 Nov 1 '20 at 20:37
1
\$\begingroup\$

Japt, 13 bytes

s"HBKD"ï"OAEI

Try it

Or, with string compression:

s`baki`ó rï

Try it

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

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.

\$\endgroup\$
1
\$\begingroup\$

Haskell, 50 bytes

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


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!

\$\endgroup\$
0
\$\begingroup\$

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.

\$\endgroup\$
0
\$\begingroup\$

C (gcc), 206 bytes

#include<stdio.h>
#include<unistd.h>
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!

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

Husk, 20 bytes

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

Try it online!

Similiar to the APL answer.

Husk, 22 bytes

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

Try it online!

Idea from Dennis' answer.

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

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