एक सार्वभौमिक-बाइनरी-फ़ंक्शन लुकअप तालिका बनाएं

19

यह गूढ़ प्रोग्रामिंग भाषा का आविष्कार करने के लिए मेरी खोज से संबंधित है ।

बाइनरी नंबरों की एक तालिका 0 .. 15 का उपयोग इंडेक्सिंग ऑपरेशंस का उपयोग करके एक सार्वभौमिक बाइनरी फ़ंक्शन को लागू करने के लिए किया जा सकता है। दो 1-बिट इनपुट X और Y को देखते हुए, सभी 16 संभावित कार्यों को 4-बिट ओपकोड में एन्कोड किया जा सकता है।

X Y  F|0 1 2 3 4 5 6 7 8 9 A B C D E F
- -    - - - - - - - - - - - - - - - -  
0 0    0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 1    0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
1 0    0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
1 1    0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
       -     -   - -   -   -   -   - -
       0    ~X  ~Y ^   &   Y   X   | 1
      ZERO    NOT-Y   AND         OR
          NOT-X   XOR              ONE

तो 16 फ़ंक्शन के इस सेट को फ़ंक्शन के रूप में बाइनरी इनपुट पर लागू किया जा सकता है

U (f, x, y): (f >> ((x << 1) | y)) & 1 ;

या

U (f, x, y): (f / 2 ^ (x × 2 + y))% 2 ,

या अनुक्रमण या मैट्रिक्स विभाजन के साथ।

इस प्रकार के बाइनरी ऑपरेशन पर निर्मित होने वाली किसी भी संभावित भाषाओं के लिए मूल्यों की ऐसी तालिका का प्रतिनिधित्व करने या उत्पन्न करने के लिए सबसे कॉम्पैक्ट तरीका जानना उपयोगी होगा।

लक्ष्य:

इस सटीक टेक्स्ट आउटपुट को जनरेट करें:

0101010101010101
0011001100110011
0000111100001111
0000000011111111

बस! सबसे छोटा-कोड जीतता है।

code-golf  kolmogorov-complexity 
— luser droog
स्रोत
2
मुझे आभास था कि एपीएल-परिवार यहां अच्छा करेगा। :)
— लूज़र ने
इसके अलावा संबंधित: एक साधारण लॉजिक गेट कैलकुलेटर
— FireFly
अग्रणी या अनुगामी newlines स्वीकार किए जाते हैं?
— टाइटस
हां, अतिरिक्त न्यूलाइन्स ठीक हैं।
— लूजर ने

जवाबों:

20

जे, 10 (13?) वर्ण

|.|:#:i.16

