12

नीचे XNOR लॉजिक गेट के लिए एक (योजनाबद्ध) डिजिटल टाइमिंग आरेख है ।

    ┌─┐ ┌─┐ ┌─────┐ ┌─┐ ┌─┐ ┌───┐       
A ──┘ └─┘ └─┘     └─┘ └─┘ └─┘   └──
  ┌───┐ ┌───┐ ┌─┐ ┌─────┐   ┌─┐ ┌─┐ 
B ┘   └─┘   └─┘ └─┘     └───┘ └─┘ └
    ┌─────┐   ┌─┐   ┌─┐   ┌───┐   
X ──┘     └───┘ └───┘ └───┘   └────

आपका लक्ष्य यह दर्शाया गया है कि इसे बिल्कुल दर्शाया गया है।

नियम:

आप या तो इसे प्रिंट कर सकते हैं या एक बहुस्तरीय स्ट्रिंग वापस कर सकते हैं;
ट्रैलिंग और / या प्रमुख नई सुर्खियों की महत्वाकांक्षी संख्या की अनुमति है;
अनुगामी (लेकिन अग्रणी नहीं!) व्हाट्सएप की अनुमति है;
यदि आप विस्तारित ASCII बॉक्स-ड्राइंग वर्णों का उपयोग नहीं कर सकते हैं, तो आप उन्हें यूनिकोड समकक्षों (बिना बाइट दंड के) के लिए स्थानापन्न कर सकते हैं।

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

बाइनरी प्रतिनिधित्व

आपकी सुविधा के लिए, ऊपर दिए गए आरेख का द्विआधारी प्रतिनिधित्व निम्नानुसार है:

INP A=0101011101010110
INP B=1101101011100101
  ___
X=A⊕B=0111001001001100

नमूना आउटपुट

पक्षीय लेख

इस सवाल पर काम करते हुए, मैंने इसके लिए दो अलग-अलग बैश समाधान लागू किए हैं, एक 122 वर्ण / बाइट लंबा (जैसा कि ऊपर दर्शाया गया है) है, और दूसरा एक बिल्कुल 100 बाइट लंबा है।

मेरे पास उन्हें पोस्ट करने की योजना नहीं है (जैसा कि मैं आम तौर पर अपने सवालों के जवाब पोस्ट नहीं करता हूं), इसलिए यह सिर्फ संदर्भ के लिए है।

मेरा यह भी मानना है कि कम से कम कुछ उप -100 बाइट समाधान संभव हैं।

— टसेपेल्लिन
स्रोत

2

यह एक XNOR गेट है, है ना ...

— clismique

@ Qwerp-Derp येप, शायद यह है :)

— zeppelin

2

सुझाव देने के बजाय (0 == 0) == 0 या तो B या X शुरू नहीं होगा और 1 पर समाप्त होगा?

— रोमन Czyborra

@ रोमान कोज़ोर्रा यकीन नहीं है कि मैं इस विचार को समझता हूं, क्या आप इस पर थोड़ा विस्तार कर सकते हैं?

— ज़ेप्लेन

1

@zeppelin पैटर्न की शुरुआत में सही देखें - पहला युगल पिक्सेल। ए, बी और एक्स सभी कम हैं। आखिर में भी यही सच है। यह एक केस क्यों है? (मेरा मानना है कि यह रोमन का सवाल है)।

— isaacg

5

05AB1E , 101 बाइट्स + 5 UTF-8 बाइट्स = 116 कुल बाइट्स = 106 बाइट्स

(विरासत 05AB1E संस्करण, TIO पर कोई नहीं)

