मैजिक पॉपकाउंट नंबर

Question

32-बिट अहस्ताक्षरित पूर्णांक में सेट बिट्स की संख्या की गणना के लिए एक प्रसिद्ध ट्रिकी एल्गोरिथ्म है :

int popcount(unsigned x) {
   x = (x & 0x55555555) + ((x >> 1) & 0x55555555);
   x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
   x = (x & 0x0F0F0F0F) + ((x >> 4) & 0x0F0F0F0F);
   x = (x & 0x00FF00FF) + ((x >> 8) & 0x00FF00FF);
   x = (x & 0x0000FFFF) + ((x >>16) & 0x0000FFFF);
   return x;
}

मैं इसे यहाँ नहीं समझाऊँगा। लेकिन 512-बिट पूर्णांक के लिए समान कोड की कल्पना करें! हेक्साडेसिमल स्थिरांक विशाल होंगे, और एक सुंदर पैटर्न बनाते हैं। आपका कार्य बस इस सटीक आउटपुट को प्रिंट करना है :

0x55555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555
0x33333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333
0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f
0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff
0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff
0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff
0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff
0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff00000000000000000000000000000000ffffffffffffffffffffffffffffffff
0x0000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff

कोई अनुगामी स्थान नहीं, कृपया - हालाँकि एक एकल अनुगामी न्यूलाइन वैकल्पिक है।

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

Comments

क्या हमें इनपुट लेने की अनुमति दी गई है (जैसा कि 0x0x0x0x0x0x0x0x0x) कुछ है?

— ouflak

@ouflak सं ---

— लिन

Answer 1

05AB1E , 26 22 21 बाइट्स

05AB1E CP-1252 एन्कोडिंग का उपयोग करता है ।

9F„0x0NÍo×9ooNoo>÷hJ,

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

व्याख्या

9F                      # for N in [0 ... 8]
  „0x                   # push the string "0x"
     0NÍo×              # push 2**(N-2) zeroes
          9oo           # 2**2**9
                 ÷      # //
             Noo>       # (2**2**N+1)
                  h     # converted to base-16
                   J    # join everything to string
                    ,   # print with a newline

अन्य संस्करण जिन्हें बेहतर बनाया जा सकता है

9F9ooNoo>÷h¾6o×J7o£R…0xÿ,
9F9ooNoo>÷h0žy×ìR7o£R…0xÿ,
9FX0No×1No×JCh7o×1K7o£…0xÿ,
8ÝovX0y×1y×JCh7o×1K7o£…0xÿ,
9F1NoÅ0D>)˜JCh1K7o×7o£…0xÿ,

Answer 2

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

Kth नंबर द्वारा दिया गया है 2**512/(2**2**k + 1)। यह 512 बिट संख्या के लिए है, इसलिए पैटर्न को विभिन्न चौड़ाई में विस्तारित करना तुच्छ है।

l=2;exec"print'0x%0128x'%(2**512/-~l);l*=l;"*9

3 बाइट्स ने डेनिस को धन्यवाद दिया।
3 बाइट्स xnor के लिए धन्यवाद बचा लिया।

Comments

मनमानी-सटीक पूर्णांक के फायदे ...

— ETHproductions

अच्छा लगा। यह कुछ बाइट्स बचाता है।

— डेनिस

l=2;exec"print'0x%0128x'%(2**512/-~l);l*=l;"*9

— शोरबा

यह मेरे दिल को वोट-लीड में पायथन देखने के लिए

— उकसाता है

@TuukkaX मुझे सिर्फ बिट ट्विडलिंग हैक्स के साथ बहुत अनुभव है। मैंने वुल्फराम अल्फ़ा का इस्तेमाल बहुत कुछ करने के लिए किया। लेकिन मूल रूप से मैं पैटर्न बनाया 01010101, 00010001, 00000001, और फिर से उन गुणा 1, 11, 1111सही द्विआधारी पैटर्न प्राप्त करने के लिए। उदाहरण के लिए 01010101आप एक निश्चित चौड़ाई w के लिए सूत्र प्राप्त कर सकते हैं sum 2^(2*k) for k = 0, w/2 - 1और यह पता लगा सकते हैं (2**w - 1)/3।