संख्या सूची:

   i.16
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15`

बाइनरी को:

   #:i.16
0 0 0 0
0 0 0 1
0 0 1 0
0 0 1 1
0 1 0 0
0 1 0 1
0 1 1 0
0 1 1 1
1 0 0 0
1 0 0 1
1 0 1 0
1 0 1 1
1 1 0 0
1 1 0 1
1 1 1 0
1 1 1 1

स्थानांतरित:

   |:#:i.16
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

उल्टा:

   |.|:#:i.16
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1

क्या हमें रिक्त स्थान निकालने की आवश्यकता है? दूसरे J उत्तर को देखते हुए ऐसा लगता है कि हम ऐसा करते हैं इसलिए हमें 3 वर्ण जोड़ने होंगे और जनवरी के उत्तर1": से उधार लेने होंगे ।

— गैरेथ
स्रोत
1
बहुत अच्छी शैली की व्याख्या। +1 (बहुत छोटा, बहुत!)
— लूज़र ने
जैसे ही मैंने पीटर के गोल्फस्क्रिप्ट उत्तर को देखा, मुझे पता था कि मैं बहुत बेहतर कर सकता था। ठीक है, आप पहले ही कर चुके थे।
— जॉन ड्वोरक
अच्छा कुछ Golfscript की तुलना में कम देखने के लिए ...
— fuenfundachtzig
— फिर से लागू किया
@luserdroog वाह। यह बहुत कोड है। हालांकि जे स्रोत कोड की तुलना में बहुत अधिक पठनीय है। :-) बहुत ही शांत।
— गारेथ
7

एपीएल (14)

मान लेना ⎕IO=0(यह एक सेटिंग है):

⎕D[⊖(4⍴2)⊤⍳16]

स्पष्टीकरण:

  • ⍳16: संख्या [0,16)
  • (4⍴2)⊤: 4 अंकों का उपयोग करके बेस 2 में प्रत्येक संख्या को एनकोड करें
  • ⊖: क्षैतिज रिवर्स (इसलिए MSB शीर्ष पर समाप्त होता है)
  • ⎕D[... ]: ये मान चुनें ⎕Dजिसमें से स्ट्रिंग है 0123456789। (एक संख्यात्मक मैट्रिक्स को मानों के बीच रिक्त स्थान के साथ प्रदर्शित किया जाता है, एक वर्ण मैट्रिक्स नहीं है। इसलिए यह प्रत्येक संख्यात्मक बिट को वर्णों में से एक में परिवर्तित करता है '0' '1')।
— मारीनस
स्रोत
क्या स्रोत में पहला चरित्र एक वर्ग की तरह दिखने वाला है, या क्या मुझे अभी भी कुछ फोंट याद आ रहे हैं?
— टिम सेग्यूइन
@TimSeguine हां, यह एक वर्ग है, जिसे एपीएल साहित्य में क्वाड कहा जाता है। क्वाड से शुरू होने वाले परिवर्तनीय नाम सिस्टम चर हैं जो पर्यावरण को बदलते हैं। IO = "सूचकांक मूल"।
— लूसर ड्रॉ
एक बाइट सहेजें: (4⍴2)⊤→2⊥⍣¯1
— Adám
6

जेली , ४२ 7 बाइट्स (गैर-प्रतिस्पर्धात्मक)

⁴ḶBUz0Y

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

डेनिस को उनकी मदद के लिए धन्यवाद। यहाँ पहला संदेश है, यहाँ आखिरी है (अन्य चर्चाएँ भी हुईं)। उनकी मदद से, मैंने स्पष्ट रूप से (लगभग) चौकोर जड़ दिया।

— आउटग्रॉफर को एरिक करें
स्रोत
चूंकि भाषा प्रश्न की तुलना में नई है, इसलिए मैं इसे उत्तर के रूप में स्वीकार नहीं कर सकता। निश्चित रूप से इनाम के लिए चल रहा है, थो!
— लूज़र
@luserdroog यह ठीक है। लेकिन, मुझे लगा कि चुनौती नई थी।
— आउटगॉल्फ
मुझे पता है कि आपका क्या मतलब है, यह बहुत पहले की तरह महसूस नहीं होता कि मैंने इसे पोस्ट किया है। लेकिन यहां तक ​​कि मेरी खुद की inca2, 2 साल की उम्र में, बहुत छोटी है।
— लूज़र ने
42 से 7 कोडगोल्फ के लिए +1। यह कुछ ऐसा है जो आप हर दिन नहीं देखते हैं (जब तक कि उद्देश्य पर नहीं किया जाता है)।
— केविन क्रूज़सेन
1
@ केविनक्रूजसेन इसे उद्देश्य पर कभी क्यों किया जाना चाहिए? मैं सिर्फ एक जेली नौसिखिया हूं (मैं पायथन 2 और 3 अच्छी तरह से जानता हूं), इसलिए मैंने इसे एक स्ट्रिंग तरीके से किया, जबकि मुझे "जेली को एक सरणी-हेरफेर भाषा के रूप में इलाज करने की आवश्यकता है"।
— आउटगॉल्फ
5

/// , 51 बाइट्स

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

/a/0101/aaaa
/b/0011/bbbb
/z/0000//o/1111/zozo
zzoo
— सेड्रिक रीचेनबैक
स्रोत
1
PPCG में आपका स्वागत है! आपने मुझे इसमें हरा दिया।
— आउटगॉल्फ
@EriktheGolfer सुधार करने के लिए स्वतंत्र महसूस करें, लेकिन मुझे लगता है कि यह सबसे कम संभव संस्करण है। :)
— सेड्रिक रीचेनबैक
मैं इसे सही करने के लिए पोर्ट कर रहा हूँ।
— आउटगॉल्फ
4

गोल्फस्क्रिप्ट (१Script १ 17) 15 वर्ण)

(हॉवर्ड के साथ धन्यवाद)

16,zip{','-~n}%

मुझे समझ नहीं आता कि 10-चार क्यों

16,zip{n}/

काम नहीं करता; मुझे संदेह है कि मानक दुभाषिया में एक बग स्टैक पर असमर्थित प्रकारों के परिणामस्वरूप है।

18 वर्णों पर एक विकल्प जिसे मैं पूरी तरह समझता हूं:

4,{2\?.2,*$8@/*n}%

28 वर्णों पर एक अधिक गणितीय दृष्टिकोण थोड़ा लंबा है:

4,{2.@??)2.4??.@/+2base(;n}/

इसका बहुत कुछ आधार रूपांतरण और शून्य-गद्दी के लिए है। उन लोगों के बिना, यह 19 वर्णों तक गिरता है,

4,{2.@??)2.4??\/n}/

आउटपुट के साथ

21845
13107
3855
255
— पीटर टेलर
स्रोत
यह सटीक पाठ आउटपुट के लिए पूछा गया था - 16,zip{n}/फिर काम क्यों करना चाहिए ?
— हावर्ड
दूसरी ओर आप कर सकते हैं16,zip{','-~n}%
— हावर्ड
@ हावर्ड, मुझे लगता है कि zipऐरे की एक सरणी वापस आनी चाहिए, लेकिन यह वास्तव में रूबी सरणियों की एक सरणी लौटाती है (यह मेरा सबसे अच्छा अनुमान है)। जो भी तत्व हैं, उन्हें `` `` लागू करने से उनके प्रिंट करने के तरीके पर कोई असर नहीं पड़ता है, जो कि 4 गोल्फस्क्रिप्ट डेटा प्रकारों में से किसी एक के विपरीत है। आप सही हैं जो ','-उन्हें सामान्य सरणियों में बदल देता है: अच्छी चाल।
— पीटर टेलर
यहाँ शून्य की 4 अतिरिक्त लाइनों का उत्पादन करने के लिए लगता है
— aditsu
@aditsu, ऑनलाइन डेमो पर काम करता है । मुझे आश्चर्य है कि अंतर क्यों। रूबी संस्करण, हो सकता है?
— पीटर टेलर
3

CJam - 16

4,{G,f{\m>2%}N}/

समतुल्य जावा कोड (स्पष्टीकरण के रूप में):

public class Lookup {
    public static void main(final String... args) {
        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 16; ++j) {
                System.out.print((j >> i) % 2);
            }
            System.out.println();
        }
    }
}
— aditsu
स्रोत
3

जावास्क्रिप्ट (ECMA6), 67

s=(k,n)=>n-.5?s((k<<n/2)^k,n/2)+"0".repeat(n)+k.toString(2)+"\n":""

इसका उपयोग करने के लिए, कॉल करें 

s(255,8)

Bitshift!
और XOR और थोड़ा सा पुनरावर्तन भी।

ध्यान देने वाली पहली बात यह है कि यदि हम कोई भी लाइन लेते हैं और आप इसे (निरंतर 0 के #) / 2 बाएं स्थानांतरित करते हैं, तो हमें अगली पंक्ति को प्राप्त करने के लिए एक अच्छा XOR मिलता है।

उदाहरण के लिए, 

0000000011111111 //line 4
0000111111110000 //shifted 4 to the left

XOR ये बिटवाइज़ हमें देते हैं

0000111100001111 //XOR'ed. This is line 3!

जो अगली पंक्ति ऊपर (पंक्ति 3) है।
लाइन 3 के लिए एक ही प्रक्रिया को लागू करना, 2 छोड़ दिया और हम प्राप्त ...

0000111100001111
0011110000111100

XOR'ed देता है

0011001100110011

जो पंक्ति 2 है।
ध्यान दें कि जिस राशि को हम शिफ्ट करते हैं वह हर बार आधी हो जाती है।
अब हम केवल 2 तर्कों के साथ इस फ़ंक्शन को पुनरावर्ती कहते हैं। इस लाइन का पूर्णांक मान और N, जो कि हमें स्थानांतरित करने के लिए कितना आवश्यक है। जब हम आवर्ती XOR'ed मान और n / 2 में बस पासिंग करते हैं।

"0".repeat(n)

प्रत्येक पंक्ति की शुरुआत में पैड 0 करने के लिए है क्योंकि स्ट्रिंग 0 से अग्रणी लेता है।

— केविन वू
स्रोत
+1 बहुत अच्छा। मैंने उस पैटर्न पर पहले गौर नहीं किया था।
— लूज़र ने 4
कुछ जोड़े को विभाजित करने के बजाय बिट शिफ्टिंग n द्वारा इसे काटा जा सकता है, और नई लाइन को टेम्पलेट स्ट्रिंग के साथ बदल सकते हैं:s=(k,n)=>n?s((k<<n/2)^k,n>>1)+"0".repeat(n)+k.toString(2)+` `:""
— Shaun H
2

जे, 21 अक्षर

1":<.2|(2^i.4)%~/i.16
  • i.16 0..15 की सूची है
  • 2^i.4 एक सूची है (1,2,4,8)
  • %~/ उन विभाजनों की तालिका तैयार करता है जहाँ बाएँ तर्क पंक्तियाँ बनाते हैं लेकिन विभाजन का सही तर्क है
  • 2| [प्रत्येक कोशिका] को दो से विभाजित करने के बाद शेष की गणना करता है
  • <. फर्श जिसका मान 0 या 1 है
  • 1": प्रति कक्ष एक वर्ण वाली तालिका को प्रारूपित करता है
— जॉन ड्वोरक
स्रोत
मुझे लगता है कि यह floorआवश्यक नहीं होना चाहिए। का डोमेन 2|पहले से ही 0 या 1 है, है ना?
— लूसर डॉग
@luserdroog |फ्लोट्स पर काम करता है । 2|3.25है 1.25। हम ऐसा नहीं चाहते हैं।
— जॉन ड्वोरक
2

रूबी (44)

बोरिंग और लंबी: संख्याओं के 0-गद्देदार बाइनरी अभ्यावेदन को बस प्रिंट करना।

[21845,13107,3855,255].map{|i|puts"%016b"%i}
— daniero
स्रोत
2

परिशिष्ट भाग 108 177 126 77 74 70

[43690 52428 61680 65280]
{16{dup 2 mod =only 2 idiv}repeat<>=}forall

एक सरल मोड बंद विधि के लिए मूल्यों को उलट दिया।

151 131 119

अधिक APL -ish दृष्टिकोण लागू करना । संपादित करें: प्रतिस्थापित चॉपिंग और सरणी ज़िपिंग को अनुक्रमण और फॉर-लूप के साथ बदल दिया गया।

[[0 1 15{}for]{16 add 2 5 string cvrs}forall]4 
-1 1{0 1 15{2 index exch get 1 index 1
getinterval =only}for pop<>=}for

इंडेंट:

[[0 1 15{}for]{16 add 2 5 string cvrs}forall]
4 -1 1{ % [] i
    0 1 15{ % [] i j
        2 index exch get % [] i [](j)
        1 index 1  % [] i [](j) i 
        getinterval  % [] i [](j)<i>
        =only  % [] i
    }for 
    pop<>= % []
}for

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

-1 16 i + #: |: |.{{==only}forall()=}forall

iयहाँ आइवरसन के प्राथमिक कार्यों में वर्णित 1-आधारित वेक्टर है , इसलिए -1 ... +उत्पादन करने के लिए 0 .. 15।

— luser droog
स्रोत
2

पर्ल (36 + 1)

sayहमेशा की तरह +1 । डबल 0टाइपो नहीं है :)

map say((00x$_,1x$_)x(8/$_)),1,2,4,8
— चीनी पर्ल गोथ
स्रोत
के लिए 1 जोड़ने की आवश्यकता नहीं है say। perl -e'...'मानक है और इसकी आवश्यकता है perl -E'...', बाइट की संख्या में कोई वृद्धि नहीं। वैसे भी, मुझे लगता है कि यह कोड गोल्फ मेटा पर तय किया गया था जो -M5.01मुफ़्त है।
— msh210
2

जावास्क्रिप्ट (ECMA6), 108

यहां एक अलग दृष्टिकोण की कोशिश कर रहा है। भले ही यह द्विआधारी ऑपरेटरों का उपयोग करने के लिए प्रोत्साहित किया गया था, मैंने खुद को इस समाधान को प्रस्तुत करने की अनुमति दी क्योंकि चालान भी कोल्मोगोरोव-जटिलता है और मैं सोच रहा था - मैं उन मूल्यों का प्रतिनिधित्व करने वाले कोड की मात्रा को कैसे कम कर सकता हूं ...? बेस ।

['gut','a43','2z3','73'].forEach(n=>{a=parseInt(n,36).toString(2);
alert(('00000000'+a).substr(a.length-8))})

(सुविधा के लिए लाइन ब्रेक)।

यह शर्म की बात है कि मुझे अग्रणी शून्य के साथ पैडिंग के साथ गड़बड़ करना पड़ा, लेकिन इस कोड का बिंदु बस बेस 36 में लक्ष्य बाइनरी परिणाम का प्रतिनिधित्व कर रहा है, जो वास्तव में उन gut, a43, 2z3, 73मूल्यों हैं।

नोट: मुझे लगता है कि यह जीतने के जवाब के पास कहीं भी नहीं होगा, लेकिन सिर्फ विचार के लिए ...

— याकूब
स्रोत
1
मैं मूल रूप से वही काम करने वाला था जब मैंने तुम्हारा देखा था। मैं इसे 92 से तकनीक का उपयोग कर बाइट्स के लिए नीचे मिला एक ऐसी ही सवाल का मेरा उत्तर : alert(['gut','a43','2z3',73].map(n=>(1e8+parseInt(n,36).toString(2)).slice(-16)).join('\n'))। यह दृष्टिकोण चार alert()एस के बजाय नईलाइन्स का उपयोग करता है ।
— निन्जाबियरनोक
2

सीजेएम ( गैर-प्रतिस्पर्धात्मक ), 10 9 बाइट्स

1 बाइट के लिए @ डेनिस को धन्यवाद!

Y4m*zW%N*

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

व्याख्या

Y     e# Push 2
4     e# Push 4
m*    e# Cartesian power of 2 (interpreted as [0 1]) with exponent 4
z     e# Zip
W%    e# Reverse the order of rows
N*    e# Join with newlines. Implicitly display
— लुइस मेंडो
स्रोत
2

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

स्ट्रिंग को पुनरावर्ती बनाता है।

f=(n=64)=>n--?f(n)+(!n|n&15?'':`
`)+(n>>(n>>4)&1):''

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

यह पुनरावृत्ति इस तथ्य पर आधारित है कि पैटर्न निबल्स 0x0 से 0xF के ऊर्ध्वाधर बाइनरी प्रतिनिधित्व से बना है:

  0101010101010101 bit #0 <- Y = 0
  0011001100110011 bit #1
  0000111100001111 bit #2
  0000000011111111 bit #3 <- Y = 3
  ----------------
  0123456789ABCDEF
  ^              ^
X = 0          X = 15

इसलिए, इस पैटर्न में प्रत्येक स्थिति (एक्स, वाई) को एक्स: के वाई-वें बिट के रूप में व्यक्त किया जा सकता है X & (1 << Y)। हम भी इस के साथ अलग कर सकते हैं (X >> Y) & 1:। X और Y पर नज़र रखने के बजाय, हम n0 से 63 तक के एक एकल चर पर पुनरावृत्ति करते हैं । इसलिए, सूत्र बन जाता है (n >> (n >> 4)) & 1:। यह वास्तव में 63 से 0 से पुनरावृति करना आसान है, इसलिए स्ट्रिंग को रिवर्स ऑर्डर में बनाया गया है। दूसरे शब्दों में, वर्ण n-1 को वर्ण n के बाईं ओर जोड़ा गया है ।

एक साइड नोट के रूप में, पुनरावर्तन छोटे कोड को छोड़कर यहां कुछ भी नहीं लाता है।

लाइनब्रेक के बिना, कोड 35 बाइट लंबा है:

f=(n=64)=>n--?f(n)+(n>>(n>>4)&1):''

लाइनब्रेक डालने के लिए हमें 17 और बाइट्स की आवश्यकता होती है। यदि एक अग्रणी लाइनब्रेक स्वीकार्य है तो इसे 14 बाइट्स के लिए छोटा किया जा सकता है।

डेमो

f=(n=64)=>n--?f(n)+(!n|n&15?'':`
`)+(n>>(n>>4)&1):''

console.log(f());
स्निपेट का विस्तार करें

— Arnauld
स्रोत
आइडोन में दोनों भाषाओं के साथ जावास्क्रिप्ट एक्सपेम में संकलित नहीं है ऊपर एक और दो है .... यह एक पुनरावर्ती कार्य का विचार अच्छा है ...
— रोजलूपी
35 बाइट्स के बाद विभाजित होने में क्या लगेगा?
— टाइटस
@ टिट्स - अच्छा। पहली नज़र में, मेरे पास इसके लिए कोई अच्छा उपाय नहीं है। यहाँ एक (बहुत बुरा) प्रयास है: (f=(n=64)=>n--?f(n)+(n>>(n>>4)&1):'')().match(/.{16}/g).join`\n` (63 बाइट्स)
— अरनौल्ड
हम्म ... और .replace(/.{16}/g,"$0\n")इसकी लंबाई समान है। बहुत बुरा।
— टाइटस
1

NARS2000 APL, 22

"01"[⊖1+(4⍴2)⊤(⍳16)-1]

मारिनस के एपीएल उत्तर से व्युत्पन्न, जो NARS2000 पर काम नहीं करता है।

वेक्टर उत्पन्न करें

      ⍳16
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

शून्य-आधारित में बदलें

      (⍳16)-1
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

सांकेतिक शब्दों में बदलना के लिए आकार उत्पन्न करें

      (4⍴2)
2 2 2 2

सांकेतिक शब्दों में बदलना

      (4⍴2)⊤(⍳16)-1
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

1-आधारित अनुक्रमण के लिए समायोजित करें

      1+(4⍴2)⊤(⍳16)-1
1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2
1 1 1 1 2 2 2 2 1 1 1 1 2 2 2 2
1 1 2 2 1 1 2 2 1 1 2 2 1 1 2 2
1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2

उल्टा प्राथमिक अक्ष

      ⊖1+(4⍴2)⊤(⍳16)-1
1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2
1 1 2 2 1 1 2 2 1 1 2 2 1 1 2 2
1 1 1 1 2 2 2 2 1 1 1 1 2 2 2 2
1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2

सूची

      "01"[⊖1+(4⍴2)⊤(⍳16)-1]
0101010101010101
0011001100110011
0000111100001111
0000000011111111
— luser droog
स्रोत
आप canIO को 0 पर सेट कर सकते हैं, ताकि आपको 1-आधारित अनुक्रमण के लिए समायोजित न करना पड़े। जो इसे 16 वर्णों तक ले जाता है।
— इलायस मैर्टनसन
हां, लेकिन फिर मुझे डर है कि यह अन्य एपीएल जवाब के समान है और यहां बिल्कुल भी नहीं होगा।
— लूसर डॉग
1

सी, 73 वर्ण

i;main(){for(;i<64;)i&15||puts(""),putchar(48|1&~0xFF0F0F33335555>>i++);}

यह चार 16-बिट ब्लॉकों में 64 बिट्स के आउटपुट के लिए सिर्फ एक सामान्य समाधान है; आपको बस 0xFF0F0F33335555दूसरे बिट अनुक्रम को आउटपुट करने के लिए संख्या को बदलने की आवश्यकता है ।

सरलीकृत और अपुष्ट:

int main() {
    int i;
    for(i = 0; i < 64; i++) {
        if(i % 16 == 0) {
            puts("");
        }
        int bit = ~0xFF0F0F33335555 >> i;
        bit &= 1;
        putchar('0' + bit);
    }
}
— MarcDefiant
स्रोत
1

हास्केल, 73

Yikes, 73 चार! मैं भगवान के प्यार के लिए यह किसी भी छोटे हालांकि नहीं मिल सकता है।

r=replicate
f n=r(div 8n)("01">>=r n)>>=id
main=mapM(putStrLn.f)[1,2,4,8]

इसके बारे में असली दुखद बात यह है कि यदि आप बैश का उपयोग करके आउटपुट को प्रतिध्वनित करते हैं, तो आपको केवल 74 वर्णों की आवश्यकता होगी।

— Flonk
स्रोत
1

जावास्क्रिप्ट (ईएस 5) 69

for(x="";4>x;x++){z="";for(n=0;16>n;)z+=1-!(n++&1<<x);console.log(z)}

— WallyWest
स्रोत
1

inca2 ,33 27 24

4 16#(,`2|(~16)%.2^~4){D

यह जान ड्वोरक के जवाब पर आधारित है । inca2 इसे कल के बगफिक्स के रूप में निष्पादित करने में सक्षम है। प्रश्न के बाद भाषा का आविष्कार होने के बाद से तकनीकी रूप से अमान्य है, लेकिन प्रश्न प्रस्तुत करने में भाषा का आविष्कार मेरे लक्ष्य का हिस्सा था। तो यहाँ अन्य जवाब के लिए आभार में कुछ वापसी है। :)