•=(Ín§Àoà`œ¯_eè8y1ÜŸ,Ú®:¹$:,õKA–x[Âì0ãXÔfz}y×ì¹Ï½uEÜ5äÀTë@ºQÈ™ñó:ò…Eä•6B"102345"" ┌─┐└┘"‡6ävyN" A B X"èì}»

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

संपीड़न:

•=(Ín§Àoà`œ¯_eè8y1ÜŸ,Ú®:¹$:,õKA–x[Âì0ãXÔfz}y×ì¹Ï½uEÜ5äÀTë@ºQÈ™ñó:ò…Eä• 
# Pattern, converted to base-6 in base-6=214.

111023102310222223102310231022231112251425142511111425142514251114221022231022231023102222231110231023151114251114251425111114222514251411102222231110231110231110222311111225111114222514222514222511142222
# Actual base-6 pattern.

1110231023102222231023102310222311
1225142514251111142514251425111422
1022231022231023102222231110231023
1511142511142514251111142225142514
1110222223111023111023111022231111
1225111114222514222514222511142222
#Pattern split into chunks of 34.

   ┌─┐ ┌─┐ ┌─────┐ ┌─┐ ┌─┐ ┌───┐  
 ──┘ └─┘ └─┘     └─┘ └─┘ └─┘   └──
 ┌───┐ ┌───┐ ┌─┐ ┌─────┐   ┌─┐ ┌─┐
 ┘   └─┘   └─┘ └─┘     └───┘ └─┘ └
   ┌─────┐   ┌─┐   ┌─┐   ┌───┐    
 ──┘     └───┘ └───┘ └───┘   └────
# Pattern after replacing 0,1,2,3,4,5 with appropriate blocks.

रूपांतरण:

6B                                   # Convert back to base-6.
  "102345"" ┌─┐└┘"‡                  # Replace numbers with appropriate counterparts.
                   6ä                # Split into 6 equal parts (the rows).
                     vy           }  # For each row (chunk).
                       N" A B X"èì   # Push label at index [i], prepend to line.
                                   » # Print all separated by newlines.

CP-1252 एन्कोडिंग का उपयोग करना ।

— जादू ऑक्टोपस Urn
स्रोत

आपको इस चुनौती के उद्देश्यों के लिए प्रत्येक यूनिकोड बॉक्स-ड्राइंग चरित्र को सिर्फ 1 बाइट के रूप में गिनने की अनुमति है, ("नियम" देखें), इसलिए आपका उत्तर इसके अनुसार 106 बाइट्स लंबा है। तर्क यह है कि इन यूनिकोड वर्णों को CP437 या IBM850 में 1 बाइट वर्णों से बदला जा सकता है, लेकिन ये प्रदर्शित करने के लिए अधिक मुश्किल हो सकते हैं।

— ज़ेपेलिन

मैं zeppelin से सहमत हूं। नियमों में दी गई रियायत को देखते हुए, यह 106 बाइट्स होगा।

— लेवल रिवर सेंट

वैकल्पिक विधि जो केवल बिलिन का उपयोग करते हुए 05AB1E के नए संस्करण में काम करती है Åв(मैंने इसके साथ

— ASCII-

4

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

00000000: 92d6 3000 5431 1505 1403 50e8 4e0a aafc  ..0.T1....P.N...
00000010: 9f62 15e6 a3ff 61fa dc05 e06d 8b66 cbc7  .b....a....m.f..
00000020: e6b6 cff8 519a b85a 3eb6 b67d 95c0 0feb  ....Q..Z>..}....
00000030: 35b5 521d 7f7e 68af a916 fa20 d999 564d  5.R..~h.... ..VM
00000040: 1f03 d559 59ed 265c f243 42be            ...YY.&\.CB.

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

VT100 वैकल्पिक वर्ण सेट से बॉक्स-ड्राइंग वर्णों का उपयोग करता है, जिसे TIO प्रदर्शित नहीं कर सकता है। सर्वोत्तम परिणामों के लिए UNIX टर्मिनल में चलाएँ। मेरा टर्मिनल एसीएस को कॉपी-एंड-पेस्ट पर यूटीएफ -8 में परिवर्तित करता है, इसलिए आप यहां प्रभाव देख सकते हैं।

anders@change-mode:/tmp$ bubblegum xnor.zlib
    ┌─┐ ┌─┐ ┌─────┐ ┌─┐ ┌─┐ ┌───┐
A ──┘ └─┘ └─┘     └─┘ └─┘ └─┘   └──
  ┌───┐ ┌───┐ ┌─┐ ┌─────┐   ┌─┐ ┌─┐
B ┘   └─┘   └─┘ └─┘     └───┘ └─┘ └
    ┌─────┐   ┌─┐   ┌─┐   ┌───┐
X ──┘     └───┘ └───┘ └───┘   └────
▒┼␍␊⎼⎽@␌␤▒┼±␊-└⎺␍␊:/├└⎻$

