Bibi-binário é um sistema numérico inventado por Boby Lapointe para representar números em letras cuja pronúncia parece engraçada.

Sua tarefa é converter números decimais em bibi-binário!

Conversão

Um número é convertido na base 16 (hexadecimal) e cada caractere é substituído pelo seu nome bibi-binário:

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

Seja Num número inteiro positivo (entre 1 -> 2 ^ 31-1). Para cada caractere na representação hexadecimal de N, substitua o caractere pelo par Bibi-binário correspondente (a tabela acima contém todos os pares).

Exemplo

• N = 156
• H= (representação hexadecimal de N) -> 9C
• 9 -> KA, C -> DO

Assim, a saída é KADO.

Entrada e saída

Você receberá um número inteiro positivo de 32 bits N, que deverá ser transformado em bibi-binário.

Você pode (devolver, imprimir, etc ...) em qualquer formato conveniente, mas os pares precisam estar conectados ! Então KA DO, não ficaria bem, mas KADOficaria.

Ambos, minúsculas e maiúsculas são permitidos.

Regras

• Sem brechas.
• Isso é código-golfe, então o código mais curto vence.

Casos de teste

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

05AB1E , 20 18 16 bytes

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

Explicação

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

Experimente online!

Economizou 2 bytes graças a Adnan

Python 2, 58 bytes

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

Uma solução recursiva. Experimente em Ideone .

Python 2, 81 76 bytes

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

Escolhe o dígito bibi para representar cada dígito hexadecimal com base nos padrões nos dígitos bibi.

Javascript (ES6), 58 53 43 bytes

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

10 bytes salvos (não há mais suporte para n = 0)

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

Pitão, 28 bytes

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

Define uma função y. Basicamente, o mesmo algoritmo da minha resposta em Python .

Explicação:

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.

Experimente aqui! (Os dois caracteres extras no final são apenas para chamar a função)

Geléia , 17 bytes

b⁴d4ị"€“BKDH“AEIO

Experimente online! ou verifique todos os casos de teste .

Como funciona

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

Ruby, 55 51 bytes

Uma função anônima recursiva:

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

Chame por exemplo com f[156]e retorna"KADO"

J, 35 33 bytes

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

Gera a tabela de valores bibi-binários para números inteiros [0, 16), depois converte a entrada n em uma lista de 16 dígitos base e seleciona o nome bibi-binário correspondente para cada dígito hexadecimal.

Guardado 2 bytes graças a @randomra.

Uso

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

Esta parte gera uma matriz de 16 x 2 de caracteres para o nome bibi-binário de cada dígito hexadecimal.

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

Explicação

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

Inclui +1 para -p

Corra com o número em STDIN

bibi.pl <<< 156

bibi.pl:

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

PHP, 63 bytes

Contribuição de @Titus Thank You

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

72 bytes trabalha também com zero

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

Versão alternativa de 76 bytes

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

Ruby, 85 83 bytes

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

Apenas uma solução rápida e simples sem codificar a string.

Pitão, 21 bytes

sm@*"HBKD""OAEI"djQ16

Um programa que recebe a entrada de um número inteiro de STDIN e imprime o resultado.

Experimente online

Como funciona

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[1]);while($h{$i}!=''|$c=hexdec($h{$i++}))echo$a{$c/4}.$a{4+$c%4};

Isso basicamente aproveita as funções hexadecimais integradas e um pequeno truque na instrução while para economizar em chaves.

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

Usando alguns truques da tabela de pesquisa O uso do tipo Long foi para depilar alguns bytes em comparação com o Número Inteiro

CJam , 20 bytes

qiGb"HBKD""OAEI"m*f=

Experimente online! (Como um conjunto de testes separado por avanço de linha.)

Explicação

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

Requer ⎕IO←0qual é o padrão em muitos sistemas.

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

∊ alistar-se (deixar completamente plano)

(...

 , o enredado

 'HBKD'∘.,'OAEI' tabela de concatenação (ou seja, todos os combos)

)[ indexado por ...

 16⊥⍣¯1 o inverso da representação da base 16 à base 10 (isto é, base 10 à base 16)

 ⊢ do

 ⎕ a entrada numérica

]

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 é irritante para esse tipo de tarefa, pois, por padrão, não contém um método de conversão hexadecimal ou binário. A maior parte da carne está convertendo-a para a base 4. Depois disso, forçamos um 0 por trás, se precisarmos usar s=("0"):rep(#s%2), então, usando gsub substituímos todos os didgets por seus equivalentes BIBI.

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

Experimente online! O TIO inclui um wrapper Bash que converte uma sequência inteira em um valor inteiro real de 32 bits.

A metade superior imprime as letras correspondentes aos dados binários, uma vez que a metade inferior detecta que alcançamos os dados interessantes (em outras palavras, pulamos os zeros iniciais. Para imprimir todos os zeros iniciais, remova a segunda linha que começa com Ae para baixo.