स्पष्टीकरण:

4 16#(,`2|(~16)%.2^~4){D
          (~16)               integers 0 .. 15 
                 2^~4         first 4 powers of 2: 1 2 4 8
          (~16)%.2^~4         division table
        2|                    mod 2 (and floor)
       `                      transpose
      ,                       ravel
     (               ){D      map to chars '0'..'9'
4 16#                         reshape to 4x16

कोष्ठकों में से कुछ अनावश्यक होना चाहिए, लेकिन जाहिर तौर पर व्याकरण की मेरी व्याख्या के साथ कुछ शेष मुद्दे हैं। और "ravel => map => reshape" वास्तव में अनाड़ी है: मानचित्र को अधिक स्मार्ट बनाने की आवश्यकता है। संपादित करें: बगफिक्स पार्न्स के उन्मूलन की अनुमति देते हैं।

एक अलग फ़ंक्शन में आधार रूपांतरण को N:x|y%.x^~1+[]/x.yफैक्टर करने से यह पैदावार होती है19 16 चार संस्करण।

4 16#(,`2N~16){D

और जब भी मैं यहाँ किसी भी तरह धोखा दे रहा हूँ, मैं आगे बढ़ चुका हूँ और यह एक अंतर्निहित कार्य है। लेकिन, भले ही यह एक निलादिक फ़ंक्शन है (एक तर्क की आवश्यकता नहीं है), निलादिक कार्यों के लिए कोई समर्थन नहीं है, और इसे एक डमी तर्क के साथ आपूर्ति की जानी चाहिए।

inca2, 2

U0
— luser droog
स्रोत
1

पायथ 24/26

सबसे छोटी विधि grc का उत्तर था जिसका अनुवाद Pyth के लिए किया गया था जो मुझे लगा कि सस्ता है इसलिए मैंने अपनी विधि स्वयं की:

मेरा: 26 वर्ण

 mpbjk*/8dS*d[0 1)[1 2 4 8

grc: 24 अक्षर

Fd[1 2 4 8)*/8d+*\0d*\1d
— अक्स।
स्रोत
1

सी ++ 130

हेक्स को बाइनरी में परिवर्तित करता है

#define B std::bitset<16>
#define C(x) cout<<x<<endl;
void main(){
B a(0xFF),b(0xF0F),c(0x3333),d(0x5555);
C(d)C(c)C(b)C(a)
}
— bacchusbeale
स्रोत
1

हास्केल (लैंबडॉट), 47 बाइट्स

unlines$reverse$transpose$replicateM 4['1','0']

Kinda चेटी क्योंकि यह Data.List से ट्रांसपोज़ का उपयोग करता है और Control.Monad से प्रतिकृति करता है , हालांकि दोनों लैंबडॉट से डिफ़ॉल्ट रूप से लोड होते हैं।

इसके अलावा, मुझे यकीन है कि सुधार के लिए जगह है, बस विचार साझा करना चाहता था

— michi7x7
स्रोत
1

जूलिया (39 बाइट्स)

दूसरी स्क्रिप्ट जो मैंने कभी जूलिया में लिखी है, मैं मानता हूँ कि मैं जूलिया को पसंद कर रहा हूँ, वह एक सुंदर जानवर है।

hcat(map(x->collect(bin(x,4)),0:15)...)

रिटर्न

[0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 
 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 
 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1]

स्पष्टीकरण:

  • bin(x,4) - बाइनरी पूर्णांक को 4 अक्षरों में पैडिंग के साथ इंट्री कन्वर्ट करें।
  • collect(_) - चार सरणी में विभाजित स्ट्रिंग।
  • map(x->_,0:15) - रेंज में पहले 16 अंकों के लिए ऐसा करें।
  • hcat(_...) - एक मैट्रिक्स में स्प्लैट और क्षैतिज रूप से समतल।
— जादू ऑक्टोपस Urn
स्रोत
1

सी 83 77 76 74 71

x;f(n){for(;x<4;x++,puts(""))for(n=0;n<16;)putchar(49-!(n++&(1<<x)));}

बहुत सीधा।

x;
f(n){
    for(;x<4;x++,puts(""))
        for(n=0;n<16;)
            putchar(49-!(n++&(1<<x)));
}
— luser droog
स्रोत
1
उपयोग न करके 2 की एक आसान बचत है ?:, और एक को स्थानांतरित करके 1 की दूसरी बचत ++।
— पीटर टेलर
बदलकर 3 सहेजा mainकरने के लिए f। lol
— luser droog
1

आर, 53 41 बाइट्स

@ जीआरसी के अजगर जवाब का अनुवाद। के उपयोग के माध्यम मूल अनुवाद से 12 बाइट्स बंद मुंडा rep()की eachऔर lengthतर्क (और आंशिक तर्क मिलान), और याद है कि द्वारा 0:1के बराबर है c(0,1)।

for(n in 2^(0:3))print(rep(0:1,e=n,l=16))


for(n in 2^(0:3))print(rep(c(rep(0,n),rep(1,n)),8/n))

आप @ गैरेथ के जे उत्तर के अनुवाद का भी प्रयास कर सकते हैं, कुछ इस तरह (34 बाइट्स):

t(e1071::bincombinations(4))[4:1,]

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

— rturnbull
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.