Bibi-Binär ist ein numerisches System, das von Boby Lapointe erfunden wurde , um Zahlen in Buchstaben darzustellen, deren Aussprache lustig erscheint.

Ihre Aufgabe ist es, Dezimalzahlen in Bibi-Binär umzuwandeln!

Umwandlung

Eine Zahl wird zur Basis 16 (hexadezimal) konvertiert und jedes Zeichen wird durch seinen bibibinären Namen ersetzt:

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

Sei Neine positive ganze Zahl (zwischen 1 -> 2 ^ 31-1). NErsetzen Sie für jedes Zeichen in der hexadezimalen Darstellung von das Zeichen durch das entsprechende Bibi-Binär-Paar (die obige Tabelle enthält alle Paare).

Beispiel

• N = 156
• H= (hexadezimale Darstellung von N) -> 9C
• 9 -> KA, C -> DO

Der Ausgang ist also KADO.

Input-Output

Sie erhalten eine positive 32-Bit-Ganzzahl N, die Sie in Bibi-Binär umwandeln müssen.

Sie können (Rückgabe, Druck, etc ...) in jedem geeigneten Format, aber die Paare müssen verbunden sein ! Also KA DOwäre nicht in Ordnung, KADOwürde aber .

Sowohl Kleinbuchstaben als auch Großbuchstaben sind zulässig.

Regeln

• Keine Lücken.
• Das ist Code-Golf, also gewinnt der kürzeste Code.

Testfälle

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

05AB1E , 20 18 16 Bytes

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

Erläuterung

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

Probieren Sie es online!

2 Bytes gespart dank Adnan

Python 2, 58 Bytes

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

Eine rekursive Lösung. Probieren Sie es auf 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:])

Wählt die Bibi-Ziffer, um jede Hex-Ziffer basierend auf den Mustern in den Bibi-Ziffern darzustellen.

Javascript (ES6), 58 53 43 Bytes

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

10 Bytes gespeichert (keine Unterstützung für n = 0 mehr)

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

Pyth, 28 Bytes

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

Definiert eine Funktion y. Grundsätzlich der gleiche Algorithmus wie meine Python-Antwort .

Erläuterung:

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.

Probieren Sie es hier aus! (Die zusätzlichen zwei Zeichen am Ende dienen nur zum Aufrufen der Funktion.)

Gelee , 17 Bytes

b⁴d4ị"€“BKDH“AEIO

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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

Eine rekursive anonyme Funktion:

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

Nenne es zum Beispiel mit f[156]und es kehrt zurück"KADO"

J, 35 33 Bytes

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

Erzeugt die Tabelle der bibibinären Werte für Ganzzahlen [0, 16), konvertiert dann die Eingabe n in eine Liste von 16-stelligen Basisziffern und wählt den entsprechenden bibibinären Namen für jede hexadezimale Ziffer aus.

2 Bytes dank @randomra gespeichert.

Verwendung

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

Dieser Teil generiert ein 16 x 2-Array von Zeichen für den bibibinären Namen jeder hexadezimalen Ziffer.

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

Erläuterung

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

Beinhaltet +1 für -p

Führen Sie mit der Nummer auf STDIN

bibi.pl <<< 156

bibi.pl:

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

PHP, 63 Bytes

Beitrag von @Titus Danke

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

72 Bytes funktioniert auch mit Null

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

Ruby, 85 83 Bytes

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

Nur eine schnelle und einfache Lösung, ohne die Zeichenfolge zu codieren.

Pyth, 21 Bytes

sm@*"HBKD""OAEI"djQ16

Ein Programm, das die Eingabe einer Ganzzahl von STDIN übernimmt und das Ergebnis ausgibt.

Probieren Sie es online aus

Wie es funktioniert

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

Dies nutzt im Grunde die integrierten hexadezimalen Funktionen und einen kleinen Trick in der while-Anweisung, um geschweifte Klammern zu sparen.

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

Verwenden einiger Nachschlagetabellen-Tricks Die Verwendung des Typs "Long" bestand darin, einige Bytes im Vergleich zu "Integer" zu sparen

CJam , 20 Bytes

qiGb"HBKD""OAEI"m*f=

Probieren Sie es online! (Als durch Zeilenvorschub getrennte Testsuite.)

Erläuterung

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

Benötigt, ⎕IO←0was auf vielen Systemen Standard ist.

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

∊ eintragen (komplett flach machen)

(...

 , das verwirrte

 'HBKD'∘.,'OAEI' Verkettungstabelle (dh alle Kombinationen)

)[ indiziert von ...

 16⊥⍣¯1 die Umkehrung der Darstellung von Basis 16 zu Basis 10 (dh Basis 10 zu Basis 16)

 ⊢ von

 ⎕ die numerische Eingabe

]

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 nervt für diese Art von Aufgabe, da sie standardmäßig keine hexadezimale oder binäre Konvertierungsmethode enthält. Das meiste Fleisch wandelt es in Basis 4 um. Danach zwingen wir eine 0 dahinter, wenn wir verwenden müssen s=("0"):rep(#s%2), dann ersetzen wir alle Didgets mit gsub durch ihr BIBI-Gegenstück.

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

Probieren Sie es online! TIO enthält einen Bash-Wrapper, der eine Ganzzahl in einen tatsächlichen 32-Bit-Ganzzahlwert konvertiert.

Die obere Hälfte druckt die Buchstaben aus, die den Binärdaten entsprechen. Sobald die untere Hälfte festgestellt hat, dass wir die interessanten Daten erreicht haben, überspringen wir führende Nullen. Um alle führenden Nullen zu drucken, entfernen Sie die zweite Zeile, die mit beginnt Aund runter.