मुझे एक डोमिनोज़ ड्रा

Question

चुनौती

इनपुट के रूप में दो अंकों 0-9 को देखते हुए, दो चेहरों पर पिप्स (डॉट्स) की संख्या के साथ एक डोमिनोज़ ( उनतीस डोमिनोज़ सेट से ) आउटपुट । दस संभावित चेहरे इस तरह दिखते हैं (पाइप द्वारा अलग किए गए):

     |     |    o|    o|o   o|o   o|o o o|o o o|o o o|o o o
     |  o  |     |  o  |     |  o  |     |  o  |o   o|o o o
     |     |o    |o    |o   o|o   o|o o o|o o o|o o o|o o o

या अलग लाइनों पर:

     
     
     
-----
     
  o  
     
-----
    o
     
o    
-----
    o
  o  
o    
-----
o   o
     
o   o
-----
o   o
  o  
o   o
-----
o o o
     
o o o
-----
o o o
  o  
o o o
-----
o o o
o   o
o o o
-----
o o o
o o o
o o o

इनपुट प्रारूप

आप किसी भी उचित प्रारूप में इनपुट ले सकते हैं, जिसमें शामिल हैं:

• दो अलग-अलग पूर्णांक, तार या सिंगलटन सरणियां;
• 0-99 से एक पूर्णांक;
• दो पूर्णांकों की एक सरणी;
• दो अंकों की एक स्ट्रिंग।

आउटपुट स्वरूप

• दो चेहरों को क्षैतिज रूप से संरेखित किया जा सकता है, जैसे पाइप द्वारा अलग किया गया:

    o|o   o
     |  o  
o    |o   o

• या वे खड़ी रूप से संरेखित हो सकते हैं, जैसे कि हाइफ़न द्वारा अलग किया गया:

    o
     
o    
-----
o   o
  o  
o   o

• आप चाहें तो डोमिन के चारों ओर एक बॉर्डर का उत्पादन कर सकते हैं।
• आप लाइनों की एक सूची, दो चेहरों की एक सूची या इनमें से एक संयोजन का उत्पादन करने के लिए भी चुन सकते हैं।
• आप पिप्स के लिए किसी भी गैर-व्हाट्सएप चरित्र का उपयोग कर सकते हैं (मैंने इस्तेमाल किया o)।
• यदि आप वास्तव में चाहते हैं, तो आप 0व्हाट्सएप के 1लिए और पिप्स के लिए उपयोग कर सकते हैं , या False/ Trueया (या आपकी भाषा के समतुल्य) अगर किसी ऐरे को आउटपुट करते हैं।
• आप स्तंभों के बीच व्हाट्सएप को हटा सकते हैं; यह 7, 7 के लिए एक मान्य आउटपुट है:

ooo|ooo
 o | o 
ooo|ooo

• किसी भी चेहरे को 90 डिग्री तक घुमाया जा सकता है। यह भी 7, 7 के लिए एक मान्य आउटपुट है:

o   o|o o o
o o o|  o  
o   o|o o o

• आपके पास जितने चाहें उतने अधिक / थोड़े अग्रणी / अनुगामी व्हाट्सएप हो सकते हैं, जब तक कि आउटपुट का मुख्य भाग अभी भी अन्य बाधाओं को पूरा करता है।
• प्रत्येक चेहरा 3 लाइनों का होना चाहिए, भले ही लाइनें खाली हों। 0, 1 के लिए आप इसे आउटपुट नहीं कर सकते:

-----

  o

लेकिन आप इसका उत्पादन कर सकते हैं :

-----

  o

इसी तरह, यदि आप लाइनों की दो सूचियों की सूची का उत्पादन कर रहे थे, तो आप कर सकते थे [["", "", ""], ["", " o", ""]], लेकिन नहीं [[""], [" o "]]।

स्कोरिंग

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

Comments

तो, इनपुट के लिए [2, 1], मैं आउटपुट कर सकता था [[[0,0,1],[0,0,0],[1,0,0]],[[0,0,0],[0,1,0],[0,0,0]]]?

— डेनिस

@ डेनिस सही।

— ETHproductions

क्या चेहरों के बीच विभाजक को डैश होना चाहिए, या क्या यह कुछ अन्य संगत मूल्य हो सकता है?

— जो राजा

@JoKing मैं कहूँगा कि आप पहले से उपयोग कर रहे लोगों के अलावा किसी भी सुसंगत चरित्र का उपयोग कर सकते हैं

— ETHproductions

[0,5,21,29,31]सभी महत्वपूर्ण संख्याएँ हैं यहाँ मेरे दोस्त।

— मैजिक ऑक्टोपस Urn

Answer 1

पायथन 2 , 101 97 92 68 64 बाइट्स

lambda*a:[[[n>3,n>5,n>1],[n>7,n%2,n>7],[n>1,n>5,n>3]]for n in a]

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

क्रेडिट

