बीबी-बाइनरी में कनवर्ट करें

Question

बॉबी लैपॉइंट द्वारा आविष्कृत बीबी-बाइनरी एक संख्यात्मक प्रणाली है, जो अक्षरों में संख्याओं का प्रतिनिधित्व करने के लिए है जो उच्चारण मजाकिया लगता है।

आपका कार्य दशमलव संख्याओं को बीबी-बाइनरी में बदलना है!

रूपांतरण

एक संख्या को आधार 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) -> 9 सी
• 9 -> केए, सी -> डीओ

इस प्रकार आउटपुट KADO है।

इनपुट आउटपुट

आपको एक सकारात्मक 32-बिट पूर्णांक प्राप्त होगा N, जिसे आपको बीबी-बाइनरी में बदलना होगा।

आप किसी भी सुविधाजनक प्रारूप में (वापसी, प्रिंट आदि ...) कर सकते हैं, लेकिन जोड़े को कनेक्ट करना होगा ! तो KA DOठीक नहीं होगा, लेकिन KADOहोगा।

दोनों, लोअरकेस और अपरकेस की अनुमति है।

नियम

• कोई खामियां नहीं।
• यह कोड-गोल्फ है, इसलिए सबसे छोटा कोड जीतता है।

परीक्षण के मामलों

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

Comments

युक्ति यह कहती है कि इनपुट एक सेक्शन में गैर-नकारात्मक होगा और दूसरे में पॉजिटिव - क्या आप स्पष्ट कर सकते हैं कि कौन सा इरादा है?

— Sp3000

@ Sp3000 पॉजिटिव का इरादा है। मुझे लगता है कि धन्यवाद में संपादित करेंगे!

— यति

आपका युक्ति अभी भी 0 -> 2 ^ 31-1 के बीच कहता है , लेकिन 0 सकारात्मक नहीं है (अंग्रेजी में)।

— डेनिस

@ डेनिस I ने 0 को सकारात्मक माना। मैं इसे संपादित करूँगा। उल्लेख के लिए धन्यवाद!

— 18

@TuukkaX 0 सकारात्मक और गैर-नकारात्मक के बीच का अंतर है।

— मोनिका

Answer 1

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 बाइट्स बचाए

Comments

…Âkdका एक संपीड़ित संस्करण है "hbkd":)।

— अदनान

इसके अलावा, मुझे यकीन नहीं है कि यह संभव है, लेकिन Hएक हेक्साडेसिमल संख्या को आधार १० में भी परिवर्तित करता है

— अदनान

Answer 2

पायथन 2, 58 बाइट्स

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

एक पुनरावर्ती समाधान। Ideone पर इसे आज़माएं ।

Comments

f=lambda n:n*'_'and f(n/16)+"HBKD"[n/4%4]+"OAEI"[n%4]5 बाइट्स बचाता है।

— डेनिस

मैंने अपनी टिप्पणी को एकमत नहीं किया। ओपी ने स्पष्ट किया और इनपुट 0 अमान्य है।

— डेनिस

Answer 3

पायथन 2, 81 76 बाइट्स

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

बीबी-अंकों को चुनता है जो कि बीबी-अंकों में पैटर्न के आधार पर प्रत्येक हेक्स अंक का प्रतिनिधित्व करता है।

Answer 4

जावास्क्रिप्ट (ईएस 6), 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

Comments

क्या अब आप इसे छोटा कर सकते हैं कि शून्य अब आवश्यकता नहीं है?

— नील

Answer 5

पायथ, 28 बाइट्स

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

एक कार्य को परिभाषित करता है y। मूल रूप से मेरे अजगर जवाब के रूप में एक ही एल्गोरिथ्म ।

स्पष्टीकरण:

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.

यहाँ कोशिश करो! (अंत में अतिरिक्त दो वर्ण केवल फ़ंक्शन को कॉल करने के लिए हैं)

Answer 6

जेली , 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).

Answer 7

रूबी, 55 51 बाइट्स

एक पुनरावर्ती अनाम फ़ंक्शन:

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

उदाहरण के लिए इसे कॉल करें f[156]और यह वापस आ जाए"KADO"

Answer 8

जे, 35 33 बाइट्स

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

पूर्णांक [0, 16) के लिए बीबी-बाइनरी मानों की तालिका बनाता है, फिर इनपुट n को आधार 16 अंकों की सूची में परिवर्तित करता है और प्रत्येक हेक्स अंक के लिए संबंधित बीबी-बाइनरी नाम का चयन करता है।

@Randomra की बदौलत 2 बाइट्स बचाए।

प्रयोग

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

Comments

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

— FrownyFrog

Answer 9

पर्ल, 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}{

Answer 10

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

Comments

यह एक कोशिश करें:for($n=$argv[1];$n;$n>>=2)$r=HBKDOAEI[$n%4+4*$t=!$t].$r;echo$r;

— टाइटस

इसके अलावा: आप अपने पहले संस्करण से कर्ल को गोल्फ करना भूल गए।

— टाइटस

for($n=$argv[1];$n;$n>>=4)$r=HBKD[$n/4&3].OAEI[$n&3].$r;echo$r;63 बाइट्स के लिए या 61 के लिए अरनुल्द के जवाब का एक हिस्सा:function f($n){return$n?f($n>>4).HBKD[$n/4&3].OAEI[$n&3]:'';}

— टाइटस

@ आपका पहला संस्करण 1 या 16 के इनपुट से सही ढंग से काम नहीं करता है। अच्छा मुझे इस बात का अहसास नहीं है कि इनपुट के रूप में शून्य की अनुमति नहीं है

— Jörg Hülsermann

हाँ, बस देखा। यह Hपहली जगह में प्रिंट नहीं करता है। दूसरा ले लो।

— टाइटस

Answer 11

रूबी, 85 83 बाइट्स

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

स्ट्रिंग को एन्कोडिंग के बिना बस एक त्वरित और सरल समाधान।

Answer 12

पायथ, 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

Answer 13

PHP, 93 बाइट्स

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

यह मूल रूप से एकीकृत हेक्साडेसिमल फ़ंक्शंस का लाभ उठाता है और घुंघराले ब्रेसिज़ को बचाने के लिए स्टेटमेंट में थोड़ी सी चाल है।

Answer 14

जावा, 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));}}}

कुछ लुकअप टेबल प्रवंचना का उपयोग करना लंबे प्रकार का उपयोग पूर्णांक की तुलना में कुछ बाइट्स से दाढ़ी करना था

Answer 15

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.

Answer 16

दिल्लोग एपीएल , 19 बाइट्स

⎕IO←0कई सिस्टम पर डिफ़ॉल्ट की आवश्यकता होती है।

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

∊ सूची (पूरी तरह से सपाट करें)

(...

 , उखड़ा हुआ

 'HBKD'∘.,'OAEI' संघनन तालिका (अर्थात सभी कम्बोड)

)[ द्वारा अनुक्रमित ...

 16⊥⍣¯1 बेस -16 का बेस 10 (यानी बेस -10 से बेस 16) का प्रतिनिधित्व

 ⊢ का

 ⎕ संख्यात्मक इनपुट

]

TryAPL ऑनलाइन!

Answer 17

लुआ, 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), तो हम gubub का उपयोग करते हुए अपने BIBI समकक्ष के साथ सभी डीड को प्रतिस्थापित करते हैं।

Answer 18

चिप , 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और नीचे।