65

रान्डेल मुनरो की पुस्तक "xkcd, खंड 0" पृष्ठ संख्याओं के लिए एक विषम संख्या प्रणाली का उपयोग करती है। पहले कुछ पेज नंबर हैं

1, 2, 10, 11, 12, 20, 100, 101, 102, 110, 111, 112, 120, 200, 1000, 1001, ...

इस त्रिगुट की तरह एक सा है, लेकिन लगता है कि वह से छोड़ देता है तो 20सीधे करने के लिए 100, से 120करने के लिए 200और से 200करने के लिए 1000। इस अनुक्रम को परिभाषित करने का एक तरीका यह है कि यह उन सभी टर्नरी नंबरों को समाहित करता है जिनमें सबसे अधिक एक होते हैं 2और उसके 1बाद नहीं 2। आप इसे प्रवेश A169683 में OEIS पर पा सकते हैं । इस संख्या प्रणाली को तिरछा बाइनरी के रूप में जाना जाता है ।

आपका काम एक सकारात्मक पूर्णांक दी के प्रतिनिधित्व को मिल रहा है Nइस संख्या प्रणाली में।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट ले रहे हैं और STDOUT (या निकटतम विकल्प), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम लिख सकते हैं।

आउटपुट एक स्ट्रिंग, एक संख्या हो सकती है जिसमें तिरछा बाइनरी प्रतिनिधित्व के बराबर एक दशमलव प्रतिनिधित्व होता है, या अंकों की सूची (पूर्णांक या वर्ण / तार के रूप में)। आपको अग्रणी शून्य वापस नहीं करना चाहिए।

यह कोड गोल्फ है, इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।

मजेदार तथ्य: इस संख्या प्रणाली में वास्तव में कुछ योग्यता है। जब एक संख्या बढ़ाई जाती है, तो आप हमेशा अधिकतम दो आसन्न अंकों में बदलेंगे - आपको पूरे नंबर के माध्यम से परिवर्तन नहीं करना पड़ेगा। सही प्रतिनिधित्व के साथ जो ओ (1) में वेतन वृद्धि की अनुमति देता है।

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

1 => 1
2 => 2
3 => 10
6 => 20
7 => 100
50 => 11011
100 => 110020
200 => 1100110
1000 => 111110120
10000 => 1001110001012
100000 => 1100001101010020
1000000 => 1111010000100100100
1048576 => 10000000000000000001

1000000000000000000 => 11011110000010110110101100111010011101100100000000000001102

मैं कम से कम जवाब देने के लिए एक इनाम दूंगा जो अंतिम परीक्षण के मामले को हल कर सकता है (और समान परिमाण के किसी भी अन्य इनपुट, इसलिए हार्डकोडिंग के बारे में ऐसा मत सोचो) एक सेकंड से भी कम समय में।

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं, उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

<script>site = 'meta.codegolf'; postID = 5314; isAnswer = true; QUESTION_ID = 51517</script><script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>jQuery(function(){var u='https://api.stackexchange.com/2.2/';if(isAnswer)u+='answers/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJeRCD';else u+='questions/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJO6t)';jQuery.get(u,function(b){function d(s){return jQuery('<textarea>').html(s).text()};function r(l){return new RegExp('<pre class="snippet-code-'+l+'\\b[^>]*><code>([\\s\\S]*?)</code></pre>')};b=b.items[0].body;var j=r('js').exec(b),c=r('css').exec(b),h=r('html').exec(b);if(c!==null)jQuery('head').append(jQuery('<style>').text(d(c[1])));if (h!==null)jQuery('body').append(d(h[1]));if(j!==null)jQuery('body').append(jQuery('<script>').text(d(j[1])))})})</script>

स्निपेट का विस्तार करें

— मार्टिन एंडर
स्रोत

32

मेरे पास वह पुस्तक है जब से वह पहली बार आई थी और कभी पृष्ठ क्रमांक पर ध्यान नहीं दिया था।

— एलेक्स ए।

2

@AlexA। मेरे पास मेरे किंडल पर है जहाँ आप कोई भी दिलचस्प पेज नंबरिंग नहीं कर सकते।

— लीजनमोनमल 978

21

@ LegionMammal978: दुखद।

— एलेक्स ए।

1

@ SuperJedi224 सर्वसम्मति प्रतीत होती है , इसलिए क्षमा करें (यदि मैं आपकी भाषा को संभाल सकता हूं तो केवल एक ही तरह का एक अपवाद होगा, यदि ऐसा कोई इनपुट हो, लेकिन ऐसा प्रतीत नहीं होता)।

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

4

यह मुझे याद दिलाता है कि जब मैं 3. था तब मैं कैसे गिनती करता था। मैंने तर्क दिया: "कोई पचास-दस नहीं है, इसलिए एक सौ-नौ के बाद दो-सौ होना चाहिए।" मुझे केवल अपनी गलती का एहसास हुआ 59->60और 109->110, अतिरिक्त के साथ-साथ अंतर को देखने पर 0.

— साइओसी

12

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

Ljb3ye.f!-P-yZ01Q

यह कुछ हद तक हास्यास्पद है - O(output^log_2(3))। यह इनपुट की लंबाई में घातांक है, लेकिन पृष्ठ पर कुछ उत्तरों की तरह दोगुना घातीय नहीं है। @ डेनिस के उत्तर से लिए गए कुछ विचार, यहां दिए गए हैं ।

प्रदर्शन।

यह .fपायथ के "लूप का उपयोग करता है जब तक कि एन मैचों को नहीं मिला है" फ़ंक्शन।

— isaacg
स्रोत

32

CJam, 24 23 22 21 19 बाइट्स