• श्री एक्सकोडर द्वारा 101 बाइट्स से 92 तक घटाया गया
• जोनाथन एलन ( डेनिस ) द्वारा 92 बाइट्स से 68 तक कम
• 68 बाइट्स से घटाकर 64 पूरी तरह से अमानवीय

Comments

@ Mr.Xcoder फिर से अपडेट किया गया।

— नील

स्वरूपण वैकल्पिक है। मैट्रीस की एक जोड़ी को वापस करने से कम से कम 22 बाइट बचती हैं।

— डेनिस

68 बाइट्स बिना किसी फॉर्मेटिंग के (ध्यान दें कि 0और Falseपायथन में समान हैं, इसलिए यह ठीक होना चाहिए)।

— जोनाथन एलन

@JonathanAllan बहुत चतुर, अद्यतन।

— नील

64 बाइट्स। यदि आपको एक लैम्ब्डा बनाना है, तो सूची की समझ शायद कम है।

— अशुभ

Answer 2

C (gcc) , 252 242 269 262 241 235 220 बाइट्स

मैं अजगर में सॉकेट्स के लिए स्टैक ओवरफ्लो पर था, जब यह पॉप अप हुआ, तो कहा कि क्यों नहीं? पहला कोड गोल्फ, इसलिए मुझे पूरी तरह से यकीन नहीं है कि अगर मैंने नियमों का पालन किया 100% (और यदि नहीं और कोई मेरी लौकिक कुकी चोरी करना चाहता है और इसे ठीक करना चाहता है, तो ऐसा हो)। 'ओ' और '' के साथ, 255 245 272 265 244 238 228 बाइट्स। +48 को * 79 + 32 से बदलें।

#define Q(P,R)(R>>P&1)+48
char a[11];i=0;f(char*c){char b=c[0];a[3]=a[7]='\n';a[5]=Q(0,b);a[1]=a[9]=Q(3,b);a[2]=a[8]=Q(2,b)|a[1];a[0]=a[10]=Q(1,b)|a[2];a[4]=a[6]=a[1]|Q(2,b)&Q(1,b);puts(a);if(i++<1){puts("---");f(c+1);}}

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

यह कैसे काम करता है:
मैं एक बिट शिफ्ट और बिटवाइज़ का उपयोग करता हूं और यह पता लगाने के लिए कि क्या कोई स्पॉट स्पष्ट या पाइप होना चाहिए, फिर 0 या 1 को सही ASCII मान से ऑफसेट करें। यह 4 और 5 को गड़बड़ करता है, इसलिए उन्हें कुछ फिक्सिंग की आवश्यकता थी। वास्तव में कुछ बाइट्स जोड़े। एक मुखौटा हटाने और सिर्फ 1 (doh) का उपयोग करके कई बाइट्स निकालने में सक्षम था

अतिरिक्त #define
परिवर्तन को हटाकर 7 कम बाइट्स के लिए श्री एक्सकोडर के लिए विशेष धन्यवाद : मेमसेट -21 बाइट्स को हटा दिया गया। 6, 4, 2 के लिए बिट तर्क को क्रमशः 8 | 4 और 2, 8 | 4, 8 | 2 | 2 पर निर्भर करें। -6 बाइट्स। प्रिंटफ के बजाय पुट का उपयोग करके अतिरिक्त न्यूलाइन्स को हटा दिया, जो छोटा भी है। अतिरिक्त असाइनमेंट को हटाते हुए, सरणी को 11 तक छोटा कर दिया। -15 बाइट्स। अब मुझे लगता है कि मैं सबसे अच्छा कर सकता हूं।

Comments

PPCG में आपका स्वागत है!

— झबरा

नमस्ते, PPCG में आपका स्वागत है! आप अपने कोड को थोड़ा और आगे बढ़ा सकते हैं, 245 बाइट्स

— श्री एक्सकोडर

'\n'द्वारा प्रतिस्थापित किया जा सकता है 10। (क्योंकि C में, char डेटा प्रकार भी पूर्णांक डेटा प्रकार हैं) कुछ charको संभवतः द्वारा प्रतिस्थापित किया जा सकता है int। (या पूरी तरह से छोड़ दें)

— user202729

नीचे 184 बाइट्स यहाँ है, लेकिन यह अभी भी वर्तमान सी गोल्फ की तुलना में अधिक है, इसलिए।

— एंड्रयू बाउमर

173

— एंड्रयू बॉमर

Answer 3

जेली , 20 बाइट्स

“¤o.ƤẸʠṚ’B¬s5ŒBị@s€3

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

वैकल्पिक संस्करण, मूल आउटपुट, 33 32 31 बाइट्स

“¤o.ƤẸʠṚ’ṃ⁾ os5ŒBị@s€3K€€Zj€”|Y

1 बाइट को बंद करने के लिए @ user202729 का धन्यवाद!

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

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

