25
\$\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\$
  • \$\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 Sep 5 '16 at 7:26

18 Answers 18

10
\$\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\$
  • \$\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
11
\$\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
    \$\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\$

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\$
  • \$\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\$

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\$
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\$
  • \$\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\$
  • \$\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\$
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\$

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.