ठीक है, चुनौती यह नहीं कहा हम टर्मिनल वापस लेने की जरूरत बाहर खोल करने के लिए लौटने से पहले एसीएस मोड की। उसके साथ अच्छा भाग्य।

— एंडर्स कसीर्ग
स्रोत

3

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

चुनौती के रूप में अधिकृत एक बाइट के रूप में मुद्रित प्रतीकों की गिनती (मुझे पता चला कि वे वास्तव में 3 बाइट्स हैं।)

6.times{|i|s=' A B X'[i]
'D]zunIWkF]nIRukFH'.bytes{|b|s+='   ┌─┐───┘ └'[(b*2>>i/2*2&6)-i%2*6,2]}
s[1]=' '
puts s}

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

least significant bit 0 New value for A  
                      1 Current value for A
                      2 New value for B
                      3 Current value for B
                      4 New value for X
                      5 Current value for X
most significant bit  6 Always 1 (to remain in printable range)

यह प्रत्येक वर्ण के लिए मुद्रित होने वाले 2 वर्णों को खोजने के लिए डिकोड किया गया है (जिनमें से पहला स्थान या क्षैतिज रेखा है।) ऊपरी और निचली पंक्तियों के लिए 8-वर्ण तार ओवरलैप: ऊपरी पंक्ति के लिए अंतिम दो वर्ण 11दो क्षैतिज रेखाएँ होती हैं, जो निचली पंक्ति के पहले दो वर्णों के लिए आवश्यक होती हैं 00। निचली पंक्ति के चारों ओर 8 अक्षर लपेटते हैं: वे अंतिम 6 और प्रतीक स्ट्रिंग के पहले 2 अक्षर हैं।

अघोषित कोड

6.times{|i|s=' A B X'[i]               #iterate through 6 lines of output. Set s to the 1st character.
  'D]zunIWkF]nIRukFH'.bytes{|b|        #for each byte in the magic string
     s+='   ┌─┐───┘ └'[(b*2>>i/2*2&6)- #add 2 bytes to s, index 0,2,4, or 6 of the symbol string depending on relevant 2 bits of the magic string.
     i%2*6,2]                          #if the second (odd) row of a particular graph, modify index to -6,-4,-2, or 0 
  }                                    #(ruby indices wrap around. mystring[-1] is the last character of the string.)
  s[1]=' '                             #replace intitial ─ of the curve with space to be consistent with question
  puts s                               #output line
}

— स्तर नदी सेंट
स्रोत

यह वास्तव में 129 बाइट्स, 113 अक्षर है।

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

1

@carusocomputing मुझे लगता है कि आपने यहां अधिकांश उत्तरों पर एक ही टिप्पणी की है। कृपया मेरी aser की पहली पंक्ति और OP के नियम 4 को देखें:

If you can not use the extended ASCII box-drawing characters, you may substitute them for the unicode equivalents (at no byte penalty)

हमने नियमों के अनुसार अपने उत्तर दिए हैं।

— लेवल रिवर सेंट

2

PowerShell, 255 वर्ण, 265 बाइट्स (UTF-8)

$a='    012 012 0111112 012 012 01112
A 113 413 413     413 413 413   411
  01112 01112 012 0111112   012 012
B 3   413   413 413     41113 413 4
    0111112   012   012   01112
X 113     41113 41113 41113   41111'
0..4|%{$a=$a-replace$_,('┌─┐┘└'[$_])};$a

यह मेरे कंप्यूटर पर काम करता है, लेकिन TIO पर बाइट्स को सही ढंग से पार्स नहीं करता ...

यह $aएक बहु-पंक्ति स्ट्रिंग है जो संख्याओं और स्थानों से भरा होता है, फिर लूप होता है 0..4|%{...}। प्रत्येक पुनरावृत्ति, हम उचित वर्ण के साथ -replaceउचित अंक और इसे वापस स्टोर करते हैं । फिर, हम बस पाइपलाइन पर छोड़ देते हैं और आउटपुट निहित है।$_'┌─┐┘└'[$_]$a$a

— AdmBorkBork
स्रोत

आपको चुनौती के अनुसार यूनिकोड वर्णों को सिंगल बाइट्स के रूप में गिनने की अनुमति है

— FlipTack

2

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