सबसे पहले, “¤o.ƤẸʠṚ’- एक पूर्णांक शाब्दिक आधार विशेषांक 250 में - 1086123479729183 पर वापसी मूल्य निर्धारित करता है ।

फिर, B¬रिटर्न मान को बाइनरी में कनवर्ट करता है और सरणी को उपजते हुए, प्रत्येक अंक का तार्किक नहीं लेता है

00001001000010110100101011110011101111101111100000

इसके बाद, s5ŒBलंबाई के टुकड़ों में है कि सरणी विभाजन 5 , तो बाउंस प्रत्येक हिस्सा, मोड़ abcde में abcdedcba , उपज

000010000 001000100 001010100 101000101 101010101

111000111 111010111 111101111 111111111 000000000

अब, इस सरणी ị@के j ^th और k ^वें आइटम को पुनः प्राप्त करता है , जहाँ j, k प्रोग्राम का पहला तर्क है। ध्यान दें कि अनुक्रमण 1-आधारित और मॉड्यूलर है, इसलिए शून्य तत्व भी दसवां है।

अंत में, s€3लंबाई नौ के प्रत्येक भाग को तीन लंबाई के तीन भाग में विभाजित करें।

Comments

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

— ArtisticPhoenix

3उपयोग कर रहा है 0पिप्स के लिए, नहीं 1सभी दूसरों की तरह।

— जोनाथन एलन

“¤o.ƤẸʠṚ’कार्य करना चाहिए।

— जोनाथन एलन

@JonathanAllan धन्यवाद! यकीन नहीं होता कि यह कैसे हुआ ...

— डेनिस

Answer 4

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

⁽½ÑD<;ḂŒBs3µ€

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

इस उत्तर में डेनिस के उपयोग का विचार ŒB(बाउंस) और 13 बाइट्स प्राप्त करने के लिए इस उत्तर में Xcali के अवलोकन का संयोजन ।

---

जेली , 28 बाइट्स

(सुंदर मुद्रण के साथ)

केवल अब मुझे पता है कि जेली स्ट्रिंग शाब्दिक स्वचालित रूप से समाप्त हो गया है ...

⁽½ÑD<;ḂŒBị⁾o Ks6Yµ€j“¶-----¶

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

Comments

जाहिरा तौर पर मेरा दृष्टिकोण ⁽½ÑDEriktheOutgolfer के उत्तर की तुलना में कम बायटेकाउंट की ओर जाता “¤¦¢¬‘ है

— user202729

क्या यह बेहतर नहीं होगा कि 13 बाइट्स (डेनिस को आउटगोल्फिंग) फंक्शन्स को रीक्रिएट किया जाए और इसे आसानी से देखा जा सके?

— जकार्इ

@ Zacharý अस्थायी समाधान। बाद में ठीक कर देंगे।

— user202729

Answer 5

पीएचपी 155 , 150 बाइट्स

function d($a){foreach($a as$n){$o="---";for($i=0;$x=2**$i,$i<9;++$i)$o.=([0,16,68,84,325,341,365,381,495,511])[$n]&$x?0:' ';echo chunk_split($o,3);}}

यह इनपुट के रूप में पूर्णांकों की एक सरणी लेता है। परीक्षण के लिए:

d([1,2]);

echo "=========\n";

d([0,1,2,3,4,5,6,7,8,9]);

आउटपुट स्वरूप:

---

 0 

---
  0

0  

इसकी जांच - पड़ताल करें यहां लाइव देखें

मेरा समाधान

मेरे समाधान के लिए मैंने बिटवाइज़ नंबरों (2 की शक्तियों) से मिलकर एक मैट्रिक्स का उपयोग किया । इसे इस तरह से देखा जा सकता है:

 1  |  2  |  4
 8  | 16  | 32
 64 | 128 | 256

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

[0,16,68,84,325,341,365,381,495,511]

तो बस स्पष्ट करने के लिए:

• उदाहरण 0: सूचकांक 0या मूल्य 0रिक्त डोमिनोज़ होगा, जो हमेशा गलत होता है।
• उदाहरण 1: सूचकांक 1या मूल्य 16नंबर एक डोमिनोज़ और केंद्र में मौजूद मैट्रिक्स में होगा 16।
• उदाहरण 2: इंडेक्स 2या वैल्यू 68नंबर दो डोमिनोज़ होगा और मैट्रिक्स में जो टॉप राइट 4और बायीं तरफ 64 या नीचे है4|64
• उदाहरण 3: इंडेक्स 5या वैल्यू 341नंबर पांच डोमिनोज़ और मैट्रिक्स में होगा1|4|16|64|256
• उदाहरण 4: सूचकांक 9या मूल्य511 संख्या नौ डोमिनोज़ होगी और मैट्रिक्स में इसके सभी बिट्स का संयोजन होगा।

एक बार जब कि स्थापित है यह मैट्रिक्स में 9 पदों के लिए पाशन, और स्थापित करने का एक अत्यंत साधारण बात है $xकरने के लिए 2करने के लिए बिजली की$i