ri_)2b,,W%{2\#(md}/

यह एक ओ (लॉग एन) दृष्टिकोण है, जहां एन इनपुट है, जो अंतिम परीक्षण मामले को तुरंत पूरा करता है। यह धर्मान्तरित n सीधे द्विआधारी तिरछा करने, अंकों के मूल्यों से मॉड्यूलर विभाजन का उपयोग कर 1 ।

यह कोड जावा इंटरप्रेटर के साथ STDERR पर जाने वाली त्रुटि के साथ समाप्त होता है, जिसे मेटा पर सर्वसम्मति के अनुसार अनुमति दी जाती है ।

यदि आप सीजेएम दुभाषिया में इस कोड की कोशिश करते हैं , तो बस सब कुछ अनदेखा करें लेकिन आउटपुट की अंतिम पंक्ति।

त्रुटि को समाप्त किया जा सकता है, 2 बाइट्स की कीमत पर, पूर्व निर्धारित 2>करके W%।

एक बाइट को बंद करने के लिए @ मार्टिनबटनर को धन्यवाद।

पृष्ठभूमि

तिरछा द्विआधारी प्रतिनिधित्व एक _के ... एक ₀ पूर्णांक n = (2 ^{k + 1} -1) a _k + ... + (2 ¹ -1) a _{0 से} मेल खाता है ।

चूंकि दोनों (2 ^k -1) + ... + (2 ¹ -1) = 2 ^{k + 1} - (k + 2) और (2 ^k -1) + ... + 2 (2 ^j -1) = 2 ^{k + 1} - (2 ^{j + 1} - 2 ^j + K + 1) कर रहे हैं कम से कम 2 ^{k + 1} -1 , के मूल्यों एक _{कश्मीर} के लिए एक ₀ द्वारा लगातार मॉड्यूलर प्रभाग द्वारा बरामद किया जा सकता 2 ^{k + 1} -1 , 2 ^के -1 , आदि।

शुरू करने के लिए, हमें पहले 2 ^{k + 1} -1 का मान ^{ज्ञात करना होगा} । चूँकि n अधिकतम 2 (2 ^{k + 1} -1) पर है , पूर्णांक n + 1 को कड़ाई से 2 ^{k + 2} से छोटा होना चाहिए ।

इस प्रकार, n + 1 पैदावार k + 1 के बाइनरी लॉगरिदम का पूर्णांक हिस्सा ले रहा है ।

अंत में, हम देखते हैं कि पूर्णांक n + 1 का आधार _{2 में} ( log ₂ (n + 1) अंक है।

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

ri    e# Read an integer N from STDIN.
2b,   e# Push the number of binary digits of N + 1, i.e, K + 2 = log(N + 1) + 1.
,W%   e# Push the range [K+1 ... 0].
{     e# For each J in the range:
  2\# e#   J -> 2**J
  (   e#     -> 2**J - 1
  md  e#   Perform modular division of the integer on the stack (initially N)
      e#   by 2**J - 1: N, 2**J - 1 -> N/(2**J - 1), N%(2**J - 1)
}/    e#

अंतिम दो पुनरावृत्तियों में, हम 1 और 0 द्वारा मॉड्यूलर विभाजन करते हैं । पहले स्टैक पर अवांछित 0 धक्का देता है । अंतिम प्रयास को अंजाम देने के लिए 0 0 md, जो स्टैक से दोनों अवांछित 0 s को पॉप करता है , किसी भी चीज को धक्का देने के बजाय तुरंत बाहर निकलता है और स्टैक को STDOUT को डंप करता है।

— डेनिस
स्रोत

28

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

def f(n):x=len(bin(n+1))-3;y=2**x-1;return n and n/y*10**~-x+f(n%y)

दिए गए परीक्षण मामलों के लिए काम करने लगता है। अगर मुझे यह अधिकार मिला है O(place values set in output), तो इस बारे में होना चाहिए , इसलिए यह आखिरी मामला आसानी से करता है।

जैसे बुलाओ f(100)। तिरछा बाइनरी के बराबर एक दशमलव प्रतिनिधित्व लौटाता है।

पायथन 3, 65 बाइट्स

def g(n,x=1):*a,b=n>x*2and g(n,x-~x)or[n];return a+[b//x,b%x][:x]

थोड़ा कम कुशल लेकिन फिर भी लघुगणक है, इसलिए अंतिम मामला निकट-तत्काल है।

जैसे बुलाओ g(100)। अंकों की सूची लौटाता है।

— Sp3000
स्रोत

2and3 में संकलन करता है ? मैं 2 में हूं और 2and2एक वाक्यविन्यास त्रुटि फेंकता हूं

— टैंकरस्मैश

3

@TankorSmash 2and2काम नहीं करेगा, क्योंकि यह पार्स हो जाएगा 2 and2- कोशिश करें 2and 2, जो कि आपके पायथन संस्करण के लिए पर्याप्त नया होने पर काम करना चाहिए (पायथन 2.7.10 में परीक्षण किया गया है)

— Sp3000

ओह अच्छा, तुम सही हो। 2.7.3 पर भी यह काम करता है।

— टैंकरमाश

12

सीजाम, 22 21 20 बाइट्स

ri_me,3fb{0-W<1-!},=

यह एक O (e ⁿ n) दृष्टिकोण है, जहाँ n इनपुट है। यह पहली बार सूचीबद्ध करता ⌊e ⁿ ⌋ गैर नकारात्मक आधार 3 में पूर्णांकों, वे होते हैं जिन्हें समाप्त 2 या 1 पहली बार तब जब रों 2 (यदि हो तो) और चयन करता n + 1 ^वें ।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

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

ri    e# Read an integer N from STDIN.
_me,  e# Push [0 ... floor(exp(N))-1].
3fb   e# Replace each integer in the range by the array of its digits in base 3.
{     e# Filter; for each array A:
  0-  e#   Remove all 0's.
  W<  e#   Remove the last element.
  1-  e#   Remove all 1's.
  !   e#   Logical NOT. Pushes 1 iff the array is empty.
},    e#   If ! pushed 1, keep the array.
=     e# Select the (N+1)th element of the filtered array.

— डेनिस
स्रोत

9

अजगर, 20 बाइट्स

Jt^2hslhQ#p/=%QJ=/J2

ओ (लॉग (इनपुट ())) में चलता है, अंतिम परीक्षण मामले के लिए एक सेकंड के तहत। त्रुटि लूप तक एक रन के आधार पर। कोई अनुगामी न्यूलाइन नहीं।

प्रदर्शन।

व्याख्या:

Jt^2hslhQ#p/=%QJ=/J2
                        Implicit: Q is the input.
      lhQ                          log(Q+1,2)
     slhQ                    floor(log(Q+1,2))
    hslhQ                    floor(log(Q+1,2))+1
  ^2hslhQ                 2^(floor(log(Q+1,2))+1)
 t^2hslhQ                 2^(floor(log(Q+1,2))+1)-1
Jt^2hslhQ               J=2^(floor(log(Q+1,2))+1)-1
         #              until an error is thrown:
            =%QJ        Q=Q%J
                =/J2    J=J/2
           /            The value Q/J, with the new values of Q and J.
          p             print that charcter, with no trailing newline.

J को सबसे छोटी तिरछी बाइनरी डिजिट पोजीशन के मान से इनिशियलाइज़ किया जाता है जो इनपुट से बड़ी होती है। फिर, हर बार लूप के माध्यम से, हम निम्नलिखित करते हैं:

मूल्य के प्रत्येक अंक निकालें Jसे Qसाथ =%QJ। उदाहरण के लिए, यदि Q=10और J=7, Qबन जाता है 3, जो तिरछा बाइनरी से बदलता 110है 10। पहले पुनरावृत्ति में इसका कोई प्रभाव नहीं है।
Jअगले छोटे तिरछा बाइनरी बेस मान के साथ बदलें =/J2। उदाहरण के लिए , इसे बदलते J=7हुए J=3, 2 से विभाजित किया गया है । क्योंकि यह पहला अंक आउटपुट से पहले होता है, Jएक अंक की स्थिति को आवश्यकता से अधिक है।
/QJ(प्रभावी रूप से) के साथ वास्तविक अंकों का मान ज्ञात कीजिए ।
pपायलिंग की डिफ़ॉल्ट प्रिंटिंग के बजाय, उस मूल्य को प्रिंट करें , जो अनुगामी न्यूलाइन से बचने के लिए है।

यह लूप Jशून्य होने तक दोहराएगा , जिस बिंदु पर शून्य त्रुटि से विभाजित किया जाएगा, और लूप समाप्त हो जाएगा।

— isaacg
स्रोत

8

ईएस 6, 105 बाइट्स

f=n=>{for(o=0;n--;c?o+=Math.pow(3,s.length-c):o++)s=t(o),c=s.search(2)+1;return t(o);},t=a=>a.toString(3)

उपयोग है: f(1048576)=> `" 10000000000000000001 "

अपने स्वयं के जोखिम पर अंतिम तर्क का परीक्षण करें। मैंने 5 सेकंड के बाद छोड़ दिया।

और टिप्पणियों के साथ बहुत अच्छा प्रिंट!

f=n=>{ //define function f with input of n (iteration)
    for(o=0; //define o (output value in decimal)
        n--; //decrement n (goes towards falsy 0) each loop until 0
        c?o+=Math.pow(3,s.length-c):o++) //if search finds a 2, increment output by 3^place (basically moves the 2 to the left and sets the place to 0), else ++
        s=t(o), //convert output to base 3      
        c=s.search(2)+1; //find the location of 2, +1, so a not-found becomes falsy 0.
    return t(o); //return the output in base 3
},

t=a=>a.toString(3);  //convert input a to base 3

— दिशा सूचक यंत्र
स्रोत

5

Btw, अनाम कार्य पूरी तरह से स्वीकार्य हैं, इसलिए आपको इसकी आवश्यकता नहीं है f=।

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

2

-16 बाइट्स:f=n=>{for(o=0;~n--;o+=c?Math.pow(3,s.length+c):1)s=o.toString(3),c=~s.search(2);return s}

— अंडर

@nderscore बहुत अच्छा: D

— कम्पास

1

-7 बाइट्स यदि आप ईएस 7 का उपयोग करते हैं: के Math.pow(3,s.length+c)साथ बदलें 3**(s.length+c)।

— गुस्तावो रॉड्रिक्स

3

@GustavoRodrigues मैंने ES6 सीखना भी समाप्त नहीं किया है! @ _ @

— कम्पास

7

रेटिना, 55 बाइट्स

^
0a
(+`12(.*a)1
20$1
0?2(.*a)1
10$1
0a1
1a
)`1a1
2a
a
<empty line>

अनरीट में इनपुट लेता है।

प्रत्येक पंक्ति को अपनी फ़ाइल पर जाना चाहिए लेकिन आप -sध्वज के साथ एक फ़ाइल के रूप में कोड चला सकते हैं । उदाहरण के लिए:

> echo 11111|retina -s skew
12

विधि: स्ट्रिंग से शुरू होने वाले एक स्ट्रिंग इनपुट नंबर समय पर वृद्धि को निष्पादित करता है 0।

हम निम्नलिखित वेतन वृद्धि नियमों का उपयोग करते हैं:

अगर होता है 2: ^2 -> ^12; 02 -> 12;12 -> 20
अगर शामिल नहीं है 2: 0$ -> 1$;1$ -> 2$

( 2स्ट्रिंग में सबसे अधिक एक हो सकता है ; ^और $नियमों में स्ट्रिंग की शुरुआत और अंत को चिह्नित करता है।)

रेटिना के बारे में अधिक जानकारी।

— randomra
स्रोत

7

जावा, 154 148

n->{String s="0";for(;n-->0;)s=s.contains("2")?s.replaceAll("(^|0)2","10").replace("12","20"):s.replaceAll("1$","2").replaceAll("0$","1");return s;}

यह उत्तर एकल अनाम फ़ंक्शन का रूप लेता है जो पूर्णांक तर्क लेता है और स्ट्रिंग के रूप में उत्तर देता है। नीचे इस समाधान के परीक्षण के लिए एक पूर्ण वर्ग है।

import java.util.function.Function;
public class Skew {
    public static void main(String[] args){
        Function<Integer,String> skew = n->{String s="0";for(;n-->0;)s=s.contains("2")?s.replaceAll("(^|0)2","10").replace("12","20"):s.replaceAll("1$","2").replaceAll("0$","1");return s;};

        for(String s:args){
            System.out.println(skew.apply(Integer.parseInt(s)));
        }
    }
}

— आंख-morpork
स्रोत

5

बाश + कोरुटिल्स, 52

dc -e3o0[r1+prdx]dx|grep -v 2.\*[12]|sed -n $1{p\;q}

यह एक ब्रूट-फॉरेसर है, इसलिए बड़ी संख्या के लिए इसकी धीमी गति है।

आउटपुट:

$ ./xkcdnum.sh 1000
111110120
$

— डिजिटल आघात
स्रोत

5

जावा, 337 335 253 246 244 बाइट्स

एक विधि जो सूचकांक में एक के रूप में लेती है longऔर परिणाम को एक स्ट्रिंग के रूप में लौटाती है

longसूचकांक के लिए उपयोग करता है तो सैद्धांतिक रूप से अंतिम परीक्षण मामले को संभाल सकता है , लेकिन मैं वास्तव में इसका सुझाव नहीं दूंगा।

String f(long i){List<Long>l=new ArrayList<>();l.add(0L);for(;i-->0;){int j=l.indexOf(2);if(j!=-1){l.set(j,0L);if(j==0){l.add(0,1L);}else{l.set(j-1,l.get(j-1)+1);}}else{j=l.size()-1;l.set(j,l.get(j)+1);}}String s="";for(long q:l)s+=q;return s;}

— SuperJedi224
स्रोत

4

आप इसे एक पूर्ण कार्यक्रम के बजाय एक फ़ंक्शन बनाकर (और एक स्कैनर के बजाय एक तर्क के रूप में इनपुट लेते हुए) इसे थोड़ा छोटा कर सकते हैं।

— Geobits

2

आपको if(j == 0) कथन (चार बाइट्स) में ब्रेसिज़ की आवश्यकता नहीं है । आपको घोषित करने की आवश्यकता नहीं है k; आप बस jफिर से (चार और) का उपयोग कर सकते हैं । आप अपनी सूची घोषणा ( new ArrayList<>();) (अन्य 4) में सामान्य प्रकार के अनुमान (जावा 7 में) का उपयोग कर सकते हैं

— ड्यूर्रोन 597

4

हास्केल, 73 72

^{1 बाइट के लिए @nimi को धन्यवाद!}

यह समाधान किसी भी इनाम में नहीं जीता जाएगा, अंतिम युगल परीक्षण को चलाने के लिए एक विषम राशि लेते हैं, लेकिन, मुझे लगता है कि मैंने इसे काफी अच्छी तरह से तैयार किया है।

i(2:b)=1:0:b
i[b]=[b+1]
i(b:2:c)=b+1:0:c
i(b:c)=b:i c
s=(iterate i[0]!!)

यह समाधान एक बल्कि भोला दृष्टिकोण है जो n0 nबार वृद्धि करके तिरछा द्विआधारी संख्या की गणना करता है।

— आंख-morpork
स्रोत

4

सीजेएम, 24 बाइट्स

Q{0\+2a/())+a\+0a*}ri*si

यह एक ओ (एन लॉग एन) दृष्टिकोण है, जहां एन इनपुट है। यह 0 के तिरछा द्विआधारी प्रतिनिधित्व के साथ शुरू होता है और इसी पूर्णांक n समय को बढ़ाता है ।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

पृष्ठभूमि

तिरछा बाइनरी में एक संख्या बढ़ाना दो आसान चरणों का पालन करके किया जा सकता है:

एक अंतिम 2 को 0 से बदलें ।
यदि एक 2 को बदल दिया गया है, तो अंक को इसके बाईं ओर बढ़ाएँ।

अन्यथा, अंतिम अंक बढ़ाएँ।

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

Q     e# Push an empty array.
{     e# Define an anonymous function:
  0\+ e#   Prepend a 0 to the array.
  2a/ e#   Split the array at 2's.
  (   e#   Shift out the first chunk of this array.
  )   e#   Pop the last digit.
  )+  e#   Increment it and append it to the array.
  a\+ e#   Prepend the chunk to the array of chunks.
  0a* e#   Join the chunks, using [0] as separator.
      e#   If there was a 2, it will get replaced with a 0. Otherewise, there's
      e#   only one chunk and joining the array dumps the chunk on the stack.
}     e#
ri*   e# Call the function int(input()) times.
si    e# Cast to string, then to integer. This eliminates leading 0's.

— डेनिस
स्रोत

4

VBA, 209 147 142 बाइट्स

Sub p(k)
For i=1To k
a=StrReverse(q)
If Left(Replace(a,"0",""),1)=2Then:q=q-2*10^(InStr(a,2)-1)+10^InStr(a,2):Else:q=q+1
Next
msgbox q
End Sub

मेरा गणित अक्षम है और मेरी गोल्फ काम का उपयोग कर सकती है। लेकिन यह PoG में मेरा पहला प्रयास है और मुझे लगा कि मैं इसे आज़माऊंगा। एक जानवर बल तरह से हालांकि।

यह केवल 1 से गिनती है जब तक कि अंतिम अंक 2 नहीं है, फिर 2 से पीछे हटता है और 10. आगे बढ़ता है।

यह 65534 पर काम करना बंद कर देता है क्योंकि VBA वैज्ञानिक संकेतन में आउटपुट देने पर जोर देता है, लेकिन तर्क को अधिक संख्या में ठीक काम करना चाहिए

गोल्फ सुझावों की प्रतीक्षा करते हुए, VBA बहुत गोल्फ के अनुकूल नहीं है, लेकिन अक्सर इसका प्रतिनिधित्व नहीं किया जाता है, और मुझे लगता है कि यह जावा को लंबाई के लिए हरा सकता है।

Edit1: 62 बाइट्स से दाढ़ी बनाने में मदद करने के लिए धन्यवाद मनु

Edit2: आउटपुट debug.printके msgboxरूप में स्वैप किया गया। बची हुई 5 बाइट्स

— JimmyJazzx
स्रोत

1

आप कोष्ठक से निकाल सकते हैं Debug.Print (q)। इसके अलावा, आप अधिकांश व्हाट्सएप को हटा सकते हैं (संपादक उन्हें वापस डाल देगा, लेकिन वे आवश्यक नहीं हैं)। आपको घोषित करने की जरूरत नहीं है k as Long, बस लिखें k। यह वेरिएंट प्रकार का एक चर होगा और कोड अभी भी काम करेगा। इन सुझावों के साथ आपको ~ 165 बाइट्स के लिए नीचे उतरना चाहिए।

— कॉमनग्यू

कुछ और विचार: आप पहले और अंतिम तर्क को छोड़ सकते InStrहैं, वे वैकल्पिक हैं। Trim()आवश्यक नहीं है, क्योंकि आपके पास व्हाट्सएप नहीं है। सही ढंग से लागू, मुझे 147 बाइट्स मिलती हैं ।

— कॉमनग्यू

1

मदद के लिए धन्यवाद मनु, एक त्वरित प्रश्न, आउटपुट मानक आउटपुट होना चाहिए। मैं अनिश्चित हूं कि वीबीए में क्या होगा। debug.print qमानक उत्पादन होगा? msgbox qकम है, लेकिन फिर से ऐसा लगता है कि इसकी मानक आउटपुट नहीं है। Sheet1.cells(1,1)ऐसा लगता है कि विशिष्ट आउटपुट लेकिन इसके एक्सेल में चल रहा है। मुझे इस बात पर बिल्कुल यकीन नहीं है कि इस तरह की चीजों के बारे में कोड-गोल्फ कितना सख्त है।

— जिम्मीजैक्स

बधाई हो, आप जावा उत्तर को हरा देते हैं;) मैं या तो नहीं जानता ... बस उपयोग करें MsgBox, अगर कोई शिकायत करता है, तो आप अभी भी इसे वापस बदल सकते हैं।

— कॉमनग्यू

4

जावास्क्रिप्ट ईएस 6, 99 86 78 76 72 चार्ट

f=n=>{for(s="1";--n;s=s.replace(/.?2|.$/,m=>[1,2,10][+m]||20));return s}

// Old version, 76 chars:
f=n=>{for(s="1";--n;s=s.replace(/02|12|2|.$/,m=>[1,2,10][+m]||20));return s}

// Old version, 86 chars:
f=n=>{for(s="1";--n;s=s.replace(/(02|12|2|.$)/,m=>[1,2,10,,,,,,,,,,20][+m]));return s}

// Old version, 99 chars:
f=n=>{for(s="1";--n;s=s.replace(/(^2|02|12|20|.$)/,m=>({0:1,1:2,2:10,12:20,20:100}[+m])));return s}

परीक्षा:

;[1,2,3,6,7,50,100,200,1000,10000,100000,1000000,1048576].map(f) == "1,2,10,20,100,11011,110020,1100110,111110120,1001110001012,1100001101010020,1111010000100100100,10000000000000000001"

मजेदार तथ्य: इस संख्या प्रणाली में वास्तव में कुछ योग्यता है। जब एक संख्या बढ़ाई जाती है, तो आप हमेशा अधिकतम दो आसन्न अंकों में बदलेंगे - आपको पूरे नंबर के माध्यम से परिवर्तन नहीं करना पड़ेगा। सही प्रतिनिधित्व के साथ जो ओ (1) में वेतन वृद्धि की अनुमति देता है।

इस तथ्य के लिए धन्यवाद - यह मेरे समाधान का आधार है :)

— Qwertiy
स्रोत

मैं रेगेक्स में अनावश्यक ब्रेसिज़ कैसे छोड़ सकता हूं? o_O

— क्वर्टी

3

ऑक्टेव, 107 101 बाइट्स

ओ (लॉग एन) होना चाहिए अगर मैं यह अधिकार लगा रहा हूं ...

function r=s(n)r="";for(a=2.^(uint64(fix(log2(n+1))):-1:1)-1)x=idivide(n,a);r=[r x+48];n-=x*a;end;end

सुंदर प्रिंट:

function r=s(n)
  r="";
  for(a=2.^(uint64(fix(log2(n+1))):-1:1)-1)
    x=idivide(n,a);
    r=[r x+48];
    n-=x*a;
  end
end

अंतिम चुनौती को संबोधित करते हुए मैं कुछ हद तक स्तब्ध था, क्योंकि ऑक्टेव डिफ़ॉल्ट रूप से फ्लोटिंग पॉइंट नंबरों के रूप में सबकुछ मानता है और मेरे पास आखिरी गणना करने के लिए आवश्यक सटीकता नहीं थी। मैं एक कीमती पूर्णांक होने के लिए सब कुछ मजबूर करने के लिए कीमती बाइट्स खर्च करके चारों ओर हो गया। पिछले एक का परिणाम एक संख्या के रूप में इलाज करने के लिए बहुत बड़ा था, इसलिए परिणाम एक स्ट्रिंग है।

आउटपुट (मैं 1e18 - 1दिखाने के लिए शामिल हूं कि मैं इसे सही ढंग से कर सकता हूं, और आउटपुट का अंतिम सेट दिखाता है कि उस मूल्य की गणना करने में कितना समय लगता है):

octave:83> s(uint64(1e18))
ans = 11011110000010110110101100111010011101100100000000000001102

octave:84> s(uint64(1e18)-1)
ans = 11011110000010110110101100111010011101100100000000000001101

octave:85> tic();s(uint64(1e18)-1);toc()
Elapsed time is 0.0270021 seconds.

— dcsohl
स्रोत

3

टी-एसक्यूएल, 221 189 177 बाइट्स

EDIT: इस कोड के मूल संस्करण कुछ संख्याओं के लिए गलत आउटपुट उत्पन्न करेंगे, यह सही कर दिया गया है।

यहां प्रत्येक क्वेरी के साथ, पहले कॉमा से पहले गणना करने के लिए संख्या जोड़ें।

हर कोई जानता है कि टी-एसक्यूएल सबसे अच्छी गोल्फिंग भाषा है। यहां एक संस्करण है जो पिछले परीक्षण मामले की भी गणना करेगा। जिस मशीन पर मैंने इसका परीक्षण किया, वह एक सेकंड के भीतर चली, मुझे यह देखने में दिलचस्पी होगी कि यह हर किसी के लिए कैसे चलती है।

DECLARE @ BIGINT=,@T VARCHAR(MAX)='';WITH M AS(SELECT CAST(2AS BIGINT)I UNION ALL SELECT I*2FROM M WHERE I<@)SELECT @T += STR(@/(I-1),1),@%=(I-1)FROM M ORDER BY I DESC SELECT @T

और यहाँ यह फिर से है, लेकिन पठनीय:

DECLARE 
    @ BIGINT=,
    @T VARCHAR(MAX)='';

WITH M AS
(
    SELECT
        CAST(2 AS BIGINT) I

    UNION ALL

    SELECT I * 2
    FROM M
    WHERE I < @
)

SELECT 
    @T+=STR(@/(I-1),1),
    @%=(I-1)
FROM M 
ORDER BY I DESC

SELECT @T

यदि मैं केवल ints का उपयोग करता हूं, तो यह थोड़ा कम हो सकता है, 157 बाइट्स पर बाहर आ रहा है:

DECLARE @ INT=,@T VARCHAR(MAX)='';WITH M AS(SELECT 2I UNION ALL SELECT I*2FROM M WHERE I<@)SELECT @T+=STR(@/(I-1),1),@%=(I-1)FROM M ORDER BY I DESC SELECT @T

और एक बार फिर, अधिक पठनीय:

DECLARE 
    @ INT=,
    @T VARCHAR(MAX)='';

WITH M AS
(
    SELECT
        2I

    UNION ALL

    SELECT 
        I * 2
    FROM M
    WHERE I < @
)

SELECT 
    @T+=STR(@/(I-1),1),
    @%=(I-1)
FROM M 
ORDER BY I DESC

SELECT @T

— PenutReaper
स्रोत

याद रखें @कि sql में एक वैध पहचानकर्ता है और आप सबसे अधिक संभावना दूर कर सकते हैं Char(8000) जो अभी भी nvarchar (अधिकतम) से सस्ता है। आप फ़ंक्शन के charबजाय परिवर्तित भी कर सकते हैं varchar, या उपयोग कर सकते strहैं।

— माइकल बी

@MichaelB ओह, मैंने सोचा था कि मैंने इस्तेमाल किया था @, मुझे मूर्खतापूर्ण। CHAR(8000)सलाह बहुत अच्छी है, मुझे लगता है कि कोशिश करेंगे। मैं हमेशा STR()सिर के लिए धन्यवाद के अस्तित्व के बारे में भूल लगता हूं ।

— पेनटूर सस्ता

वास्तव में मदद नहीं करता है। हालाँकि, आप CTE में भाग को फिर से लिख सकते हैं :: select @t=concat(@t,@/i)जो छोटा होना चाहिए। हालांकि sql2012 की आवश्यकता है।

— माइकल बी

@MichaelB आह। CONCAT, मैं 2008 पर हूं। इसलिए मैं अभी SQL फिडेल का उपयोग किए बिना इसका परीक्षण नहीं कर सकता। हालांकि अच्छी कॉल।

— पेनुआरट्रॉट

3

ट्यूरिंग मशीन कोड, 333 293 बाइट्स

मैं यहाँ एन्कोडिंग का उपयोग कर रहा हूँ ।

यह मशीन 9 राज्यों और 11 रंगों का उपयोग करती है।

यदि बाइनरी इनपुट अनुमेय है, तो इसे केवल 4 रंगों में घटाया जा सकता है, जिससे प्रक्रिया में कुछ दसियों बाइट्स बचते हैं।

0 _ _ l 1
0 * * r 0
1 9 8 l 2 
1 8 7 l 2
1 7 6 l 2
1 6 5 l 2
1 5 4 l 2
1 4 3 l 2
1 3 2 l 2
1 2 1 l 2
1 1 0 l 2
1 0 9 l 1
1 _ _ r 8
2 _ _ l 3
2 * * l 2
3 _ 1 r 4
3 * * l 5
4 _ _ r 0
4 * * r 4
5 * * l 5
5 _ _ r 6
6 _ _ l 7
6 2 0 l 7
6 * * r 6
7 _ 1 r 4
7 0 1 r 4
7 1 2 r 4
8 _ _ * halt
8 * _ r 8

यदि उपरोक्त लिंक काम नहीं कर रहा है (कभी-कभी यह मेरे लिए काम करता है, तो दूसरी बार पृष्ठ लोड होने से इनकार करता है) आप इस जावा कार्यान्वयन का उपयोग करके इसका परीक्षण भी कर सकते हैं ।

— SuperJedi224
स्रोत

2

पर्ल, 66 बाइट्स

नंबर STDIN के माध्यम से इनपुट किया जाना है।

$_=1;$c=<>;s/(.*)(.?)2(.*)/$1.$2+1 .$3.0/e||$_++while(--$c);print;

— फ्रेडरिक
स्रोत

क्या आप बता सकते हैं कि आपका समाधान कैसे काम करता है? मैं कैसे आप की जरूरत नहीं दिख रहा है (.?)में $2के बाद से (.*)में $1लालची हो सकता है और पहला यह है कि चरित्र मिलना चाहिए। लेकिन अगर यह हटा दिया जाता है तो कोड सही परिणाम नहीं देता है! वैसे, आपको अंतिम की आवश्यकता नहीं है ;।

— CJ डेनिस

@CJDennis के लिए धन्यवाद कि बाइट बच गई। वैसे भी? जब तक वहाँ कोई अंक न हो (उदाहरण 20), तब तक अंक दो से ठीक पहले आएगा। 120 या 10020 जैसे मामलों में, रेगेक्स समूह इस तरह हैं: () (1) 2 (0) और (10) (0) 2 (0)। फिर पहले समूह को केवल अनदेखा किया जाता है, दूसरे समूह (जो कि हमेशा एक अंक होता है यदि संभव हो या रिक्त हो) को बढ़ाया जाता है, और तीसरे समूह (हमेशा शून्य से मिलकर) को अनदेखा किया जाता है और एक शून्य जोड़ा जाता है। मैं बस इस regex के लिए मेरे गाइड के रूप में OEIS प्रविष्टि का उपयोग किया।

— फ्रेडरिक

मुझे आपका कोड 53 बाइट्स में मिला $c=<>;s/(.*)2(.*)/$1+1 .$2.0/e||$_++while($c--);print:। मैं सही था, (.?)कभी किसी चीज पर कब्जा नहीं किया।

— सीजे डेनिस

के लिए अनुकूलित किया जा सकता है $_=1;$c=<>;s/(.?)2/1+$1.0/e||$_++while(--$c);print, जो 50 बाइट्स है। .*शुरुआत या अंत में दूर किया जा सकता है, अगर आप इसे मूल पाठ से बदल देते हैं। इसके अलावा अंत में 0 जोड़ने का कोई कारण नहीं है, क्योंकि मूल में हमेशा शून्य होते हैं $3।

— तेरह

2

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

m/=%Qtydtd^L2_SslhQ

लॉगरिदमिक जटिलता। आसानी से आवश्यक समय में पूरा करता है। अंकों की सूची के रूप में आउटपुट।

प्रदर्शन ।

— isaacg
स्रोत

2

पर्ल, 84 70 67 बाइट्स

$n=<>;$d*=2while($d++<$n);$_.=int($n/$d)while($n%=$d--,$d/=2);print

~~बहुत गोल्फ नहीं,~~ बेहतर हो रहा है लेकिन यह बहुत जल्दी काम करता है!

डेनिस का सुझाव इसे 51 तक ले जाता है (50 बाइट्स-पी स्विच)

$d*=2while$d++<$_;$\.=$_/$d|0while$_%=$d--,$d/=2}{

यह कहा जाना चाहिए कि उस पर एन्कोड करने के लिए संख्या के साथ एक एकल रेखा perl -p skew_binary.pl num_list.txtकहां num_list.txtहै।

— सीजे डेनिस
स्रोत

@ फ़्रेडरिक हम अपनी सीटों के किनारे पर इंतज़ार कर रहे हैं 2.

— रॉबर्ट ग्रांट

@RobertGrant उन्होंने अपनी टिप्पणी को दो चीजों से एक चीज में शामिल किया!

— सीजे डेनिस

दो बातें: 1. $ ARGV [0] का उपयोग करने के बजाय, इनपुट के रूप में <> का उपयोग करें। यह स्टड से इनपुट लेगा जब तक कि कोई फाइल तर्क के रूप में न हो। 2. इस तरह विषम गणना योजनाओं के लिए, नियमित अभिव्यक्ति का उपयोग करें। अजीब गणित संचालन करने के बजाय, आप अंकों को एक संख्या में बदल सकते हैं जैसे कि यह एक स्ट्रिंग है। सबसे अच्छी बात यह है कि आप एक ही समय में इस पर गणित के संचालन (जैसे वेतन वृद्धि) का उपयोग कर सकते हैं, बशर्ते कि यह पूरी तरह से अंकों से युक्त एक स्ट्रिंग हो। नियमित अभिव्यक्ति ऑपरेटरों के लिए प्रलेखन की जांच करें, क्योंकि वे इतने सारे अवसरों में बहुत उपयोगी हो सकते हैं।

— फ्रेडरिक

क्षमा करें, मैंने प्रविष्टि को दबाया और टिप्पणी को समाप्त करने से पहले इसे सहेज लिया।

— फ्रेडरिक

@frederick इतना मामूली नहीं होना चाहिए। हम जानते हैं कि क्या हुआ!

— रॉबर्ट ग्रांट

1

गणितज्ञ, ६५

इसे काफी तेज होना चाहिए, हालांकि मुझे इसे बनाने से पहले अन्य सबमिशन में झांकना होगा।

f = (n = #;
     l = 0; 
     While[n > 0,
      m = Floor[Log2[1 + n]];
      l += 10^(m - 1);
      n -= 2^m - 1
     ]; l)&

उपयोग:

f[1000000000000000000]

आउटपुट:

11011110000010110110101100111010011101100100000000000001102

MaxExtraPreaches त्रुटि संदेश पिछले 10 ^ 228 (जिसके लिए यह मेरी मशीन पर .03 सेकंड में परिणाम की गणना करता है) को देने की शुरुआत करता है

मैक्सएक्स्ट्राप्रिच सीमा को हटाने के बाद, यह एक सेकंड में लगभग 10 ^ 8000 तक की संख्या को संभाल लेगा।

इनपुट:

Timing[Block[{$MaxExtraPrecision = Infinity}, f[10^8000]];]

आउटपुट:

{1.060807, Null}

— गणना
स्रोत

1

सी, 95 बाइट्स

void f(unsigned long i,int*b){for(unsigned long a=~0,m=0;a;a/=2,b+=!!m)m|=*b=i/a,i-=a**b;*b=3;}

यह एक पूर्णांक और एक बफर को स्वीकार करता है जिसमें अंकों को वापस करना है। परिणामों को संग्रहीत किया जाता है b, मूल्य के साथ समाप्त किया जाता है 3(जो आउटपुट में नहीं हो सकता है)। हमें 0(केवल सकारात्मक पूर्णांक निर्दिष्ट किए गए प्रश्न के रूप में) इनपुट को संभालने की आवश्यकता नहीं है , इसलिए खाली आउटपुट से बचने के लिए कोई विशेष आवरण नहीं है।

विस्तारित कोड

void f(unsigned long i,int*b)
{
    for (unsigned long a=~0, m=0;  a;  a/=2, b+=(m!=0)) {
        *b = i/a;               /* rounds down */
        i -= *b * a;
        m = m | *b;             /* m != 0 after leading zeros */
    }
    *b=3;                       /* add terminator */
}

हम क्रमिक घटाव द्वारा संचालित करते हैं, जो सबसे महत्वपूर्ण अंक से शुरू होता है। एकमात्र जटिलता यह है कि हम mअग्रणी शून्य को मुद्रित करने से बचने के लिए चर का उपयोग करते हैं । unsigned long long10 बाइट की कीमत पर, यदि वांछित है, तो एक प्राकृतिक विस्तार किया जा सकता है।

परीक्षण कार्यक्रम

कमांड तर्कों के रूप में परिवर्तित किए जाने वाले पास नंबर। यह intएरे बफर को प्रिंट करने योग्य डिजिट स्ट्रिंग में परिवर्तित करता है । इनपुट के लिए रनटाइम एक मिलीसेकंड से कम है 1000000000000000000।

#include <stdio.h>
#include <stdlib.h>
int main(int argc, char**argv)
{
    while (*++argv) {
        unsigned long i = strtoul(*argv, NULL, 10);
        int result[1024];
        f(i,result);

        /* convert to string */
        char s[1024];
        {char*d=s;int*p=result;while(*p!=3)*d++=*p+++'0';*d=0;}
        printf("%lu = %s\n", i, s);
    }

    return EXIT_SUCCESS;
}

परीक्षण के परिणाम

$ ./51517 $(seq 20)
1 = 1
2 = 2
3 = 10
4 = 11
5 = 12
6 = 20
7 = 100
8 = 101
9 = 102
10 = 110
11 = 111
12 = 112
13 = 120
14 = 200
15 = 1000
16 = 1001
17 = 1002
18 = 1010
19 = 1011
20 = 1012

— टोबी स्पाईट
स्रोत

मुझे लगता है कि एक सी ++ संस्करण समान है, लेकिन auto a=~0ullएक मामूली लाभ के लिए उपयोग कर सकते हैं ...

— टोबी स्पाइट

1

जावास्क्रिप्ट (Node.js) , 40 बाइट्स

v=>(g=n=>n>v?'':g(n-~n)+(v-(v%=n))/n)(1)

इसे ऑनलाइन आज़माएं!

यह समाधान अंतिम टेस्टकेस पर काम नहीं करता है। यह बस उस पर ढेर अतिप्रवाह का कारण बनता है।

— TSH
स्रोत

0

कॉफीस्क्रिप्ट, 92 69 बाइट्स

क्वर्टी के जवाब और अपडेट के आधार पर :

f=(n)->s='1';(s=s.replace /(.?2|.$)/,(m)->[1,2,10][+m]||20)while--n;s

# older version, 92 bytes
f=(n)->s='1';(s=s.replace /(^2|02|12|20|.$)/,(m)->{0:1,1:2,2:10,12:20,20:100}[+m])while--n;s

— rink.attendant.6
स्रोत

2

Regex में अनावश्यक ब्रेसिज़ को हटाकर सरल अनुकूलन के बिना भी अन्य भाषा में परिवर्तित करना मेरे लिए अच्छा नहीं लगता ...

— Qwertiy

@ क्वर्टी ने मुझे आपके उत्तर के लिए अटेंशन प्रदान किया है, और दोनों उत्तरों के साथ मैं रेगेक्स में ब्रैकेट्स के बिना एक ही परिणाम नहीं दे सकता हूं

— rink.attenders.6

पूरी घटना को बदल दिया जाता है। आपको समूह के अंदर रहने की आवश्यकता क्यों है? जेएस संस्करण फ़ायरफ़ॉक्स में ब्रैकेट्स के बिना काम करता है।

— क्वर्टी

0

जाप , 31 बाइट्स

_r/?2|.$/g_÷C ç20 ª°Zs3}}gU['0]

इसे ऑनलाइन आज़माएं!

इस जेएस समाधान का लगभग सीधा बंदरगाह । कोई विचार नहीं है अगर वहाँ बेहतर तरीका है।

अनपैक्ड और यह कैसे काम करता है

X{Xr/?2|.$/gZ{Z÷C ç20 ||++Zs3}}gU['0]

X{     Declare a function...
Xr       Accept a string, replace the regex...
/?2|.$/g   /.?2|.$/   (g is needed to match *only once*, opposite of JS)
Z{       ...with the function... (matched string will be 0,1,2,02 or 12)
Z÷C        Implicitly cast the matched string into number, divide by 12
ç20        Repeat "20" that many times (discard fractions)
||         If the above results in "", use the next one instead
++Z        Increment the value
s3         Convert to base-3 string (so 0,1,2 becomes 1,2,10)
}}
gU['0] Repeatedly apply the function on "0", U (input) times

— bubbler
स्रोत

0

स्टैक्स , 16 बाइट्स

üxëàè£öΦGΩ│Je5█ò

इसे चलाएं और डीबग करें

मुझे यकीन नहीं है कि औपचारिक जटिलता वर्ग वास्तव में क्या है, लेकिन यह इस मशीन पर एक सेकंड के दसवें में सभी परीक्षण मामलों को करने के लिए पर्याप्त तेज़ है।

अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, यह इस तरह दिखता है। इस प्रोग्राम में, x रजिस्टर में मूल रूप से इनपुट होता है।

z       push []
{       start block for while loop
 |X:2N  -log2(++x)
 {^}&   increment array at index (pad with 0s if necessary)
 xc:G-X unset high bit of x; write back to x register
w       while; loop until x is falsy (0)
$       convert to string

इसको चलाओ

— पुनरावर्ती
स्रोत

xkcd- स्टाइल पेज नंबरिंग

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

लीडरबोर्ड

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

CJam, 24 23 22 21 19 बाइट्स

पृष्ठभूमि

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

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

पायथन 3, 65 बाइट्स

सीजाम, 22 21 20 बाइट्स

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

अजगर, 20 बाइट्स

ईएस 6, 105 बाइट्स

रेटिना, 55 बाइट्स

जावा, 154 148

बाश + कोरुटिल्स, 52

आउटपुट:

जावा, 337 335 253 246 244 बाइट्स

हास्केल, 73 72

सीजेएम, 24 बाइट्स

पृष्ठभूमि

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

VBA, 209 147 142 बाइट्स

जावास्क्रिप्ट ईएस 6, 99 86 78 76 72 चार्ट

ऑक्टेव, 107 101 बाइट्स

टी-एसक्यूएल, 221 189 177 बाइट्स

ट्यूरिंग मशीन कोड, 333 293 बाइट्स

पर्ल, 66 बाइट्स

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

पर्ल, 84 70 67 बाइट्स

गणितज्ञ, ६५

सी, 95 बाइट्स

विस्तारित कोड

परीक्षण कार्यक्रम

परीक्षण के परिणाम

जावास्क्रिप्ट (Node.js) , 40 बाइट्स

कॉफीस्क्रिप्ट, 92 69 बाइट्स

जाप , 31 बाइट्स

अनपैक्ड और यह कैसे काम करता है

स्टैक्स , 16 बाइट्स