Bibi-binary es un sistema numérico inventado por Boby Lapointe para representar números en letras cuya pronunciación parece divertida.

¡Su tarea es convertir números decimales en bibi-binario!

Conversión

Un número se convierte en base 16 (hexadecimal) y cada carácter se reemplaza por su nombre Bibi-binario:

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

Sea Nun número entero positivo (entre 1 -> 2 ^ 31-1). Para cada carácter en la representación hexadecimal de N, reemplace el carácter por su par Bibi-binario correspondiente (la tabla anterior contiene todos los pares).

Ejemplo

• N = 156
• H= (representación hexadecimal de N) -> 9C
• 9 -> KA, C -> DO

Por lo tanto, la salida es KADO.

De entrada y salida

Recibirá un entero positivo de 32 bits N, que deberá convertir en Bibi-binary.

Puede (devolver, imprimir, etc.) en cualquier formato conveniente, ¡ pero los pares deben estar conectados ! Entonces KA DOno estaría bien, pero lo KADOestaría.

Se permiten tanto minúsculas como mayúsculas .

Reglas

• No hay escapatorias.
• Este es el código de golf, por lo que gana el código más corto.

Casos de prueba

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

05AB1E , 20 18 16 bytes

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

Explicación

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

Pruébalo en línea!

Guardado 2 bytes gracias a Adnan

Python 2, 58 bytes

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

Una solución recursiva. Pruébalo en 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:])

Elige el dígito bibi para representar cada dígito hexadecimal en función de los patrones en los dígitos bibi.

Javascript (ES6), 58 53 43 bytes

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

10 bytes guardados (ya no se admite n = 0)

Manifestación

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

Pyth, 28 bytes

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

Define una función y. Básicamente el mismo algoritmo que mi respuesta de Python .

Explicación:

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.

Pruébalo aquí! (Los dos caracteres adicionales al final son solo para llamar a la función)

Jalea , 17 bytes

b⁴d4ị"€“BKDH“AEIO

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo 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

Una función anónima recursiva:

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

Llámalo por ejemplo con f[156]y devuelve"KADO"

J, 35 33 bytes

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

Genera la tabla de valores bibi-binarios para enteros [0, 16), luego convierte la entrada n en una lista de 16 dígitos base y selecciona el nombre bibi-binario correspondiente para cada dígito hexadecimal.

Guardado 2 bytes gracias a @randomra.

Uso

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

Esta parte genera una matriz de caracteres de 16 x 2 para el nombre bibi-binario de cada dígito hexadecimal.

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

Explicación

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

Incluye +1 para -p

Ejecutar con el número en STDIN

bibi.pl <<< 156

bibi.pl:

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

PHP, 63 bytes

contribución de @Titus Gracias

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

72 Bytes funciona también con cero

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

Versión 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]}*''}

Solo una solución rápida y simple sin codificar la cadena.

Pyth, 21 bytes

sm@*"HBKD""OAEI"djQ16

Un programa que toma la entrada de un número entero de STDIN e imprime el resultado.

Pruébalo en línea

Cómo 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};

Básicamente, esto aprovecha las funciones hexadecimales integradas y un pequeño truco en la instrucción while para ahorrar en llaves.

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

El uso de algunos trucos de la tabla de búsqueda El uso del tipo Long fue reducir algunos bytes en comparación con Integer

CJam , 20 bytes

qiGb"HBKD""OAEI"m*f=

Pruébalo en línea! (Como un conjunto de pruebas separado por salto de línea).

Explicación

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

Requiere ⎕IO←0cuál es el predeterminado en muchos sistemas.

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

∊ alistarse (hacer completamente plano)

(...

 , el desvencijado

 'HBKD'∘.,'OAEI' tabla de concatenación (es decir, todos los combos)

)[ indexado por ...

 16⊥⍣¯1 la inversa de la representación de base 16 a base 10 (es decir, base 10 a base 16)

 ⊢ de

 ⎕ la entrada numérica

]

TryAPL en línea!

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 es molesto para este tipo de tarea, ya que por defecto no contiene un método de conversión hexadecimal o binario. La mayor parte de la carne lo está convirtiendo en base 4. Después de eso s=("0"):rep(#s%2), forzamos un 0 detrás de él si necesitamos usarlo , luego usando gsub reemplazamos todos los didgets con su contraparte 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]'

Pruébalo en línea!TIO incluye un contenedor Bash que convierte una cadena entera en un valor entero real de 32 bits.

La mitad superior imprime las letras correspondientes a los datos binarios, una vez que la mitad inferior ha detectado que hemos alcanzado los datos interesantes (en otras palabras, omitimos los ceros iniciales. Para imprimir todos los ceros iniciales, elimine la segunda línea que comienza con Ay abajo.