for($i=0;$x=2**$i,$i<9;++$i)

फिर हम एक बिटवाइज़ करते हैं और &जैसा कि हम उन स्पॉट्स के माध्यम से पुनरावृति करते हैं। उदाहरण के लिए, ऊपर से उदाहरण 2 का उपयोग करेंगे और मैं xदृश्य स्पष्टता के लिए रिक्त स्थान के बजाय इसका उपयोग करूंगा :

• पुनरावृति 1, 68 & 1 ? 0 : 'x'जिसके परिणामस्वरूप है'x'
• पुनरावृति 2, 68 & 2 ? 0 : 'x'जिसके परिणामस्वरूप'x'
• पुनरावृति 3, 68 & 4 ? 0 : 'x'जिसके परिणामस्वरूप है0
• पुनरावृति 4, 68 & 8 ? 0 : 'x'जिसके परिणामस्वरूप है'x'
• पुनरावृति 5, 68 & 16 ? 0 : 'x'जिसके परिणामस्वरूप'x'
• पुनरावृति 6, 68 & 32 ? 0 : 'x'जिसके परिणामस्वरूप'x'
• पुनरावृत्ति 7, 68 & 64 ? 0 : 'x'जिसके परिणामस्वरूप0
• पुनरावृत्ति 8, 68 & 128 ? 0 : 'x'जिसके परिणामस्वरूप'x'
• पुनरावृति 9, 68 & 256 ? 0 : 'x'जिसके परिणामस्वरूप'x'

जब लूप पूरा हो जाता है तो हम इस तार से हवा करते हैं "xx0xxx0xx"।

फिर हम "---xx0xxx0xx"इसे सीमा जोड़ते हैं (मैं वास्तव में सीमा के साथ शुरू करता हूं, लेकिन जो भी हो) ।

और अंत में हम 3 के लिए इसे chunk_split () करते हैं:

---
xx0
xxx
0xx

बेझिझक मुझे बताएं कि आप क्या सोचते हैं।

Comments

Php.net/manual/en/language.operators.arithmetic.php के** बजाय PHP 5.6 में शुरू किए गए घातांक ऑपरेटर का उपयोग करके आप इसे और भी छोटा कर सकते हैंpow()

— डेनियल

@ डैनियल - धन्यवाद 5 बाइट्स बचाए गए! मुझे नहीं पता था कि उन्होंने कहा कि, मैं हमेशा ^इसका उपयोग करने की कोशिश करता हूं, लेकिन इसके बिटकॉइन XOR ... lol

— ArtisticPhoenix

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

— 12M2121

मुझे दिखाओ कि यह दूर से ओपी में संकेत भी देता है।

— आर्टिस्टिकफोनिक्स

मुझे लगता है कि यह कम चालू होगा $argv। PHP में फ़ंक्शन ओवरहेड आमतौर पर 13 बाइट्स होता है।

— टाइटस

Answer 6

पर्ल 5 , 107 76 70 + 1 ( -a) = 70 बाइट्स

पर्ल 5 , 70 बाइट्स

$,="
---
";say map{$_='351
7 7
153'=~s/\d/$_>$&||0/ger=~s/ /$_%2/er}<>

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

व्हॉट्सएप के लिए 0 और पिप्स के लिए 1 का उपयोग करता है। बहुत सरल विधि: निरीक्षण करें कि जैसे ही अंक ऊपर जाता है, एक बार एक पाइप "चालू" होता है, यह कभी भी "बंद" नहीं होता है, केवल बीच में एक को छोड़कर। मध्य स्थिति में, यह सभी विषम संख्याओं के लिए है। इस प्रकार, प्रत्येक स्थिति के लिए, यह जांचने का एक सरल मामला है कि क्या अंक अंतिम अंक से अधिक है जिसके लिए वह बंद है। ||0जब हालत झूठी है उत्पादन पैदा करता है। पर्ल में, झूठा है undefजो अशक्त के रूप में आउटपुट है।

Answer 7

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

सहेजे गए 1 बाइट @ETHproductions के लिए धन्यवाद

करी सिंटैक्स में इनपुट लेता है (a)(b)और एक ऊर्ध्वाधर ASCII डोमिनो को आउटपुट करता है।

a=>b=>(g=n=>`351
707
153`.replace(/./g,d=>' o'[(+d?n>d:n)&1]))(a)+`
---
`+g(b)

डेमो

let f =

a=>b=>(g=n=>`351
707
153`.replace(/./g,d=>' o'[(+d?n>d:n)&1]))(a)+`
---
`+g(b)

console.log(f(4)(2))
console.log(f(3)(7))

---

क्षैतिज संस्करण, 80 79 बाइट्स

सहेजे गए 1 बाइट @ETHproductions के लिए धन्यवाद

