Convierte a Bibi-binario


25

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

La especificación parece decir que la entrada será no negativa en una sección y positiva en otra. ¿Podría aclarar cuál es la intención?
Sp3000

@ Sp3000 positivo está destinado. Lo editaré en, gracias!
Yytsi

Su especificación todavía dice entre 0 -> 2 ^ 31-1 , pero 0 no es positivo (en inglés).
Dennis

@Dennis Traté a 0 como positivo. Lo editaré. Gracias por la mención!
Yytsi

@TuukkaX 0 es precisamente la distinción entre positivo y no negativo.
Vuelva a instalar Mónica

Respuestas:


10

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


…Âkdes una versión comprimida de "hbkd":).
Adnan

Además, no estoy seguro de si es posible, pero Htambién convierte un número hexadecimal a base 10.
Adnan

11

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 .


2
f=lambda n:n*'_'and f(n/16)+"HBKD"[n/4%4]+"OAEI"[n%4]ahorra 5 bytes.
Dennis

No borré mi comentario. El OP se aclaró y la entrada 0 no es válida.
Dennis

4

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.


4

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


¿Puedes acortar esto ahora que cero ya no es un requisito?
Neil

3

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)


3

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

3

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"


3

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

'HBKDOAEI'{~[:(+0 4$~$)4#.inv]
FrownyFrog

3

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}{

3

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

Pruebe este:for($n=$argv[1];$n;$n>>=2)$r=HBKDOAEI[$n%4+4*$t=!$t].$r;echo$r;
Titus

1
Además: olvidó jugar al golf desde su primera versión.
Tito

for($n=$argv[1];$n;$n>>=4)$r=HBKD[$n/4&3].OAEI[$n&3].$r;echo$r;para también 63 bytes o un puerto de la respuesta de Arnauld para 61:function f($n){return$n?f($n>>4).HBKD[$n/4&3].OAEI[$n&3]:'';}
Titus

@Titus, su primera versión no funciona correctamente con una entrada de 1 o 16. Agradable, no me he dado cuenta de que cero ya que la entrada ya no está permitida
Jörg Hülsermann

Sí, acabo de notar. no imprime el Hen primer lugar. Toma el segundo.
Tito

2

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.


2

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

2

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.


2

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


2

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.

2

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!


1

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.


0

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.

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.