पूर्णांक को देखते हुए, इसके लेवेंशेटिन कोड की गणना करें

Question

^{डिस्क्लेमर: लेवेंसहाइट कोडिंग लेवेंसहाइट एडिट दूरी डिस्ट्रिक से पूरी तरह से असंबंधित है ।}

<इस बारे में लंबी कहानी डालें कि लेवेंसहाइट कोड की गणना यहाँ करने की आवश्यकता क्यों है।>

कोड

Levenshtein कोडिंग नॉनजेगेटिव पूर्णांकों को बाइनरी कोड असाइन करने की एक प्रणाली है जो संभाव्यता में कुछ अजीब संपत्ति को बरकरार रखती है जो इस चुनौती के लिए प्रासंगिक नहीं है। हम इस कोड को L ( n ) के रूप में निरूपित करेंगे । विकिपीडिया इसे पाँच-चरणीय प्रक्रिया के रूप में वर्णित करता है:

1. चरण गणना चर C से 1 को प्रारंभ करें ।
2. 1कोड की शुरुआत के लिए अग्रणी के बिना संख्या का द्विआधारी प्रतिनिधित्व लिखें ।
3. बता दें कि M चरण 2 में लिखे गए बिट्स की संख्या है।
4. यदि M 0 नहीं है , तो C को बढ़ाएं , नए नंबर के रूप में M के साथ चरण 2 से दोहराएं ।
5. C 1 बिट्स और 0कोड की शुरुआत में लिखें ।

हालाँकि, कोड को पुनरावर्ती रूप से भी वर्णित किया जा सकता है:

1. यदि संख्या 0 है, तो इसका कोड है 0।
2. 1कोड की शुरुआत के लिए अग्रणी के बिना संख्या का द्विआधारी प्रतिनिधित्व लिखें ।
3. बता दें कि M चरण 2 में लिखे गए बिट्स की संख्या है।
4. कोड की शुरुआत में L ( M ) लिखें ।
5. 1कोड की शुरुआत में थोड़ा सा लिखें ।

उदाहरण के लिए, जो लोग पसंद करते हैं, यहां L (87654321) के लिए पुनरावर्ती प्रक्रिया है , जिसमें संगोष्ठी दर्शाती है:

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें, जो एक नंबर n दिया गया है , बिटस्ट्रिंग L ( n ) को किसी भी उचित प्रारूप में आउटपुट करता है (इसमें उक्त बिट्स के साथ एक नंबर वापस करना शामिल है)। मानक खामियां, हमेशा की तरह, अस्वीकृत हैं।

उदाहरण

इनपुट: 5

आउटपुट: 1110001

इनपुट: 30

आउटपुट: 111100001110

इनपुट: 87654321

आउटपुट: 111110000101001001110010111111110110001

इनपुट: 0

आउटपुट: 0

Answer 1

जेली , 13 11 बाइट्स

Ḣ;LÑ$;
BÇṀ¡

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

सबमिशन में पारस्परिक रूप से पुनरावर्ती लिंक की एक जोड़ी होती है।

BÇṀ¡    Main link. Argument: n

B       Convert n to binary.
   ¡    Execute...
 Ç        the helper link...
  Ṁ       m times, where m is the maximum of n's binary digits.

Ḣ;LÑ$;  Helper link. Argument: A (array of binary digits)

Ḣ       Head; remove and return the first element of A.
    $   Combine the two links to the left into a monadic chain.
  L       Yield the length (l) of A without its first element.
   Ñ      Call the main link with argument l.
 ;      Concatenate the results to both sides.
     ;  Append the tail of A.

Answer 2

हास्केल, 70 बाइट्स

b 0=[]
b n=b(div n 2)++[mod n 2]
f 0=[0]
f n|1:t<-b n=1:f(length t)++t

एक कार्य को परिभाषित करता है f : Int -> [Int]। उदाहरण के लिए, f 5 == [1,1,1,0,0,0,1]।

Answer 3

पायथन, 49 बाइट्स

f=lambda n:n and'1%s'%f(len(bin(n))-3)+bin(n)[3:]

Ideone पर इसका परीक्षण करें ।

Answer 4

गणितज्ञ, 61 बाइट्स