2 पूर्णांकों की एक सरणी के रूप में इनपुट लेता है और एक क्षैतिज ASCII डोमिनोज़ आउटपुट करता है।

a=>`240|351
686|797
042|153`.replace(/\d/g,d=>' o'[(d<8?(x=a[d&1])>(d|1):x)&1])

डेमो

let f =

a=>`240|351
686|797
042|153`.replace(/\d/g,d=>' o'[(d<8?(x=a[d&1])>(d|1):x)&1])

console.log(f([4,2]))
console.log(f([3,7]))

Comments

अच्छा लगा, मेरे जैसा ही था। n>d|0या तो साथ एक बाइट बचाओ या(+d?n>d:n)&1

— ETHproductions 15

Answer 8

एपीएल (डायलॉग) , 25 बाइट्स

2∘|(3 3⍴⊢,,∘⌽)¨>∘3 5 1 7¨

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

-2 धन्यवाद ngn ।

आउटपुट स्वरूप थोड़ा अजीब है: यह फ़ंक्शन एक सरणी देता है जिसमें 0 और 1s वाले दो आकृति-3,3 सरणियाँ होती हैं।

Comments

-2 बाइट्स के लिए फिर से लिखना:2∘|(3 3⍴⊢,,∘⌽)¨>∘3 5 1 7¨

— ngn

@ धन्यवाद, यह चतुर है: पी

— एरिक आउटोलॉफ़र

Answer 9

सी (जीसीसी) , 115 बाइट्स

i;g(x){for(i=0;++i<10;)printf("%c%c",32+(i^5?x>" CEAG@GAEC"[i]-64:x%2),i%3?32:10);}f(a,b){g(a),puts("-----"),g(b);}

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

Comments

113 बाइट्स

— सीलिंगकैट

Answer 10

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

a=>b=>[(s=n=>[[n>3,n>5,n>1],[n>7,n%2,n>7],[n>1,n>5,n>3]].map(c=>c.map(b=>+b)))(a),s(b)]

f=a=>b=>[(s=n=>[[n>3,n>5,n>1],[n>7,n%2,n>7],[n>1,n>5,n>3]].map(c=>c.map(b=>+b)))(a),s(b)]

<div oninput="o.innerText=JSON.stringify(f(a.value)(b.value))"><input id=a type=number min=1 max=9 value=1><input id=b type=number min=1 max=9 value=1><pre id=o>

Comments

अच्छा डोमिनोज़ ...

— फल

Answer 11

हास्केल - 88 वर्ण

map$zipWith(zipWith($))[[(>4),(>5),(>1)],[(>7),odd,(>7)],[(>1),(>5),(>3)]].repeat.repeat

चेहरों को दर्शाने वाली दो नंबरों की सूची लेता है, बूल की सूची की सूची लौटाता है। यह छोटा नहीं है, लेकिन मुझे समाधान दिलचस्प लगता है।

Comments

आप mapइसके बजाय बस का उपयोग कर सकते हैं : repeatऔर इसे ऑनलाइन आज़माएं! zipWithmap$(<$>[[(>4),(>5),(>1)],[(>7),odd,(>7)],[(>1),(>5),(>3)]]).map.flip($)

— लैकोनी

गैर-पॉइंटफ्री दो और बाइट्स बचाता है: इसे ऑनलाइन आज़माएं!

— लैकोनी

Answer 12

पिप , 32 27 24 21 बाइट्स

^{-3 बाइट्स @DLosc को धन्यवाद}

FcgP[Yc>_M3517c%2RVy]

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

स्पष्टीकरण:

F                      For each
 c                       character $c
  g                      in the list of inputs:
   P                     Print
    [               ]      an array consisting of
                             an array of bits representing whether
      c>                       $c is greater than
        _M                       each of
          3517                     3, 5, 1, and 7
     Y                       (call this bit array $y),
              c%2            $c mod 2,
                 RV          and the reverse
                   y           of $y.

Comments

पिप इनाम जीतने के लिए बधाई! अब जब बाउंटी की अवधि समाप्त हो गई है, तो मैं आपको बता सकता हूं: 3517सूची के बजाय स्केलर पर मैप करके 3 बाइट्स बचाएं [3 5o7]। ;)

— डीएलस्को

Answer 13

> <> , 57 + 3 = 60 बाइट्स

>{:3)$:5)$:1)$:7)$:2%$\ao \
\?%cl999)3$)5:$)1:$)7:/nnn<rp

यह ऑनलाइन की कोशिश करो । डॉट्स के लिए 1s के साथ वर्टिकल डोमिनोज़ के रूप में आउटपुट, व्हॉट्सएप के लिए 0s और विभाजकों के लिए 9s जैसे:

001
000
100
999
111
111
111

तकनीकी रूप से इसे 12 इनपुट मूल्यों तक बढ़ाया जा सकता है।

पुराना संस्करण:

> <> , 76 + 3 = 79 बाइट्स