— orlp

Answer 3

PHP, 111 110 108 बाइट्स

एक बाइट ने @ user59178 को धन्यवाद दिया।

<?=($p=str_pad)("0x",130,5).$p($s="\n0x",131,3);for($x=1;$x<65;$x*=2)echo($p($s,131,$p(0,$x,0).$p(f,$x,f)));

1024 बिट्स के लिए पैटर्न क्या है? : डी

Comments

आप $x<65इसके बजाय का उपयोग करके एक बाइट बचा सकते हैं $i++<7। इस बार मैंने इसे और सब कुछ परखा।

— user59178

Answer 4

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

:`
0x128$*5
:`5
3
;{:`33
0f
0(f+)(0+)
0$2$1

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

व्याख्या

यह आम तौर पर उपयोग किए गए :विकल्प का बहुत उपयोग करता है जो आपको मध्यवर्ती परिणाम प्रिंट करने देता है, क्योंकि यह पूरे आउटपुट को बनाने की तुलना में एक पंक्ति को संशोधित करने के लिए बहुत कम है।

:`
0x128$*5

यह 0x128 इनपुट के साथ खाली इनपुट को प्रतिस्थापित करता है 5और इसे पहली पंक्ति उत्पन्न करने के लिए प्रिंट करता है।

:`5
3

यह दूसरी पंक्ति उत्पन्न करने के लिए 5s के साथ 3s को प्रतिस्थापित करता है और इसे प्रिंट भी करता है।

;{:`33
0f

यह अंतिम विशेष आवरण वाली रेखा है और यह तीसरी पंक्ति को उत्पन्न करने के लिए प्रत्येक दो 3s में बदल जाती है 0f। यह अंतिम दो चरणों ( {) के माध्यम से एक लूप भी शुरू करता है । हालाँकि, यह अवस्था पहले पुनरावृत्ति के बाद कुछ भी नहीं करेगी सिवाय वर्तमान स्थिति को प्रिंट करने के। ;दबा कार्यक्रम के अंत में उत्पादन अंतिम पंक्ति डुप्लिकेट करने से बचने के लिए।

0(f+)(0+)
0$2$1

यह प्रतिस्थापन अब प्रत्येक पंक्ति को fs और 0s की प्रत्येक अन्य जोड़ी को स्वैप करके, अगली पंक्ति में बदल देता है । "हर दूसरी जोड़ी" की स्थिति को शून्य के सामने मिलान करके लागू किया जाता है f, जिससे मैचों को ओवरलैप नहीं होने के बाद से लगातार जोड़े से मिलान करना असंभव हो जाता है।

Answer 5

विम, 32 बाइट्स

i5<CR>3<Esc>qqYpVrf$<C-V>{yPG1vr0q6@q<C-V>{I0x<Esc>

मुझे केवल मैन्युअल रूप से पहला 5और लिखने की जरूरत है 3, और मैक्रो बाकी को ध्यान में रखता है, "हर बार चलने वाली बिट गिनती" को दोगुना करना। मैक्रो में चरणों का क्रम थोड़ा अजीब है (एक नई fलाइन बनाएं, ब्लॉक-वार कॉपी, लाइन 0में डालने के लिए दृश्य ब्लॉक आकार का पुन: उपयोग करें f), लेकिन यह सबसे तेज संस्करण है जो मैंने पाया है।

Answer 6

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

V9%"0x%0128x"/^2 512h^2^2N

मेरे पायथन जवाब का पोर्ट।

Answer 7

जे, 46 34 बाइट्स

मैं इसे गोल्फ पर काम कर रहा हूं, लेकिन यह बच्चा 46 बाइट्स में रहना पसंद करता है ... अब और नहीं! -12 बाइट मील के लिए धन्यवाद!

'0x',"1'5','3','0f'(128$#)"{~2^i.7

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

परिणाम

   '0x',"1'5','3','0f'(128$#)"{~2^i.7
0x55555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555
0x33333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333
0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f
0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff
0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff
0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff
0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff
0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff00000000000000000000000000000000ffffffffffffffffffffffffffffffff
0x0000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff

---

इस उत्तर के लिए, मुझे रैंक के साथ एक क्रिया की आवश्यकता है (आदर्श रूप से) 0 1ताकि इसे u"vरैंक की परिभाषा में उपयोग किया जा सके ; हालाँकि, मील ने देखा कि 0 _हाथ में काम के लिए पर्याप्त था।

┌──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│= │< │<.│<:│> │>.│>:│+ │+.│+:│* │*.│*:│_ 0 0│_ 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│- │-.│-:│% │%.│%:│^ │^.│$ │$.│$:│~.│~:│0 0 0│0 _ _│0 _ _│0 0 0│2 _ 2│0 0 0│0 0 0│0 0 0│_ 1 _│_ _ _│_ _ _│_ 0 0│_ 0 0│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│| │|.│, │,.│,:│; │;:│# │#.│#:│! │/:│\:│0 0 0│_ 1 _│_ _ _│_ _ _│_ _ _│_ _ _│1 _ _│_ 1 _│1 1 1│_ 1 0│0 0 0│_ _ _│_ _ _│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│[ │[:│] │{ │{.│{:│}.│}:│".│":│? │?.│a │_ _ _│_ _ _│_ _ _│1 0 _│_ 1 _│_ 0 0│_ 1 _│_ 0 0│1 _ _│_ 1 _│0 0 0│_ 0 0│_ _ _│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│A │A.│b │C │C.│d │D │e │e.│E │E.│f │H │_ _ _│1 0 _│_ _ _│_ _ _│1 1 _│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│0 _ _│_ _ _│_ _ _│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│i │i.│i:│I │I.│j │j.│L │L.│M │o │o.│p │_ _ _│1 _ _│0 _ _│_ _ _│1 _ _│_ _ _│0 0 0│_ _ _│_ 0 0│_ _ _│_ _ _│0 0 0│_ _ _│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│p.│p:│q │q:│r │r.│s │s:│S │t │T │u:│x:│1 1 0│0 _ _│_ _ _│0 0 0│_ _ _│0 0 0│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘

यहां आपको क्रियाओं के स्ट्रिंग प्रतिनिधित्व का एक गुच्छा उनके संबंधित रैंक के साथ दिखाई देता है। यह वह स्क्रिप्ट है जिसका उपयोग मैंने इसे बनाने के लिए किया था।

Comments

रैंक वाली एक क्रिया 0 _यहाँ ठीक है। आप इसे 34 बाइट्स तक छोटा कर सकते हैं'0x',"1'5','3','0f'(128$#)"{~2^i.7

— मील

@ मीलों हुह। मुझे लगा कि मैंने कोशिश की है कि ... अच्छा! और मैं जम्मू के ऑटो-पंक्ति-भरण सुविधा के बारे में भूल गया, फिर से धन्यवाद!

— कॉनर ओ'ब्रायन

Answer 8

दरअसल , 25 बाइट्स

9r`╙╙u9╙╙\#"0x%0128x"%`Mi

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

यह समाधान मानों की गणना करने के लिए इस तथ्य का उपयोग करता है कि f(n) = 2**512//(2**2**n + 1)(जहां //फ्लोर्ड डिवीजन है)।

स्पष्टीकरण:

9r`╙╙u9╙╙\#"0x%0128x"%`Mi
9r`╙╙u9╙╙\#"0x%0128x"%`M   for n in range(1, 10):
      9╙╙\                   2**2**9//
   ╙╙u                                (2**2**n + 1)
          #"0x%0128x"%       pad with zeroes to 128 digits, prefix with "0x"
                        i  flatten and implicitly print

Answer 9

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30+), 139 113 112 92 83 80 बाइट्स

_=>[for(x of"970123456")(f=y=>y--?f(y)+(x>6?x-4:y>>x&1&&'f'):'0x')(128)].join`
`

अंत में पुनरावर्ती मीठे स्थान को हिट करें :-) 3 बाइट्स को बचाने के लिए एक आसान-डंडी स्ट्रिंग समझ का उपयोग करता है .map:

_=>[..."970123456"].map(x=>(f=y=>y--?f(y)+(x>6?x-4:y>>x&1&&'f'):'0x')(128)).join`
`

.replace 83 बाइट्स भी है:

_=>"970123456".replace(/./g,x=>(f=y=>y--?f(y)+(x>6?x-4:y>>x&1&&'f'):'0x')(128)+`
`)

यदि एक प्रमुख नई लाइन की अनुमति दी गई थी, तो यह भी 80 बाइट्स होगी:

_=>"970123456".replace(/./g,x=>(f=y=>y--?f(y)+(x>6?x-4:y>>x&1&&'f'):`
0x`)(128))

Answer 10

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

k=1
exec"print'0x%0128x'%int(256/k*('0'*k+'1'*k),2);k*=2;"*9

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

Answer 11

बबलगम , 65 बाइट्स

00000000: c5cb 4501 0441 1043 d17b d4fc 254b d110  ..E..A.C.{..%K..
00000010: f7cb 9761 9e7a 8d45 e451 4ce4 564c 04d7  ...a.z.E.QL.VL..
00000020: 2e11 b02b 8f08 80df aa5e 11fe fc77 762c  ...+.....^...wv,
00000030: 428b 5b8e ae8b 30c1 13b6 ce8b b091 377a  B.[...0.......7z
00000040: 01                                       .

अप्रचलित बबलगम का जवाब।

Answer 12

हास्केल, 84 72 बाइट्स

पोर्टिंग @ orlp का उत्तर:

import Text.Printf
mapM(\n->printf"0x%0128x\n"$div(2^2^9)$2^2^n+1)[0..8]

की शक्ति के बिना 94 बाइट विकल्प Text.Printf:

import Data.List
mapM(putStrLn.("0x"++))$transpose$("53"++).reverse<$>sequence(["0f"]<*[1..7])

r=[0..127]
mapM(putStrLn.("0x"++))$('5'<$r):('3'<$r):[["0f"!!mod(div x(2^y))2|x<-r]|y<-[0..6]]

Comments

@ एनआईएम व्हाट्सएप, Control.Monadआरईपीएल में लोड किया होगा। फिक्स्ड।

— आंग। डे।

Answer 13

PowerShell v2 +, 68 बाइट्स

5,3|%{"0x"+"$_"*128}
($a=1)..7|%{"0x"+('0'*$a+'f'*$a)*(128/($a*=2))}

PowerShell में [bigint]कॉल का उपयोग किए बिना सटीक रूप से सटीक पूर्णांक नहीं हैं, और वे आसानी से हेक्साडेसिमल में परिवर्तित नहीं हो सकते हैं, इसलिए हम इसे स्ट्रिंग-आधारित चुनौती के रूप में मान रहे हैं।

पहली पंक्ति दोहराव को संभालती है 5और 3एक स्ट्रिंग गुणा करने के लिए बाहर करती है128 पात्रों के और 0xमोर्चे पर निपटने से ।

अगली पंक्ति से लूप $a=1करने के लिए 7, प्रत्येक यात्रा एक और स्ट्रिंग outputting। फिर हम है 0xसामने पर हमला बोला, और हम बीच में स्ट्रिंग गुणा कर रहे हैं की उचित संख्या के निर्माण के लिए 0और fएक साथ concatenated, और उसके बाद की स्ट्रिंग गुणा कर कि पात्रों की उचित संख्या के लिए बाहर। ध्यान दें कि हम $aयहाँ वेरिएबल का उपयोग कर रहे हैं, न कि लूप काउंटर का $_, इसलिए हम ठीक से स्केल कर सकते हैं (अन्यथा हमें जैसे लूप की आवश्यकता होगी 1,2,4,8,16,32,64|%{...}, जो अधिक लंबा है)।

परिणामी तार को पाइपलाइन पर छोड़ दिया जाता है, और निहितार्थ के माध्यम से आउटपुट Write-Outputप्रोग्राम पूरा होने पर होता है, तत्वों के बीच एक नई रेखा के साथ।

Answer 14

वी , 43 बाइट्स

64i0fòYpÓ¨¨0«©¨f«©©û2}/²²³³òdd{3ÄÒ5jÒ3Îi0x

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

यह एक सबसे लंबे समय तक संकुचित रीगेक्स का उपयोग करता है जिसकी मुझे कभी वी उत्तर में आवश्यकता होती है। यहाँ अधिक पठनीय संस्करण है, जहाँ मैंने पठनीय रीजेक्स के लिए एक बाइट जोड़ी है, और इसे करने के लिए अनुचित भागने के चरित्र को बदल दिया है<esc>

64i0f<esc>òYpÓö((0+)(f+)){2}/²²³³òdd{3ÄÒ5jÒ3Îi0x

स्पष्टीकरण (पठनीय संस्करण का उपयोग करके):

64i0f<esc>                                          " Insert 64 "0f"s and escape to normal mode
          ò                      ò                  " Recursively:
           Yp                                       "   Duplicate this line
             Ó                                      "   Substitute:
              ö                                     "     (Optionally Turn the readable version on)
               ((0+)(f+))                           "     One or more '0's followed by one or more 'f's
                         {2}                        "     Repeated twice
                            /                       "   With:
                             ²²                     "     The second capture group twice (the '0's)
                               ³³                   "     Followed by the third capture group twice (the 'f's)
                                                    "   Once the search is not found, the loop will break
                                  dd                " Delete a line (because we have one too many)
                                    {               " Move to the first line
                                     3Ä             " Make three copies of this line
                                       Ò5           " Replace the first one with '5's
                                         jÒ3        " Move down a line and replace the second with '3's
                                            Î       " On every line:
                                             i0x    "   Insert a '0x'

Answer 15

जावास्क्रिप्ट (ईएस 6), 74 72 70 बाइट्स

वैकल्पिक अनुगामी न्यूलाइन शामिल है।

f=(i=1152)=>i--?f(i)+(i&127?'':`
0x`)+('53'[y=i>>7]||i&1<<y-2&&'f'):''

f=(i=1152)=>i--?f(i)+(i&127?'':`
0x`)+('53'[y=i>>7]||i&1<<y-2&&'f'):''

console.log(f())

Answer 16

पायथ - 31 30 बाइट्स

के अलावा पैटर्न प्राप्त करने के लिए 3की और 5'यह संचयी कम कर देता है, हर बार हिस्सा दोगुना है।

jm+"0x".[dd128+`3+`5.u.iNN6"0f

इसे यहाँ ऑनलाइन आज़माएँ ।

Answer 17

बैच, 216 बाइट्स

@echo off
set s=5
call:c
set s=3
call:c
set a=0
set b=f
for /l %%i in (1,1,7)do call:l %%i
exit/b
:l
set s=%a%%b%
:c
for /l %%j in (0%1,1,6)do call set s=%%s%%%%s%%
echo 0x%s%
set a=%a%%a%
set b=%b%%b%

Answer 18

72 बाइट्स निकालें

i0x128a5Ypll128r3o0x64a0fa0Ypqqffdt0fft0p@qq@qqwYp@qq@w@w@w@w:%s/0$

TryItOnline!

Unprintables:

i0x^[128a5^[Ypll128r3o0x^[64a0f^[a0^[Ypqqffdt0fft0p@qq@qqwYp@qq@w@w@w@w:%s/0$

@wअंत में 4 s मुझे गुस्सा दिला रहे हैं, लेकिन क्योंकि मैं @qएक पंक्ति के अंत में असफल होने का भरोसा कर रहा था , यह @w के रूप में अच्छी तरह से विफल रहता है। मैं सिर्फ 32 बार q चलाने की कोशिश कर सकता हूं और यह देख सकता हूं कि क्या यह बाद की लाइनों को गड़बड़ करता है।

Answer 19

सी, 146 बाइट्स

#define F for(i=0;++i<129;)s[i+1]=
#define P ;puts(s);
i,j;f(){char s[131]={'0','x'};F'5'P F'3'P for(j=1;(j*=2)<129;){F(i-1)%j<j/2?'0':'f'P}}

Ungolfed:

#define F for(i=0;++i<129;)s[i+1]=
#define P ;puts(s);
i,j;f(){
  char s[131]={'0','x'};
  F'5'P
  F'3'P
  for(j=1;(j*=2)<129;){
    F(i-1)%j<j/2?'0':'f'P 
  }
}

Comments

133 बाइट्स

— सीलिंगकैट

Answer 20

ब्रेनफक , 211 बाइट्स

+++++++>++>>-[>>>>+<<++<+<-----]>--->>++++++++++>++<<<<<<[->----[>+++<--]>-->.<.++++++++[->>>>.<<<<]>>>.>--[<]<<]+<[->>----[>+++<--]>-->.<.++++++++[<<[>+>->.<<<-]>[<+>>->>.<<<-]>]>>>.<<<<[-<+>]<[->++<]>[-<+>]<<]

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

Comments

कुछ अलग लूप चेक के माध्यम से 197 बाइट्स । मुझे पूरा यकीन है कि xजनरेटर को अब लूप के बाहर ले जाया जा सकता है

— जो किंग

Answer 21

GNU sed 4.2.2 , 77

s/^/0x5/
:
s/x5{,127}$/&5/
t
p
y/5/3/
p
s/33/0f/gp
:a
s/(f+)(0+f+)/\2\1/gp
ta

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

Answer 22

रूबी , 66 60 45 बाइट्स

x=2;9.times{puts"0x%0128x"%(2**512/-~x);x*=x}

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

Orlp से चोरी हुआ आइडिया

Answer 23

सी #, 168 बाइट्स

()={string R="",o="0",f="f";for(int i=0,j;i<9;i++){R+="0x";if(i>2){o+=o;f+=f;}for(j=0;j<128;){R+=i<1?"5":i<2?"3":o+f;j+=i>1?(int)Math.Pow(2,i-1):1;}R+="\n";}return R;};

Answer 24

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

⌡hÅék╝94"ºé♪╛#V┐5í╒

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

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

512r        [0..511]
{:Brm       convert each to bits and reverse each
M           transpose matrix, filling missing elements in rectangle with zero
m           map over each element of array, using the rest of the program.  outputs implicitly.
  4/        split bits into groups of 4
  {:b|Hm    convert each 4-bit binary number to single digit hex string
  .0xp      print "0x" without newline

इसको चलाओ

Answer 25

/// , 193 बाइट्स

/*/\/\///X/
0x*F/5555*G/FFFF*T/3333*U/TTTT*o/0f0f*1/oooo*t/00ff*2/tttt*g/0000*h/ffff*4/ghgh*6/gghh*7/gggg*8/hhhh*9/7788/0xGGGGGGGGXUUUUUUUUX11111111X22222222X44444444X66666666X78787878X99X77988

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