f@0={0};f@n_:=Join[{1},f@Length@#,#]&@Rest@IntegerDigits[n,2]

Comments

मुझे पूरा यकीन है कि आप ±एक फ़ंक्शन के बजाय एक अपर ऑपरेटर को परिभाषित करके कुछ बाइट्स बचा सकते हैं f।

— मार्टिन एंडर

Answer 5

जावास्क्रिप्ट (ईएस 6), 54 52 बाइट्स

f=n=>(s=n.toString(2)).replace(1,_=>1+f(s.length-1))

<input type=number oninput=o.textContent=f(+this.value)><pre id=o>

संपादित करें: सहेजे गए 2 बाइट @Arnauld के लिए धन्यवाद।

Comments

मुझे लगता है कि आप सुरक्षित रूप replace(1,...से replace(/1/,...=> 52 बाइट्स

— Arnauld

Answer 6

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

L&bX1.Bbyslb

प्रदर्शन

( y अंत में इनपुट पर परिणामी फ़ंक्शन को चलाना है)

स्पष्टीकरण:

L&bX1.Bbyslb
L               def y(b):
 &b             If b is 0, return 0. This is returned as an int, but will be cast
                to a string later.
          lb    Take the log of b
         s      Floor
        y       Call y recursively
   X1           Insert at position 1 into
     .Bb        Convert b to binary.

Answer 7

SQF, 110

पुनरावर्ती समारोह:

f={params[["i",0],["l",[]]];if(i<1)exitWith{[0]};while{i>1}do{l=[i%2]+l;i=floor(i/2)};[1]+([count l]call f)+l}

इस रूप में कॉल करें: [NUMBER] call f

ध्यान दें कि यह वास्तव में एआरएमए इंजन में बग के कारण 87654321 या अन्य बड़ी संख्या के लिए काम नहीं करता है। हालांकि यह शायद जल्द ही तय हो जाएगा, और कल्पना के अनुसार काम करना चाहिए।

( यह टिकट यहां )

Answer 8

PHP, 116 114 बाइट्स

<?$f=function($i)use(&$f){$b=decbin($i);return!$b?0:preg_replace('/^1/',1 .$f(~~log10($b)),$b);};echo$f($argv[1]);

पहले तर्क के रूप में संख्या प्रदान करें।

अपडेट करें:

• के strlen($b)-1साथ प्रतिस्थापित करके एक बाइट को बचाया ~~log10($b)(अंत में समझा गया कि क्यों हर कोई लघुगणक का उपयोग कर रहा था) और दूसरे ने अलग-अलग तरीके से सहमति व्यक्त की ।

Answer 9

रूबी, 38 बाइट्स

नील के जावास्क्रिप्ट उत्तर के समान ।

f=->n{("%b"%n).sub(/1\K/){f[$'.size]}}

इसे repl.it पर देखें: https://repl.it/CnhQ

Answer 10

जावा 8 (पूर्ण कार्यक्रम), 257 249 बाइट्स

interface M{static void main(String[]a)throws Exception{int i=0,j;while((j=System.in.read())>10)i=i*10+j-48;System.out.print(L(i));}static String L(int i){if(i==0)return "0";String s=Integer.toString(i,2);return "1"+L(s.length()-1)+s.substring(1);}}

पठनीय संस्करण w / स्पष्टीकरण (यह ज्यादातर सिर्फ पुनरावृत्ति है):

interface M {
    static void main(String[]a) throws Exception { // Using Exception is unadvised in real coding, but this is Code Gold
        int i = 0, j; // i stores the input; j is a temporary variable
        while ((j = System.in.read()) > 10) // Read the input to j and stop if it is a newline. Technically this stops for tabulators as well, but we shouldn't encounter any of those...
            i = i * 10 + j - 48; // Looping this step eventually reads the whole number in from System.in without using a reader (those take up a lot of bytes)
        System.out.print(L(i)); // Make a method call
    }

    static String L(int i) { // This gets the actual Levenshtein Code
        if (i == 0)
            return "0"; // The program gets a StackOverflowException without this part
        String s = Integer.toString(i, 2); // Shorter than toBinaryString
        return "1" + L(s.length() - 1) + s.substring(1); // Write in the first character (which is always a one), followed by the next L-code, followed by the rest of the binary string
    }
}

EDIT 1 : सहेजे गए 8 बाइट्स : बाइनरी स्ट्रिंग का पहला वर्ण हमेशा 1 होता है; इसलिए, उपयोग करने के बजाय s.charAt(0), एक बेहतर विकल्प बस है "1"।