>{:3)$:5)$:1)$a$:7)$:2%$:7)\&?o~?!n\
\?(*a3la"---"a)3$)5:$)1:$a$/$&:)9::<r~p

यह ऑनलाइन की कोशिश करो । डॉट्स के लिए 1s के साथ वर्टिकल डोमिनोज़ के रूप में आउटपुट और व्हॉट्सएप के लिए 0s जैसे:

001
000
100
---
111
111
111

Answer 14

चारकोल , 46 44 43 39 बाइट्स

ＥＥ²℅§@APQTUVW^_ＮＥ⪪Ｅ⁹§ o÷ιＸ²↔⁻⁴λ³⪫λ Ｍ⁵↑⁵

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

ＥＥ²℅§@APQTUVW^_Ｎ

दो पूर्णांक पढ़ें और उन्हें लुकअप तालिका में मैप करें। फिर परिणाम पर नक्शा। (यह परिणाम को अस्थायी रूप से प्रभावी रूप से पकड़ लेता है।)

  Ｅ⁹                Loop `l` (!) from 0 to 8
            ⁻⁴λ     Subtract from 4
           ↔        Absolute value
         Ｘ²         Power of 2
       ÷ι           Divide into the looked-up value `i`
    § o             Convert to space or o
 ⪪             ³    Split into (3) groups of 3
Ｅ                   Map over each group
                ⪫λ  Join the 3 characters with spaces

फिर परिणाम अलग-अलग लाइनों पर मुद्रित होते हैं, प्रत्येक चेहरे के बीच एक अतिरिक्त रिक्त रेखा के साथ क्योंकि परिणाम नस्ट होते हैं।

Ｍ⁵↑⁵

ऊपर ले जाएं और चेहरे के बीच में विभाजन रेखा खींचें।

पिछला 43-बाइट क्षैतिज संस्करण:

↶Ｐ³Ｍ⁷←ＦＥ²℅§@APQTUVW^_ＮＦ⁹«Ｆ¬﹪κ³⸿⸿§ o÷ιＸ²↔⁻⁴κ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

↶

लंबवत कार्य करें।

Ｐ³

विभाजन रेखा प्रिंट करें।

Ｍ⁷←

पहले चेहरे की शुरुआत के लिए स्थिति।

ＦＥ²℅§@APQTUVW^_Ｎ

दो पूर्णांक पढ़ें और उन्हें लुकअप तालिका में मैप करें।

Ｆ⁹«

9 oएस तक उत्पादन के लिए तैयार करें ।

Ｆ¬﹪κ³⸿⸿

लेकिन हर तीन oएस में एक नया कॉलम शुरू करें ।

§ o÷ιＸ²↔⁻⁴κ

ASCII कोड के निचले 5 बिट्स को बाइनरी में कनवर्ट करें, और फिर शेष 4 oएस के लिए आउटपुट को मिरर करें ।

Comments

आउटपुट प्रारूप बल्कि उदार है, जिसे कुछ बाइट्स को सहेजना चाहिए।

— डेनिस

यह जादू टोना क्या है

— ArtisticPhoenix

@ डेनिस वास्तव में मूल आउटपुट प्रारूप सबसे अधिक उपयोगी है, क्योंकि यह स्वचालित रूप से मुझे विभाजन रेखा खींचने के लिए कमरा देता है।

— नील

हे भगवान, दो नील हैं।

— जकार्इ

@ Zacharý वास्तव में उपयोगकर्ता पृष्ठ के अनुसार आठ, या 40 हैं यदि आप उन लोगों को शामिल करते हैं जिनके नाम नील होते हैं ...

— नील

Answer 15

जेली , 16 बाइट्स

>⁽¤xb8¤;ḂŒḄs3
Ç€

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

उपयोग किया गया नील की रणनीति का और आधार विसंपीड़न मूल्यों उत्पन्न करने के लिए; बाइनरी सरणी के रूप में आउटपुट। इनपुट के रूप में एक सूची लेता है।

स्पष्टीकरण:

Ç€
 € for €ach input,
Ç  execute the previous line.

>⁽¤xb8¤;ḂŒḄs3
 ⁽¤xb8¤       the array [3, 5, 1, 7]
>             1 if the input is greater than each element, 0 otherwise
       ;Ḃ     append input % 2
         ŒḄ   bounce array
           s3 split into chunks of 3

Answer 16

एपीएल + विन, 49 47 बाइट्स

4⌽'|',⌽⍉6 3⍴,⍉(9⍴2)⊤(+\∊0 241 52 24 114,¨16)[⎕]

एडम की टिप्पणी के अनुसार संपादित, धन्यवाद, सूचकांक मूल शून्य के साथ चलाने के लिए।

प्रत्येक चेहरे के लिए पूर्णांक के वेक्टर के रूप में स्क्रीन इनपुट के लिए संकेत।

आउटपुट फॉर्म का है:

1 1 1 | 0 0 1    0 0 0 | 1 0 1
0 1 0 | 0 1 0    0 0 0 | 0 1 0
1 1 1 | 1 0 0    0 0 0 | 1 0 1

के इनपुट के लिए 7 3और0 5

स्पष्टीकरण:

(+\∊0 241 52 24 114,¨16) create a vector of integers whose binaries
                         represent the dots on the domino faces

[1+⎕] take input integers as indices to select from above vector

⍉6 3⍴,⍉(9⍴2)⊤ convert selected integers to a 9x2 binary matrix and reshape
              to match the orientation of the domino faces

4⌽'|',⌽ rotate, concatenate centre line markers and rotate again to centre 

Comments

क्यों नहीं ⎕IO←0अपने आप को बचाने के लिए उपयोग करें 1+?

— एडम डे

@ अदम वास्तव में क्यों नहीं - आलसी;)

— ग्राहम

Answer 17

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

lambda x,y,d="001155777702020202570044557777":[("%03d"%int(bin(int(o))[2:]),"---")[o=="3"]for o in d[x::10]+"3"+d[y::10]]

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

वापस जाने और नियमों को फिर से पढ़ने के बाद एक लंबोदा का उपयोग करके 121 तक घटा दिया गया। अब लाइनों की एक सूची तैयार करता है।

पिछले संस्करण के साथ अच्छी तरह से स्वरूपित आउटपुट:

पायथन 2 , 156 153 147 141 बाइट्स

x,y=input()
d="001155777702020202570044557777"
a=["%03d"%int(bin(int(o))[2:])for o in d[x::10]+d[y::10]]
for x in a[:3]+["---"]+a[3:]:print x

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

-3 धन्यवाद @NieDzejkob के साथ

इनपुट को 2 पूर्णांक के रूप में लेता है और 0 = स्पेस और 1 = डॉट के साथ वर्टिकल फॉर्मेट में आउटपुट करता है।

Comments

153 बाइट्स

— NieDzejkob

Answer 18

पाइट , 220 154 बाइट्स

दूसरा प्रयास (154 बाइट्स)

46281ᴇ8264áĐ9ř3%¬Đ¬2⁵*⇹1ᴇ*+03Ș←Đ3Ș≥Đ6²⁺3**⇹¬2⁵*+⇹9ř5=⇹2%*9²2-*+⇹9ř9<*Ž⇹ŕ⇹9ř3%¬Đ¬2⁵*⇹1ᴇ*+03Ș←Đ3Ș≥Đ6²⁺3**⇹¬2⁵*+⇹9ř5=⇹2%*9²2-*+⇹9ř9<*Ž⇹ŕ5⑴9△*Ƈǰ⇹Ƈǰ64ȘƇǰ6↔ŕ↔ŕ↔

स्पष्टीकरण:

46281ᴇ8264áĐ                                    Pattern matching for every cell but the middle
9ř3%¬Đ¬2⁵*⇹1ᴇ*+03Ș                              Non-pip characters
←Đ3Ș≥Đ6²⁺3**⇹¬2⁵*+⇹9ř5=⇹2%*9²2-*+⇹9ř9<*Ž⇹ŕ⇹     Make top cell
9ř3%¬Đ¬2⁵*⇹1ᴇ*+03Ș                              Non-pip characters
←Đ3Ș≥Đ6²⁺3**⇹¬2⁵*+⇹9ř5=⇹2%*9²2-*+⇹9ř9<*Ž⇹ŕ      Make bottom cell
5⑴9△*Ƈǰ⇹Ƈǰ64ȘƇǰ6↔ŕ↔ŕ↔                          Make boundary and combine

---

पहला प्रयास (220 बाइट्स):

