Ci-dessous, un diagramme de temps numérique (schématique) pour la porte logique XNOR .

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

Votre objectif est de le reproduire exactement comme illustré.

Règles:

• Vous pouvez l'imprimer ou renvoyer une chaîne multiligne;

• Un nombre arbitraire de nouvelles lignes d'essai et / ou de début est autorisé;

• Les espaces de fin (mais pas de tête!) Sont autorisés;

• Si vous ne pouvez pas utiliser les caractères de dessin de boîte ASCII étendus, vous pouvez les remplacer par les équivalents Unicode (sans pénalité d'octet).

Il s'agit de code-golf donc la réponse la plus courte en octets l'emporte.

Représentation binaire

Pour votre commodité, la représentation binaire du diagramme ci-dessus est la suivante:

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

Exemple de sortie

Sidenote

En travaillant sur cette question, j'ai implémenté deux solutions bash différentes, l'une de 122 caractères / octets de long (comme illustré ci-dessus) et l'autre de 100 octets de long exactement.

Je n'ai pas l'intention de les publier (car je ne publie pas normalement les réponses à mes propres questions), donc c'est juste pour référence.

Je pense également qu'au moins certaines solutions inférieures à 100 octets sont possibles.

05AB1E , 101 octets + 5 octets UTF-8 = 116 octets totaux = 106 octets

(VERSION LEGACY 05AB1E, N'EST PLUS SUR TIO)

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

Essayez-le en ligne!

La compression:

•=(Í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.

La conversion:

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.

Utilisation de l' encodage CP-1252 .

Bubblegum , 76 octets

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.

Essayez-le en ligne!

Utilise des caractères de dessin de boîte du jeu de caractères alternatif VT100, ce que TIO ne peut pas démontrer. Exécutez dans un terminal UNIX pour de meilleurs résultats. Mon terminal convertit l'ACS en UTF-8 sur copier-coller, vous pouvez donc voir l'effet ici.

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

Eh bien, le défi n'a pas dit que nous devons prendre le terminal arrière en mode ACS avant de revenir à la coquille. Bonne chance avec ça.

Rubis, 113 octets

compter les symboles imprimés comme un octet comme autorisé par le défi (j'ai été surpris de découvrir qu'ils sont en fait de 3 octets.)

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 lignes de sortie se prêtent à un encodage de 6 bits pour chaque caractère de la chaîne magique. Mais les caractères de chaîne magique encodent en fait pour chaque transition ainsi:

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)

Ceci est décodé pour trouver les 2 caractères qui doivent être imprimés pour chaque transition (dont le premier est soit un espace soit une ligne horizontale.) Les chaînes de 8 caractères pour les lignes supérieures et inférieures se chevauchent: Les deux derniers caractères pour la ligne supérieure 11sont deux lignes horizontales, qui correspondent à ce qui est nécessaire pour les deux premiers caractères de la ligne inférieure 00. Les 8 caractères de la ligne inférieure s'enroulent: ce sont les 6 derniers et les 2 premiers caractères de la chaîne de symboles.

Code non golfé

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
}

PowerShell, 255 caractères, 265 octets (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

Cela fonctionne sur mon ordinateur, mais ne semble pas analyser correctement les octets sur TIO ...

Il $as'agit d'une chaîne de plusieurs lignes remplie de nombres et d'espaces, puis en boucle 0..4|%{...}. À chaque itération, nous avons -replacele chiffre approprié $_avec le caractère approprié '┌─┐┘└'[$_]et le stockons dans $a. Ensuite, nous laissons simplement $ale pipeline et la sortie est implicite.

JavaScript (ES6), 163 158 154 octets

NB: compter les caractères UTF-8 comme octets, comme autorisé par le challenge.

_=>[..." 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`
`

Démo

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 octets enregistrés grâce à Neil

C, 213 205 octets

Pour changer, la taille du programme C, sur ce défi, n'est pas complètement ridicule par rapport aux autres langages.

#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');}

Non golfé, définir développé et commenté:

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');
}

Remarque: la chaîne C ne doit pas contenir de caractères unicode. Tous les caractères affichables doivent être de simples anciens caractères 8 bits (mais ils peuvent être choisis dans la plage étendue). Donc, fondamentalement, la validité de la sortie dépend de votre page de codes.

tcl, 221 caractères, 299 octets

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└────"}

peut être exécuté sur: http://rextester.com/live/VVQU99270