Биби-двоичный код представляет собой числовую систему, изобретенную Боби Лапойнтом для обозначения чисел буквами, произношение которых кажется забавным.

Ваша задача - преобразовать десятичные числа в двоичные числа Биби!

преобразование

Число преобразуется в основание 16 (шестнадцатеричное), и каждый символ заменяется его биби-двоичным именем:

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

Позвольте Nбыть положительным целым числом (между 1 -> 2 ^ 31-1). Для каждого символа в шестнадцатеричном представлении Nзамените символ его соответствующей парой биби-двоичных кодов (таблица выше содержит все пары).

пример

• N = 156
• H= (шестнадцатеричное представление N) -> 9C
• 9 -> KA, C -> DO

Таким образом, на выходе получается КАДО.

Ввод, вывод

Вы получите положительное 32-разрядное целое число N, которое вам нужно будет преобразовать в двоично-двоичный код.

Вы можете (вернуть, распечатать и т. Д.) В любом удобном формате, но пары должны быть связаны ! Так KA DOчто не будет в порядке, но KADOбудет.

И, в нижнем регистре и верхний регистр разрешены.

правила

• Нет лазеек.
• Это код-гольф, поэтому выигрывает самый короткий код.

Testcases

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

05AB1E , 20 18 16 байт

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

объяснение

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

Попробуйте онлайн!

Сохранено 2 байта благодаря Аднану

Python 2, 58 байт

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

Рекурсивное решение. Попробуйте это на Ideone .

Python 2, 81 76 байт

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

Выбирает цифру bibi для представления каждой шестнадцатеричной цифры на основе шаблонов в цифрах bibi.

Javascript (ES6), 58 53 43 байта

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

Сохранено 10 байт (больше не поддерживается n = 0)

демонстрация

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 байт

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

Определяет функцию y. В основном тот же алгоритм, что и мой ответ Python .

Объяснение:

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.

Попробуй это здесь! (Дополнительные два символа в конце просто для вызова функции)

Желе , 17 байт

b⁴d4ị"€“BKDH“AEIO

Попробуйте онлайн! или проверьте все контрольные примеры .

Как это работает

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

Рубин, 55 51 байт

Рекурсивная анонимная функция:

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

Назовите это, например, с помощью f[156]и он возвращает"KADO"

J, 35 33 байта

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

Создает таблицу двоичных значений для целых чисел [0, 16), а затем преобразует входные данные n в список из 16 основных цифр и выбирает соответствующее двоичное имя для каждой шестнадцатеричной цифры.

Сохранено 2 байта благодаря @randomra.

использование

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

Эта часть генерирует массив символов 16 x 2 для двоичного имени каждой шестнадцатеричной цифры.

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

объяснение

,/'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 байт

Включает +1 для -p

Запустить с номером на STDIN

bibi.pl <<< 156

bibi.pl:

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

PHP, 63 байта

Вклад @Titus Спасибо

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

72 байта работает также с нуля

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

76 байтов альтернативная версия

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

Рубин, 85 83 байта

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

Просто быстрое и простое решение без кодирования строки.

Pyth, 21 байт

sm@*"HBKD""OAEI"djQ16

Программа, которая принимает ввод целого числа из STDIN и печатает результат.

Попробуйте онлайн

Как это работает

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 байта

$a=HBKDOAEI;$h=dechex($argv[1]);while($h{$i}!=''|$c=hexdec($h{$i++}))echo$a{$c/4}.$a{4+$c%4};

Это в основном использует интегрированные шестнадцатеричные функции и небольшую хитрость в операторе while для экономии на фигурных скобках.

Java, 224 байта

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

Использование некоторой хитрости таблицы поиска Использование типа Long должно было сократить количество байт по сравнению с Integer.

CJam , 20 байтов

qiGb"HBKD""OAEI"m*f=

Попробуйте онлайн!(Как набор тестов с разделением строк).

объяснение

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.

Дьялог АПЛ , 19 байт

Требуется ⎕IO←0по умолчанию во многих системах.

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

∊ подключить (сделать полностью плоским)

(...

 , буйный

 'HBKD'∘.,'OAEI' таблица объединения (то есть все комбинации)

)[ проиндексировано ...

 16⊥⍣¯1 обратное представление от base-16 до base 10 (то есть от base-10 до base 16)

 ⊢ из

 ⎕ числовой ввод

]

Попробуй APL онлайн!

Луа, 196 байт

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 раздражает задачу такого рода, так как по умолчанию она не содержит шестнадцатеричный или двоичный метод преобразования. Большая часть плоти преобразует ее в базу 4. После этого мы устанавливаем 0 за ней, если нам нужно использовать s=("0"):rep(#s%2), тогда мы с помощью gsub заменяем все объекты на их аналог BIBI.

Чип , 174 байта

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

Попробуйте онлайн!TIO включает в себя оболочку Bash, которая преобразует целочисленную строку в фактическое 32-разрядное целочисленное значение.

Верхняя половина печатает буквы, соответствующие двоичным данным, как только нижняя половина обнаружит, что мы достигли интересных данных (другими словами, мы пропускаем начальные нули. Чтобы напечатать все начальные нули, удалите вторую строку, которая начинается с Aи вниз.