2`↔←Đ4≥Đ6²⁺3**⇹¬5«+2⁵⇹3ȘĐ6≥Đ6²⁺3**⇹¬5«+2⁵⇹3ȘĐ2≥Đ6²⁺3**⇹¬5«+1ᴇ⇹3ȘĐ8≥Đ6²⁺3**⇹¬5«+2⁵⇹3ȘĐ2%Đ6²⁺3**⇹¬5«+2⁵⇹3ȘĐ8≥Đ6²⁺3**⇹¬5«+1ᴇ⇹3ȘĐ2≥Đ6²⁺3**⇹¬5«+2⁵⇹3ȘĐ6≥Đ6²⁺3**⇹¬5«+2⁵⇹3Ș4≥Đ6²⁺3**⇹¬5«+1ᴇ9△ĐĐĐĐ1ᴇ↔⁻łŕ↔ŕŕŕŕŕŕáƇǰ

स्पष्टीकरण:

2                           Push 2 (this is how many 'cells' to make)
`     ... ł                 While the top of the stack is not zero, loop
↔                           Flip the stack (useless at the beginning, undoes the flip at the end of the loop)
←Đ4≥Đ6²⁺3**⇹¬5«+            Set top-left pip
2⁵⇹3Ș                       Space
Đ6≥Đ6²⁺3**⇹¬5«+             Set top-middle pip
2⁵⇹3Ș                       Space
Đ2≥Đ6²⁺3**⇹¬5«+             Set top-right pip
1ᴇ⇹3Ș                       New line
Đ8≥Đ6²⁺3**⇹¬5«+             Set middle-left pip
2⁵⇹3Ș                       Space
Đ2%Đ6²⁺3**⇹¬5«+             Set center pip
2⁵⇹3Ș                       Space
Đ8≥Đ6²⁺3**⇹¬5«+             Set middle-right pip
1ᴇ⇹3Ș                       New line
Đ2≥Đ6²⁺3**⇹¬5«+             Set bottom-left pip
2⁵⇹3Ș                       Space
Đ6≥Đ6²⁺3**⇹¬5«+             Set bottom-middle pip
2⁵⇹3Ș                       Space
4≥Đ6²⁺3**⇹¬5«+              Set bottom-right pip
1ᴇ                          New line
9△ĐĐĐĐ                      Add 5 dashes
1ᴇ                          New line
↔⁻ł                         Decrement counter (if >0, loop; otherwise, exit loop)
ŕ↔ŕŕŕŕŕŕ                    Remove all unnecessary items on the stack
áƇǰ                         Push stack to an array, get characters at unicode codepoints given by values in the array, join characters with empty string

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

Answer 19

05AB1E , 34 बाइट्स

•ΩõIº•R2ô¹2÷è¹È-bDg5s-ú.∞3ô»TR„ o‡

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

---

यह मुश्किल था क्योंकि 05AB1E में खराब पैडिंग है।

---

मूल व्याख्या:

• यहाँ 4 महत्वपूर्ण पैटर्न हैं जो 2, 4, 6 और 8 हैं।
• 3,5,7 और 9 अन्य पैटर्न प्लस 1 हैं।
• 1 समरूपता के कारण महत्वपूर्ण नहीं है, यदि इनपुट समान है, तो बीच के बिट को टॉगल करने के लिए 1 को घटाएं।
• एलएसबी को टॉगल करने से मिररिंग के कारण मध्य बिट को फ़्लिप किया जा सकता है।

Answer 20

स्माइलबासिक, 92 69 बाइट्स

INPUT N,M
DEF Q?N>3;N>5;N>1?N>7;1AND N;N>7?N>1;N>5;N>3
END
Q?777N=M
Q

उदाहरण:

? 7,2
111
010
111
777
001
000
100

ऐसा तब होता है जब आपके नियम काफी सख्त नहीं होते हैं।

Answer 21

FALSE, 116 80 78 70 69 66 63 61 59 58 बाइट्स

[$3[>_$.\$]$p:!5p;!1p;!"
"7p;!%1&.."
"..."
"]$s:!"---
"s;!

अभी भी इस पर काम चल रहा है ...

Answer 22

टुकड़ा ,142 135 बाइट्स

! CvDvB
>v-]-x.
|Z-]-]e
|Z]xe|
|ZR(-'
|Zx.AD
|Zxx]x.
|Zx^-]e
|Z<,(-.
|Zx]xe|
|Zx-]-]e
|Zx-]-x'
|Z<C^D^B
|>x~s
|Zx.
|Zx<
|Zxb
|Z+^~f
`zd

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

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

प्रत्येक Z(या z) आउटपुट के एक चरित्र से मेल खाती है, वे ऊपर से नीचे तक क्रम में आग लगाने के लिए तैनात हैं। पूंजीकृत A, B, C, और Dइनपुट की कम चार बिट के अनुरूप (हम सभी को देखो है कि, तो "34" == "CD" == "st" ...)। लोअरकेस b, d, e,f उत्पादन के विभिन्न टुकड़ों के अनुरूप हैं।

अनंत-लंबाई वाले डोमिनोज़ भी बना सकते हैं; 0123456789इनपुट के रूप में देने का प्रयास करें ।

Answer 23

PHP, 116 बाइट्स

while($i<6)echo strtr(sprintf("%03b",[_011557777,_202020267,_044557777][$i/2][$argv[$i%2+1]]),10,"o "),"|
"[$i++%2];

PHP 5.5 या बाद के संस्करण की आवश्यकता है। इसे ऑनलाइन चलाएं -nrया इसके लिए प्रयास करें ।

Answer 24

सी (जीसीसी) , 150 146 बाइट्स

• छत के लिए धन्यवाद चार बाइट्स बचाता है ।

p(b){printf(" %c",33-b);}P(a){p(a<4),p(a<6),p(a<2),p(23),p(a<8),p(~a&1),p(a<8),p(23),p(a<2),p(a<6),p(a<4),p(23);}f(a,b){P(a),puts(" -----"),P(b);}

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

Comments

@ceilingcat धन्यवाद।

— जोनाथन फ्रेच