NB: बाइट के रूप में UTF-8 वर्णों को गिनना, चुनौती द्वारा अधिकृत के रूप में।

_=>[..." A B X"].map((c,i)=>c+" "+[...Array(33)].map((_,j)=>j%2?" ─"[p^i&1]:" ┐┌─└┘ "[p+(p=[27370,42843,12878][i>>1]>>j/2&1)*2+i%2*3]).join``,p=0).join`
`

डेमो

कोड स्निपेट दिखाएं

let f =

_=>[..." A B X"].map((c,i)=>c+" "+[...Array(33)].map((_,j)=>j%2?" ─"[p^i&1]:" ┐┌─└┘ "[p+(p=[27370,42843,12878][i>>1]>>j/2&1)*2+i%2*3]).join``,p=0).join`
`

console.log(f())

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

नील को धन्यवाद देकर 4 बाइट्स बचाए

— Arnauld
स्रोत

j%2?" ─"[p^i&1]:" ┐┌─└┘ "[p+(p=[27370,42843,12878][i>>1]>>j/2&1)*2+i%2*3]3 बाइट्स बचाता है।

— नील

ओह, और 17 से 33 भी बदलें।

— नील

एक बार फिर, 152 अक्षर, 164 बाइट्स।

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

2

सी, 213 205 बाइट्स

एक बदलाव के लिए, इस चुनौती पर, सी प्रोग्राम का आकार, अन्य भाषाओं की तुलना में पूरी तरह से हास्यास्पद नहीं है।

#define X(a) u[i]=C[a],l[i++]=C[(a)+4]
p(n,c){char u[34],l[34],*C=" ┐┌──└┘ ",i=0;while(i<34)X(n&3),n>>=1,X((n&1)*3);printf("  %.33s\n%c %.33s\n",u,c,l);}main(){p(0xD5D4,'A');p(0x14EB6,'B');p(0x649C,'X');}

असंबद्ध, परिभाषित विस्तार, और टिप्पणी:

p(n,c){
    // u is the upper line of the graph, l the lower line
    char u[34],l[34],*C=" ┐┌──└┘ ",i=0;
    while(i<34)
        u[i]=C[n&3],            // using the two LSBs to set the transition char depending on the current and next state
        l[i++]=C[(n&3)+4],      // do for both upper and lower lines
        n>>=1,                  // shift bits right to go to next state
        u[i]=C[(n&1)*3],        // using only the LSB to set the "steady" char depending on current state only
        l[i++]=C[((n&1)*3)+4];  // do for both upper and lower lines
    printf("  %.33s\n%c %.33s\n",u,c,l);
}
main() {
    // Call p for each graph
    // Constants are chosen so the display is consistent with the request.
    // Each bit represents a state, but the order is reversed
    // (leftmost is put on lowest significant bit, after a 0)
    p(0xD5D4,'A');p(0x14EB6,'B');p(0x649C,'X');
}

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

— मंद ने एसई में विश्वास खो दिया
स्रोत

1

tcl, 221 chars, 299 बाइट्स

lmap {b _ n u A V} {"   " ┌─────┐ ┌───┐ └───┘ ┌─┐ └─┘} {puts "[set S \ $b][set m $A\ $A] $_ $m $n
A ──┘ [set w $V\ $V][set s \ $S]$w $V$b└──
  $n $n $A $_$b$m
B ┘$b$V$b$w$s$u $V └
$S$_$b$A$b$A$b$n
X ──┘$s$u $u $u$b└────"}

पर चलाया जा सकता है: http://rextester.com/live/VVQU99270

— sergiol
स्रोत

228 वर्ण, हालांकि यह 306 बाइट्स है।

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

@carusocomputing: चार्ट के बजाय बाइट्स गिनने के लिए आप किस ऑनलाइन टूल का उपयोग करते हैं? अग्रिम रूप से।

— सर्गियोल

mothereff.in/byte-counter

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

XNOR डिजिटल टाइमिंग आरेख ड्रा करें

05AB1E , 101 बाइट्स + 5 UTF-8 बाइट्स = 116 कुल बाइट्स = 106 बाइट्स

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

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

PowerShell, 255 वर्ण, 265 बाइट्स (UTF-8)

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

डेमो

सी, 213 205 बाइट्स

tcl, 221 chars, 299 बाइट्स